def disable_action(self, request: HttpRequest, queryset: QuerySet):
"""Disable selected stubs.
:param request: http request
:param queryset: queryset of the selected objects
"""
queryset.update(is_active=False)
def disable_action(self, request: HttpRequest, queryset: QuerySet):
"""Экшн выключающий выбранные заглушки.
:param request: http запрос
:param queryset: кверисет выбранных объектов
"""
queryset.update(is_active=False)
def deactivate(modeladmin: admin.ModelAdmin, request: WSGIRequest,
queryset: QuerySet):
queryset.update(active=False)
model = queryset.model
model.objects.disconnect(model.signal, model.receiver, model)
modeladmin.message_user(request,
_('Total deactivated: %s' % queryset.count()))
def toggle_licensed(self, request: HttpRequest, queryset: QuerySet):
"""
Toggle the licensing status of the selected series.
:param request: The original request.
:param queryset: The original queryset.
"""
queryset.update(licensed=Q(licensed=False))
def toggle_completed(self, request: HttpRequest, queryset: QuerySet):
"""
Toggle the publication status of the selected series.
:param request: The original request.
:param queryset: The original queryset.
"""
queryset.update(completed=Q(completed=False))
def toggle_final(self, request: HttpRequest, queryset: QuerySet):
"""
Toggle the status of the selected chapters.
:param request: The original request.
:param queryset: The original queryset.
"""
queryset.update(final=Q(final=False))
def upload_and_create_envelopes(
workbaskets: QuerySet,
rendered_envelopes: Sequence[RenderedTransactions],
first_envelope_id,
) -> UploadTaskResultData:
"""
Upload Envelope data to the the s3 and create artifacts in the database.
Side effects on success:
Create Envelope, EnvelopeTransaction and Upload objects in the database and upload envelope XML to an S3 object.
:return: :class:`~exporter.util.UploadTaskResultData`.
"""
# upload_status holds data to pass to the next Task, including messages to the user.
upload_status = UploadTaskResultData()
current_envelope_id = first_envelope_id
for rendered_envelope in rendered_envelopes:
envelope = Envelope.new_envelope()
if current_envelope_id != int(envelope.envelope_id):
logger.error(
"Envelope created out of sequence: %s != %i this may be due to simultaneous updates causing a race "
"condition.",
(current_envelope_id, int(envelope.envelope_id)),
)
raise RaceCondition(
f"Envelope out of sequence: {envelope.envelope_id} != {current_envelope_id}",
)
current_envelope_id = int(envelope.envelope_id)
envelope_transactions = [
EnvelopeTransaction(order=order, envelope=envelope, transaction=transaction)
for order, transaction in enumerate(rendered_envelope.transactions)
]
EnvelopeTransaction.objects.bulk_create(envelope_transactions)
envelope.save()
rendered_envelope.output.seek(0, os.SEEK_SET)
content_file = ContentFile(rendered_envelope.output.read())
upload = Upload()
upload.envelope = envelope
upload.file = content_file
rendered_envelope.output.seek(0, os.SEEK_SET)
upload.checksum = md5(rendered_envelope.output.read()).hexdigest()
upload.file.save(upload.filename, content_file)
upload_status.add_upload_pk(upload.pk)
logger.info("Workbasket saved to CDS S3 bucket")
workbaskets.update(status=WorkflowStatus.SENT)
logger.debug("Uploaded: %s", upload.filename)
upload_status.add_envelope_messages(
envelope.envelope_id,
[f"Uploaded {upload.filename}"],
)
return upload_status
def update_if_not_equal(obj: QuerySet, row: dict):
# Can not delete the "id" key-value from `rows` as it will manipulate the data which is later used in
# `delete_unused_objects`
attributes = {k: v for k, v in row.items() if k != "id"}
obj = obj.exclude(**attributes)
if obj.exists():
obj.update(**attributes)
if not settings.SUPPRESS_TEST_OUTPUT:
print(f"UPDATED {obj.model.__name__}: {dict(row)}")
def make_published(modeladmin, request, queryset: QuerySet):
published_recruitments = list(
Recruitment.objects.filter(is_published=True))
for recruitment in published_recruitments:
recruitment.is_published = False
Recruitment.objects.bulk_update(published_recruitments,
fields=['is_published'])
queryset.update(is_published=True)
def upload_and_create_envelopes(
workbaskets: QuerySet,
rendered_envelopes: Sequence[RenderedTransactions],
first_envelope_id,
) -> Dict[Union[int, None], str]:
# {envelope_id: message} User messages can be returned to the caller of the task.
user_messages = {}
current_envelope_id = first_envelope_id
for rendered_envelope in rendered_envelopes:
envelope = Envelope.new_envelope()
if current_envelope_id != int(envelope.envelope_id):
# TODO consider locking the table for writes instead
logger.error(
"Envelope created out of sequence: %s != %s this may due to simultaneous updates causing a race condition.",
(current_envelope_id, int(envelope.envelope_id)),
)
raise RaceCondition(
f"Envelope out of sequence: {envelope.envelope_id} != {current_envelope_id}",
)
current_envelope_id = int(envelope.envelope_id)
envelope_transactions = [
EnvelopeTransaction(order=order,
envelope=envelope,
transaction=transaction)
for order, transaction in enumerate(rendered_envelope.transactions)
]
EnvelopeTransaction.objects.bulk_create(envelope_transactions)
envelope.save()
rendered_envelope.output.seek(0, os.SEEK_SET)
content_file = ContentFile(rendered_envelope.output.read())
upload = Upload()
upload.envelope = envelope
upload.file = content_file
rendered_envelope.output.seek(0, os.SEEK_SET)
upload.checksum = md5(rendered_envelope.output.read()).hexdigest()
upload.file.save(upload.filename, content_file)
if settings.EXPORTER_DISABLE_NOTIFICATION:
logger.info("HMRC notification disabled.")
else:
logger.info("Notify HMRC of upload, %s", upload.filename)
upload.notify_hmrc() # sets notification_sent
logger.info("Workbasket sent to CDS")
workbaskets.update(status=WorkflowStatus.SENT_TO_CDS)
logger.debug("Uploaded: %s", upload.filename)
user_messages[envelope.envelope_id] = f"Uploaded {upload.filename}"
return user_messages
def make_accepted(self: "RenewAdmin", request: WSGIRequest,
queryset: QuerySet) -> None:
"""Custom action that update the status of renew to Accepted."""
renew_request = queryset.first()
user = renew_request.user
user.expired_at = renew_request.create_at + timezone.timedelta(
days=365)
user.save()
queryset.update(status="Accepted")
def search_title_from_title(self, request: HttpRequest, queryset: QuerySet) -> None:
rows_updated = queryset.update(search_title=F('title'))
if rows_updated == 1:
message_bit = "1 gallery was"
else:
message_bit = "%s galleries were" % rows_updated
self.message_user(request, "%s successfully set search title from title." % message_bit)
def mark_not_keep_search(self, request: HttpRequest, queryset: QuerySet) -> None:
rows_updated = queryset.update(keep_searching=False)
if rows_updated == 1:
message_bit = "1 gallery was"
else:
message_bit = "%s galleries were" % rows_updated
self.message_user(request, "%s successfully marked as not keep searching." % message_bit)
def mark_found(self, request: HttpRequest, queryset: QuerySet) -> None:
rows_updated = queryset.update(found=True)
if rows_updated == 1:
message_bit = "1 gallery was"
else:
message_bit = "%s galleries were" % rows_updated
self.message_user(request, "%s successfully marked as found." % message_bit)
def unpublish_page(modeladmin: admin.ModelAdmin, request: HttpRequest, queryset: QuerySet):
pages_updated = queryset.update(published=False)
if pages_updated == 1:
message = '1 page was'
else:
message = '{:d} page were'.format(pages_updated)
modeladmin.message_user(request, '{:s} successfully marked as published.'.format(message))
def resend_invoices(modeladmin, request: HttpRequest, queryset: QuerySet): # pylint: disable=unused-argument
"""
Marks invoices with as un-sent.
:param modeladmin:
:param request:
:param queryset:
:return:
"""
user = request.user
assert isinstance(user, User)
for obj in queryset:
assert isinstance(obj, Invoice)
admin_log([obj, user],
"Invoice id={invoice} marked for re-sending".format(
invoice=obj.id),
who=user)
queryset.update(sent=None)
def set_reason(self, request: HttpRequest, queryset: QuerySet) -> None:
source_type = request.POST['extra_field']
rows_updated = queryset.update(reason=source_type)
if rows_updated == 1:
message_bit = "1 wanted gallery was"
else:
message_bit = "%s wanted galleries were" % rows_updated
self.message_user(request, "%s successfully set as reason: %s." % (message_bit, source_type))
def publish(self, request: WSGIRequest, queryset: QuerySet):
"""Publish this movie"""
row_update = queryset.update(draft=False)
if row_update == 1:
message_bit = '1 row was published.'
else:
message_bit = f'{row_update} rows were published.'
self.message_user(request, message_bit)
def disapprove_event(self, request: http.HttpRequest,
queryset: models.QuerySet) -> None:
updated = queryset.update(active=False)
self.message_user(
request,
translation.ngettext(
'%d event was disapproved.',
'%d events were disapproved.',
updated,
) % updated, messages.SUCCESS)
def disable_notify_when_found(self, request: HttpRequest,
queryset: QuerySet) -> None:
rows_updated = queryset.update(notify_when_found=False)
if rows_updated == 1:
message_bit = "1 gallery was"
else:
message_bit = "%s galleries were" % rows_updated
self.message_user(
request,
"%s successfully disabled for notify when found." % message_bit)
def approve_image(self, request: http.HttpRequest,
queryset: models.QuerySet) -> None:
updated = queryset.update(active=True)
self.message_user(
request,
translation.ngettext(
'%d image was approved.',
'%d images were approved.',
updated,
) % updated, messages.SUCCESS)
def make_published(self, request: HttpRequest, queryset: QuerySet) -> None:
updated = queryset.update(is_public=True)
self.message_user(
request,
ngettext(
"%d question was successfully marked as published.",
"%d questions were successfully marked as published.",
updated,
) % updated,
messages.SUCCESS,
)
def reorder_list_by_slugs(queryset: QuerySet, field: str, slugs: List[str]) -> None:
"""Alter objects' `field` value so slugs[0] is at position 0 and so on.
For instance:
`remove_gap_from_list(workflow.blocks, 'position', ["block-1", "block-2")`
will set `.position = 0` for block-1 and `.position = 1` for block-2.
This must be called within a database transaction.
This could be a single `UPDATE`. However, Postgres checks uniqueness
constraints _before the statement ends_, so it leads to a conflict.
TODO use Django 3.1 with DEFERRABLE INITIALLY DEFFERED constraint to avoid
this problem. In the meantime, write one row at a time to avoid conflict.
"""
# Make sure we don't overwrite any positions: make all existing numbers
# negative.
assert queryset.count() == len(slugs)
queryset.update(**{field: -1 - F(field)})
for position, slug in enumerate(slugs):
queryset.filter(slug=slug).update(**{field: position})
def update_returning_pk(qs: QuerySet, updates: dict) -> Set[Any]:
"""
Updates QuerySet items returning primary key values.
This method should not depend on database engine, though can have optimization performances for some engines.
:param qs: QuerySet to update
:param updates: Update items as passed to QuerySet.update(**updates) method
:return: A set of primary keys
"""
qs._for_write = True
if django_pg_returning_available(qs.db) and hasattr(
qs, 'update_returning'):
pk_name = qs.model._meta.pk.name
qs = qs.only(pk_name).update_returning(**updates)
pks = set(qs.values_list(pk_name, flat=True))
else:
with transaction.atomic(using=qs.db):
pks = set(qs.select_for_update().values_list('pk', flat=True))
QuerySet.update(qs, **updates)
return pks
def set_wait_for_time(self, request: HttpRequest,
queryset: QuerySet) -> None:
wait_for_time = request.POST['extra_field']
rows_updated = queryset.update(
wait_for_time=parse_duration(wait_for_time))
if rows_updated == 1:
message_bit = "1 wanted gallery was"
else:
message_bit = "%s wanted galleries were" % rows_updated
self.message_user(
request, "%s successfully set wait for time to: %s." %
(message_bit, wait_for_time))
def confirm_entry(queryset: QuerySet) -> int:
"""
Confirm all entries in the queryset
:param queryset: queryset of entries
:type queryset: Queryset[Entry]
:return: number of updated rows
:rtype: integer
"""
queryset = queryset.filter(status=Entry.STATUS_CONFIRM)
rows_updated = queryset.update(status=Entry.STATUS_REVIEW,
updated_at=timezone.now())
return rows_updated
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 reset_ttl(queryset: QuerySet) -> None:
queryset.update(ttl=timezone.now() +
datetime.timedelta(seconds=settings.DEFAULT_TTL))
def make_accepted(self: "BusinessAdmin", request: WSGIRequest,
queryset: QuerySet) -> None:
"""Custom action that update the status of business to Accepted."""
queryset.update(status="Accepted")
queryset.update(is_active=True)
def approve_comments(queryset: QuerySet, moderator: User) -> None:
queryset.update(pending_moderation=False, moderator=moderator)
for comment in queryset:
CommentNotificationsService(comment).send_notifications(force=True)
CommentNotificationsService(comment).send_approval_notification()
def make_deny(self: "BusinessAdmin", request: WSGIRequest,
queryset: QuerySet) -> None:
"""Custom action that update the status of business to Deny."""
queryset.update(status="Deny")
queryset.update(is_active=False)
