def filter_header(queryset: QuerySet, field_name: str, values: str):
"""
Returns a desired lookup for a DicomHeader field.
Parameters
----------
queryset : :class:`~django.db.models.QuerySet`
The filtered queryset
field_name : str
The name of the field the queryset is being filtered by
values : dict
The fields and values to filter by
"""
if not values:
return queryset
series_all = queryset.all()
values_json = json.loads(values)
series_ids = []
for series in series_all:
header = series.image_set.first().header.instance
result = validation.run_checks(values_json, header)
if result:
series_ids.append(series.id)
return queryset.filter(id__in=series_ids).all()
def optimized_resolve(
info: graphql.ResolveInfo,
queryset: djm.QuerySet,
**kwargs,
) -> dict:
"""Resolve django queryset base on query selection.
And prime dataloader cache.
Args:
info (graphql.ResolveInfo): Resolve info.
queryset (djm.QuerySet): Queryset to resolve.
Returns:
dict: Connection resolve result.
"""
qs = qs_.optimize(queryset.all(), info)
ret = resolve(qs, **kwargs)
def _prime_nodes(v):
for i in v:
# Prime dataloader cache
Resolver(info=info).resolve_gid(i)
return v
nodes = ret['nodes']
ret['nodes'] = lazy.Proxy(lambda: _prime_nodes(nodes))
return ret
def retry_all(qs: QuerySet) -> bool:
for delay in (0.5, 1, 2, 4, None):
result = all(qs.all())
if result:
return result
elif delay:
time.sleep(delay)
else:
return False
def accept_entries(user_id: int, queryset: QuerySet) -> int:
"""
Accept all entries in the queryset
:param user_id: Id of the user executing this action
:param queryset: queryset of entries
:type queryset: Queryset[Entry]
:return: number of updated rows
:rtype: integer
"""
queryset = queryset.filter(status=Entry.STATUS_REVIEW)
entries = queryset.all()
updated_entries = []
for entry in entries:
# Check if the user is unique
if not check_unique_user(entry):
# User is not unique, do not proceed
continue
entry.status = Entry.STATUS_ACCEPTED
entry.updated_at = timezone.now()
entry.payment = _create_payment_for_entry(entry)
log_obj = None
try:
if entry.registration.username is None:
entry.registration.username = _generate_username(
entry.registration)
entry.registration.save()
emails.send_registration_accepted_message(entry.registration,
entry.payment)
log_obj = entry.registration
except Registration.DoesNotExist:
try:
emails.send_renewal_accepted_message(entry.renewal,
entry.payment)
log_obj = entry.renewal
except Renewal.DoesNotExist:
pass
if log_obj:
LogEntry.objects.log_action(
user_id=user_id,
content_type_id=get_content_type_for_model(log_obj).pk,
object_id=log_obj.pk,
object_repr=str(log_obj),
action_flag=CHANGE,
change_message="Change status to approved",
)
entry.save()
updated_entries.append(entry.pk)
return len(updated_entries)
def _items_count(self, queryset: QuerySet) -> int:
"""
Since lists are mainly compatible with QuerySets and can be passed to paginator.
We will first to try to use .count - and if not there will use a len
"""
try:
# forcing to find queryset.count instead of list.count:
return queryset.all().count()
except AttributeError:
return len(queryset)
def get_unrestricted_users(users: QuerySet, job) -> QuerySet:
# If there is no job then there is nothing to compare users against and none are restricted.
if not job:
return users
attribute_classes = [provider_task.provider.attribute_class for provider_task in job.data_provider_tasks.all()]
unrestricted = users.all()
for attribute_class in attribute_classes:
if attribute_class:
unrestricted = unrestricted.filter(attribute_classes=attribute_class)
unrestricted = unrestricted.distinct()
return unrestricted
def count_badges(user_badges: QuerySet, badge_class: str) -> int:
"""Count the user badges for a class.
:param user_badges: The user badges.
:param badge_class: The badge class.
:return: The number of badges for the class.
"""
count = 0
for user_badge in user_badges.all():
if user_badge.badge.badge_class == badge_class:
count += 1
return count
def add_reference_to_field_on_related_model(cls, qs: QuerySet, **kwargs):
cls.assert_is_proxy(qs)
modified_qs = qs.all()
if qs.order_by('related_model_name').distinct('related_model_name').count() == 1:
related_model_name = qs.first().related_model_name
modified_qs = modified_qs.annotate(**{
key: F('{}__{}'.format(related_model_name, value))
for key, value in kwargs.items()
})
return modified_qs
def paginate(query: QuerySet,
schema: BaseModel,
params: Optional[AbstractParams] = None) -> AbstractPage:
params = resolve_params(params)
raw_params = params.to_raw_params()
total = query.count()
start = raw_params.limit * raw_params.offset
end = start + raw_params.limit
rows = query.all()[start:end]
items = [schema.from_django(row) for row in rows]
return create_page(items, total, params)
def check_and_associate_configurable_options(product: Product, options: QuerySet):
with transaction.atomic():
# associate options with product
if ProductConfigurableOption.objects.filter(
product=product,
configurable_option__in=options,
).count() < 3:
ProductConfigurableOption.objects.filter(product=product).delete()
for configurable_option in options.all():
ProductConfigurableOption.objects.create(
product=product,
configurable_option=configurable_option
)
product.save()
def add_reference_to_field_on_related_model(cls, qs: QuerySet, **kwargs):
cls.assert_is_proxy(qs)
modified_qs = qs.all()
if qs.order_by('related_model_name').distinct(
'related_model_name').count() == 1:
related_model_name = qs.first().related_model_name
modified_qs = modified_qs.annotate(
**{
key: F('{}__{}'.format(related_model_name, value))
for key, value in kwargs.items()
})
return modified_qs
def auto_pay_invoice(recurring_payment_options: QuerySet,
invoice_id: str) -> bool:
# Method that will try to pay the remaining invoice balance if it's more than zero using one or more gateways
# configured by client in his preferred order.
charged_successfully = False
for recurring_payment_option in recurring_payment_options.all(
).order_by('order'):
if not charged_successfully:
method_path = get_recurring_payment_method_path(
gateway_name=recurring_payment_option.gateway_name)
try:
recur_payment_method = import_string(method_path)
except ImportError:
LOG.error(
'Could not get recurring payment method for {}'.format(
recurring_payment_option.gateway_name))
else:
charged_successfully = recur_payment_method(
invoice_id=invoice_id)
return charged_successfully
def reject_entries(user_id: int, queryset: QuerySet) -> int:
"""
Reject all entries in the queryset
:param user_id: Id of the user executing this action
:param queryset: queryset of entries
:type queryset: Queryset[Entry]
:return: number of updated rows
:rtype: integer
"""
queryset = queryset.filter(status=Entry.STATUS_REVIEW)
entries = list(queryset.all())
rows_updated = queryset.update(status=Entry.STATUS_REJECTED,
updated_at=timezone.now())
for entry in entries:
log_obj = None
try:
emails.send_registration_rejected_message(entry.registration)
log_obj = entry.registration
except Registration.DoesNotExist:
try:
emails.send_renewal_rejected_message(entry.renewal)
log_obj = entry.renewal
except Renewal.DoesNotExist:
pass
if log_obj:
LogEntry.objects.log_action(
user_id=user_id,
content_type_id=get_content_type_for_model(log_obj).pk,
object_id=log_obj.pk,
object_repr=str(log_obj),
action_flag=CHANGE,
change_message="Changed status to rejected",
)
return rows_updated
def delete_by_queryset(self, queryset: QuerySet) -> int:
for entity in queryset.all():
self._message_publisher.send_entity_delete_message(entity)
# return only the number of deleted objects
return queryset.delete()[0]
def render_availabilities(self, value: QuerySet):
return format_html_join("\n", "{} - {}<br>",
((availability.start_date.strftime('%d.%m.%Y'),
availability.end_date.strftime('%d.%m.%Y'))
for availability in value.all()))
def export_result(self, request, queryset: QuerySet):
return redirect('export_result', id=queryset.all()[0].id)
def get_sum_of_task_sp(self, tasks: QuerySet):
sum_of_sp = 0
for task in tasks.all():
sum_of_sp += task.storypoints
return sum_of_sp
def list_all_values_from_relation(relation: QuerySet):
return list(relation.all().values_list('name', flat=True))
def __init__(self, qs: QuerySet):
self.media = Static(Static.MAIN).link
self.caption = "Все сериалы"
self.qs: Collection[models.Series] = qs.all()
