def validate_post(request_media, organization_code, session):
errors = []
# Validate IT asset id
# -----------------------------------------------------
it_asset_id = request_media.get('it_asset_id')
if it_asset_id is None:
errors.append(
build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name='itAssetId'))
elif not session.query(ITAsset).get(it_asset_id):
errors.append(
build_error(Message.ERR_FIELD_VALUE_INVALID,
field_name='itAssetId'))
# Validate external identifier if informed
# There MUST NOT exist the same (IT asset id + external identifier) combination in organization
# -----------------------------------------------------
external_identifier = request_media.get('external_identifier')
error = validate_str('externalIdentifier',
external_identifier,
max_length=constants.GENERAL_NAME_MAX_LENGTH)
if error:
errors.append(error)
elif exists_it_asset(session, organization_code, it_asset_id,
external_identifier):
errors.append(
build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS,
field_name='externalIdentifier'))
return errors
def validate_post(request_media, organization_code, session):
errors = []
# Validate security threat id and if it's already exists in organization
# -----------------------------------------------------
security_threat_id = request_media.get('security_threat_id')
if security_threat_id is None:
errors.append(
build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name='securityThreatId'))
elif not session.query(SecurityThreat).get(security_threat_id):
errors.append(
build_error(Message.ERR_FIELD_VALUE_INVALID,
field_name='securityThreatId'))
elif find_organization_security_threat(security_threat_id,
organization_code, session):
errors.append(
build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS,
field_name='securityThreatId'))
# Validate exposure level id
# -----------------------------------------------------
threat_level_id = request_media.get('threat_level_id')
if threat_level_id and not session.query(RatingLevel).get(threat_level_id):
errors.append(
build_error(Message.ERR_FIELD_VALUE_INVALID,
field_name='threatLevelId'))
return errors
def validate_patch(request_media, it_asset_instance, organization_code,
session):
errors = []
if not request_media:
errors.append(build_error(Message.ERR_NO_CONTENT))
return errors
# Validate external identifier if informed
# There MUST NOT exist the same (IT asset id + external identifier) combination in organization except itself
# -----------------------------------------------------
if 'external_identifier' in request_media:
external_identifier = request_media.get('external_identifier')
error = validate_str('externalIdentifier',
external_identifier,
max_length=constants.GENERAL_NAME_MAX_LENGTH)
if error:
errors.append(error)
elif exists_other_it_asset(session, organization_code,
it_asset_instance, external_identifier):
errors.append(
build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS,
field_name='externalIdentifier'))
return errors
def validate_post(request_media, organization_code, it_service_instance_id,
session):
errors = []
# Validate IT asset instance id
# It MUST exist in organization and MUST NOT already exist in organization IT service
# -----------------------------------------------------
it_asset_instance_id = request_media.get('it_asset_instance_id')
if it_asset_instance_id is None:
errors.append(
build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name='itAssetInstanceId'))
elif not find_it_asset_in_organization(it_asset_instance_id,
organization_code, session):
errors.append(
build_error(Message.ERR_FIELD_VALUE_INVALID,
field_name='itAssetInstanceId'))
elif find_it_service_it_asset(it_asset_instance_id, it_service_instance_id,
session):
errors.append(
build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS,
field_name='itServiceInstanceId/itAssetInstanceId'))
# Validate relevance level if informed
# -----------------------------------------------------
relevance_level_id = request_media.get('relevance_level_id')
if relevance_level_id and not session.query(RatingLevel).get(
relevance_level_id):
errors.append(
build_error(Message.ERR_FIELD_VALUE_INVALID,
field_name='relevanceLevelId'))
return errors
def validate_post(request_media, session):
errors = []
# Validate name
# -----------------------------------------------------
name = request_media.get('name')
error = validate_str('name', name,
is_mandatory=True,
max_length=constants.GENERAL_NAME_MAX_LENGTH,
exists_strategy=exists_name(name, session))
if error:
errors.append(error)
# Validate description
# -----------------------------------------------------
description = request_media.get('description')
error = validate_str('description', description, max_length=constants.GENERAL_DESCRIPTION_MAX_LENGTH)
if error:
errors.append(error)
# Asset category id is mandatory and must be valid
# -----------------------------------------------------
category_id = request_media.get('category_id')
if category_id is None:
errors.append(build_error(Message.ERR_FIELD_CANNOT_BE_NULL, field_name='categoryId'))
elif not session.query(ITAssetCategory).get(category_id):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='categoryId'))
return errors
def validate_number(field_name,
field_value,
is_mandatory=False,
min_value=None,
max_value=None,
exists_strategy=None):
"""Validates a number with general predefined rules.
:param field_name: The field name to put in error object.
:param field_value: The field value to be validated.
:param is_mandatory: Indicates that the field is mandatory. That means that
an error is returned if value is None.
Default is false.
:param min_value: Minimum value considered valid (inclusive).
Default is None.
:param max_value: Maximum value considered valid (inclusive).
Default is None.
:param exists_strategy: A function that returns True (or something) when
value already exists. If the function returns None or False, the value
is considered new and validation will pass. If function is None, this
validation will be skipped.
Default is None.
Note: The function will not be executed if field value is None.
:return: A dict containing an error code, a message and the field name.
"""
# Field was not informed...
if field_value is None:
if is_mandatory:
return build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name=field_name)
# OK, it's not mandatory.
return None
# Must be of one of numeric types
if not isinstance(field_value, numbers.Number):
return build_error(Message.ERR_FIELD_VALUE_MUST_BE_NUMBER,
field_name=field_name)
# Check min and/or max when requested
if min_value and field_value < min_value:
return build_error(Message.ERR_FIELD_VALUE_BELOW_MIN,
min_value,
field_name=field_name)
if max_value and field_value > max_value:
return build_error(Message.ERR_FIELD_VALUE_ABOVE_MAX,
max_value,
field_name=field_name)
# Must be unique
if exists_strategy and exists_strategy():
return build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS,
field_name=field_name)
def validate_put(request_media, user_id, role_id, session):
errors = []
# Validate role id
# -----------------------------------------------------
if not role_id:
errors.append(
build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name='route:role_id'))
elif not session.query(SystemRole).get(role_id):
errors.append(
build_error(Message.ERR_FIELD_VALUE_INVALID,
field_name='route:role_id'))
return errors
def validate_post(request_media):
errors = []
# Validate description if informed
# -----------------------------------------------------
description = request_media.get('description')
error = validate_str('description',
description,
max_length=constants.ANALYSIS_DESCRIPTION_MAX_LENGTH)
if error:
errors.append(error)
# Validate scopes if informed
# -----------------------------------------------------
scopes = request_media.get('scopes') or []
for i, scope in enumerate(scopes):
scope_i = f'scopes[{i}]'
# departmentId is the minimum scope that must be informed
if scope.get('department_id') is None:
errors.append(
build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name=f'{scope_i}.departmentId'))
# macroprocessId cannot be null when processId is filled
if scope.get('macroprocess_id') is None and scope.get(
'process_id') is not None:
errors.append(
build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name=f'{scope_i}.macroprocessId'))
# Validate if values are numbers greater than 0
errors.append(
validate_number(f'{scope_i}.departmentId',
scope.get('department_id'),
min_value=1))
errors.append(
validate_number(f'{scope_i}.macroprocessId',
scope.get('macroprocess_id'),
min_value=1))
errors.append(
validate_number(f'{scope_i}.processId',
scope.get('process_id'),
min_value=1))
# Remove None's before returning
return [err for err in errors if err is not None]
def validate_patch(request_media, session):
errors = []
if not request_media:
errors.append(build_error(Message.ERR_NO_CONTENT))
return errors
# Validate name if informed
# -----------------------------------------------------
if 'name' in request_media:
name = request_media.get('name')
error = validate_str('name', name,
is_mandatory=True,
max_length=constants.GENERAL_NAME_MAX_LENGTH,
exists_strategy=exists_name(name, session))
if error:
errors.append(error)
# Validate name if informed
# -----------------------------------------------------
if 'description' in request_media:
description = request_media.get('description')
error = validate_str('description', description, max_length=constants.GENERAL_DESCRIPTION_MAX_LENGTH)
if error:
errors.append(error)
return errors
def validate_post(request_media, organization_code, session):
errors = []
# Validate department id
# -----------------------------------------------------
department_id = request_media.get('id')
if department_id is None:
errors.append(build_error(Message.ERR_FIELD_CANNOT_BE_NULL, field_name='id'))
elif not session.query(BusinessDepartment).get(department_id):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='id'))
# Validate department in organization
# -----------------------------------------------------
elif find_organization_department(department_id, organization_code, session):
errors.append(build_error(Message.ERR_DEPARTMENT_ID_ALREADY_IN_ORGANIZATION, field_name='id'))
return errors
def validate_patch(request_media, organization_code, session):
errors = []
if not request_media:
errors.append(build_error(Message.ERR_NO_CONTENT))
return errors
# Validate relevance level id if informed
# -----------------------------------------------------
if 'relevance_level_id' in request_media:
relevance_level_id = request_media.get('relevance_level_id')
# This value CAN be null if informed...
if relevance_level_id and not session.query(RatingLevel).get(relevance_level_id):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='relevanceLevelId'))
return errors
def authenticate_user(request_media, session):
errors = []
# Validate email
# -----------------------------------------------------
email = request_media.get('email')
user = session.query(SystemUser).filter(SystemUser.email == email).first()
if not user:
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='email'))
return errors, None
# Check password
# -----------------------------------------------------
password = request_media.get('password')
if not bcrypt.checkpw(password.encode('UTF-8'), user.hashed_password):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='password'))
return errors, user
return errors, user
def validate_post(request_media, it_asset_instance_id, organization_code, session):
errors = []
# Validate mitigation control id
# -----------------------------------------------------
mitigation_control_id = request_media.get('mitigation_control_id')
if mitigation_control_id is None:
errors.append(build_error(Message.ERR_FIELD_CANNOT_BE_NULL, field_name='mitigationControlId'))
elif not session.query(MitigationControl).get(mitigation_control_id):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='mitigationControlId'))
elif find_mitigation_control_in_it_asset(mitigation_control_id, it_asset_instance_id, organization_code, session):
errors.append(build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS, field_name='mitigationControlId'))
# Validate description if informed
# -----------------------------------------------------
description = request_media.get('description')
error = validate_str('description', description, max_length=constants.GENERAL_DESCRIPTION_MAX_LENGTH)
if error:
errors.append(error)
return errors
def validate_post(request_media, organization_code, session):
errors = []
# Validate macroprocess instance id
# -----------------------------------------------------
macroprocess_instance_id = request_media.get('macroprocess_instance_id')
if macroprocess_instance_id is None:
errors.append(build_error(Message.ERR_FIELD_CANNOT_BE_NULL, field_name='macroprocessInstanceId'))
elif not find_organization_macroprocess(macroprocess_instance_id, session):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='macroprocessInstanceId'))
# Validate process id and if it's already in organization macroprocess
# -----------------------------------------------------
process_id = request_media.get('process_id')
if process_id is None:
errors.append(build_error(Message.ERR_FIELD_CANNOT_BE_NULL, field_name='processId'))
elif not session.query(BusinessProcess).get(process_id):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='processId'))
elif find_organization_process(process_id, macroprocess_instance_id, organization_code, session):
errors.append(build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS, field_name='macroprocessInstanceId/processId'))
# Validate relevance level if informed
# -----------------------------------------------------
relevance_level_id = request_media.get('relevance_level_id')
if relevance_level_id and not session.query(RatingLevel).get(relevance_level_id):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='relevanceLevelId'))
return errors
def validate_patch(request_media, session):
errors = []
if not request_media:
errors.append(build_error(Message.ERR_NO_CONTENT))
return errors
# Validate vulnerability level id if informed
# -----------------------------------------------------
if 'vulnerability_level_id' in request_media:
vulnerability_level_id = request_media.get('vulnerability_level_id')
if vulnerability_level_id is None:
errors.append(
build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name='vulnerabilityLevelId'))
elif not session.query(RatingLevel).get(vulnerability_level_id):
errors.append(
build_error(Message.ERR_FIELD_VALUE_INVALID,
field_name='vulnerabilityLevelId'))
return errors
def validate_post(request_media, organization_code, session):
errors = []
# Validate department id in organization
# -----------------------------------------------------
department_id = request_media.get('department_id')
if department_id is None:
errors.append(build_error(Message.ERR_FIELD_CANNOT_BE_NULL, field_name='departmentId'))
elif not find_organization_department(department_id, organization_code, session):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='departmentId'))
# Validate macroprocess id and if it's already in department
# -----------------------------------------------------
macroprocess_id = request_media.get('macroprocess_id')
if macroprocess_id is None:
errors.append(build_error(Message.ERR_FIELD_CANNOT_BE_NULL, field_name='macroprocessId'))
elif not session.query(BusinessMacroprocess).get(macroprocess_id):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='macroprocessId'))
elif find_organization_macroprocess(macroprocess_id, department_id, organization_code, session):
errors.append(build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS, field_name='departmentId/macroprocessId'))
return errors
def validate_post(request_media, session):
errors = []
# Validate name
# -----------------------------------------------------
full_name = request_media.get('full_name')
error = validate_str('fullName',
full_name,
is_mandatory=True,
max_length=constants.GENERAL_NAME_MAX_LENGTH)
if error:
errors.append(error)
# Validate email
# -----------------------------------------------------
email = request_media.get('email')
error = validate_str('email',
email,
is_mandatory=True,
max_length=constants.EMAIL_MAX_LENGTH,
exists_strategy=exists_email(email, session))
if error:
errors.append(error)
# Validate password
# -----------------------------------------------------
password = request_media.get('password')
error = validate_str('password',
password,
is_mandatory=True,
min_length=constants.PASSWORD_MIN_LENGTH)
if error:
errors.append(error)
# Validate roles
# -----------------------------------------------------
roles = request_media.get('roles')
if roles:
# Get the system roles (get scalars from tuples returned)
existing_roles = session.query(SystemRole.id).all()
existing_roles_ids = [role_id for (role_id, ) in existing_roles]
# Check if id informed exists
for idx, role in enumerate(roles):
if role.get('id') not in existing_roles_ids:
field_name = 'role[{}].id'.format(idx)
errors.append(
build_error(Message.ERR_FIELD_VALUE_INVALID,
field_name=field_name))
return errors
def validate_patch(request_media, session):
errors = []
if not request_media:
errors.append(build_error(Message.ERR_NO_CONTENT))
return errors
# Validate name if informed
# -----------------------------------------------------
if 'name' in request_media:
name = request_media.get('name')
error = validate_str('name', name,
is_mandatory=True,
max_length=constants.GENERAL_NAME_MAX_LENGTH,
exists_strategy=exists_name(name, session))
if error:
errors.append(error)
# Validate description if informed
# -----------------------------------------------------
if 'description' in request_media:
description = request_media.get('description')
error = validate_str('description', description, max_length=constants.GENERAL_DESCRIPTION_MAX_LENGTH)
if error:
errors.append(error)
# Validate asset category id if informed
# -----------------------------------------------------
if 'category_id' in request_media:
category_id = request_media.get('category_id')
# Cannot be null if informed and must be valid
if category_id is None:
errors.append(build_error(Message.ERR_FIELD_CANNOT_BE_NULL, field_name='categoryId'))
elif not session.query(ITAssetCategory).get(category_id):
errors.append(build_error(Message.ERR_FIELD_VALUE_INVALID, field_name='categoryId'))
return errors
def validate_post(request_media, organization_code, it_asset_instance_id,
session):
errors = []
# Validate vulnerability level id
# -----------------------------------------------------
vulnerability_level_id = request_media.get('vulnerability_level_id')
if vulnerability_level_id is None:
errors.append(
build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name='vulnerabilityLevelId'))
elif not session.query(RatingLevel).get(vulnerability_level_id):
errors.append(
build_error(Message.ERR_FIELD_VALUE_INVALID,
field_name='vulnerabilityLevelId'))
# Validate security threat id and if it's already in the IT asset vulnerability records
# -----------------------------------------------------
security_threat_id = request_media.get('security_threat_id')
if security_threat_id is None:
errors.append(
build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name='securityThreatId'))
elif not find_organization_security_threat(security_threat_id,
organization_code, session):
errors.append(
build_error(Message.ERR_ORGANIZATION_SECURITY_THREAT_ID_INVALID,
field_name='securityThreatId'))
elif find_it_asset_instance_security_threat(security_threat_id,
it_asset_instance_id,
organization_code, session):
errors.append(
build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS,
field_name='itAssetInstanceId/securityThreatId'))
return errors
def validate_patch(request_media):
errors = []
if not request_media:
errors.append(build_error(Message.ERR_NO_CONTENT))
return errors
# Validate description if informed
# -----------------------------------------------------
if 'description' in request_media:
description = request_media.get('description')
error = validate_str(
'description',
description,
max_length=constants.ANALYSIS_DESCRIPTION_MAX_LENGTH)
if error:
errors.append(error)
return errors
def validate_patch(request_media, session):
errors = []
if not request_media:
errors.append(build_error(Message.ERR_NO_CONTENT))
return errors
# Validate name if informed
# -----------------------------------------------------
if 'full_name' in request_media:
email = request_media.get('full_name')
error = validate_str('fullName',
email,
is_mandatory=True,
max_length=constants.GENERAL_NAME_MAX_LENGTH)
if error:
errors.append(error)
# Validate email if informed
# -----------------------------------------------------
if 'email' in request_media:
email = request_media.get('email')
error = validate_str('email',
email,
is_mandatory=True,
max_length=constants.EMAIL_MAX_LENGTH,
exists_strategy=exists_email(email, session))
if error:
errors.append(error)
# Validate password if informed
# -----------------------------------------------------
if 'password' in request_media:
password = request_media.get('password')
error = validate_str('password',
password,
is_mandatory=True,
min_length=constants.PASSWORD_MIN_LENGTH)
if error:
errors.append(error)
return errors
def validate_patch(request_media, session):
errors = []
if not request_media:
errors.append(build_error(Message.ERR_NO_CONTENT))
return errors
# Validate Tax ID if informed
# -----------------------------------------------------
if 'tax_id' in request_media:
tax_id = request_media.get('tax_id')
error = validate_str('taxId', tax_id,
is_mandatory=True,
max_length=constants.TAX_ID_MAX_LENGTH,
exists_strategy=exists_tax_id(tax_id, session))
if error:
errors.append(error)
# Validate legal name if informed
# -----------------------------------------------------
if 'legal_name' in request_media:
legal_name = request_media.get('legal_name')
error = validate_str('legalName', legal_name,
is_mandatory=True,
min_length=constants.GENERAL_NAME_MIN_LENGTH,
max_length=constants.GENERAL_NAME_MAX_LENGTH,
exists_strategy=exists_legal_name(legal_name, session))
if error:
errors.append(error)
# Validate trade name if informed
# -----------------------------------------------------
if 'trade_name' in request_media:
trade_name = request_media.get('trade_name')
error = validate_str('tradeName', trade_name,
min_length=constants.GENERAL_NAME_MIN_LENGTH,
max_length=constants.GENERAL_NAME_MAX_LENGTH)
if error:
errors.append(error)
return errors
def on_post(self, req, resp, organization_code):
"""Creates a new analysis for the organization considering the already filled values
for relevance, vulnerability and security threat levels in processes, IT services,
IT assets and security threats.
:param req: See Falcon Request documentation.
:param resp: See Falcon Response documentation.
:param organization_code: The code of the organization.
"""
session = Session()
try:
organization = session.query(Organization).get(organization_code)
if organization is None:
raise falcon.HTTPNotFound()
errors = validate_post(req.media)
if errors:
raise HTTPUnprocessableEntity(errors)
scopes = remove_redundant_scopes(req.media.get('scopes'))
accepted_fields = ['description']
item = OrganizationAnalysis().fromdict(req.media,
only=accepted_fields)
item.organization_id = organization_code
item.total_processed_items = process_analysis(
session, item, organization_code, scopes)
if item.total_processed_items == 0:
raise HTTPUnprocessableEntity(
[build_error(Message.ERR_NO_ITEMS_TO_ANALYZE)])
session.add(item)
session.commit()
resp.status = falcon.HTTP_CREATED
resp.location = req.relative_uri + f'/{item.id}'
resp.media = {'data': create_response_asdict(item)}
finally:
session.close()
def validate_post(request_media):
errors = []
if not request_media:
errors.append(build_error(Message.ERR_NO_CONTENT))
return errors
# Validate email
# -----------------------------------------------------
email = request_media.get('email')
error = validate_str('email', email, is_mandatory=True)
if error:
errors.append(error)
return errors
# Validate password
# -----------------------------------------------------
password = request_media.get('password')
error = validate_str('password', password, is_mandatory=True)
if error:
errors.append(error)
return errors
return errors
def validate_str(field_name,
field_value,
is_mandatory=False,
min_length=None,
max_length=None,
exists_strategy=None):
"""Validates a string with general predefined rules.
The string cannot be empty or contain any leading or trailing whitespace.
This rule is always applied as long as the value of the field is informed
and is a string.
:param field_name: The field name to put in error object.
:param field_value: The field value to be validated.
:param is_mandatory: Indicates that the field is mandatory. That means that
an error is returned if value is None.
Default is false.
:param min_length: Minimum length allowed. An error is returned if len(field_value)
is below this value. When None, this validation will be skipped.
Default is None.
:param max_length: Maximum length allowed. An error is returned if len(field_value)
is above this value. When None, this validation will be skipped.
Default is None.
:param exists_strategy: A function that returns True (or something) when
value already exists. If the function returns None or False, the value
is considered new and validation will pass. If function is None, this
validation will be skipped.
Default is None.
Note: The function will not be executed if field value is None.
:return: A dict containing an error code, a message and the field name.
"""
# Field was not informed...
if field_value is None:
if is_mandatory:
return build_error(Message.ERR_FIELD_CANNOT_BE_NULL,
field_name=field_name)
# OK, it's not mandatory.
return None
# Must be of type 'string'
if not isinstance(field_value, str):
return build_error(Message.ERR_FIELD_VALUE_MUST_BE_STRING,
field_name=field_name)
# Cannot be empty (general safe rule whether it's mandatory or not)
if not field_value or field_value.isspace():
return build_error(Message.ERR_FIELD_CANNOT_BE_EMPTY,
field_name=field_name)
# Prevent values with leading or trailing spaces
if len(field_value) != len(field_value.strip()):
return build_error(Message.ERR_FIELD_WITH_LEADING_OR_TRAILING_SPACES,
field_name=field_name)
# Length must be valid
if min_length and len(field_value) < min_length:
return build_error(Message.ERR_FIELD_MIN_LENGTH,
min_length,
field_name=field_name)
if max_length and len(field_value) > max_length:
return build_error(Message.ERR_FIELD_MAX_LENGTH,
max_length,
field_name=field_name)
# Must be unique
if exists_strategy and exists_strategy():
return build_error(Message.ERR_FIELD_VALUE_ALREADY_EXISTS,
field_name=field_name)
