def _detach_signals(self):
'''
Detach all signals for eav
'''
post_init.disconnect(Registry.attach_eav_attr, sender=self.model_cls)
pre_save.disconnect(Entity.pre_save_handler, sender=self.model_cls)
post_save.disconnect(Entity.post_save_handler, sender=self.model_cls)
def _disconnect_signals():
""" used in testing """
post_save.disconnect(plan_watchers.notify_on_plan_is_updated, TestPlan)
pre_delete.disconnect(
plan_watchers.load_email_settings_for_later_deletion, TestPlan)
post_delete.disconnect(plan_watchers.notify_deletion_of_plan, TestPlan)
pre_save.disconnect(plan_watchers.pre_save_clean, TestPlan)
def unregister(self, model):
post_save.disconnect(add_obj_to_autocompleter,
sender=model, dispatch_uid='autocompleter.%s.add' % (model))
pre_save.disconnect(remove_old_obj_from_autocompleter, sender=model,
dispatch_uid='autocompleter.%s.remoe_old' % (model))
post_delete.disconnect(remove_obj_from_autocompleter,
sender=model, dispatch_uid='autocompleter.%s.remove' % (model))
def test_without_signal(self):
pre_save.disconnect(maybe_update_homepage, sender=Page,
dispatch_uid='slugpage_maybe_update_homepage')
page = Page(title='test', template='test', slug='test',
is_homepage=True)
page.save()
page2 = Page(title='test2', template='test2', slug='test2',
is_homepage=False)
page2.save()
# now two pages, the first of which is the homepage.
results = tuple(Result(pk=x.pk, homepage=x.is_homepage)
for x in Page.objects.all().order_by('pk'))
self.assertEqual(results, (
Result(pk=1, homepage=True),
Result(pk=2, homepage=False),
))
page2.is_homepage = True
page2.save()
# now two pages, but both are the homepage.
results = tuple(Result(pk=x.pk, homepage=x.is_homepage)
for x in Page.objects.all().order_by('pk'))
self.assertEqual(results, (
Result(pk=1, homepage=True),
Result(pk=2, homepage=True),
))
def handle(self, *args, **options):
if settings.RELEASE_ENV != "dev" and not settings.TUTORIAL_MODE:
self.stdout.write("Command can only be run on dev instances and instances "\
"with tutorial mode enabled")
return
if not options.get("commit"):
self.stdout.write("This will sync data from {url} to this instance, and will take "\
"roughly 20 minutes to complete on a fresh db. "\
"Run the command with `--commit` if you are sure you want "\
"to do this.".format(**options))
return
djpdb_settings.SYNC_URL = options.get("url")
pre_save.disconnect(signals.addressmodel_save,
sender=pdb_models.Facility)
djpdb_models.all_models = [
pdb_models.Organization, pdb_models.Facility, pdb_models.Network,
pdb_models.InternetExchange, pdb_models.InternetExchangeFacility,
pdb_models.IXLan, pdb_models.IXLanPrefix,
pdb_models.NetworkContact, pdb_models.NetworkFacility,
pdb_models.NetworkIXLan
]
call_command("pdb_sync")
def run(self):
if self.overwrite:
self.print('Removing existing neighborhoods...', end='')
if self.real_run:
Neighborhood.objects.all().delete()
self.print('Done')
# Disconnect this temporarily so that the ``unique='name'`` option
# passed to LayerMapping will work correctly (it collects all
# records from the RLIS neighborhoods shapefile with the same name
# into a single database record; if we normalize the names on save,
# this feature won't work).
pre_save.disconnect(normalize_name, sender=Neighborhood)
self.print('Adding neighborhoods...', end='')
if self.real_run:
mapping = LayerMapping(
Neighborhood, self.path, Neighborhood.layer_mapping, source_srs=self.from_srid,
unique='name')
mapping.save(strict=True)
self.print('Done')
self.print('Normalizing neighborhood names...', end='')
neighborhoods = Neighborhood.objects.all()
if self.real_run:
with transaction.atomic():
for neighborhood in neighborhoods:
neighborhood.name = Neighborhood.normalize_name(neighborhood.name)
neighborhood.save()
self.print('Done')
pre_save.connect(normalize_name, sender=Neighborhood)
def postdelete_recibo(sender, instance, **kwargs):
pre_save.disconnect(presave_factventa, sender=FacturaVenta)
# post_save.disconnect(postsave_facventa, sender=FacturaVenta)
instance.facturaventa.saldo += instance.monto
instance.facturaventa.save()
pre_save.connect(presave_factventa, sender=FacturaVenta)
def process_response(self, request, response):
"""
Disconnects the signal receiver to prevent it from staying active.
"""
# Disconnecting the signal receiver is required because it will not be garbage collected (non-weak reference)
pre_save.disconnect(dispatch_uid=(self.__class__, request))
return response
def process_response(self, request, response):
"""
Disconnects the signal receiver to prevent it from staying active.
"""
if hasattr(threadlocal, 'auditlog'):
pre_save.disconnect(sender=LogEntry, dispatch_uid=threadlocal.auditlog['signal_duid'])
return response
def process_exception(self, request, exception):
"""
Disconnects the signal receiver to prevent it from staying active in case of an exception.
"""
if hasattr(request, 'auditlog_ts'):
pre_save.disconnect(sender=LogEntry, dispatch_uid=(self.__class__, request.auditlog_ts))
return None
def process_response(self, request, response):
"""
Disconnects the signal receiver to prevent it from staying active.
"""
if hasattr(threadlocal, 'auditlog'):
pre_save.disconnect(sender=LogEntry, dispatch_uid=threadlocal.auditlog['signal_duid'])
return response
def process_exception(self, request, exception):
"""
Disconnects the signal receiver to prevent it from staying active in case of an exception.
"""
if hasattr(threadlocal, 'auditlog'):
pre_save.disconnect(sender=LogEntry, dispatch_uid=threadlocal.auditlog['signal_duid'])
return None
def set_specimen_url(sender, **kwargs): pre_save.disconnect(set_specimen_url, sender=Specimen) specimen = kwargs['instance'] url_string = "http://spectrum.ucdavis.edu/EditRecord.php?TableName=Specimen&Ids[]=%s" % (specimen.specimen_id,) specimen.specimen_url = url_string specimen.save() pre_save.connect(set_specimen_url, sender=Specimen)
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)
pre_save.disconnect(pre_save_user, sender=User)
pre_save.disconnect(pre_save_auth_state, sender=AuthServicesInfo)
def unregister(self, model):
"""Removes a model from version control."""
if not self.is_registered(model):
raise RegistrationError, "%r has not been registered with django-reversion" % model
del self._registered_models[model]
self._revision_context_manager._pre_save_hooked_models.pop(model, None)
pre_save.disconnect(self._pre_save_receiver, model)
post_save.disconnect(self._post_save_receiver, model)
pre_delete.disconnect(self._pre_delete_receiver, model)
def setUpClass(cls):
"""Disable post_save signals during this test case"""
pre_save.disconnect(hydrate_from_rolodex,
dispatch_uid="hydrate_from_rolodex",
sender=Recipient)
pre_save.disconnect(hydrate_from_staff_api,
dispatch_uid="hydrate_from_staff_api",
sender=Sender)
super(SlackMsgTestCase, cls).setUpClass()
def _create(cls, target_class, *args, **kwargs):
dispatch_uid = 'userprofile_email_mentor_notification'
pre_save.disconnect(email_mentor_notification, UserProfile,
dispatch_uid=dispatch_uid)
profile = super(UserProfileFactory, cls)._create(target_class,
*args, **kwargs)
pre_save.connect(email_mentor_notification, UserProfile,
dispatch_uid=dispatch_uid)
return profile
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)
def process_response(self, request, response):
"""
Disconnects the signal receiver to prevent it from staying active.
"""
# Disconnecting the signal receiver is required because it will not be garbage collected (non-weak reference)
if hasattr(request, 'auditlog_ts'): # admin wipes auditlog_ts from request...
pre_save.disconnect(sender=LogEntry, dispatch_uid=(self.__class__, request.auditlog_ts))
return response
def disconnect_signals():
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)
def _create(cls, target_class, *args, **kwargs):
dispatch_uid = 'userprofile_email_mentor_notification'
pre_save.disconnect(email_mentor_notification, UserProfile,
dispatch_uid=dispatch_uid)
profile = super(UserProfileFactory, cls)._create(target_class,
*args, **kwargs)
pre_save.connect(email_mentor_notification, UserProfile,
dispatch_uid=dispatch_uid)
return profile
def update(self, request, *args, **kwargs):
if request.data.get('API_CONNECT', False):
pre_save.disconnect(pre_save_handler, sender=WarehouseOrder)
response = super(WarehouseOrderViewSet,
self).update(request, *args, **kwargs)
pre_save.connect(pre_save_handler, sender=WarehouseOrder)
else:
response = super(WarehouseOrderViewSet,
self).update(request, *args, **kwargs)
return response
def disconnect(self, model):
if model in self.models:
post_save.disconnect(dispatch_uid=str(self.__class__) + str(model) + "_create")
pre_save.disconnect(dispatch_uid=str(self.__class__) + str(model) + "_update")
pre_delete.disconnect(dispatch_uid=str(self.__class__) + str(model) + "_delete")
self.models.pop(model)
for m2mfield in model._meta.many_to_many:
m2m_attr = getattr(model, m2mfield.name)
m2m_changed.disconnect(dispatch_uid=str(self.__class__) + str(m2m_attr.through) + "_associate")
def sync_user_data_locally(data):
try:
pre_save.disconnect(save_user_to_auth_api, sender=KagisoUser)
user = KagisoUser.objects.filter(
id=data['id']).first() or KagisoUser()
user.build_from_auth_api_data(data)
user.save()
return user
finally:
pre_save.connect(save_user_to_auth_api, sender=KagisoUser)
def process_exception(self, request, exception):
"""
Disconnects the signal receiver to prevent it from staying active in case of an exception.
"""
if hasattr(request, 'auditlog_ts'):
pre_save.disconnect(sender=LogEntry,
dispatch_uid=(self.__class__,
request.auditlog_ts))
return None
def job_model_saved(mocker):
from django.db.models.signals import pre_save
from django_remote_submission.models import Job
mock = mocker.Mock()
pre_save.connect(mock, sender=Job)
yield mock
pre_save.disconnect(mock, sender=Job)
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
def process_exception(self, request, exception):
"""
Disconnects the signal receiver to prevent it from staying active in case of an exception.
"""
if hasattr(threadlocal, "auditlog"):
pre_save.disconnect(
sender=LogEntry,
dispatch_uid=threadlocal.auditlog["signal_duid"])
return None
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)
def set_study_id(sender, **kwargs): pre_save.disconnect(set_study_id, sender=Study) study = kwargs['instance'] data_group_id = db.get_data_group_id(study.data_group) study.study_id = db.get_study_id(study.name, data_group_id) if study.study_id != None: study.save() pre_save.connect(set_study_id, sender=Study)
def test_pre_save_is_sent_before_reorder(self):
updated_instances = []
def listener(sender, instance, **kwargs):
updated_instances.append(instance.pk)
in_data = {'startorder': 7, 'endorder': 2} # from 12345667 to 1273456
pre_save.connect(listener)
response = self.client.post(self.ajax_update_url, in_data, **self.http_headers)
pre_save.disconnect(listener)
self.assertEqual(len(updated_instances), 5)
self.assertEqual(updated_instances, [7, 6, 5, 4, 3])
def fix_null_related_action_items(apps): # noqa
""""""
post_save.disconnect(dispatch_uid="serialize_on_save")
pre_save.disconnect(dispatch_uid="requires_consent_on_pre_save")
ActionItem = apps.get_model("edc_action_item", "ActionItem")
fix_null_action_items(apps)
related_action_items = {}
for action_cls in site_action_items.registry.values():
if action_cls.related_reference_fk_attr:
for action_item in ActionItem.objects.filter(
related_action_item__isnull=True,
action_type__name=action_cls.name):
related_action_item = None
try:
reference_obj = action_item.reference_obj
except ObjectDoesNotExist:
print("No reference object", action_item)
else:
try:
related_reference_obj = getattr(
reference_obj,
action_cls.related_reference_fk_attr)
except ObjectDoesNotExist:
print("related_reference_obj does not exist")
related_reference_obj = None
if action_item.parent_action_item:
related_action_item = action_item.parent_action_item
elif reference_obj.parent_action_item:
related_action_item = reference_obj.parent_action_item
else:
related_action_item = related_reference_obj.action_item
if related_action_item:
related_action_items.update(
{related_action_item: related_action_item})
action_item.related_action_item = related_action_item
action_item.save()
if reference_obj:
reference_obj.related_action_item = related_action_item # noqa
reference_obj.save()
if (ActionItem.objects.filter(
related_action_item__isnull=True,
action_type__name=action_cls.name).count() > 0):
# raise ValidationError(
# 'Some related action identifiers are still `none`')
print("Some related action identifiers are still `none`")
# verify sequence
for related_action_item in related_action_items:
fix_action_item_sequence(
ActionItem,
action_identifier=related_action_item.action_identifier,
subject_identifier=related_action_item.subject_identifier,
)
def _detach_signals(self):
'''
Detach all signals for eav
'''
post_init.disconnect(Registry.attach_eav_attr, sender=self.model_cls)
pre_save.disconnect(getattr(self.config_cls.entity_class,
'pre_save_handler'),
sender=self.model_cls)
post_save.disconnect(getattr(self.config_cls.entity_class,
'post_save_handler'),
sender=self.model_cls)
def unregister(model):
"""Unregisters a model from automatic indexing.
Return value: the tuple of fields which were being indexed
"""
pre_delete.disconnect(unindex_instance, sender=model)
post_save.disconnect(index_instance, sender=model)
pre_save.disconnect(unindex_old_instance, sender=model)
fields = registry[model]
del registry[model]
return fields
def tearDown(self):
redis.client = None
pre_save.disconnect(redis.listing_pre_save, sender=Listing)
post_save.disconnect(redis.listing_post_save, sender=Listing)
pre_delete.disconnect(redis.listing_pre_delete, sender=Listing)
post_delete.disconnect(redis.listing_post_delete, sender=Listing)
content_published.disconnect(redis.publishable_published)
content_unpublished.disconnect(redis.publishable_unpublished)
super(TestRedisListings, self).tearDown()
self.redis.flushdb()
def set_specimen_id(sender, **kwargs):
pre_save.disconnect(set_specimen_id, sender=Specimen)
specimen = kwargs['instance']
old_id = specimen.specimen_id
new_id = db.get_specimen_id(specimen)
if old_id != new_id:
specimen.specimen_id = db.get_specimen_id(specimen)
specimen.save()
pre_save.connect(set_specimen_id, sender=Specimen)
def setUp(self):
# Disconnect signals
pre_save.disconnect(receiver=preSave_User, sender=User, dispatch_uid='website.signals.preSave_User')
post_save.disconnect(receiver=postSave_User, sender=User, dispatch_uid='website.signals.postSave_User')
user = User.objects.create_user(username='******', email='*****@*****.**', password='******')
self.user_info = UserInfo.objects.create(
user = user,
algoritmo_code = 1,
company_name = 'Test Company'
)
def tearDown(self):
redis.client = None
pre_save.disconnect(redis.listing_pre_save, sender=Listing)
post_save.disconnect(redis.listing_post_save, sender=Listing)
pre_delete.disconnect(redis.listing_pre_delete, sender=Listing)
post_delete.disconnect(redis.listing_post_delete, sender=Listing)
content_published.disconnect(redis.publishable_published)
content_unpublished.disconnect(redis.publishable_unpublished)
super(TestAuthorLH, self).tearDown()
self.redis.flushdb()
def handle(self, *args, **options):
if settings.RELEASE_ENV != "dev" and not settings.TUTORIAL_MODE:
self.stdout.write(
"Command can only be run on dev instances and instances "
"with tutorial mode enabled")
return
if not options.get("commit"):
self.stdout.write(
"This will sync data from {url} to this instance, and will take "
"roughly 20 minutes to complete on a fresh db. "
"Run the command with `--commit` if you are sure you want "
"to do this.".format(**options))
return
# settings.USE_TZ = True
db_settings = settings.DATABASES.get("default")
config = {
"sync": {
"url": options.get("url")
},
"orm": {
"secret_key": settings.SECRET_KEY,
"backend": "peeringdb_server",
"migrate": False,
"database": {k.lower(): v
for k, v in db_settings.items()},
},
}
apply_defaults(ClientSchema(), config)
pre_save.disconnect(signals.addressmodel_save,
sender=pdb_models.Facility)
djpdb_models.all_models = [
pdb_models.Organization,
pdb_models.Facility,
pdb_models.Network,
pdb_models.InternetExchange,
pdb_models.InternetExchangeFacility,
pdb_models.IXLan,
pdb_models.IXLanPrefix,
pdb_models.NetworkContact,
pdb_models.NetworkFacility,
pdb_models.NetworkIXLan,
]
SUPPORTED_BACKENDS[
"peeringdb_server"] = "peeringdb_server.client_adaptor"
client = Client(config)
client.update_all(resource.all_resources(), since=None)
def process_response(self, request, response):
"""
Disconnects the signal receiver to prevent it from staying active.
"""
# Disconnecting the signal receiver is required because it will not be garbage collected (non-weak reference)
if hasattr(request, 'auditlog_ts'):
pre_save.disconnect(sender=LogEntry,
dispatch_uid=(self.__class__,
request.auditlog_ts))
return response
def unregister(self, model):
"""Removes a model from version control."""
if isinstance(model, (str, unicode)):
model = get_model(*model.split("."))
if not self.is_registered(model):
raise RegistrationError("{model} has not been registered with django-reversion".format(model=model))
del self._registered_models[model]
post_save.disconnect(self._post_save_receiver, model)
pre_delete.disconnect(self._pre_delete_receiver, model)
pre_save.disconnect(self.pre_save_smart_handler, model)
post_delete.disconnect(self.post_delete_smart_handler, model)
def unregister(model):
"""Unregister a model to the audit code.
:param model: Model to unregister.
:type model: object
"""
try:
pre_save.disconnect(_pre_save, sender=model, dispatch_uid=str(model))
post_save.disconnect(_post_save, sender=model, dispatch_uid=str(model))
pre_delete.disconnect(_pre_delete, sender=model, dispatch_uid=str(model))
except Exception as e:
logger.error("<Unregister> %s", e.message)
def update_patient(sender, instance=None, **kwargs):
pre_save.disconnect(update_patient, sender=Patient)
new_patient = instance
old_patient = Patient.objects.filter(pk=new_patient.id).first()
if old_patient:
if old_patient.is_active == True and new_patient.is_active == False:
new_patient.date_deactivate = timezone.now()
new_patient.save()
elif old_patient.is_active == False and new_patient.is_active == True:
new_patient.date_deactivate = None
new_patient.save()
pre_save.connect(update_patient, sender=Patient)
def set_study_id(sender, **kwargs):
pre_save.disconnect(set_study_id, sender=Study)
study = kwargs['instance']
print 'getting data group id'
data_group_id = db.get_data_group_id(study.data_group)
print data_group_id
study.study_id = db.get_study_id(study.name, data_group_id)
print study.study_id
if study.study_id is not None:
study.save()
pre_save.connect(set_study_id, sender=Study)
def handle(self, **options):
pre_save.disconnect(prevent_updates_on_published_items,
sender=Questionnaire)
configuration_code = 'unccd'
config = get_configuration(configuration_code, edition='2015')
questionnaires = Questionnaire.objects.filter(
code__startswith=configuration_code)
self.find_int_values(questionnaires, config)
pre_save.connect(prevent_updates_on_published_items,
sender=Questionnaire)
def handle(self, *fixture_labels, **options):
if options["media"]:
for ModelClass in get_models_with_media_fields():
pre_save.connect(self.load_media, sender=ModelClass)
command_result = super().handle(*fixture_labels, **options)
if options["media"]:
for ModelClass in get_models_with_media_fields():
pre_save.disconnect(self.load_media, sender=ModelClass)
return command_result
def setUp(self):
# Disconnect signals
pre_save.disconnect(receiver=preSave_User, sender=User, dispatch_uid='website.signals.preSave_User')
post_save.disconnect(receiver=postSave_User, sender=User, dispatch_uid='website.signals.postSave_User')
user = User.objects.create_user(username='******', email='*****@*****.**', password='******')
user_info = UserInfo.objects.create(
user = user,
algoritmo_code = 1,
company_name = 'Test Company'
)
self.notification = mixer.blend(Notifications, title='Notification Test')
self.viewed_notification = mixer.blend(ViewedNotifications, notification=self.notification, user=user)
def sync_user_data_locally(data):
try:
pre_save.disconnect(
save_user_to_auth_api,
sender=KagisoUser
)
user = KagisoUser.objects.filter(
id=data['id']
).first() or KagisoUser()
user.build_from_auth_api_data(data)
user.save()
return user
finally:
pre_save.connect(save_user_to_auth_api, sender=KagisoUser)
def lecture_pre_save(sender, instance, *args, **kwargs):
"""Delete old poster image if exists."""
if instance.pk:
old_lecture = Lecture.objects.get(pk=instance.pk)
# If new poster has different name
if old_lecture.poster and instance.poster and old_lecture.poster.name != instance.poster.name:
pre_save.disconnect(lecture_pre_save, sender=sender)
old_lecture.poster.delete()
pre_save.connect(lecture_pre_save, sender=sender)
# If poster is removed
elif old_lecture.poster and not instance.poster:
pre_save.disconnect(lecture_pre_save, sender=sender)
old_lecture.poster.delete()
pre_save.connect(lecture_pre_save, sender=sender)
def test_object_not_indexable_if_disabled(self):
from haystack.query import SearchQuerySet
from django.db.models.signals import pre_save
from aristotle_mdr.models import check_concept_app_label
pre_save.disconnect(check_concept_app_label)
unindexed_item = Question.objects.create(
name="Different Question",
definition="Some different unique string")
pre_save.connect(check_concept_app_label)
sqs = SearchQuerySet().auto_query("Different Question unique")
self.assertTrue(unindexed_item.pk not in [s.object.pk for s in sqs])
def unregister(self, model_class):
"""Removes a model from version control."""
try:
registration_info = self._registry.pop(model_class)
except KeyError:
raise RegistrationError, "%r has not been registered with " \
"Reversion." % model_class
else:
for field in registration_info.file_fields:
field.storage = field.storage.wrapped_storage
post_save.disconnect(self.post_save_receiver, model_class)
pre_delete.disconnect(self.pre_delete_receiver, model_class)
pre_save.disconnect(self.pre_save_receiver, model_class)
post_init.disconnect(self.post_init_receiver, model_class)
def unregister(model):
"""Unregister a model to the audit code.
:param model: Model to unregister.
:type model: object
"""
try:
pre_save.disconnect(_pre_save, sender=model, dispatch_uid=str(model))
post_save.disconnect(_post_save, sender=model, dispatch_uid=str(model))
pre_delete.disconnect(_pre_delete,
sender=model,
dispatch_uid=str(model))
except Exception as e:
logger.error("<Unregister> %s", e.message)
def test_object_not_indexable_if_disabled(self):
from haystack.query import SearchQuerySet
from django.db.models.signals import pre_save
from aristotle_mdr.models import check_concept_app_label
pre_save.disconnect(check_concept_app_label)
unindexed_item = Question.objects.create(
name="Different Question",
definition="Some different unique string"
)
pre_save.connect(check_concept_app_label)
sqs = SearchQuerySet().auto_query("Different Question unique")
self.assertTrue(unindexed_item.pk not in [s.object.pk for s in sqs])
def handle(self, **options):
pre_save.disconnect(
prevent_updates_on_published_items, sender=Questionnaire
)
configuration_code = 'unccd'
config = get_configuration(configuration_code, edition='2015')
questionnaires = Questionnaire.objects.filter(
code__startswith=configuration_code)
self.find_int_values(questionnaires, config)
pre_save.connect(
prevent_updates_on_published_items, sender=Questionnaire
)
def test_connection(self) -> None:
"""Тестирование успешного подключения сигнала."""
is_disconnected = pre_save.disconnect(
receiver=update_scheduler_status_from_cartridge, sender=Cartridge)
self.assertTrue(is_disconnected)
pre_save.connect(receiver=update_scheduler_status_from_cartridge,
sender=Cartridge)
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(pre_save_user, 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)
def setUpClass(cls):
"""Disable post_save signals during this test case"""
post_save.disconnect(foia_to_slack,
sender=Foia,
dispatch_uid="foiatracker_slack")
pre_save.disconnect(hydrate_from_rolodex,
dispatch_uid="hydrate_from_rolodex",
sender=Recipient)
pre_save.disconnect(hydrate_from_staff_api,
dispatch_uid="hydrate_from_staff_api",
sender=Sender)
fixture_path = os.path.join(os.path.dirname(__file__),
'fixtures/mailgun-post.json')
with open(fixture_path, 'r') as f:
cls.mailgun_fixture = json.loads(f.read())
super(InboundWebHookTestCase, cls).setUpClass()
def handle(self, **options):
# Temporarily disconnect the signal preventing updates on published
# Questionnaires.
pre_save.disconnect(prevent_updates_on_published_items, sender=Questionnaire)
filename = 'qcat_prais_data_language_mapping.csv'
with open(os.path.join(os.path.dirname(__file__), filename)) as file:
reader = csv.reader(file)
# Skip the header
next(reader)
for row in reader:
map_language(row[0], row[3], row[4])
# Reconnect the signal.
pre_save.connect(prevent_updates_on_published_items, sender=Questionnaire)
def pos_create_product(sender, instance, **kwargs):
product = instance
if product.id and product.img_product:
if '0_' in product.img_product:
try:
imagem = ImageUpload.objects.get(pk=product.image.id)
img_path = default_storage.location+'/'+product.img_product.__str__()
img_logo = File(open(img_path, 'r'))
default_storage.delete(img_path)
default_storage.save(img_path.replace('0_', product.id.__str__()+'_'), img_logo)
imagem.upload = imagem.upload.replace('0_', product.id.__str__()+'_')
imagem.name = imagem.name.replace('0_', product.id.__str__()+'_')
product.img_product = imagem.upload
imagem.save()
pre_save.disconnect(receiver, sender)
product.save()
pre_save.connect(receiver, sender)
except:
pass
