def validate_rate(rate):
if rate is None:
return None
if not isinstance(rate, (int, float)):
raise InvalidEntityException(source='validator',
code='invalid_rate',
message="Invalid type for rate")
if rate < 0:
raise InvalidEntityException(source='validator',
code='invalid_rate',
message="Negative rate")
def validate(self, username, user=None):
if len(username) > self.max_len:
raise InvalidEntityException(
source='username',
code='not_allowed',
message="Your username is too long. Max allowed length is %d."
% self.max_len)
def _validate_project_payment(self, type_of_payment, eq_type_of_payment):
if type_of_payment != eq_type_of_payment:
raise InvalidEntityException(
source='validate',
code='other_type_of_payment',
message="The type of payment for the project must be %s" %
eq_type_of_payment)
def validate_type_of_payment(type_of_payment):
if type_of_payment not in ('T_P', 'M_P', 'H_P'):
raise InvalidEntityException(
source='validator',
code='other_type_of_payment',
message=
"The type of payment must be only one of T_P, H_P and M_P")
def validate(self, username, user=None):
if len(username) < self.min_len:
raise InvalidEntityException(
source='username',
code='not_allowed',
message="Your username must contain at least %d character." %
self.min_len)
def validate(self, password, user=None):
if self.min_len > len(password):
raise InvalidEntityException(
source='password',
code='not_allowed',
message="Your password must contain at least %d character." %
self.min_len)
def validate_date_format(date_string):
if date_string is None:
return None
try:
return datetime.datetime.strptime(date_string, DATE_FORMAT)
except:
raise InvalidEntityException(source='validator',
code='invalid_format',
message="Invalid date format")
def create(self, hour_payment):
try:
db_hour_payment = HourPaymentORM.objects.create(
project_id=hour_payment.project_id, rate=hour_payment.rate)
except Exception as e:
raise InvalidEntityException(source='entity',
code='not_null',
message=str(e))
return self._decode_db_hour_payment(db_hour_payment)
def validate(value, user=None, validators=None):
errors = []
for validator in validators:
try:
validator.validate(value, user)
except Exception as error:
errors.append(error)
if errors:
raise InvalidEntityException(source='validate',
code='not_allowed',
message=str(errors[0]))
def create(self, work_time):
try:
db_work_time = WorkTimeORM.objects.create(
hour_payment_id=work_time.hour_payment_id,
start_work=work_time.start_work,
end_work=work_time.end_work,
paid=work_time.paid)
return self._decode_db_work_time(db_work_time)
except Exception as e:
raise InvalidEntityException(source='entity',
code='not_null',
message=str(e))
def validate(self, password, user=None):
if not user:
return
for attr_name in self.user_attrs:
value = getattr(user, attr_name, None)
if not value or not isinstance(value, str):
continue
value_parts = re.split(r'\W', value) + [value]
for part in value_parts:
if SequenceMatcher(None, a=password.lower(), b=part.lower()) \
.quick_ratio() >= self.max_similarity:
raise InvalidEntityException(source='password', code='not allowed', \
message="Your password is too similar to your other fields.")
def validate(self, password, user=None):
if password.isdigit():
raise InvalidEntityException(source='password', code='not allowed', \
message="Your password consists of only digits.")
def validate(self, email, user=None):
if email.split('@')[-1] in self.forbidden_email_domains:
raise InvalidEntityException(source='email',
code='not_allowed',
message='Email not allowed')
def validate(self, email, user=None):
if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
raise InvalidEntityException(source='email',
code='not_allowed',
message="Invalid email address")
def validate(self, username, user=None):
if not re.match(self.username_regex, username):
raise InvalidEntityException(source='username',
code='not_allowed',
message='Username not allowed')
def validate(self, password, user=None):
for sequence in self.common_sequences:
if password in sequence:
raise InvalidEntityException(source='password', code='not allowed', \
message="Your password is a common sequence.")
def validate(self, username, user=None):
if username.lower() in self.forbidden_usernames:
raise InvalidEntityException(source='username',
code='not_allowed',
message='Username not allowed')