def verify_parameter_uniquesness(sender, **kwargs):
parameter = kwargs.get('instance', None)
if not isinstance(parameter, AbstractInteractionParameter):
return
cls = type(parameter)
compounds_set = kwargs.get('pk_set', None)
action = kwargs.get('action', None)
if action in ('pre_add', ):
if parameter.compounds.all().distinct().count() == 2:
raise IntegrityError(
'This interaction parameter has its compounds '
'already defined')
if len(compounds_set) == 2:
compounds = list(compounds_set)
qs = cls.objects.filter(
compounds__id=compounds[0],
eos=parameter.eos).filter(compounds__id=compounds[1])
else:
qs = cls.objects.filter(compounds__in=parameter.compounds.all()).\
filter(compounds__id__in=compounds_set, eos=parameter.eos)
if parameter.setup:
qs = qs.filter(setup=parameter.setup)
else:
qs = qs.filter(setup__isnull=True)
if parameter.user:
qs = qs.filter(user=parameter.user)
else:
qs = qs.filter(user__isnull=True)
if qs.exists():
raise IntegrityError(
'Already exists a parameter matching these condition')
def save(self):
'''
Speichert das Objekt ab. Zuvor wird eine Reihe von Validierungen durchgeführt.
Validierungen:
* Name innerhalb des Projekts nicht eindeutig.
* Fälligkeitsdatum liegt in der Vergangenheit.
* Projekt ist bereits geschlossen.
.. throws: IntegrityError Falls eine der Validierungen fehlschlägt.
'''
if Aufgabe.objects.filter(titel=self.titel, projekt=self.projekt).exclude(pk=self.pk).count() != 0:
raise IntegrityError(c.FEHLER_AUFGABE_NAME)
if self.faelligkeitsDatum < timezone.now():
raise IntegrityError(c.FEHLER_AUFGABE_DATUM)
if self.projekt.status == c.PROJEKT_STATUS_CL:
raise IntegrityError(c.FEHLER_AUFGABE_PROJEKTSTATUS)
if self.bearbeiter and self.status == c.AUFGABE_STATUS_OP:
self.status = c.AUFGABE_STATUS_IP
if not self.bearbeiter and self.status == c.AUFGABE_STATUS_IP:
self.status = c.AUFGABE_STATUS_OP
super(Aufgabe, self).save()
def validating_students(sender, **kwargs):
action = kwargs.get('action')
reverse = kwargs.get('reverse')
if action == 'pre_add':
if reverse:
student = kwargs.get('instance')
dsessions = kwargs.get('pk_set')
college = student.college
for dsession in dsessions:
dsession = DummySession.objects.get(pk=dsession)
if dsession.dummy_company.college != college:
raise IntegrityError(
_('Student doesn\'t belong to this college, thus cannot be added to the session.'
))
else:
dsession = kwargs.get('instance')
students = kwargs.get('pk_set')
college = dsession.dummy_company.college
for student in students:
student = Student.studying.get(
pk=student
) # Only currently studying students can be added to a session
if student.college != college:
raise IntegrityError(
_('Student %s doesn\'t belong to this college, thus cannot be added to the session.'
% (student.profile.username)))
def clean(self):
super().clean(self)
if self.bookmark is None:
if self.comment is None:
raise IntegrityError(
'A like must be made to either a bookmark or comment')
elif self.comment is not None:
raise IntegrityError(
'A like cannot be made to both a bookmark and a comment')
def validate_requester(sender, **kwargs):
requester = kwargs.get('instance')
user = requester.requester
if user.type not in ['C', 'CO', 'F']:
raise IntegrityError('This user type is not allowed to create download requestes')
batch = requester.requested.batch
if user.type == 'CO':
if not user.company.associations.filter(college=batch.college, approved=True).exists():
raise IntegrityError('The company requesting doesn\'t have any session with requested college')
def clean(self, *args, **kwargs):
super(SelectionCriteria, self).clean()
years = self.years.split(',')
for each in years:
if not each and len(years) > 1:
raise IntegrityError(_('There must not be any spaces in the years.'))
elif len(each) > 1:
raise IntegrityError(_('Make sure the year is entered in the proper desired format'))
elif each.isalpha() and int(each) > 6:
raise IntegrityError(_('Maximum year value can be 6.'))
def validate_student(sender, **kwargs):
student = kwargs.pop('instance')
college = student.college
course = student.course
if college and course:
if not college.courses.filter(pk=course.pk):
raise IntegrityError(_("Invalid college and course options."))
elif int(student.year) > int(student.course.max_years):
raise IntegrityError(
_("Invalid current year. Exceeds the max duration offered by the course."
))
def make_unique_violation():
"""Make a serialization exception.
Artificially construct an exception that resembles what Django's ORM would
raise when PostgreSQL fails a transaction because of a unique violation.
:returns: an instance of :py:class:`IntegrityError` that will pass the
`is_unique_violation` predicate.
"""
exception = IntegrityError()
exception.__cause__ = UniqueViolation()
assert is_unique_violation(exception)
return exception
def enforce_blacklist(sender, instance, **kwargs):
"""
Prevents certain usernames from being created
Checks usernmames against settings.BLACKLISTED_USERNAMES
"""
if instance is not None:
username = instance.username.lower()
if not username:
raise IntegrityError("Username required.")
if username in [x.lower() for x in settings.BLACKLISTED_USERNAMES]:
raise IntegrityError(
"Failed to create user. The name {0} is reserved"
"for DataHub use.".format(username))
def validating_students(sender, **kwargs):
session = kwargs.get('instance', None)
action = kwargs.get('action', None)
reverse = kwargs.get('reverse')
if action == 'pre_add' and not reverse: # Validation when reverse=True, i.e. student has applied using the form, is taken care of in the views
# Validating if the admin adds incorrectly
students = kwargs.get('pk_set', None)
for student in students:
student = Student.studying.get(pk=student) # Only currently studying students can be addded to a session
if student.college != session.association.college:
raise IntegrityError(_('Student %s doesn\'t belong to this college, thus cannot be added to the session.'))
if not session.association.streams.filter(pk=student.stream.pk).exists():
raise IntegrityError(_('Student %s doesn\'t belong to this programme, thus cannot be added to the session.'))
def comment_block(request, object):
"""
Returns the info needed to be used with the comments template
Params:
request: The request instance
object: The object to comment on (for instance an Event)
"""
if 'new_comment' in request.POST:
comment_form = CommentForm(object, request.POST)
if comment_form.is_valid():
comment = comment_form.save(commit=False)
comment.user = request.user
comment.save()
comment_form = CommentForm(object)
request.message_success(_("Comment added successfully!"))
else:
comment_form = CommentForm(object)
try:
object.comments
except:
raise IntegrityError(
"Models using comments should have a generic relation named 'comments' to the Comment model!"
)
return {'form': comment_form, 'list': object.comments.all()}
def signup(request):
if request.method == 'POST':
try:
req_data = json.loads(request.body.decode())
username = req_data["username"]
email = req_data["email"]
password = req_data["password"]
role = req_data["role"]
except (KeyError, JSONDecodeError) as error:
return HttpResponseBadRequest(error)
try:
same_name = User.objects.filter(username=username).count()
same_email = User.objects.filter(email=email).count()
if same_name > 0 or same_email > 0:
raise IntegrityError()
user = User.objects.create_user(
username=username, email=email, salt="", role=role, password=password)
if role == User.Role.Coder:
Coder(user=user).save()
elif role == User.Role.Manager:
Manager(user=user).save()
elif role == User.Role.Researcher:
Researcher(user=user).save()
except IntegrityError:
return HttpResponse(status=409)
return HttpResponse(status=201)
return HttpResponseNotAllowed(['POST'])
def cart_pre_save(sender, instance, **kwargs):
# There can only be one active (uncheckedout) cart
try:
cart = Cart.objects.filter(user=instance.user, checked_out=False)
if cart.count() > 1: raise IntegrityError('This user already have an active cart')
except Cart.DoesNotExist:
pass
def save_return_table(self, table_name, table_rows, request):
"""
Persist Return Table of data to database.
:param table_name:
:param table_rows:
:param request:
:return:
"""
try:
# wrap atomic context here to allow natural handling of a Record
# Modified concurrent error. (optimistic lock)
# get the Return Table record and save immediately to check if
# it has been concurrently modified.
return_table, created = ReturnTable.objects.get_or_create(
name=table_name, ret=self)
return_table.save()
# delete any existing rows as they will all be recreated
return_table.returnrow_set.all().delete()
return_rows = [
ReturnRow(return_table=return_table, data=row)
for row in table_rows
]
ReturnRow.objects.bulk_create(return_rows)
# log transaction
self.log_user_action(
ReturnUserAction.ACTION_SAVE_REQUEST.format(self), request)
except RecordModifiedError:
raise IntegrityError(
'A concurrent save occurred please refresh page details.')
except BaseException:
raise
def check_restrictions_multiple_voters(voting_id, voters):
"""
This method checks all the conditions that must be satisfied in order for the census objects to be created:
1. The voting id must exist.
2. All the voters ids must exist.
3. All the census objects must not already exist in the database.
4. All the voters must pass the voting age and gender restricctions if any.
:return: True if all conditions are passed, an Exception is raised otherwise.
"""
# This will fail if any of the elements does not exist
voting = Voting.objects.get(id=voting_id)
users = []
invalid_ids = []
for voter_id in voters:
try:
users.append(User.objects.get(id=voter_id))
except ObjectDoesNotExist:
invalid_ids.append(voter_id)
if len(invalid_ids) > 0:
raise ValidationError(
'The following user IDs aren\'t valid: {}'.format(invalid_ids))
for user in users:
if Census.objects.filter(voting_id=voting_id,
voter_id=user.id).count():
raise IntegrityError(
'The user "{}" with id "{}" is already in this census'.
format(user.username, user.id))
Census.gender_and_age(voting, user)
return True
def check_restrictions_multiple_voters(voting_id, voters):
"""
This method checks all the conditions that must be satisfied in order for the census objects to be created:
1. The voting id must exist.
2. All the voters ids must exist.
3. All the census objects must not already exist in the database.
4. All the voters must pass the voting age and gender restricctions if any.
:return: True if all conditions are passed, an Exception is raised otherwise.
"""
# This will fail if any of the elements does not exist
voting = Voting.objects.get(id=voting_id)
users = [User.objects.get(id=voter_id) for voter_id in voters]
for voter_id in voters:
if Census.objects.filter(voting_id=voting_id,
voter_id=voter_id).count():
raise IntegrityError(
'Conflict: The census (voting_id:{},voter_id:{}) already exists'
.format(voting_id, voter_id))
for user in users:
Census.gender_and_age(voting, user)
return True
def save(self, *args, **kwargs): # pylint: disable=arguments-differ
if APP.valid_objects.filter(uid=self.uid).exclude(pk=self.pk).exists():
msg = "UNIQUE constraint failed: " \
"oneid_meta.APP UniqueConstraint(fields=['uid'], condition=Q(is_del='False')"
raise IntegrityError(msg)
super(APP, self).save(*args, **kwargs)
def update(self,
filename=None,
batch_id=None,
prev_batch_id=None,
producer=None,
count=None):
"""Creates an history model instance.
"""
# TODO: refactor model enforce unique batch_id
# TODO: refactor model to not allow NULLs
if not filename:
raise BatchHistoryError('Invalid filename. Got None')
if not batch_id:
raise BatchHistoryError('Invalid batch_id. Got None')
if not prev_batch_id:
raise BatchHistoryError('Invalid prev_batch_id. Got None')
if not producer:
raise BatchHistoryError('Invalid producer. Got None')
if self.exists(batch_id=batch_id):
raise IntegrityError('Duplicate batch_id')
try:
obj = self.model.objects.get(batch_id=batch_id)
except self.model.DoesNotExist:
obj = self.model(filename=filename,
batch_id=batch_id,
prev_batch_id=prev_batch_id,
producer=producer,
total=count)
obj.transaction_file.name = filename
obj.save()
return obj
def clean(self):
for player in self.players.all():
if Team.objects.filter(league=self.league).exclude(
id=self.pk).filter(players__name=player.name):
raise IntegrityError(
'%s is already on a team in this league: %s' %
(player.name, self.name))
def _make_result(self, entity, fields):
"""
Decodes values for the given fields from the database entity.
The entity is assumed to be a dict using field database column
names as keys. Decodes values using `value_from_db` as well as
the standard `convert_values`.
"""
result = []
for field in fields:
value = entity.get(field.column, NOT_PROVIDED)
if value is NOT_PROVIDED:
value = field.get_default()
else:
value = self.ops.value_from_db(value, field)
# This is the default behavior of ``query.convert_values``
# until django 1.8, where multiple converters are a thing.
value = self.connection.ops.convert_values(value, field)
if hasattr(field, "from_db_value"):
value = field.from_db_value(value, None, self.connection,
None)
if value is None and not field.null:
raise IntegrityError("Non-nullable field %s can't be None!" %
field.name)
result.append(value)
return result
def execute_sql(self, return_id=False):
field_values = {}
pk = self.query.get_meta().pk
for (field, value), column in zip(self.query.values,
self.query.columns):
# Raise an exception for non-nullable fields without a value.
if field is not None:
if not field.null and value is None:
raise IntegrityError("You can't set %s (a non-nullable "
"field) to None!" % field.name)
# Use the primary key field when our sql.Query provides a
# value without a field.
if field is None:
field = pk
assert field.column == column
assert field not in field_values
# Prepare value for database, note that query.values have
# already passed through get_db_prep_save.
value = self.ops.value_for_db(value, field)
field_values[field] = value
key = self.insert(field_values, return_id=return_id)
# Pass the key value through normal database deconversion.
return self.ops.convert_values(self.ops.value_from_db(key, pk), pk)
def users(replace: bool = False,
ignore_errors: bool = False) -> Dict[str, str]:
"""Initializes users preconfigured in 'accounts.yaml' in the 'configs' directory
See the '_users_output' function for how the emails and passwords are stored
:param replace: Replace existing users with the ones specified in the init configuration
:param ignore_errors: Ignore errors and continue the initialization process
:return: A dictionary containing new superusers' username as keys and passwords as values
"""
user_list = dict()
if 'users' in configs.resolve('accounts.init'):
for user_config in configs.resolve('accounts.init.users'):
try:
if replace:
try:
user = CustomUser.objects.get_by_natural_key(
user_config['username'])
user.delete()
verbose.warn("User '%s' found and deleted" %
user_config['username'])
except ObjectNotFound:
pass
user = CustomUser.objects.create_user(user_config['username'],
user_config['email'],
user_config['password'])
if 'groups' in user_config:
user.groups.set([
Group.objects.get_by_natural_key(g)
for g in user_config['groups']
])
if 'permissions' in user_config:
user.user_permissions.set([
Permission.objects.get(codename=p)
for p in user_config['permissions']
])
[
setattr(user, k, v) for k, v in user_config.items()
if k not in ('username', 'password', 'email', 'groups',
'permissions')
]
user.save()
user_list[user_config['email']] = user_config['password']
except IntegrityError:
message = "User '%s' or email '%s' already exists" % (
user_config['username'], user_config['email'])
if ignore_errors:
verbose.error(message)
else:
raise IntegrityError(message)
_users_output(user_list, 'users')
return user_list
def siswa_pre_save(sender, instance, **kwargs):
try:
siswa = Siswa.objects.filter(Q(nis=instance.nis) | Q(nisn=instance.nisn))
if siswa and instance not in siswa:
raise IntegrityError('NIS or NISN must be unique.')
except ObjectDoesNotExist:
pass
def create_provider(provider):
"""
Creating HostProvider object
:param provider: HostProvider object in dictionary format
:type provider: dict
:return: HostProvider object
:rtype: models.HostProvider
"""
bundle_hash = provider.pop('bundle_hash')
ex_id = provider.pop('id')
try:
same_name_provider = HostProvider.objects.get(name=provider['name'])
if same_name_provider.prototype.bundle.hash != bundle_hash:
raise IntegrityError(
'Name of provider already in use in another bundle')
create_file_from_config(same_name_provider, provider['config'])
return ex_id, same_name_provider
except HostProvider.DoesNotExist:
prototype = get_prototype(bundle_hash=bundle_hash, type='provider')
config = provider.pop('config')
provider = HostProvider.objects.create(prototype=prototype,
config=create_config(config),
**provider)
create_file_from_config(provider, config)
return ex_id, provider
def clone(self, user):
''' clone this map for a specific user '''
usermap = Map.objects.filter(name=self.name, user=user).first()
if usermap:
raise IntegrityError('Map already exists.')
# query groups and evaluate queryset
groups = list(self.group_set.all())
# clone ourselves
usermap = self
usermap.pk = None
usermap.user = user
usermap.save()
# clone groups and layers
for group in groups:
# query layers and evaluate queryset
layers = list(group.layer_set.all())
group.pk = None
group.map = usermap
group.save()
for layer in layers:
layer.pk = None
layer.map = usermap
layer.group = group
layer.save()
return usermap
def set_id_random(account, tries=3):
'''
Attempt to generate and save unique account.id_random
:param int tries: to generate unique id_random field (> 0)
'''
if account.id_random:
return
id_rand = False
# make sure we do not overwrite existing id with new one
if account.pk:
checked_data = account.__class__.objects.values('id_random').get(
pk=account.pk)
if checked_data and 'id_random' in checked_data:
id_rand = checked_data['id_random']
if not id_rand:
# Try to generate unique `id_random` field
for i in range(tries):
id_rand = id_random()
if not account.__class__.objects.filter(
id_random=id_rand).exists():
break
else:
error = "Could not produce unique ID for {0} model.".format(
type(account))
raise IntegrityError(error)
account.id_random = id_rand
def create_module(self, module_code, module_name, module_credits,
module_level, semester, delivery_language,
module_leader):
"""
Method to create a module model
"""
# ensure that module leader is not None
if module_leader is None:
raise IntegrityError("Module Leader cannot be None")
# check that credits do not exceed ranges
if module_credits < 10 or module_credits > 120:
raise ValueError(
"Module credits must be between 10 to 120 credits")
model = self.model.objects.create(module_code=module_code,
module_name=module_name,
module_credits=module_credits,
module_level=module_level,
semester=semester,
delivery_language=delivery_language,
module_leader=module_leader)
module_leader.is_module_leader = True
module_leader.save()
return model
def get_prep_value(self, value: LocalizedIntegerValue) -> dict:
"""Gets the value in a format to store into the database."""
# apply default values
default_values = LocalizedIntegerValue(self.default)
if isinstance(value, LocalizedIntegerValue):
for lang_code, _ in settings.LANGUAGES:
local_value = value.get(lang_code)
if local_value is None:
value.set(lang_code, default_values.get(lang_code, None))
prepped_value = super().get_prep_value(value)
if prepped_value is None:
return None
# make sure all values are proper integers
for lang_code, _ in settings.LANGUAGES:
local_value = prepped_value[lang_code]
try:
if local_value is not None:
int(local_value)
except (TypeError, ValueError):
raise IntegrityError(
'non-integer value in column "%s.%s" violates '
"integer constraint" % (self.name, lang_code))
# convert to a string before saving because the underlying
# type is hstore, which only accept strings
prepped_value[lang_code] = (str(local_value)
if local_value is not None else None)
return prepped_value
def execute_sql(self, return_id=False):
self.pre_sql_setup()
to_insert = []
pk_field = self.query.get_meta().pk
for obj in self.query.objs:
field_values = {}
for field in self.query.fields:
value = field.get_db_prep_save(
getattr(obj, field.attname) if self.query.raw else
field.pre_save(obj, obj._state.adding),
connection=self.connection)
if value is None and not field.null and not field.primary_key:
raise IntegrityError("You can't set %s (a non-nullable "
"field) to None!" % field.name)
# Prepare value for database, note that query.values have
# already passed through get_db_prep_save.
value = self.ops.value_for_db(value, field)
field_values[field.column] = value
to_insert.append(field_values)
key = self.insert(to_insert, return_id=return_id)
# Pass the key value through normal database deconversion.
return self.ops.convert_values(self.ops.value_from_db(key, pk_field),
pk_field)
def create_user_db_and_data_folder_if_needed(sender, instance, **kwargs):
"""
Creates a Postgres role and db and data folder to go with new Django users.
Raises an exception if the role, database, or user data folder exists
before this user.
"""
username = instance.username
hashed_password = instance.password
# The Django user doesn't exist yet, so we can't just try to create a
# DataHubManager connection as the user. We need to act as the db
# superuser and check for any existing db role or database.
db_exists = DataHubManager.database_exists(username)
user_exists = DataHubManager.user_exists(username)
user_data_folder_exists = DataHubManager.user_data_folder_exists(username)
if db_exists and user_exists and user_data_folder_exists:
# Make sure new users don't inherit orphaned roles or databases that
# are missing a matching Django user.
try:
User.objects.get(username=username)
except User.DoesNotExist:
raise IntegrityError("Failed to create user. That name is already"
" in use by an orphaned user.")
elif not db_exists and not user_exists and not user_data_folder_exists:
try:
DataHubManager.create_user(username=username,
password=hashed_password)
except OperationalError:
raise
else:
raise Exception("Failed to create user. That name is already"
" in use by either a role, database, or data folder.")
