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_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 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 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 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