Exemplo n.º 1
0
def install_cacheops():
    """
    Installs cacheops by numerous monkey patches
    """
    global installed
    if installed:
        return # just return for now, second call is probably done due cycle imports
    installed = True

    monkey_mix(Manager, ManagerMixin)
    monkey_mix(QuerySet, QuerySetMixin)
    monkey_mix(ValuesQuerySet, QuerySetMixin, ['iterator'])
    monkey_mix(ValuesListQuerySet, QuerySetMixin, ['iterator'])
    monkey_mix(DateQuerySet, QuerySetMixin, ['iterator'])

    # Install profile and signal handlers for any earlier created models
    from django.db.models import get_models
    for model in get_models(include_auto_created=True):
        model._default_manager._install_cacheops(model)

    # Turn off caching in admin
    from django.conf import settings
    if 'django.contrib.admin' in settings.INSTALLED_APPS:
        from django.contrib.admin.options import ModelAdmin
        def ModelAdmin_queryset(self, request):
            return o_ModelAdmin_queryset(self, request).nocache()
        o_ModelAdmin_queryset = ModelAdmin.queryset
        ModelAdmin.queryset = ModelAdmin_queryset

    # bind m2m changed handler
    m2m_changed.connect(invalidate_m2m)
Exemplo n.º 2
0
 def ready(self):
     from c3nav.editor.models import ChangeSet
     from c3nav.editor.signals import set_changeset_author_on_login
     post_save.connect(ChangeSet.object_changed_handler)
     post_delete.connect(ChangeSet.object_changed_handler)
     m2m_changed.connect(ChangeSet.object_changed_handler)
     user_logged_in.connect(set_changeset_author_on_login)
Exemplo n.º 3
0
 def ready(self):
     from .models import AdditionalInformationForPrice
     from .signals import m2m_changed_information
     m2m_changed.connect(
         receiver=m2m_changed_information,
         sender=AdditionalInformationForPrice.information.through
     )
Exemplo n.º 4
0
def install_cacheops():
    """
    Installs cacheops by numerous monkey patches
    """
    monkey_mix(Manager, ManagerMixin)
    monkey_mix(QuerySet, QuerySetMixin)
    monkey_mix(ValuesQuerySet, QuerySetMixin, ['iterator'])
    monkey_mix(ValuesListQuerySet, QuerySetMixin, ['iterator'])
    monkey_mix(DateQuerySet, QuerySetMixin, ['iterator'])

    # Install profile and signal handlers for any earlier created models
    from django.db.models import get_models
    for model in get_models(include_auto_created=True):
        model._default_manager._install_cacheops(model)

    # Turn off caching in admin
    from django.contrib.admin.options import ModelAdmin
    def ModelAdmin_queryset(self, request):
        queryset = o_ModelAdmin_queryset(self, request)
        if queryset._cacheprofile is None:
            return queryset
        else:
            return queryset.nocache()
    o_ModelAdmin_queryset = ModelAdmin.queryset
    ModelAdmin.queryset = ModelAdmin_queryset

    # bind m2m changed handler
    m2m_changed.connect(invalidate_m2m)
Exemplo n.º 5
0
	def register_poster(self, model, stream_field, *actions):
		field = getattr(model, stream_field).field
		stream = field.rel.to
		
		if isinstance(stream, str):
			stream = get_model(*stream.split('.'))
		
		if not stream in self._registry:
			raise NotRegistered('Model %s not registered.' % stream)
		
		self._models[model] = stream_field
		
		if isinstance(field, ForeignKey):
			self.logger.debug(
				'Registered poster model %s for stream model %s' % (
					model._meta.verbose_name.capitalize(),
					stream._meta.verbose_name.capitalize()
				)
			)
		elif isinstance(field, ManyToManyField):
			m2m_changed.connect(receivers.m2m_changed)
			
			self.logger.debug(
				'Registered poster model %s for many-to-many stream model %s' % (
					model._meta.verbose_name.capitalize(),
					stream._meta.verbose_name.capitalize()
				)
			)
		else:
			raise ImproperlyConfigured('Connecting field must be a ForeignKey or ManyToMany field')
		
		pre_save.connect(receivers.pre_save, sender = model)
		pre_delete.connect(receivers.pre_delete, sender = model)
		post_save.connect(receivers.post_save, sender = model)
Exemplo n.º 6
0
    def register(self, model_or_iterable, model_metatags_class=None, **options):
        if not model_metatags_class:
            model_metatags_class = ModelMetatags

        if isinstance(model_or_iterable, ModelBase):
            model_or_iterable = [model_or_iterable]
        for model in model_or_iterable:
            if model in self._registry:
                raise AlreadyRegistered(
                    u'The model %s already registered' % model.__name__)

            self._append_inline_instance(model)

            if options:
                options['__module__'] = __name__
                model_metatags_class = type(
                    '%sMetatags' % model.__name__,
                    (model_metatags_class,), options)
            model_metatags = model_metatags_class()
            self._registry[model] = model_metatags

            pre_delete.connect(self.delete_metatag, sender=model)
            post_save.connect(self.check_metatag_url_path, sender=model)
            post_save.connect(self.check_metatag_language, sender=model)

            sites_field_class = model_metatags.sites_field_class(model)
            if sites_field_class is ManyToManyField:
                through_model = getattr(
                    model, model_metatags.sites_field_name).through
                m2m_changed.connect(
                    self.check_metatag_sites, sender=through_model)
            else:
                post_save.connect(self.check_metatag_site, sender=model)
Exemplo n.º 7
0
    def test_admin_form_should_stop_user_demoting_themselves(self):
        self.login()
        
        from models import IntranetGroup 
        manager = IntranetGroup.objects.get(name="Manager")
        self.assertTrue(manager.administrators, """This test will not work 
            unless the Manager group's administrators flag is set""")
        self.assertTrue(self.current_user.is_superuser)
        self.assertIn(manager.group, self.current_user.groups.all())

        url = reverse('admin:binder_intranetuser_change',
            args=[self.current_user.id])
        response = self.client.get(url)

        # POST without changing anything should be fine
        form = self.assertInDict('adminform', response.context).form
        new_values = self.update_form_values(form)
        response = self.client.post(url, new_values, follow=True)
        self.assert_changelist_not_admin_form_with_errors(response)

        # but changing the group should result in an error
        user = IntranetGroup.objects.get(name="User")
        new_values = self.update_form_values(form, groups=[user.pk])
        response = self.client.post(url, new_values)
        self.assert_admin_form_with_errors_not_changelist(response,
            {'groups': ['You cannot demote yourself from the %s group' %
                manager.name]})
        
        # shouldn't be allowed to do anything that removes our superuser flag
        # remove us from manager group, but keep superuser flag.
        # temporarily disable the signal listener so that it doesn't
        # automatically demote us from superuser
        from django.db.models.signals import m2m_changed
        from django.dispatch import receiver
        m2m_changed.disconnect(sender=User.groups.through,
            receiver=IntranetUser.groups_changed, dispatch_uid="User_groups_changed")
        self.current_user.groups = [user]
        m2m_changed.connect(sender=User.groups.through,
            receiver=IntranetUser.groups_changed, dispatch_uid="User_groups_changed")
        
        self.current_user = self.current_user.reload()
        self.assertItemsEqual([user.group], self.current_user.groups.all())
        self.assertTrue(self.current_user.is_superuser)
        # now we're not removing ourselves from any groups, but saving
        # would still demote us automatically from being a superuser.
        response = self.client.post(url, new_values)
        self.assert_admin_form_with_errors_not_changelist(response,
            {'groups': ['You cannot demote yourself from being a superuser. ' +
                'You must put yourself in one of the Administrators groups: ' +
                '%s' % IntranetGroup.objects.filter(administrators=True)]})
        
        # we shouldn't be allowed to delete ourselves either
        deleted = IntranetGroup.objects.get(name="Deleted")
        user = IntranetGroup.objects.get(name="User")
        new_values = self.update_form_values(form, groups=[manager.pk, deleted.pk])
        # import pdb; pdb.set_trace()
        response = self.client.post(url, new_values)
        self.assert_admin_form_with_errors_not_changelist(response,
            {'groups': ['You cannot place yourself in the %s group' %
                deleted.name]})
Exemplo n.º 8
0
    def ready(self):
        RabbitWorker().declare_exchange()
        from models import Collection, Export
        from sched import start_sched, schedule_harvest_receiver, unschedule_harvest_receiver
        from export import export_receiver, export_m2m_receiver
        from notifications import send_user_harvest_emails

        if settings.SCHEDULE_HARVESTS:
            log.debug("Setting receivers for collections.")
            post_save.connect(schedule_harvest_receiver, sender=Collection)
            pre_delete.connect(unschedule_harvest_receiver, sender=Collection)

        # Export
        if settings.PERFORM_EXPORTS:
            log.debug("Setting receiver for exports.")
            post_save.connect(export_receiver, sender=Export)
            m2m_changed.connect(export_m2m_receiver, sender=Export.seeds.through)

        # Add 5 minute interval
        if settings.FIVE_MINUTE_SCHEDULE:
            log.debug("Adding 5 minute timer")
            Collection.SCHEDULE_CHOICES.append((5, "Every 5 minutes"))

        if settings.RUN_SCHEDULER:
            log.debug("Running scheduler")
            sched = start_sched()
            if settings.PERFORM_USER_HARVEST_EMAILS:
                if sched.get_job('user_harvest_emails') is not None:
                    sched.remove_job('user_harvest_emails')
                sched.add_job(send_user_harvest_emails, 'cron', hour=settings.USER_HARVEST_EMAILS_HOUR,
                              minute=settings.USER_HARVEST_EMAILS_MINUTE, id='user_harvest_emails')

        else:
            log.debug("Not running scheduler")
Exemplo n.º 9
0
def add_signal_listeners():
    for table, properties in holonet_settings.MAPPING_MODELS.items():
        model = get_model(*table.split('.'))
        post_save.connect(mapping_change, model)
        post_delete.connect(mapping_delete, model)
        pre_save.connect(pre_save_mapping_check, model)

        # Add signal på many to many relations
        relation_list = properties.get('recipient_relations', [])
        if not isinstance(relation_list, list):
            raise HolonetConfigurationError('recipient_relations needs to be a list of strings.')

        for relation in relation_list:
            if not isinstance(relation, str):
                raise HolonetConfigurationError('Each item in recipient_relations need to be a '
                                                'string.')

            relation_field = getattr(model, relation, None)
            if relation_field is None:
                raise HolonetConfigurationError('Could not find the relation_field on the model.')

            if not isinstance(relation_field, ReverseManyDescriptor):
                raise HolonetConfigurationError('The relation field needs to be of type '
                                                'models.ManyToManyField')

            m2m_changed.connect(mapping_recipient_list_change, relation_field.through)
Exemplo n.º 10
0
    def _connect_signal_handlers(self):
        post_save.connect(self.handle_object_update, sender=self.model)
        pre_delete.connect(self.handle_object_deletion, sender=self.model)

        sites_field_class = self.sites_field_class()
        if sites_field_class is ManyToManyField:
            self._through = getattr(self.model, self.sites_field_name).through
            m2m_changed.connect(self.handle_object_update, self._through)
Exemplo n.º 11
0
def register_signals():
    from c3nav.mapdata.models.geometry.base import GeometryMixin
    for model in get_submodels(GeometryMixin):
        post_delete.connect(geometry_deleted, sender=model)

    from c3nav.mapdata.models.locations import SpecificLocation
    for model in get_submodels(SpecificLocation):
        m2m_changed.connect(locationgroup_changed, sender=model.groups.through)
Exemplo n.º 12
0
def finalize():
    for relation in modules.tax.Tax.m2m_invalidations:
        field = getattr(modules.tax.Tax, relation)
        m2m_changed.connect(on_tax_m2m_changed, sender=field.through)
    for subtype in modules.tax.subtypes:
        pre_save.connect(on_tax_pre_save, sender=subtype)
        post_save.connect(on_tax_post_save, sender=subtype)
        pre_delete.connect(on_tax_pre_delete, sender=subtype)
Exemplo n.º 13
0
 def test_m2m_changed_signal_is_fired(self):
     # Use object attrs instead of mocks for Django 1.4 compat
     self.m2m_changed_fired = False
     def test_m2m_changed(*args, **kwargs):
         self.m2m_changed_fired = True
     m2m_changed.connect(test_m2m_changed, dispatch_uid='test_m2m_changed')
     store = mommy.make(Store, make_m2m=True)
     self.assertTrue(self.m2m_changed_fired)
Exemplo n.º 14
0
 def register_signal_handlers(self, sender):
     post_save.connect(self.post_save, sender=sender, weak=False)
     post_delete.connect(self.post_delete, sender=sender, weak=False)
     get_m2m_through_classes = M2MThroughClassesGatherer(sender)
     through_classes = get_m2m_through_classes()
     for through_class in through_classes:
         m2m_changed.connect(self.m2m_changed, sender=through_class,
                             weak=False)
Exemplo n.º 15
0
    def setup(self):
        super(AristotleChannelsSignalProcessor, self).setup()

        from aristotle_mdr.models import ReviewRequest, concept_visibility_updated

        post_save.connect(self.update_visibility_review_request, sender=ReviewRequest)
        m2m_changed.connect(self.update_visibility_review_request, sender=ReviewRequest.concepts.through)
        concept_visibility_updated.connect(self.handle_concept_recache)
Exemplo n.º 16
0
 def connect_signals(self):
     """
     * m2m validation before templates are added to a config
     """
     from .models import Config
     m2m_changed.connect(Config.clean_templates,
                         sender=Config.templates.through)
     m2m_changed.connect(Config.templates_changed,
                         sender=Config.templates.through)
Exemplo n.º 17
0
 def setup(self):
     from aristotle_mdr.models import _concept, Workgroup, ReviewRequest, concept_visibility_updated
     post_save.connect(self.handle_concept_save)
     # post_revision_commit.connect(self.handle_concept_revision)
     pre_delete.connect(self.handle_concept_delete, sender=_concept)
     post_save.connect(self.update_visibility_review_request, sender=ReviewRequest)
     m2m_changed.connect(self.update_visibility_review_request, sender=ReviewRequest.concepts.through)
     concept_visibility_updated.connect(self.handle_concept_recache)
     super(AristotleSignalProcessor, self).setup()
Exemplo n.º 18
0
 def ready(self):
     m2m_changed.connect(
         issue_tags_changed,
         sender=self.get_model('Issue').tags.through,
         dispatch_uid="tags_change"
     )
     post_save.connect(
         issue_created,
         sender=self.get_model('Issue')
     )
Exemplo n.º 19
0
    def ready(self):

        from .models import MeetingInteraction, PhoneInteraction
        from .signals.handlers import set_attendees_string

        m2m_changed.connect(
            set_attendees_string, sender=PhoneInteraction.attendees.through)
        m2m_changed.connect(
            set_attendees_string, sender=MeetingInteraction.attendees.through)

        AppConfig.ready(self)
Exemplo n.º 20
0
def install_cacheops():
    """
    Installs cacheops by numerous monkey patches
    """
    monkey_mix(Manager, ManagerMixin)
    monkey_mix(QuerySet, QuerySetMixin)
    QuerySet._cacheprofile = QuerySetMixin._cacheprofile
    QuerySet._cloning = QuerySetMixin._cloning

    # DateQuerySet existed in Django 1.7 and earlier
    # Values*QuerySet existed in Django 1.8 and earlier
    from django.db.models import query
    for cls_name in ('ValuesQuerySet', 'ValuesListQuerySet', 'DateQuerySet'):
        if hasattr(query, cls_name):
            cls = getattr(query, cls_name)
            monkey_mix(cls, QuerySetMixin, ['iterator'])

    try:
        # Use app registry in Django 1.7
        from django.apps import apps
        admin_used = apps.is_installed('django.contrib.admin')
        get_models = apps.get_models
    except ImportError:
        # Introspect INSTALLED_APPS in older djangos
        from django.conf import settings
        admin_used = 'django.contrib.admin' in settings.INSTALLED_APPS
        from django.db.models import get_models

    # Install profile and signal handlers for any earlier created models
    for model in get_models(include_auto_created=True):
        model._default_manager._install_cacheops(model)

    # Turn off caching in admin
    if admin_used:
        from django.contrib.admin.options import ModelAdmin

        # Renamed queryset to get_queryset in Django 1.6
        method_name = 'get_queryset' if hasattr(ModelAdmin, 'get_queryset') else 'queryset'

        @monkey(ModelAdmin, name=method_name)
        def get_queryset(self, request):
            return get_queryset.original(self, request).nocache()

    # Bind m2m changed handler
    m2m_changed.connect(invalidate_m2m)

    # Make buffers/memoryviews pickleable to serialize binary field data
    if six.PY2:
        import copy_reg
        copy_reg.pickle(buffer, lambda b: (buffer, (bytes(b),)))
    if six.PY3:
        import copyreg
        copyreg.pickle(memoryview, lambda b: (memoryview, (bytes(b),)))
 def setup(self):
     from aristotle_mdr.models import _concept, concept_visibility_updated
     from aristotle_mdr.contrib.reviews.models import ReviewRequest
     from aristotle_mdr.contrib.help.models import HelpPage, ConceptHelp
     post_save.connect(self.handle_concept_save)
     # post_revision_commit.connect(self.handle_concept_revision)
     pre_delete.connect(self.handle_concept_delete, sender=_concept)
     post_save.connect(self.update_visibility_review_request, sender=ReviewRequest)
     m2m_changed.connect(self.update_visibility_review_request, sender=ReviewRequest.concepts.through)
     concept_visibility_updated.connect(self.handle_concept_recache)
     post_save.connect(self.async_handle_save, sender=HelpPage)
     post_save.connect(self.async_handle_save, sender=ConceptHelp)
     super().setup()
Exemplo n.º 22
0
def install_cacheops():
    """
    Installs cacheops by numerous monkey patches
    """
    monkey_mix(Manager, ManagerMixin)
    monkey_mix(QuerySet, QuerySetMixin)

    # Use app registry to introspect used apps
    from django.apps import apps

    # Install profile and signal handlers for any earlier created models
    for model in apps.get_models(include_auto_created=True):
        if family_has_profile(model):
            if not isinstance(model._default_manager, Manager):
                raise ImproperlyConfigured("Can't install cacheops for %s.%s model:"
                                           " non-django model class or manager is used."
                                            % (model._meta.app_label, model._meta.model_name))
            model._default_manager._install_cacheops(model)

            # Bind m2m changed handlers
            rel_attr = 'remote_field' if django.VERSION >= (1, 9) else 'rel'
            m2ms = (f for f in model._meta.get_fields(include_hidden=True) if f.many_to_many)
            for m2m in m2ms:
                rel = m2m if hasattr(m2m, 'through') else getattr(m2m, rel_attr, m2m)
                opts = rel.through._meta
                m2m_changed.connect(invalidate_m2m, sender=rel.through,
                                    dispatch_uid=(opts.app_label, opts.model_name))

    # Turn off caching in admin
    if apps.is_installed('django.contrib.admin'):
        from django.contrib.admin.options import ModelAdmin

        @monkey(ModelAdmin)
        def get_queryset(self, request):
            return get_queryset.original(self, request).nocache()

    # Make buffers/memoryviews pickleable to serialize binary field data
    if six.PY2:
        import copy_reg
        copy_reg.pickle(buffer, lambda b: (buffer, (bytes(b),)))  # noqa
    if six.PY3:
        import copyreg
        copyreg.pickle(memoryview, lambda b: (memoryview, (bytes(b),)))

    # Fix random ordered dict keys producing different SQL for same QuerySet
    if (3, 3) <= sys.version_info < (3, 6):
        from django.db.models.query_utils import Q

        def Q__init__(self, *args, **kwargs):  # noqa
            super(Q, self).__init__(children=list(args) + list(sorted(kwargs.items())))
        Q.__init__ = Q__init__
Exemplo n.º 23
0
    def ready(self):
        # connect m2m_changed signal for TrainingRequest.domains to calculate
        # score_auto
        TrainingRequest = self.get_model('TrainingRequest')

        m2m_changed.connect(
            trainingrequest_m2m_changed,
            sender=TrainingRequest.domains.through,
        )

        m2m_changed.connect(
            trainingrequest_m2m_changed,
            sender=TrainingRequest.previous_involvement.through,
        )
def _track_class_field(cls, field):
    """ Track a field on the current model """
    if '__' in field:
        _track_class_related_field(cls, field)
        return
    # Will raise FieldDoesNotExist if there is an error
    cls._meta.get_field(field)
    # Detect m2m fields changes
    if isinstance(cls._meta.get_field(field), ManyToManyField):
        m2m_changed.connect(
            tracking_m2m,
            sender=getattr(cls, field).through,
            dispatch_uid=repr(cls),
        )
Exemplo n.º 25
0
def setup_discounts():
    for relation in modules.discount.Discount.m2m_invalidations:
        field = getattr(modules.discount.Discount, relation)
        m2m_changed.connect(on_discount_m2m_changed, sender=field.through)
    for subtype in modules.discount.subtypes:
        pre_save.connect(on_discount_pre_save, sender=subtype)
        post_save.connect(on_discount_post_save, sender=subtype)
        pre_delete.connect(on_discount_pre_delete, sender=subtype)

    if modules.discount.user_discount_enabled:
        m2m_changed.connect(
            on_discount_groups_changed,
            sender=modules.discount.Discount.groups.through)
        post_save.connect(
            on_group_post_save, sender=modules.discount.DiscountGroup)
Exemplo n.º 26
0
def turn_on_syncing(for_post_save=True, for_post_delete=True, for_m2m_changed=True, for_post_bulk_operation=False):
    """
    Enables all of the signals for syncing entities. Everything is True by default, except for the post_bulk_operation
    signal. The reason for this is because when any bulk operation occurs on any mirrored entity model, it will
    result in every single entity being synced again. This is not a desired behavior by the majority of users, and
    should only be turned on explicitly.
    """
    if for_post_save:
        post_save.connect(save_entity_signal_handler, dispatch_uid='save_entity_signal_handler')
    if for_post_delete:
        post_delete.connect(delete_entity_signal_handler, dispatch_uid='delete_entity_signal_handler')
    if for_m2m_changed:
        m2m_changed.connect(m2m_changed_entity_signal_handler, dispatch_uid='m2m_changed_entity_signal_handler')
    if for_post_bulk_operation:
        post_bulk_operation.connect(bulk_operation_signal_handler, dispatch_uid='bulk_operation_signal_handler')
Exemplo n.º 27
0
def connect_signals():
    post_save.connect(prepare_estate_childs, sender=Estate)
    post_save.connect(set_validity, sender=Estate)
    post_save.connect(set_validity, sender=Bidg)
    post_save.connect(set_validity, sender=Stead)
    post_save.connect(update_deleted, sender=Client)
    post_save.connect(update_estate, sender=Contact)
    post_save.connect(estate_client_handler, sender=EstateClient)
    post_delete.connect(estate_client_handler, sender=EstateClient)
    post_save.connect(update_geo, sender=Bid) # @UndefinedVariable
    pre_save.connect(update_from_pickle, sender=Bid)
    post_save.connect(bid_event_history, sender=BidEvent)
    post_save.connect(estate_wp_meta, sender=Estate)
    m2m_changed.connect(estate_param_wp_meta, sender=Estate.estate_params.through)  # @UndefinedVariable
    post_save.connect(update_estate_m2m, sender=EntranceEstate)  # @UndefinedVariable    
    post_save.connect(update_estate_m2m, sender=EstatePhoto)  # @UndefinedVariable
    post_save.connect(save_estate, sender=Layout)
Exemplo n.º 28
0
 def connect(self, model):
     """
     Connect to the model. It is called in `Registry.register` method thus
     users should not call this method directly
     """
     self.model = model
     self.app_label = model._meta.app_label
     # connect post_save/pre_delete signal
     post_save.connect(self._post_save_receiver, sender=model,
                       weak=False)
     pre_delete.connect(self._pre_delete_receiver, sender=model,
                        weak=False)
     # connect m2m_changed signal of all ManyToMany fields
     for m2m in self.get_m2m_fields():
         m2m_changed.connect(self._m2m_changed_receiver,
                             sender=m2m.rel.through,
                             weak=False)
Exemplo n.º 29
0
 def connect(self):
     for signal_name in ('pre_migrate', 'post_migrate'):
         signal = globals()[signal_name]
         dispatch_uid = self.get_dispatch_uid(signal_name)
         signal.connect(
             getattr(self, 'on_{}'.format(signal_name)),
             sender=self.m2m_model_class._meta.app_config,
             dispatch_uid=dispatch_uid,
         )
         log_trace('%r: connect %s', self, dispatch_uid)
     dispatch_uid = self.get_dispatch_uid('m2m_changed')
     m2m_changed.connect(
         self.on_m2m_changed,
         sender=self.m2m_model_class,
         dispatch_uid=dispatch_uid,
     )
     log_trace('%r: connect %s', self, dispatch_uid)
Exemplo n.º 30
0
Arquivo: redis.py Projeto: kvbik/ella
def connect_signals():
    from django.db.models.signals import pre_save, post_save, post_delete, pre_delete, m2m_changed
    from ella.core.signals import content_published, content_unpublished
    from ella.core.models import Listing, Publishable

    if not core_settings.USE_REDIS_FOR_LISTINGS:
        return
    # when redis is availible, use it for authors
    m2m_changed.connect(update_authors, sender=Publishable._meta.get_field('authors').rel.through)

    content_published.connect(publishable_published)
    content_unpublished.connect(publishable_unpublished)

    pre_save.connect(listing_pre_save, sender=Listing)
    post_save.connect(listing_post_save, sender=Listing)

    pre_delete.connect(listing_pre_delete, sender=Listing)
    post_delete.connect(listing_post_delete, sender=Listing)
Exemplo n.º 31
0
    def __str__(self):
        return str(self.id)


def m2m_changed_carrinho_receiver(
        sender, instance, action, *args,
        **kwargs):  # quando a venda é salva, chamamos este método
    if action == 'post_add' or action == 'post_remove' or action == 'post_clear':
        produtos = instance.produtos.all()
        total = 0
        for item in produtos:
            total += item.price
        if instance.subtotal != total:
            instance.subtotal = total
            instance.save()


m2m_changed.connect(m2m_changed_carrinho_receiver,
                    sender=Carrinho.produtos.through)


def pre_save_carrinho_receiver(sender, instance, *args, **kwargs):
    if instance.subtotal > 0:
        instance.total = instance.subtotal + 10
    else:
        instance.total = 0.00


pre_save.connect(pre_save_carrinho_receiver, sender=Carrinho)
Exemplo n.º 32
0
def increment_range_cache_version(sender, instance, **kwargs):
    instance.increment_cache_version()


def invalidate_pricing_cache_ns(sender, instance, **kwargs):
    transaction.on_commit(lambda: pricing_cache_ns.invalidate())


def update_range_member_cache(sender, instance, **kwargs):
    for r in Range.objects.all():
        r.increment_cache_version()


# Invalidate range cache when it's data changes
m2m_changed.connect(increment_range_cache_version, sender=Range.included_products.through)
m2m_changed.connect(increment_range_cache_version, sender=Range.excluded_products.through)
m2m_changed.connect(increment_range_cache_version, sender=Range.classes.through)
m2m_changed.connect(increment_range_cache_version, sender=Range.included_categories.through)

# Update range member cache when a product/category is saved
post_save.connect(update_range_member_cache, sender=ProductCategory)
post_save.connect(update_range_member_cache, sender=Product)

# Invalidate cosmetic price cache whenever any Offer data changes
post_save.connect(invalidate_pricing_cache_ns, sender=OfferGroup)
post_save.connect(invalidate_pricing_cache_ns, sender=ConditionalOffer)
post_save.connect(invalidate_pricing_cache_ns, sender=Benefit)
post_save.connect(invalidate_pricing_cache_ns, sender=Condition)

# Invalidate cosmetic price cache whenever any Product Range data changes
Exemplo n.º 33
0
    objects = CartManager()

    def __str__(self):
        return str(self.id)

def m2m_changed_cart_receiver(sender, instance, action, *args, **kwargs):
    if action == "post_add" or action == "post_remove" or action == "post_clear":
    # print(action)
    # print(instance.product.all())
    # print(instance.total)
        product = instance.product.all()
        total = 0
        for x in product:
            total += x.price
        if instance.subtotal != total:
            #print(total)
            instance.subtotal = total
            instance.save()

m2m_changed.connect(m2m_changed_cart_receiver, sender=Cart.product.through)


def pre_save_cart_receiver(sender, instance, *args, **kwargs):
    if instance.subtotal > 0:
        instance.total = instance.subtotal + 10 #* 1.08
    else:
        instance.total = 0.00


pre_save.connect(pre_save_cart_receiver, sender = Cart)
Exemplo n.º 34
0
            faculty.save()


def create_faculty_profile(sender, instance, created, **kwargs):
    if instance.groups.filter(name="teacher").count():
        create_faculty(instance)


def create_faculty_profile_m2m(sender, instance, action, reverse, model,
                               pk_set, **kwargs):
    if action == 'post_add' and instance.groups.filter(name="teacher").count():
        create_faculty(instance)


post_save.connect(create_faculty_profile, sender=User)
m2m_changed.connect(create_faculty_profile_m2m, sender=User.groups.through)


class UserPreference(models.Model):
    """ User Preferences """
    file_format_choices = (
        ('o', 'Open Document Format (.odt, .ods)'),
        ('m', 'Microsoft Binary (.doc, .xls)'),
        ('x',
         'Microsoft Office Open XML (.docx, .xlsx) Not recommended, formatting may be lost!'
         ),
    )
    prefered_file_format = models.CharField(
        default=settings.PREFERED_FORMAT,
        max_length="1",
        choices=file_format_choices,
Exemplo n.º 35
0
    total = models.DecimalField(decimal_places=2, max_digits=7, default=0.00)

    updated = models.DateTimeField(auto_now=True)
    timestamp = models.DateTimeField(auto_now_add=True)

    objects = CartManager()


# check for product manyToMany Changes and update cart total
def m2m_cart_reciever(sender, instance, action, *args, **kwargs):
    if action == 'post_add' or action == 'post_remove' or action == 'post_clear':
        total = 0
        for product in instance.products.all():
            total += product.price
        print(total)
        instance.subtotal = total
    instance.save()


m2m_changed.connect(m2m_cart_reciever, sender=Cart.products.through)


# update total when cart presave
def pre_save_cart(sender, instance, *args, **kwargs):
    if instance.subtotal > 0:
        instance.total = instance.subtotal + 10
    else:
        instance.total = 0.00


pre_save.connect(pre_save_cart, sender=Cart)
Exemplo n.º 36
0
        for email, ident in cls.objects.filter(services__in=services)\
                                       .values_list('email', 'ident')\
                                       .distinct():
            # send email
            body = SUBSCRIPTION_EMAIL_TEMPLATE % dict(
                sub_url=urlparse.urljoin(
                    conf.BASE_URL,
                    reverse('overseer:update_subscription', args=[ident])),
                message=message,
                affects=affects,
                name=conf.NAME,
            )
            send_mail('Status Change on %s' % conf.NAME,
                      body,
                      conf.FROM_EMAIL, [email],
                      fail_silently=True)


class UnverifiedSubscription(BaseSubscription):
    """
    A temporary store for unverified subscriptions.
    """
    email = models.EmailField()


post_save.connect(Service.handle_event_save, sender=Event)
post_save.connect(Event.handle_update_save, sender=EventUpdate)
m2m_changed.connect(Service.handle_event_m2m_save,
                    sender=Event.services.through)
post_save.connect(Subscription.handle_update_save, sender=EventUpdate)
Exemplo n.º 37
0
    m2m_changed.connect(emit_update_inventory_computed_fields,
                        sender=Group.inventory_sources.through)
    post_save.connect(emit_update_inventory_on_created_or_deleted,
                      sender=InventorySource)
    post_delete.connect(emit_update_inventory_on_created_or_deleted,
                        sender=InventorySource)
    post_save.connect(emit_update_inventory_on_created_or_deleted, sender=Job)
    post_delete.connect(emit_update_inventory_on_created_or_deleted,
                        sender=Job)


connect_computed_field_signals()

post_save.connect(emit_job_event_detail, sender=JobEvent)
post_save.connect(emit_ad_hoc_command_event_detail, sender=AdHocCommandEvent)
m2m_changed.connect(rebuild_role_ancestor_list, Role.parents.through)
m2m_changed.connect(org_admin_edit_members, Role.members.through)
m2m_changed.connect(rbac_activity_stream, Role.members.through)
m2m_changed.connect(rbac_activity_stream, Role.parents.through)
post_save.connect(sync_superuser_status_to_rbac, sender=User)
post_save.connect(create_user_role, sender=User)
pre_delete.connect(cleanup_detached_labels_on_deleted_parent,
                   sender=UnifiedJob)
pre_delete.connect(cleanup_detached_labels_on_deleted_parent,
                   sender=UnifiedJobTemplate)

# Migrate hosts, groups to parent group(s) whenever a group is deleted


@receiver(pre_delete, sender=Group)
def save_related_pks_before_group_delete(sender, **kwargs):
Exemplo n.º 38
0
    order.save()


def saveOrder(sender,instance,**kwargs):
    try:
        order=Order.objects.get(user=instance.user)
    except Order.DoesNotExist:
        pass
    else:
        updateTotal(order)
        

pre_delete.connect(deleteOrder,sender=Order) #Before you delete the order delete all items associated with it
post_save.connect(saveOrder,sender=OrderItem)#After saving an Orderitem update the order total
post_delete.connect(saveOrder,sender=OrderItem)#After deleting an OrderItem update the total
m2m_changed.connect(OrderItemChanged,sender=Order.items.through)#IF an item has been added or removed to my order, update the total


class CaoruselImages(models.Model):
    CaoruselImage=models.ImageField(upload_to="Carousel_Images")

    def get_img_url(self):
            return self.CaoruselImage.url

    def __str__(self):
        return f'Caorusel Image {self.id}'

        
class CategoryInfo(models.Model):
    CategoryImages=models.ImageField(upload_to="Category_Images")
    category=models.CharField(max_length=15,choices=category_choices,default='ADD SOON')
Exemplo n.º 39
0
                                   max_digits=100,
                                   decimal_places=2)
    timestamp = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

    objects = CartManager()

    def __str__(self):
        return str(self.id)


def cart_m2m_changed_save_receiver(sender, instance, action, *args, **kwargs):
    if action in ['post_add', 'post_remove', 'post_clear']:
        products = instance.products.all()
        total = sum([x.price for x in products])
        if instance.subtotal != total:
            instance.subtotal = total
            instance.save()


def cart_pre_save_receiver(sender, instance, *args, **kwargs):
    if instance.subtotal > 0:
        instance.total = instance.subtotal + 20
    else:
        instance.total = 0


pre_save.connect(cart_pre_save_receiver, sender=Cart)
m2m_changed.connect(cart_m2m_changed_save_receiver,
                    sender=Cart.products.through)
        instance.costList = []
        for i in instance.food.all():
            instance.costList.append(i.pricePerQuantity *
                                     int(instance.quantity[count]))
            cost = cost + (i.pricePerQuantity * int(instance.quantity[count]))
            count = count + 1
        instance.totalCost = cost
        instance.save()


def orderConfirmed(sender, instance, created, **kwargs):
    if (instance.order_status == '2'):
        broadcast_to_socket(instance)


m2m_changed.connect(newOrderCreated, sender=Orders.food.through)
post_save.connect(orderConfirmed, sender=Orders)


def editFood(request, key):
    obj = Food.objects.get(pk=key)
    if request.method == 'POST':
        form = editFoodForm(request.POST, instance=obj)
        if form.is_valid:
            form.save()
            messages.success(request, f'Food Item updated successfully!')
            return redirect('viewMenu')
        else:
            messages.warning(request, f'Invalid input')
    else:
        form = editFoodForm(instance=obj)
Exemplo n.º 41
0
    # garantee that student has been subscribe in only one class
    if action == 'post_add':
        try:
            for student in instance.students.all():
                classes = student.classes.filter(
                    course=instance.course).exclude(id=instance.id)
                for classe in classes:
                    student.classes.remove(classe)

        # garantee that this block executes only when instance == Class.
        except AttributeError:
            pass


m2m_changed.connect(remove_duplicate_classes, sender=Class.students.through)


class Course(models.Model):
    STATES = (
        ('draft', _('Draft')),
        ('published', _('Published')),
    )

    slug = models.SlugField(_('Slug'), max_length=255, unique=True)
    name = models.CharField(_('Name'), max_length=255, blank=True)
    intro_video = models.ForeignKey(Video,
                                    verbose_name=_('Intro video'),
                                    null=True,
                                    blank=True)
    application = models.TextField(_('Application'), blank=True)
Exemplo n.º 42
0
        users = get_user_model().objects.filter(pk__in=kwargs['pk_set'])

        # Clear the user's 'owned_groups' cache
        for user in users:
            cache.delete(user.cache_key + 'owned_groups')

    # Make sure group owners can direct message all other users
    if kwargs['action'] == 'post_add':
        direct_message_permission = Permission.objects.get(
            codename='can_initiate_direct_messages',
            content_type__app_label='accounts')
        for user in users:
            user.user_permissions.add(direct_message_permission)


m2m_changed.connect(group_owners_changed, Group.owners.through)


class GroupRequestManager(models.Manager):
    """Manager for GroupRequest."""
    def unapproved(self):
        """Get unapproved requests."""
        return super(GroupRequestManager,
                     self).get_queryset().filter(moderated_by__isnull=True)


class GroupRequest(TimestampModel):
    """GroupRequest model."""
    user = models.ForeignKey(settings.AUTH_USER_MODEL)
    group = models.ForeignKey(Group)
    moderated_by = models.ForeignKey(settings.AUTH_USER_MODEL,
Exemplo n.º 43
0
    def _attach_signals(live_model):
        post_save.connect(save_copy_post_save, live_model)

        for field in live_model._meta.many_to_many:
            through_model = getattr(live_model, field.name).through
            m2m_changed.connect(on_m2m_change, sender=through_model)
Exemplo n.º 44
0
        # raw_ext = os.path.splitext(instance.raw_file.path)[1]
        # new_raw_filename = get_formatted_filename(instance.get_person(), instance.title, instance.date.year, raw_ext)


# def get_formatted_filename(person, title_str, year, ext):
#     initial_path = instance.pdf_file.path
#     person = instance.get_person()
#     name = person.last_name
#     year = instance.date.year
#     title = instance.title.title()
#     title = ''.join(x for x in title if not x.isspace())
#     title = ''.join(e for e in title if e.isalnum())
#
#     # change the pdf_file path to point to the renamed file
#     instance.pdf_file.name = os.path.join(dir_name, name + '_' + title + '_' + str(year) + '.pdf')
#     new_path = os.path.join(settings.MEDIA_ROOT, instance.pdf_file.name)
#     os.rename(initial_path, new_path)
#     instance.save()

m2m_changed.connect(update_file_name_talks, sender=Talk.speakers.through)


@receiver(post_delete, sender=Talk)
def talk_delete(sender, instance, **kwargs):
    if instance.pdf_file:
        instance.pdf_file.delete(True)
    if instance.raw_file:
        instance.raw_file.delete(True)
    if instance.thumbnail:
        instance.thumbnail.delete(True)
Exemplo n.º 45
0
        associated ``EncodeProfile``s.
        """
        from .tasks import encode_media, upload_media

        if not profiles:
            profiles = list(self.profiles.values_list('pk', flat=True))

        for profile_id in profiles:
            (encode_media.s(self.id, profile_id)
             | upload_media.s(self.id, profile_id)).apply_async()

    def set_active(self):
        """
        Set the media as active when it has been encoded into all
        associated ``EncodeProfile``s. Currently this is a one-way
        transition to prevent media from dropping in and out of the
        active set.
        """
        if not self.active:
            storage_keys = set(
                self.remotestorage_set.values_list('profile', flat=True))
            profile_keys = set(self.profiles.values_list('pk', flat=True))
            if storage_keys == profile_keys:
                self.active = True
                self.save()


pre_save.connect(set_encode_profiles, sender=Media)
m2m_changed.connect(encode_profiles_changed, sender=Media.profiles.through)
pre_delete.connect(delete_remote_storage, sender=Media)
Exemplo n.º 46
0
    objects = ThreadManager()

    class Meta:
        ordering = ['-updated']


    # Buscar los mensajes que sí están en pk set y los borra de pk_set
def messages_changed(sender, **kwargs):
    instance = kwargs.pop("instance", None)
    action = kwargs.pop("action", None)
    pk_set = kwargs.pop("pk_set", None)
    print(instance, action, pk_set)

    false_pk_set = set()
    if action is "pre_add":
        for msg_pk in pk_set:
            msg = Message.objects.get(pk=msg_pk)
            if msg.user not in instance.users.all():
                print("Ups, ({}) no forma parte del hilo".format(msg.user))
                false_pk_set.add(msg_pk)

        # Forzar la actualización haciendo save
        instance.save()

    # Borramos de pk_set los mensajes que concuerdan con los de false_pk_set
    pk_set.difference_update(false_pk_set)


m2m_changed.connect(messages_changed, sender=Thread.messages.through)
Exemplo n.º 47
0
                                   decimal_places=2)
    total = models.DecimalField(default=0.00, max_digits=100, decimal_places=2)
    updated = models.DateTimeField(auto_now=True)
    timestamp = models.DateTimeField(auto_now_add=True)
    objects = CartManager()

    def __str__(self):
        return str(self.id)


def m2m_changed_cart_receiver(sender, instance, action, *args, **kwargs):
    if action == 'post_add' or action == 'post_remove' or action == 'post_clear':
        products = instance.products.all()
        total = 0
        for x in products:
            total += x.price
        if instance.subtotal != total:
            instance.subtotal = total
            instance.save()


m2m_changed.connect(m2m_changed_cart_receiver,
                    sender=Cart.products.through,
                    weak=False)


def pre_save_cart_receiver(sender, instance, *args, **kwargs):
    instance.total = instance.subtotal  #*1.08


pre_save.connect(pre_save_cart_receiver, sender=Cart)
Exemplo n.º 48
0
            sub.date = datetime.datetime.utcnow().replace(tzinfo=utc)
            sub.save()
            # Increase the subscription count of the root.
            Post.objects.filter(pk=root.id).update(subs_count=F('subs_count') +
                                                   1)

    @staticmethod
    def finalize_delete(sender, instance, *args, **kwargs):
        # Decrease the subscription count of the post.
        Post.objects.filter(pk=instance.post.root_id).update(
            subs_count=F('subs_count') - 1)


# Admin interface for subscriptions
class SubscriptionAdmin(admin.ModelAdmin):
    search_fields = ('user__name', 'user__email')
    list_select_related = ["user", "post"]


admin.site.register(Subscription, SubscriptionAdmin)

# Data signals
from django.db.models.signals import post_save, post_delete, m2m_changed

post_save.connect(Post.check_root, sender=Post)
post_save.connect(Subscription.create, sender=Post, dispatch_uid="create_subs")
post_delete.connect(Subscription.finalize_delete,
                    sender=Subscription,
                    dispatch_uid="delete_subs")
m2m_changed.connect(Tag.update_counts, sender=Post.tag_set.through)
Exemplo n.º 49
0
class CardProducts(models.Model):
    cart = models.ForeignKey(Cart, on_delete=models.CASCADE)
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    quantity = models.IntegerField(default=1)
    created_at = models.DateTimeField(auto_now_add=True)

    objects = CartProductManager()

    def update_quantity(self, quantity=1):
        self.quantity = quantity
        self.save()


def set_cart_id(sender, instance, *args, **kwargs):
    if not instance.cart_id:
        instance.cart_id = str(uuid.uuid4())


def update_totals(sender, instance, action, *args, **kwarg):
    if action == 'post_add' or action == 'post_remove' or action == 'post_clear':
        instance.update_totals()


def post_save_update_totals(sender, instance, *args, **kwargs):
    instance.cart.update_totals()


pre_save.connect(set_cart_id, sender=Cart)
post_save.connect(post_save_update_totals, sender=CardProducts)
m2m_changed.connect(update_totals, sender=Cart.products.through)
Exemplo n.º 50
0
    def __init__(self, *args, **kwargs):
        try:
            self._meta.get_field('status').default = get_default_status()
        except django.db.utils.ProgrammingError:
            pass
        return super(Poi, self).__init__(*args, **kwargs)


def update_properties_cache(sender, instance, action, reverse, model, pk_set,
                            **kwargs):
    "Property cache actualization at POI save. It will not work yet after property removal."
    if action == 'post_add':
        instance.save_properties_cache()


m2m_changed.connect(update_properties_cache, Poi.properties.through)


class GpxPoiForm(ModelForm):
    gpx_file = forms.FileField(required=False,
                               help_text=_(u"Upload geometry by GPX file"))

    class Meta:
        model = Marker
        exclude = ('geom', )

    def clean(self):
        cleaned_data = super(GpxPoiForm, self).clean()
        if 'gpx_file' in self.cleaned_data:
            gpx_file = self.cleaned_data['gpx_file']
            if gpx_file:
Exemplo n.º 51
0
        return {
            'handle': instance.handle,
            'github_url': instance.github_url,
            'local_avatar_url': instance.local_avatar_url,
            'url': instance.get_relative_url()
        }


@receiver(pre_save, sender=Tip, dispatch_uid="normalize_tip_usernames")
def normalize_tip_usernames(sender, instance, **kwargs):
    """Handle pre-save signals from Tips to normalize Github usernames."""
    if instance.username:
        instance.username = instance.username.replace("@", '')


m2m_changed.connect(m2m_changed_interested, sender=Bounty.interested.through)
# m2m_changed.connect(changed_fulfillments, sender=Bounty.fulfillments)


class UserAction(SuperModel):
    """Records Actions that a user has taken ."""

    ACTION_TYPES = [
        ('Login', 'Login'),
        ('Logout', 'Logout'),
    ]
    action = models.CharField(max_length=50, choices=ACTION_TYPES)
    profile = models.ForeignKey('dashboard.Profile',
                                related_name='actions',
                                on_delete=models.CASCADE)
    metadata = JSONField(default={})
Exemplo n.º 52
0
                     **kwargs):
    """
    Validates that a user is a friend before adding them to a FriendList.
    """
    friendlist = instance
    if action == 'pre_add' and not reverse and model == User:
        friends = User.objects.filter(pk__in=pk_set)
        for friend in friends:
            if not Friendship.objects.are_friends(friendlist.owner, friend):
                raise ValidationError(
                    "FriendList owner id %d is not friends with User id: %d" %
                    (friendlist.id, friend.id))


m2m_changed.connect(only_add_friends,
                    sender=FriendList.friends.through,
                    dispatch_uid='validate_adding_friends')


def remove_deleted_friendships_from_list(sender, instance, **kwargs):
    """
    When a friendship is deleted, remove each user from each other's lists.
    """
    user1 = instance.from_user
    user2 = instance.to_user

    for user, other_user in [(user1, user2), (user2, user1)]:
        lists = FriendList.objects.filter(owner=user)
        for l in lists:
            l.friends.remove(other_user)
Exemplo n.º 53
0
        kwargs.get('instance'), username))


def user_groups_changed(sender, **kwargs):
    group_map = {1: 'Moderators', 2: 'Editors'}
    action_map = {'post_add': 'added', 'post_remove': 'removed'}
    if kwargs.get('action').split('_')[0] == 'post':
        for index in kwargs.get('pk_set'):
            action = 'to' if kwargs.get('action').split(
                '_')[1] == 'add' else 'from'
            logger.info("User change: User {0} was {1} {2} group {3}".format(
                kwargs.get('instance').get_username(),
                action_map[kwargs.get('action')], action, group_map[index]))


m2m_changed.connect(user_groups_changed, sender=User.groups.through)


class HomePage(ContentPage, UniqueModel):
    """Unique home page."""
    @property
    def content_section(self):
        return ''


class Author(models.Model):
    name = models.CharField(max_length=255)
    title = models.CharField(max_length=255, blank=True)
    email = models.EmailField(blank=True)
    photo = models.ForeignKey('wagtailimages.Image',
                              blank=True,
Exemplo n.º 54
0
    comments = models.ManyToManyField(Comment, blank=True)
    average_rating = models.DecimalField(default=0.00, max_digits=9, decimal_places=1)
    objects = ProductManager()

    def get_absolute_url(self):
        return f'product/{self.slug}'

    def __str__(self):
        return self.name


def product_pre_save_receiver(sender, instance, *args, **kwargs):
    if instance.slug is None:
        instance.slug = unique_slug_generator(instance)


pre_save.connect(product_pre_save_receiver, sender=Product)


def average_rating_func(sender, instance, action, *args, **kwargs):
    if action == 'post_add' or action == 'post_remove' or action == 'post_clear':
        all_comments = instance.comments.all()
        total = 0
        for i in all_comments:
            total += i.rating
        instance.average_rating = total/all_comments.count()
        instance.save()


m2m_changed.connect(average_rating_func, sender=Product.comments.through)
Exemplo n.º 55
0
        try:
            clusters_to_refresh_set = diff_clusters_set.difference(
                instance.refreshed_clusters)
        except AttributeError:
            clusters_to_refresh_set = diff_clusters_set
        return list(clusters_to_refresh_set.intersection(set(all_clusters)))
    except (AttributeError, TypeError):
        return all_clusters


def mark_cluster_as_refreshed(director, clusters):
    try:
        director.refreshed_clusters |= set(clusters)
    except AttributeError:
        director.refreshed_clusters = set(clusters)


def reset_refreshed_clusters(director):
    director.refreshed_clusters = set()


def is_only_cluster_update(instance):
    try:
        return set(instance.new_data.keys()) == {'cluster'}
    except AttributeError:
        return False


m2m_changed.connect(model_update, sender=Director.cluster.through)
m2m_changed.connect(model_update, sender=Route.clusters.through)
Exemplo n.º 56
0


    def __str__(self):
        return str(self.id)


def pre_save_cart(sender,instance,action,*args,**kwargs):
    if action== 'post_add' or action =='post_remove' or action=='post_clear':
        products=instance.products.all()
        print(products)
        count=0
        total=0
        for product in products:
            total=total+product.price
            count=count+1
        instance.subtotal=total
        instance.total_count=count
        instance.save()
m2m_changed.connect(pre_save_cart,sender=Cart.products.through)

def pre_save_cart_add(sender,instance,*args,**kwargs):
    if instance.subtotal>0:
        instance.total_price=instance.subtotal+40
    else:
        instance.total_price=0.00

pre_save.connect(pre_save_cart_add,sender=Cart)


Exemplo n.º 57
0
            })

        yield SimpleHelpBlock(text=_("Add a product to see it in your store"),
                              actions=actions,
                              icon_url="shuup_admin/img/product.png",
                              priority=0,
                              category=HelpBlockCategory.PRODUCTS,
                              done=Product.objects.filter(
                                  shop_products__shop=request.shop).exists()
                              if kind == "setup" else False)

    def get_required_permissions(self):
        return (get_permissions_from_urls(self.get_urls())
                | get_default_model_permissions(Product)
                | get_default_model_permissions(File))

    def get_model_url(self, object, kind, shop=None):
        if isinstance(object, Product):
            object = object.get_shop_instance(shop)
        return derive_model_url(ShopProduct, "shuup_admin:shop_product",
                                object, kind)


m2m_changed.connect(update_categories_through,
                    sender=ShopProduct.categories.through,
                    dispatch_uid="shop_product:update_categories_through")

post_save.connect(update_categories_post_save,
                  sender=ShopProduct,
                  dispatch_uid="shop_product:update_categories")
Exemplo n.º 58
0
def update_rb_review_group(sender, instance, created, **kwargs):
    course = instance
    logger.info("update_rb_review_group: '%s'", course)

    if not course.is_rb_integrated():
        return

    rb_review_group_name = "teachers_{0}".format(course.id)
    rg = RbReviewGroup(rb_review_group_name)
    rg.create()
    teachers = set([teacher.username for teacher in course.teachers.all()])
    rg_users = set(rg.list())

    logger.info("Course: '%s', teachets '%s', rg_users '%s'", course, teachers,
                rg_users)

    for rg_user in rg_users:
        if rg_user not in teachers:
            logger.info("Course: '%s', user_del '%s'", course, rg_user)
            rg.user_del(rg_user)

    for teacher in teachers:
        if teacher not in rg_users:
            logger.info("Course: '%s', user_add '%s'", course, teacher)
            rg.user_add(teacher)


m2m_changed.connect(add_default_issue_fields,
                    sender=Course.issue_fields.through)
post_save.connect(update_rb_review_group, sender=Course)
Exemplo n.º 59
0
    timestamp = models.DateTimeField(auto_now_add=True)

    objects = BookManager()

    def __str__(self):
        return str(self.id)


def m2m_changed_book_receiver(sender, instance, action, *args, **kwargs):
    if action == 'post_add' or action == 'post_remove' or action == 'post_clear':
        products = instance.products.all()
        total = 0
        for x in products:
            total += x.price
        if instance.subtotal != total:
            instance.subtotal = total
            instance.save()


m2m_changed.connect(m2m_changed_book_receiver, sender=Book.products.through)


def pre_save_book_receiver(sender, instance, *args, **kwargs):
    if instance.subtotal > 0:
        instance.total = Decimal(instance.subtotal) * Decimal(1.08)  # 8% tax
    else:
        instance.total = 0.00


pre_save.connect(pre_save_book_receiver, sender=Book)
Exemplo n.º 60
0
    meeting = kwargs['instance']
    for mk_id in kwargs['pk_set']:
        m = Member.objects.get(pk=mk_id)
        if Action.objects.filter(actor_object_id=m.id,
                                 actor_content_type=member_ct,
                                 verb='attended',
                                 target_object_id=meeting.id,
                                 target_content_type=cm_ct).count() == 0:
            action.send(m,
                        verb='attended',
                        target=meeting,
                        description='committee meeting',
                        timestamp=meeting.date)


m2m_changed.connect(record_committee_presence,
                    sender=CommitteeMeeting.mks_attended.through)


@disable_for_loaddata
def handle_annotation_save(sender, created, instance, **kwargs):
    if created:
        action.send(instance.content_object.meeting,
                    verb='annotation-added',
                    target=instance,
                    description=unicode(instance.flag_value))
        action.send(instance.user,
                    verb='annotated',
                    target=instance,
                    description=unicode(instance.flag_value))
        follow(instance.user, instance.content_object.meeting)