def approve_supersedes(self, review, reg_date):
        sups = review.proposed_supersedes

        old_items = [s.older_item.id for s in sups]

        if not reg_date:
            reg_date = timezone.now().date()

        # Set all old items to the Superseded status
        register_args=[
            old_items,
            False,
            MDR.STATES.superseded,
            review.registration_authority_id,
            self.request.user.id,
            "",
            (reg_date.year, reg_date.month, reg_date.day),
            False
        ]

        # Run as celery task unless always sync
        if settings.ALWAYS_SYNC_REGISTER:
            register_items(*register_args)
        else:
            run_task_on_commit(
                register_items,
                args=register_args
            )

        # Approve all proposed supersedes
        sups.update(proposed=False)
Exemple #2
0
    def register_changes(self, form_dict, change_form=None):

        can_cascade = True
        items = self.get_items()

        try:
            review_data = form_dict['review_changes'].cleaned_data
        except KeyError:
            review_data = None

        # If user went through to review changes form
        if review_data:
            selected_list = review_data['selected_list']
            # Set items based on user selected items
            items = selected_list
            # Make sure we dont cascade when items were specifically selected
            can_cascade = False

        # Get ids of items
        if isinstance(items, QuerySet):
            item_ids = list(items.values_list('id', flat=True))
        else:
            item_ids = [i.id for i in items]

        # process the data in form.cleaned_data as required
        if change_form:
            cleaned_data = form_dict[change_form].cleaned_data
        else:
            cleaned_data = self.get_change_data()

        ras = cleaned_data['registrationAuthorities']
        state = cleaned_data['state']
        regDate = cleaned_data['registrationDate']
        cascade = cleaned_data['cascadeRegistration']
        changeDetails = cleaned_data['changeDetails']

        if changeDetails is None:
            changeDetails = ""

        if not regDate:
            regDate = timezone.now().date()

        cascading = (can_cascade and cascade)

        # Register items (using celery if required)
        register_args = [
            item_ids, cascading, state, ras[0].id, self.request.user.id,
            changeDetails, (regDate.year, regDate.month, regDate.day)
        ]

        use_celery: bool = (len(item_ids) > 1 or cascading)
        if settings.ALWAYS_SYNC_REGISTER:
            use_celery = False

        if use_celery:
            run_task_on_commit(register_items, args=register_args)
        else:
            register_items(*register_args)
Exemple #3
0
    def async_handle_save(self, sender, instance, **kwargs):
        # Dev tests settings
        if not settings.ARISTOTLE_ASYNC_SIGNALS:
            super().handle_save(sender, instance, **kwargs)  # Call haystack handle save
        else:
            message = clean_signal(kwargs)

            task_args = [
                {  # sender
                    'app_label': sender._meta.app_label,
                    'model_name': sender._meta.model_name,
                },
                {  # instance
                    'pk': instance.pk,
                    'app_label': instance._meta.app_label,
                    'model_name': instance._meta.model_name,
                },
            ]

            # Start task on commit
            run_task_on_commit(update_search_index, args=task_args, kwargs=message)