Serializers
GroupsSchema
Schema that receives a queryset from the Groups model and returns an object with the name of the group
class GroupsSchema(Schema):
name = fields.Str()
UserSchema
Schema that receives a queryset from the CustomUser model and returns an object.
def get_user_profile(user):
try:
user_profile = models.UserProfile.objects.get(user=user)
except models.UserProfile.DoesNotExist:
user_profile = models.UserProfile(user=user)
user_profile.save()
else:
return serialiazers.ProfileSchema().dump(user_profile)
class UserSchema(Schema):
email = fields.Email()
first_name = fields.Str(data_key="firstName")
last_name = fields.Str(data_key="lastName")
is_active = fields.Boolean(data_key="isActive")
user_id = fields.Function(lambda o: o.id)
groups = fields.Function(lambda o: GroupsSchema(many=True).dump(o.groups.all()))
profile = fields.Function(lambda o: get_user_profile(o))
The main fields are:
path: Path of the url.
is_active: Boolean field that tells the system if the path should be recorded in the log when it is visited by the user.
The methods of this model are:
create_register: Method to register a new Url. It does not require to instantiate the model.
ModelListLog
Model to store the list of System Models. To do this, in each model.py file there must be an object called apps_audit_models whose key is the name of the model and the value is the model (an example can be seen at the end of the models section of accounts).
class ModelListLog(TimeStampedModel):
model = models.CharField(max_length=100, blank=True, null=True)
model_name = models.CharField(max_length=100, blank=True, null=True)
is_active = models.BooleanField(default=False)
@classmethod
def create_register(cls, model: str, model_name: str):
if bool(ModelListLog.objects.filter(model_name=model_name)):
return None
obj = cls()
obj.model = model
obj.model_name = model_name
obj.save()
return obj
The email, first_name, last_name and is_active fields are rendered as they come from the CustomUser model. The rest of the fields are modified and obtained by functions.
The user_id field represents the id of the user.
groups is a schema relationship function GroupSchema.
profile is a relationship function with the ProfileSchema schema of the core app.
CreateUserSchema
Schema that validates for the creation of a new userto have a personalized log of a specific point in the flow of the application.
def user_group_validation(value):
groups = utils.get_groups()
try:
groups[value]
except KeyError:
raise ValidationError("Invalid user group.")
class CreateUserSchema(Schema):
firstName = fields.Str(required=True)
lastName = fields.Str(required=True)
email = fields.Email(required=True)
group = fields.Str(required=True, validate=user_group_validation)
All fields are required. Additionally, the group field contains a validation that verifies that the data entered belongs to the groups enabled in the system.
SystemAppNameSchema
Schema that validates the fields to change the name of the application.
class SystemAppNameSchema(Schema):
appName = fields.Str(required=True, validate=validate.Length(min=1))
The appName field is required and also cannot be left blank.
SystemExpireTimeSchema
Schema that validates the fields to change the session expiration time due to inactivity.
class SystemExpireTimeSchema(Schema):
sessionExpireTime = fields.Integer(required=True)
The sessionExpireTime field is required.
GlobalSettingsScripts
Schema that validates the fields to register custom scripts in the system.
class GlobalSettingsScripts(Schema):
header = fields.Str(required=True)
body = fields.Str(required=True)
footer = fields.Str(required=True)
All fields are required.
EmailProvidersSchema
Schema that receives a queryset from the EmailProvider model and returns an object.
class EmailProvidersSchema(Schema):
id = fields.Str()
provider = fields.Method("get_provider_name")
name = fields.Str()
from_email = fields.Email(data_key="email")
active = fields.Boolean()
def get_provider_name(self, obj):
return obj.get_provider_display()
The id, name, from_email and active fields are presented as they come from the EmailProvider model. The provider field is of type method that returns the name of the provider.
EmailProviderTemplateSchema
Schema that receives a queryset from the EmailProviderTemplate model and returns an object. Additionally, it is also used to register a new Template for a specific provider.
class EmailProviderTemplateSchema(Schema):
id = fields.Str()
provider = fields.Str()
providerId = fields.Method("get_provider_id")
name = fields.Str(required=True)
template_id = fields.Str(required=True, data_key="templateId")
language = fields.Str(required=True)
can_delete = fields.Boolean(data_key="canDelete")
def get_provider_id(self, obj):
return obj.provider.id
The id, provider, name, template_id, language and can_delete fields are rendered as they come from the EmailProviderTemplate model. The provider_id field is of type method that returns the id of the provider.
EmailProvidersCreateSchema
Schema that validates the fields to register an email provider.
class EmailProvidersCreateSchema(Schema):
id = fields.Str()
provider = fields.Str(required=True)
name = fields.Str(required=True)
from_email = fields.Email(required=True, data_key="email")
secret_key = fields.Str(required=True, data_key="secretKey")
active = fields.Boolean(required=True)
All fields are required except id.
CaptchaProviderSchema
Schema that receives a queryset from the EmailProviderTemplate model and returns an object.
class CaptchaProviderSchema(Schema):
provider = fields.Str(required=True)
site_key = fields.Str(required=True, data_key="siteKey")
secret_key = fields.Str(required=True, data_key="secretKey")
url_verify = fields.Str(required=True, data_key="urlVerify")
configuration = fields.Str(required=True)
active = fields.Boolean(required=True)
All fields are required.