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)