def add_submission_number(self):
self.submission_number = models.F("submission_number") + 1
self.save()
def store(cls, request):
obj = cls.get_obj(request)
obj.attempt = models.F('attempt') + 1
obj.save() #update_fields=['attempt']
def inc_completed_count(self):
self.completed_count = models.F('completed_count') + 1
self.save()
def delete(self, *args, **kwargs):
fields_after = self.form.fields.filter(order__gte=self.order)
fields_after.update(order=models.F("order") - 1)
super(Field, self).delete(*args, **kwargs)
def test_invalid_check_types(self):
msg = (
'CheckConstraint.check must be a Q instance or boolean expression.'
)
with self.assertRaisesMessage(TypeError, msg):
models.CheckConstraint(check=models.F('discounted_price'), name='check')
def test_negative_values(self):
p = PositiveIntegerModel.objects.create(value=0)
p.value = models.F('value') - 1
with self.assertRaises(IntegrityError):
p.save()
def remove_point(self, point):
self.point = models.F('point') - point
self.save()
def increment(self, amount=1):
self.current = models.F('current') + amount
def get(self, request, version=None):
project_query = request.GET.get('projects')
fields_query = request.GET.get('fields')
projects = Project.get_for_member(request.user)
if project_query:
projects = projects.filter(id__in=project_query.split(','))
fields = None
if fields_query:
fields = fields_query.split(',')
options = {}
project_filter = models.Q(project__in=projects)
options['lead_group'] = [
{
'key': group.id,
'value': group.title,
} for group in LeadGroup.objects.filter(project_filter).distinct()
] if (fields is None or 'lead_group' in fields) else []
options['assignee'] = [{
'key': user.id,
'value': user.profile.get_display_name(),
} for user in _filter_users_by_projects_memberships(
User.objects.all(),
projects,
).prefetch_related('profile').distinct()] if (
fields is None or 'assignee' in fields) else []
options['confidentiality'] = [{
'key': c[0],
'value': c[1],
} for c in Lead.Confidentiality.choices]
options['status'] = [{
'key': s[0],
'value': s[1],
} for s in Lead.Status.choices]
options['priority'] = [{
'key': s[0],
'value': s[1],
} for s in Lead.Priority.choices]
options['project'] = [{
'key': project.id,
'value': project.title,
} for project in projects.distinct()] if (
fields is None or 'projects' in fields) else []
# Create Emm specific options
options['emm_entities'] = EMMEntity.objects.filter(
lead__project__in=projects).distinct().values('name').annotate(
total_count=models.Count('lead'),
label=models.F('name'),
key=models.F('id'),
).values('key', 'label', 'total_count').order_by('name')
options['emm_keywords'] = LeadEMMTrigger.objects.filter(
lead__project__in=projects).values('emm_keyword').annotate(
total_count=models.Sum('count'),
key=models.F('emm_keyword'),
label=models.F('emm_keyword')).order_by('emm_keyword')
options['emm_risk_factors'] = LeadEMMTrigger.objects.filter(
~models.Q(emm_risk_factor=''),
~models.Q(emm_risk_factor=None),
lead__project__in=projects,
).values('emm_risk_factor').annotate(
total_count=models.Sum('count'),
key=models.F('emm_risk_factor'),
label=models.F('emm_risk_factor'),
).order_by('emm_risk_factor')
# Add info about if the project has emm leads, just check if entities or keywords present
options['has_emm_leads'] = (not not options['emm_entities']) or (
not not options['emm_keywords'])
options['organization_types'] = [{
'key': organization_type.id,
'value': organization_type.title,
} for organization_type in OrganizationType.objects.all()]
return response.Response(LegacyLeadOptionsSerializer(options).data)
def enroll_user_and_require_2fa(self, user, organization):
TotpInterface().enroll(user)
organization.update(
flags=models.F('flags').bitor(Organization.flags.require_2fa))
assert organization.flags.require_2fa.is_set
def __delitem__(self, idx):
exercise = self[idx]
self.exercises.filter(order__gt=exercise.order).update(
order=models.F('order') - 1)
exercise.delete()
def delete(self, *args, **kwargs):
fields_after = self.form.fields.filter(order__gte=self.order)
fields_after.update(order=models.F("order") - 1)
DocumentSetFieldEntry.objects.filter(field_id=self.id).delete()
super(DocumentSetFormField, self).delete(*args, **kwargs)
def devalue_hotness(self, factor=1.0):
"""Devalue hot count for all stories."""
hot_stories = self.filter(hot_count__gte=1)
hot_stories.update(hot_count=(models.F('hot_count') - 1) * factor)
cold_stories = self.filter(hot_count__gt=0, hot_count__lt=1)
cold_stories.update(hot_count=0)
def add_score(self, this_time_score, last_time_score=None):
last_time_score = last_time_score or 0
self.total_score = models.F(
"total_score") - last_time_score + this_time_score
self.save()
def copy_date_done_to_date_created(apps, schema_editor):
TaskResult = apps.get_model('django_celery_results', 'taskresult')
db_alias = schema_editor.connection.alias
TaskResult.objects.using(db_alias).all().update(
date_created=models.F('date_done'))
def post(self, request, version=None):
serializer = LeadOptionsBodySerializer(data=request.data)
serializer.is_valid(raise_exception=True)
fields = serializer.data
projects_id = fields['projects']
lead_groups_id = fields['lead_groups']
organizations_id = fields['organizations']
members_id = fields['members']
emm_entities = fields['emm_entities']
emm_keywords = fields['emm_keywords']
emm_risk_factors = fields['emm_risk_factors']
organization_type_ids = fields['organization_types']
projects = Project.get_for_member(request.user).filter(
id__in=projects_id, )
if not projects.exists():
raise exceptions.NotFound('Provided projects not found')
project_filter = models.Q(project__in=projects)
members_qs = User.objects.filter(
id__in=members_id) if len(members_id) else User.objects
options = {
'projects': projects,
# Static Options
'confidentiality': [
{
'key': c[0],
'value': c[1],
} for c in Lead.Confidentiality.choices
],
'status': [
{
'key': s[0],
'value': s[1],
} for s in Lead.Status.choices
],
'priority': [
{
'key': s[0],
'value': s[1],
} for s in Lead.Priority.choices
],
# Dynamic Options
'lead_groups': LeadGroup.objects.filter(project_filter, id__in=lead_groups_id).distinct(),
'members': _filter_users_by_projects_memberships(members_qs, projects)\
.prefetch_related('profile').distinct(),
'organizations': Organization.objects.filter(id__in=organizations_id).distinct(),
# EMM specific options
'emm_entities': EMMEntity.objects.filter(
lead__project__in=projects,
name__in=emm_entities,
).distinct().values('name').annotate(
total_count=models.Count('lead'),
label=models.F('name'),
key=models.F('id'),
).values('key', 'label', 'total_count').order_by('name'),
'emm_keywords': LeadEMMTrigger.objects.filter(
emm_keyword__in=emm_keywords,
lead__project__in=projects
).values('emm_keyword').annotate(
total_count=models.Sum('count'),
key=models.F('emm_keyword'),
label=models.F('emm_keyword')
).values('key', 'label', 'total_count').order_by('emm_keyword'),
'emm_risk_factors': LeadEMMTrigger.objects.filter(
emm_risk_factor__in=emm_risk_factors,
lead__project__in=projects,
).values('emm_risk_factor').annotate(
total_count=models.Sum('count'),
key=models.F('emm_risk_factor'),
label=models.F('emm_risk_factor'),
).order_by('emm_risk_factor'),
'has_emm_leads': (
EMMEntity.objects.filter(lead__project__in=projects).exists() or
LeadEMMTrigger.objects.filter(lead__project__in=projects).exists()
),
'organization_types': OrganizationType.objects.filter(id__in=organization_type_ids).distinct(),
}
return response.Response(LeadOptionsSerializer(options).data)
def save(self, *args, **kwrags):
self.points or self._set_points()
if not self.pk:
CustomUser.objects.filter(pk=self.user.pk).update(
award_points=models.F('award_points') + self.points)
return super(Awards, self).save(*args, **kwrags)
def total(self):
aggregate_queryset = self.items.aggregate(
total=models.Sum(models.F('price') * models.F('quantity'),
output_field=models.DecimalField()))
return aggregate_queryset['total']
def add_point(self, point):
self.point = models.F('point') + point
self.save()
def total(self, cart_key):
aggregate_queryset = CartItem.objects.filter(
cart_key=cart_key).aggregate(
total=models.Sum(models.F('price') * models.F('quantity'),
output_field=models.DecimalField()))
return float(aggregate_queryset['total'] or 0)
def decrease_count(self):
"""Decrease flag count and save the model """
self.refresh_from_db()
field = 'count'
self.count = models.F(field) - 1
self.save(update_fields=[field])
def release_populate_last_modified_forwards(apps, schema_editor):
Release = apps.get_model('releng', 'Release')
Release.objects.update(last_modified=models.F('created'))
def get_leaves(self, model: Type[models.Model] = None):
'''
Leaf nodes correspond to concrete models
'''
return self.get_descendants(model).filter(rgt=models.F('lft') + 1)
def with_total_value(self):
return self.annotate(total_value=models.Count('guest') * models.F('unit_price'))
def forwards(self, orm):
db.rename_column('sharing_afp_share', 'afp_noadouble', 'afp_adouble')
orm.AFP_Share.objects.all().update(
afp_adouble=not models.F('afp_adouble'))
def _rate_value_condition(self, value):
return models.Case(
models.When(ratings__value=value, then=models.F('ratings__id')),
output_field=models.IntegerField()
)
def inc_taken_count(self):
self.taken_count = models.F('taken_count') + 1
self.save()
def with_dencity(self):
return self.annotate(dencity=models.F('population') / models.F('area'))
def dec_completed_count(self):
self.completed_count = models.F('completed_count') - 1
self.save()
def add_accepted_problem_number(self):
self.accepted_number = models.F("accepted_number") + 1
self.save()
