Python pre_save.disconnect方法代碼示例

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def _disconnect(cls):
        """
        Disconnect signal from current model
        """
        pre_save.disconnect(
            notify_items_pre_save, sender=cls,
            dispatch_uid='knocker_pre_save_{0}'.format(cls.__name__)
        )
        post_save.disconnect(
            notify_items_post_save, sender=cls,
            dispatch_uid='knocker_post_save_{0}'.format(cls.__name__)
        )
        pre_delete.disconnect(
            notify_items_pre_delete, sender=cls,
            dispatch_uid='knocker_pre_delete_{0}'.format(cls.__name__)
        )
        post_delete.disconnect(
            notify_items_post_delete, sender=cls,
            dispatch_uid='knocker_post_delete_{0}'.format(cls.__name__)
        ) 

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def test_update_fields_signals(self):
        p = Person.objects.create(name='Sara', gender='F')
        pre_save_data = []

        def pre_save_receiver(**kwargs):
            pre_save_data.append(kwargs['update_fields'])
        pre_save.connect(pre_save_receiver)
        post_save_data = []

        def post_save_receiver(**kwargs):
            post_save_data.append(kwargs['update_fields'])
        post_save.connect(post_save_receiver)
        p.save(update_fields=['name'])
        self.assertEqual(len(pre_save_data), 1)
        self.assertEqual(len(pre_save_data[0]), 1)
        self.assertIn('name', pre_save_data[0])
        self.assertEqual(len(post_save_data), 1)
        self.assertEqual(len(post_save_data[0]), 1)
        self.assertIn('name', post_save_data[0])

        pre_save.disconnect(pre_save_receiver)
        post_save.disconnect(post_save_receiver) 

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def test_empty_update_fields(self):
        s = Person.objects.create(name='Sara', gender='F')
        pre_save_data = []

        def pre_save_receiver(**kwargs):
            pre_save_data.append(kwargs['update_fields'])
        pre_save.connect(pre_save_receiver)
        post_save_data = []

        def post_save_receiver(**kwargs):
            post_save_data.append(kwargs['update_fields'])
        post_save.connect(post_save_receiver)
        # Save is skipped.
        with self.assertNumQueries(0):
            s.save(update_fields=[])
        # Signals were skipped, too...
        self.assertEqual(len(pre_save_data), 0)
        self.assertEqual(len(post_save_data), 0)

        pre_save.disconnect(pre_save_receiver)
        post_save.disconnect(post_save_receiver) 

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def process_response(self, request, response):
        """
        Disconnects the signal receiver to prevent it from staying active.
        """
        if hasattr(threadlocal, 'actionslog'):
            pre_save.disconnect(sender=LogAction, dispatch_uid=threadlocal.actionslog['signal_duid'])

        return response 

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def process_exception(self, request, exception):
        """
        Disconnects the signal receiver to prevent it from staying active in case of an exception.
        """
        if hasattr(threadlocal, 'actionslog'):
            pre_save.disconnect(sender=LogAction, dispatch_uid=threadlocal.actionslog['signal_duid'])

        return None 

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def register_pre_save_on_AUTH_USER_MODER_change(sender, setting, value, enter, **kwargs):
    if setting == "AUTH_USER_MODEL" and value != USER_MODEL:
        if enter:
            pre_save.connect(useraudit.password_expiry.user_pre_save, sender=value)
        else:
            pre_save.disconnect(useraudit.password_expiry.user_pre_save, sender=value) 

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def test_signal(self):
        def handler(sender, user=None, **kwargs):
            self.handler_called = True
            self.assertEquals(sender, type(self.user))
            self.assertEquals(user, self.user)
        login_failure_limit_reached.connect(handler)

        self.handler_called = False

        _ = authenticate(username=self.username, password="INCORRECT")
        _ = authenticate(username=self.username, password="INCORRECT")

        login_failure_limit_reached.disconnect(handler)

        self.assertTrue(self.handler_called) 

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def pre_post_save_wrapper(self):
        self.pre_save_called = False
        self.post_save_called = False

        self.bar

        def pre_save_handler(sender, instance, **kwargs):
            # Assert that a pre_save handler gets the proper information on which fields have changed
            # (hence the translations have not yet been saved to the db).

            self.pre_save_called = True

            field_fr = instance._linguist_translations["title"].get("fr", None)
            field_en = instance._linguist_translations["title"].get("en", None)

            assert field_fr.has_changed
            assert not field_en.has_changed

        pre_save.connect(pre_save_handler, sender=BarModel)

        def post_save_handler(sender, instance, **kwargs):
            # Assert that a post_save handler that refreshes the model gets the saved translations
            # (hence the translations have been saved to the db).

            self.post_save_called = True

            title_fr = instance.title_fr
            title_en = instance.title_en

            instance = BarModel.objects.get(pk=instance.pk)

            assert instance.title_fr == title_fr
            assert instance.title_en == title_en

        post_save.connect(post_save_handler, sender=BarModel)

        yield

        pre_save.disconnect(pre_save_handler, sender=BarModel)
        post_save.disconnect(post_save_handler, sender=BarModel) 

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def disconnect_signals():
    post_save.disconnect(receiver=reassess_on_profile_save, sender=UserProfile)
    pre_save.disconnect(receiver=signals.pre_save_config, sender=AutogroupsConfig)
    pre_delete.disconnect(receiver=signals.pre_delete_config, sender=AutogroupsConfig)
    post_save.disconnect(receiver=signals.check_groups_on_profile_update, sender=UserProfile)
    m2m_changed.disconnect(receiver=signals.autogroups_states_changed, sender=AutogroupsConfig.states.through) 

# 需要導入模塊: from django.db.models.signals import pre_save [as 別名]
# 或者: from django.db.models.signals.pre_save import disconnect [as 別名]
def disconnect_signals(cls):
        m2m_changed.disconnect(m2m_changed_user_groups, sender=User.groups.through)
        m2m_changed.disconnect(m2m_changed_group_permissions, sender=Group.permissions.through)
        m2m_changed.disconnect(m2m_changed_user_permissions, sender=User.user_permissions.through)
        m2m_changed.disconnect(m2m_changed_state_permissions, sender=State.permissions.through)
        pre_save.disconnect(disable_services_on_inactive, sender=User)
        m2m_changed.disconnect(state_member_corporations_changed, sender=State.member_corporations.through)
        m2m_changed.disconnect(state_member_characters_changed, sender=State.member_characters.through)
        m2m_changed.disconnect(state_member_alliances_changed, sender=State.member_alliances.through)
        post_save.disconnect(state_saved, sender=State)