def register(model, fields, restrict_to=None, manager=None):
"""Tell vinaigrette which fields on a Django model should be translated.
Arguments:
model -- The relevant model class
fields -- A list or tuple of field names. e.g. ['name', 'nickname']
restrict_to -- Optional. A django.db.models.Q object representing the subset
of objects to collect translation strings from.
manager -- Optional. A reference to a manager -- e.g. Person.objects -- to use
when collecting translation strings.
Note that both restrict_to and manager are only used when collecting translation
strings. Gettext lookups will always be performed on relevant fields for all
objects on registered models.
"""
global _registry
_registry[model] = {
'fields': fields,
'restrict_to': restrict_to,
'manager': manager
}
for field in fields:
setattr(model, field, VinaigretteDescriptor(field))
model.untranslated = lambda self, fieldname: self.__dict__[fieldname]
pre_save.connect(_vinaigrette_pre_save, sender=model)
post_save.connect(_vinaigrette_post_save, sender=model)
def ready(self):
super(MirroringApp, self).ready()
Document = apps.get_model(app_label='documents', model_name='Document')
IndexInstanceNode = apps.get_model(
app_label='document_indexing', model_name='IndexInstanceNode'
)
pre_delete.connect(
handler_document_cache_delete,
dispatch_uid='mirroring_handler_document_cache_delete',
sender=Document
)
pre_delete.connect(
handler_node_cache_delete,
dispatch_uid='mirroring_handler_node_cache_delete',
sender=IndexInstanceNode
)
pre_save.connect(
handler_document_cache_delete,
dispatch_uid='mirroring_handler_document_cache_delete',
sender=Document
)
pre_save.connect(
handler_node_cache_delete,
dispatch_uid='mirroring_handler_node_cache_delete',
sender=IndexInstanceNode
)
def _run_listen():
post_save.connect(run_watchers.post_run_saved, sender=TestRun)
post_save.connect(run_watchers.post_case_run_saved, sender=TestCaseRun,
dispatch_uid='tcms.testruns.models.TestCaseRun')
post_delete.connect(run_watchers.post_case_run_deleted, sender=TestCaseRun,
dispatch_uid='tcms.testruns.models.TestCaseRun')
pre_save.connect(run_watchers.pre_save_clean, sender=TestRun)
def register(cls, admin_cls):
cls.add_to_class("SLEEPING", 10)
cls.add_to_class("QUEUED", 20)
cls.add_to_class("SENT", 30)
cls.add_to_class("UNKNOWN", 0)
PINGING_CHOICES = (
(cls.SLEEPING, _("sleeping")),
(cls.QUEUED, _("queued")),
(cls.SENT, _("sent")),
(cls.UNKNOWN, _("unknown")),
)
cls.add_to_class(
"pinging", models.SmallIntegerField(_("ping"), editable=False, default=cls.SLEEPING, choices=PINGING_CHOICES)
)
if admin_cls:
if not hasattr(admin_cls, "actions"):
setattr(admin_cls, "actions", [])
admin_cls.actions.append(
_entry_admin_update_fn(_("queued"), {"pinging": cls.QUEUED}, short_description=_("Ping Again"))
)
pre_save.connect(pre_save_handler, sender=cls)
def register_signal_handlers():
Image = get_image_model()
Rendition = Image.get_rendition_model()
pre_save.connect(pre_save_image_feature_detection, sender=Image)
post_delete.connect(post_delete_file_cleanup, sender=Image)
post_delete.connect(post_delete_file_cleanup, sender=Rendition)
def tag_model(cls, admin_cls=None, field_name='tags', sort_tags=False, select_field=False):
"""
tag_model accepts a number of named parameters:
admin_cls If set to a subclass of ModelAdmin, will insert the tag
field into the list_display and list_filter fields.
field_name Defaults to "tags", can be used to name your tag field
differently.
sort_tags Boolean, defaults to False. If set to True, a pre_save
handler will be inserted to sort the tag field alphabetically.
This is useful in case you want a canonical representation
for a tag collection, as when you're presenting a list of
tag combinations (e.g. in an admin filter list).
select_field If True, show a multi select instead of the standard
CharField for tag entry.
"""
from ..tagging.fields import TagField
from ..tagging import register as tagging_register
cls.add_to_class(field_name, (select_field and TagSelectField or TagField)(field_name.capitalize(), blank=True))
# use another name for the tag descriptor
# See http://code.google.com/p/django-tagging/issues/detail?id=95 for the reason why
tagging_register(cls, tag_descriptor_attr='tagging_' + field_name)
if admin_cls:
admin_cls.list_display.append(field_name)
admin_cls.list_filter.append(field_name)
if sort_tags:
pre_save.connect(pre_save_handler, sender=cls)
def test_model(self):
pre_tsh = TestSignalHandler()
pre_save.connect(pre_tsh)
post_tsh = TestSignalHandler()
post_save.connect(post_tsh)
# Content unicode should be set automatically.
trail = Trail.objects.create(
**{
"user": self.superuser,
"user_unicode": unicode(self.superuser),
"content_type": ContentType.objects.get_for_model(self.superuser),
"object_id": self.superuser.pk,
"action": "some other action",
}
)
self.assertTrue(trail.content_unicode)
self.assertTrue(pre_tsh)
self.assertTrue(post_tsh)
# Model should never save again after initially created.
pre_tsh.reset()
post_tsh.reset()
self.assertFalse(pre_tsh)
self.assertFalse(post_tsh)
trail.save()
self.assertFalse(pre_tsh)
self.assertFalse(post_tsh)
def _attach_signals(self):
'''
Attach all signals for eav
'''
post_init.connect(Registry.attach_eav_attr, sender=self.model_cls)
pre_save.connect(Entity.pre_save_handler, sender=self.model_cls)
post_save.connect(Entity.post_save_handler, sender=self.model_cls)
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)
def __new__(cls, name, bases, attrs):
result = super(WorkflowModelMetaclass, cls).__new__(cls, name, bases, attrs)
pre_save.connect(_pre_save, result, False)
post_save.connect(_post_save, result, False)
return result
def register(cls, admin_cls):
cls.add_to_class('creation_date', models.DateTimeField(_('creation date'), editable=False))
cls.add_to_class('modification_date', models.DateTimeField(_('modification date'), editable=False))
cls.cache_key_components.append(lambda page: page.modification_date and page.modification_date.strftime('%s'))
pre_save.connect(pre_save_handler, sender=cls)
def ready(self): pre_save.connect(self.update_count_pre_save) pre_delete.connect(self.update_count_pre_save) post_save.connect(self.update_count_post_save) user_logged_out.connect(self.remove_auth_token) self.set_registration_active() self.clear_last_objects_cache()
def register(self, model):
post_save.connect(add_obj_to_autocompleter, sender=model,
dispatch_uid='autocompleter.%s.add' % (model))
pre_save.connect(remove_old_obj_from_autocompleter, sender=model,
dispatch_uid='autocompleter.%s.remoe_old' % (model))
post_delete.connect(remove_obj_from_autocompleter,
sender=model, dispatch_uid='autocompleter.%s.remove' % (model))
def finalize(self, model):
inline_settings = self._inline_settings
self._inline_settings = {}
for setting, (related_model, one,
admin) in six.iteritems(inline_settings):
field = models.OneToOneField if one else models.ForeignKey
related_model = type(
related_model.__name__,
(related_model, ),
{
'Meta': type(
'Meta', (related_model.Meta, object), {
'app_label': 'settings'
}
),
'__module__': related_model.__module__,
'settings': field(
model,
related_name=setting
)
}
)
admin = type(
related_model.__name__, (admin, ), {
'model': related_model
}
)
self._inline_settings[setting] = (related_model, one, admin)
self._model = model
pre_save.connect(self._on_model_changed, sender=model)
pre_delete.connect(self._on_model_changed, sender=model)
def handle(self, *args, **options):
try:
shapefile = args[0]
name_field = args[1]
boundary_field = args[2]
except IndexError:
raise CommandError(_("You must provide a shapefile, name "
"field and boundary field argument"))
mapping = {'name': name_field,
'boundary': boundary_field
}
if options['geolevel']:
geolevel = GeoLevel.objects.get(slug=options['geolevel'])
def _set_geolevel(sender, instance, **kwargs):
"""
Signal callback to set the geolevel for a
place
"""
instance.geolevel = geolevel
pre_save.connect(_set_geolevel, sender=Place)
lm = LayerMapping(Place, shapefile, mapping)
lm.save(verbose=True)
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)
def connect_cleanup_files_signals():
connections = ConnectionHandler()
backend = connections[DEFAULT_DB_ALIAS]
for model in _find_models_with_filefield():
pre_save.connect(remove_files_on_change, sender=model)
post_delete.connect(remove_files_on_delete, sender=model)
def register(cls, admin_cls):
cls.add_to_class('_ct_inventory', JSONField(_('content types'), editable=False, blank=True, null=True))
cls.content_proxy_class = TrackerContentProxy
pre_save.connect(single_pre_save_handler, sender=cls)
if hasattr(cls, 'get_descendants'):
post_save.connect(tree_post_save_handler, sender=cls)
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 __new__(cls, name, bases, attrs):
if name == 'SlugBase':
return super(SlugMeta, cls).__new__(cls, name, bases, attrs)
pre_name = attrs.get('_slug_prepopulate_from')
if not pre_name:
raise TypeError("No valid '_slug_prepopulate_from' class attribute found")
del attrs['_slug_prepopulate_from']
pre_field = attrs.get(pre_name)
if not pre_field:
raise TypeError("No '%s' field found" % pre_name)
if not isinstance(pre_field, models.CharField):
raise TypeError("Wrong type for '%s' field" % pre_name)
if 'slug' in attrs:
raise TypeError("A 'slug' field already exists")
if '_slug_field_args' in attrs:
kw = attrs['_slug_field_args']
del attrs['_slug_field_args']
else:
kw = {}
attrs['slug'] = models.CharField(max_length=pre_field.max_length, **kw)
attrs['_slug_pre'] = property(lambda s: getattr(s, pre_name))
new_class = super(SlugMeta, cls).__new__(cls, name, bases, attrs)
pre_save.connect(new_class._slug_pre_save, sender=new_class)
return new_class
def ready(self):
Attachment = self.get_model('Attachment')
pre_delete.connect(self.delete_file, sender=Attachment)
pre_delete.connect(self.delete_attachmentimage, sender=Attachment)
pre_save.connect(self.delete_attachmentimage, sender=Attachment)
post_save.connect(self.create_attachmentimage, sender=Attachment)
def _listen():
""" signals listen """
# case save/delete listen for email notify
post_save.connect(case_watchers.on_case_save, TestCase)
post_delete.connect(case_watchers.on_case_delete, TestCase)
pre_save.connect(case_watchers.pre_save_clean, TestCase)
def ready(self):
from .models import clear_usersettings_cache
from .shortcuts import get_usersettings_model
usersettings_model = get_usersettings_model()
pre_save.connect(clear_usersettings_cache, sender=usersettings_model)
pre_delete.connect(clear_usersettings_cache, sender=usersettings_model)
def cache_purge_hook(model, func=None):
pre_save.connect(
partial(__pre_save_hook, model, func),
dispatch_uid="cache_purge_hook",
sender=model,
weak=False,
)
post_save.connect(
partial(__post_save_hook, model, func),
dispatch_uid="cache_purge_hook",
sender=model,
weak=False,
)
pre_delete.connect(
partial(__pre_delete_hook, model, func),
dispatch_uid="cache_purge_hook",
sender=model,
weak=False,
)
post_delete.connect(
partial(__post_delete_hook, model, func),
dispatch_uid="cache_purge_hook",
sender=model,
weak=False,
)
def register(cls, admin_cls):
cls.add_to_class('SLEEPING', 10)
cls.add_to_class('QUEUED', 20)
cls.add_to_class('SENT', 30)
cls.add_to_class('UNKNOWN', 0)
PINGING_CHOICES = (
(cls.SLEEPING, _('sleeping')),
(cls.QUEUED, _('queued')),
(cls.SENT, _('sent')),
(cls.UNKNOWN, _('unknown')),
)
cls.add_to_class(
'pinging',
models.SmallIntegerField(
_('ping'),
editable=False,
default=cls.SLEEPING,
choices=PINGING_CHOICES,
)
)
if admin_cls:
if not hasattr(admin_cls, 'actions'):
setattr(admin_cls, 'actions', [])
admin_cls.actions.append(
entry_admin_update_fn(_('queued'), {'pinging': cls.QUEUED},
short_description=_('Ping Again')))
pre_save.connect(pre_save_handler, sender=cls)
def spy_on_model(model, agents):
if not issubclass(model, models.Model):
raise WatchException("'%s' is not a subclass of django.db.models.Model" % (model.__name__, ))
model_fields = [field.name for field in model._meta.fields]
pre_save_agents = []
post_save_agents = []
for agent in agents:
field_name = agent.field_name
is_pre_save = agent.pre_save
if not field_name in model_fields:
raise WatchException("'%s' is not a field of '%s'" % (field_name, model.__name__))
if is_pre_save:
pre_save_agents.append(agent)
else:
post_save_agents.append(agent)
# Add an attribute for each agent (a 'bug') to keep track of the field values
def bug_instance(instance):
for agent in agents:
field_name = agent.field_name
agent_name = _watch_name(field_name)
current_value = getattr(instance, field_name)
setattr(instance, agent_name, current_value)
dispatch_uid = 'spy_post_init_%s' % model.__name__
@receiver(post_init, sender=model, dispatch_uid=dispatch_uid)
def init_bugs(sender, instance, **kwargs):
bug_instance(instance)
def get_detect_change(pre_save=True):
if pre_save:
event_agents = pre_save_agents
else:
event_agents = post_save_agents
def detect_change_and_reset_bugs(sender, instance, **kwargs):
for agent in event_agents:
field_name = agent.field_name
agent_name = _watch_name(field_name)
old_value = getattr(instance, agent_name)
new_value = getattr(instance, field_name)
# If the value has changed, call the on_change method of the agent
if old_value != new_value:
agent.on_change(instance, old_value, new_value)
# Reset the bugs for this instance
bug_instance(instance)
return detect_change_and_reset_bugs
detect_changes_pre_save = get_detect_change(True)
detect_changes_post_save = get_detect_change(False)
if pre_save_agents:
dispatch_uid = 'spy_pre_save_%s' % model.__name__
pre_save.connect(detect_changes_pre_save, sender=model, dispatch_uid=dispatch_uid)
if post_save_agents:
dispatch_uid = 'spy_post_save_%s' % model.__name__
post_save.connect(detect_changes_post_save, sender=model, dispatch_uid=dispatch_uid)
return model
def handle_model(self):
self.model.add_to_class('_ct_inventory', JSONField(
_('content types'), editable=False, blank=True, null=True))
self.model.content_proxy_class = TrackerContentProxy
pre_save.connect(single_pre_save_handler, sender=self.model)
if hasattr(self.model, 'get_descendants'):
post_save.connect(tree_post_save_handler, sender=self.model)
def register(cls, admin_cls):
cls.add_to_class('_ct_inventory', models.CharField(_('content types'), max_length=500, editable=False))
cls.add_to_class('count_content_types', page_count_content_types)
cls.orig_get_content_types_for_region = cls._get_content_types_for_region
cls._get_content_types_for_region = page_get_content_types_for_region
pre_save.connect(pre_save_handler, sender=cls)
def register():
if settings.AUTHOR_MODELS:
for model in settings.AUTHOR_MODELS:
app_label, model = model.split('.', 1)
ct = ContentType.objects.get_by_natural_key(app_label, model)
pre_save.connect(pre_save_callback, sender=ct.model_class())
else:
pre_save.connect(pre_save_callback)
def __init__(self, obj, attr, callback):
super(ValueWatcher, self).__init__(obj, attr, callback)
model = self._obj.__class__
# Add recivers
pre_save.connect(self._pre_save_reciver, sender=model, weak=False)
post_save.connect(self._post_save_reciver, sender=model, weak=False)
# Initialize variable
self._previous_value = None
content = models.TextField(max_length=5000, null=True, blank=True)
slug = models.SlugField(unique=True, null=True, blank=True)
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("info", args=[str(self.slug)])
def info_pre_save_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = unique_slug_generator(instance)
pre_save.connect(info_pre_save_receiver, sender=Info)
class InfoImage(models.Model):
image = models.ForeignKey("audiovisual.Image", on_delete=models.CASCADE)
general = models.ForeignKey(Info, on_delete=models.CASCADE)
uploaded_at = models.DateTimeField(auto_now_add=True)
def __str__(self):
return self.image.title
class NewsList(models.Model):
"""
TODO: I want to automatize this with a job that takes the next 3 events, with workshops
as preferences and sets it every week?
category = models.ForeignKey(Category, on_delete=models.CASCADE)
slug = models.SlugField(unique = True, null=True, blank=True)
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse("Alt:shirts", kwargs={"slug": self.slug})
def slug_generator(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug='SLUG'
pre_save.connect(slug_generator, sender=Shirt)
class NonProfit(models.Model):
name= models.CharField(max_length=50, blank=False, null=False)
logo = models.TextField()
description =models.TextField()
year_started = models.IntegerField()
mission_statement=models.TextField()
vision_statement=models.TextField()
website_url= models.URLField()
category = models.ForeignKey(Category, on_delete=models.CASCADE)
slug = models.SlugField(unique = True)
updated = models.DateTimeField(auto_now=True)
#my_date_field = models.DateField(auto_now = False, auto_now_add=False)
slug = models.SlugField(null=True, blank=True)
def __str__(self):
return self.name
@property
def title(self):
return self.name
def rl_pre_save_receiver(sender, instance, *args, **kwargs):
#print('saving..')
#print(instance.timestamp)
if not instance.slug:
instance.slug = unique_slug_generator(instance)
# def rl_post_save_receiver(sender, instance, *args, **kwargs):
# print('saved..')
# print(instance.timestamp)
# if not instance.slug:
# instance.slug = unique_slug_generator(instance)
# instance.save()
pre_save.connect(rl_pre_save_receiver, sender=RestaurantLocation)
#post_save.connect(rl_post_save_receiver, sender = RestaurantLocation)
def get_markdown(self):
content = self.content
markdown_text = markdown(content)
return mark_safe(markdown_text)
def create_slug(instance, new_slug=None):
slug = slugify(instance.title)
if new_slug is not None:
slug = new_slug
qs = Post.objects.filter(slug=slug).order_by("-id")
exists = qs.exists()
if exists:
new_slug = "%s-%s" % (slug, qs.first().id)
return create_slug(instance, new_slug=new_slug)
return slug
def pre_save_post_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = create_slug(instance)
if instance.content:
html_string = instance.get_markdown()
read_time_var = get_read_time(html_string)
instance.read_time = read_time_var
pre_save.connect(pre_save_post_receiver, sender=Post)
except:
return "Unknown"
if difference <= timedelta(minutes=1):
return 'just now'
return '{time} ago'.format(
time=timesince(publish_time).split(', ')[0])
return "Not published"
def blog_post_model_pre_save_receiver(sender, instance, *args, **kwargs):
print("before save")
if not instance.slug and instance.title:
instance.slug = slugify(instance.title)
pre_save.connect(blog_post_model_pre_save_receiver, sender=PostModel)
def blog_post_model_post_save_receiver(sender, instance, created, *args,
**kwargs):
print("after save")
print(created)
if created:
if not instance.slug and instance.title:
instance.slug = slugify(instance.title)
instance.save()
post_save.connect(blog_post_model_post_save_receiver, sender=PostModel)
'''
python manage.py makemigrations #every time you change models.py
def rl_pre_save_reciever(sender, instance, *args, **kwargs):
print('saving..')
print(instance.timestamp)
if not instance.slug:
instance.slug = unique_slug_generator(instance)
if not instance.location:
instance.location = grab_location(instance)
def rl_post_save_reciever(sender, instance, created, *args, **kwargs):
print('saved')
print(instance.timestamp)
pre_save.connect(rl_pre_save_reciever, sender=Post)
post_save.connect(rl_post_save_reciever, sender=Post)
class movies(models.Model):
movie_id = models.IntegerField(default=0)
imdb_id = models.IntegerField(default=0)
movie_name = models.CharField(max_length=200)
genre = models.CharField(max_length=200)
vectors = models.CharField(max_length=200)
class links(models.Model):
movie_id = models.IntegerField(default=0)
url = models.CharField(max_length=300)
class VoterDetails(ModelBase):
user = models.ForeignKey('users.UserProfile', related_name='voter_details')
taxonomy = models.ManyToManyField(VoterTaxonomy)
class Judge(ModelBase):
challenge = models.ForeignKey(Challenge)
user = models.ForeignKey('users.UserProfile', related_name='judges')
class Meta:
unique_together = (('challenge', 'user'), )
admin.site.register(Judge)
### Signals
def submission_markdown_handler(sender, **kwargs):
submission = kwargs.get('instance', None)
if not isinstance(submission, Submission):
return
if submission.description:
submission.description_html = bleach.clean(
markdown(submission.description),
tags=TAGS,
attributes=ALLOWED_ATTRIBUTES)
pre_save.connect(submission_markdown_handler, sender=Submission)
timestamp = models.DateTimeField(auto_now_add=True)
update = models.DateTimeField(auto_now=True)
def __str__(self):
return self.title
class Meta:
ordering = ['-timestamp']
def blog_category_pre_save_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = blog_unique_slug_generator(instance)
pre_save.connect(blog_category_pre_save_receiver, sender=BlogCategory)
class BlogSubCategory(models.Model):
title = models.CharField(max_length=120)
slug = models.SlugField(null=True, blank=True, max_length=50)
timestamp = models.DateTimeField(auto_now_add=True)
update = models.DateTimeField(auto_now=True)
def __str__(self):
return self.title
class Meta:
ordering = ['-timestamp']
return cards_qs.filter(active=True).count()
def billing_profile_created_receiver(sender, instance, *args, **kwargs):
if not instance.stripe_cust_id and instance.email:
print(
"ACTUAL API REQUEST Send to Stripe or some other payment processor"
)
# call Stripe API to return Stripe customer id based on CRV19 email
customer = stripe.Customer.create(email=instance.email)
print(customer)
# customer.id or customer.stripe_id ??
instance.stripe_cust_id = customer.id
pre_save.connect(billing_profile_created_receiver, sender=BillingProfile)
# when user is Created, use the signal below to create the billing profile automatically
def user_created_receiver(sender, instance, created, *args, **kwargs):
if created and instance.email:
BillingProfile.objects.get_or_create(user=instance,
email=instance.email)
post_save.connect(user_created_receiver, sender=User)
class CardManager(models.Manager):
# Overide to include only active = True. Don't pull in inactive cards
def all(self, *args, **kwargs):
from .utils import unique_slug_generator
from django.db.models.signals import pre_save, post_save
class Category(models.Model):
name=models.CharField(max_length=100,null=True,blank=True,unique=True)
slug= models.SlugField(max_length=250, null=True, blank=True)
def __str__(self):
return str(self.name)
def rl_pre_save_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = unique_slug_generator(instance)
pre_save.connect(rl_pre_save_receiver, sender=Category)
class portfolio(models.Model):
category = models.ForeignKey(Category,on_delete=models.SET_NULL,null=True,blank=True)
image= models.ImageField(null=True,blank=True)
link=models.CharField(max_length=100,null=True,blank=True)
title=models.CharField(max_length=100,null=True,blank=True)
icon=models.CharField(max_length=100,null=True,blank=True)
def __str__(self):
return str(self.title)
@property
def imageURL(self):
class TagManager(models.Manager):
def get_queryset(self):
return TagQuerySet(self.model, using=self._db)
def all(self, *args, **kwargs):
return super(TagManager, self).all(*args, **kwargs).active()
class Tag(models.Model):
title = models.CharField(max_length=120, unique=True)
slug = models.SlugField(unique=True)
products = models.ManyToManyField(Product, blank=True)
active = models.BooleanField(default=True)
objects = TagManager()
def __str__(self):
return str(self.title)
def get_absolute_url(self):
view_name = "tags:detail"
return reverse(view_name, kwargs={"slug": self.slug})
def tag_pre_save_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = slugify(instance.title)
pre_save.connect(tag_pre_save_receiver, sender=Tag)
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[self.email],
html_message=html_,
fail_silently=False,
)
return sent_mail
return False
def pre_save_email_activation(sender, instance, *args, **kwargs):
if not instance.activated and not instance.forced_expired:
if not instance.key:
instance.key = unique_key_generator(instance)
pre_save.connect(pre_save_email_activation, sender=EmailActivation)
def post_save_user_create_receiver(sender, instance, created, *args, **kwargs):
if created:
obj = EmailActivation.objects.create(user=instance,
email=instance.email)
obj.send_activation_email()
post_save.connect(post_save_user_create_receiver, sender=User)
class GuestEmail(models.Model):
email = models.EmailField(max_length=254)
uddate = models.DateField(auto_now=True)
actors_by_type[actor.type].append(actor)
resolved_actors = {}
for type, actors in actors_by_type.items():
resolved_actors[type] = {
actor.id: actor
for actor in type.objects.filter(id__in=[a.id for a in actors])
}
return {
key: resolved_actors[value.type][value.id]
for key, value in actor_dict.items()
}
def handle_actor_pre_save(instance, **kwargs):
# we want to create an actor if we don't have one
if not instance.actor_id:
instance.actor_id = Actor.objects.create(
type=ACTOR_TYPES[type(instance).__name__.lower()]).id
pre_save.connect(handle_actor_pre_save,
sender="sentry.Team",
dispatch_uid="handle_actor_pre_save",
weak=False)
pre_save.connect(handle_actor_pre_save,
sender="sentry.User",
dispatch_uid="handle_actor_pre_save",
weak=False)
# price_6_months = models.FloatField(_("6 months price"),
# blank=True, null=True)
# price_12_months = models.FloatField(_("12 months price"),
# blank=True, null=True)
# price_24_months = models.FloatField(_("24 months price"),
# blank=True, null=True)
# price_36_months = models.FloatField(_("36 months price"),
# blank=True, null=True)
# price_40_months = models.FloatField(_("40 months price"),
# blank=True, null=True)
# slug = models.SlugField(_("slug"))
# class Meta:
# verbose_name = _("Mobile Price")
# verbose_name_plural = _("Mobile Prices")
# def __str__(self):
# return str(self.price)
# def get_absolute_url(self):
# return reverse("mobile_price", kwargs={"pk": self.pk})
def pre_save_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = unique_slug_generator(instance=instance)
# pre_save.connect(pre_save_receiver, sender=Mobile)
pre_save.connect(pre_save_receiver, sender=TelecomCompany)
recipient_list,
html_message=html_, # If content_type is text/html
fail_silently=
False # If false, then an email will be sent if error occurs while sending the email
)
return sent_mail
return False
def pre_save_email_activation_receiver(sender, instance, *args, **kwargs):
if not instance.activated and not instance.forced_expire:
if not instance.key:
instance.key = unique_key_generator(instance)
pre_save.connect(pre_save_email_activation_receiver, sender=EmailActivation)
def post_save_user_create_receiver(sender, instance, created, *args, **kwargs):
if created:
email_obj = EmailActivation.objects.create(user=instance,
email=instance.email)
email_obj.send_activation()
post_save.connect(post_save_user_create_receiver, sender=User)
class GuestModel(models.Model):
email = models.EmailField()
active = models.BooleanField(default=True)
class Product(models.Model):
title = models.CharField(max_length=50)
description = models.TextField()
price = models.DecimalField(max_digits=8, decimal_places=2, default=0.0)
slug = models.SlugField(null=False, blank=False, unique=True)
image = models.ImageField(upload_to='products/', null=False, blank=False)
created_at = models.DateField(auto_now=True)
# def save(self, *args, **kwargs):
# self.slug = slugify(self.title)
# super(Product,self).save(*args, **kwargs)
def __str__(self):
return self.title
def set_slug(sender, instance, *args, **kwargs): #callback
if instance.title and not instance.slug:
slug = slugify(instance.title)
while Product.objects.filter(slug=slug).exists():
slug = slugify('{}-{}'.format(instance.title,
str(uuid.uuid4())[:8]))
instance.slug = slug
pre_save.connect(set_slug, sender=Product)
timestamp = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=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
instance.subtotal = total
instance.save()
m2m_changed.connect(m2m_changed_cart_receiver, sender=Cart.products.through)
def pre_save_cart_receiver(sender, instance, *args, **kwargs):
if instance.subtotal > 0:
instance.total = float(instance.subtotal) * float(1.08)
else:
instance.total = 0
pre_save.connect(pre_save_cart_receiver, sender=Cart)
return self.like.count()
def total_like_after_dislike(self):
if self.like:
self.like -= 1
return self.like.count()
else:
return self.like.count()
def pre_save_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = unique_slug_generator(instance)
pre_save.connect(pre_save_receiver, sender=Blogpost)
class Categories(models.Model):
name = models.CharField(max_length=100)
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse('home')
class UserProfile(models.Model):
user = models.OneToOneField(User, null=True, on_delete=models.CASCADE)
bio = models.TextField(max_length=400)
owner = models.ForeignKey(
User
) # class_instance.model_set.all() # Django Models Unleashed JOINCFE.com
name = models.CharField(max_length=120)
timestamp = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
slug = models.SlugField(null=True, blank=True)
#my_date_field = models.DateField(auto_now=False, auto_now_add=False)
objects = TodoManager()
def __str__(self):
return self.name
def get_absolute_url(self): #get_absolute_url
#return f"/restaurants/{self.slug}"
return reverse('detailt', kwargs={'slug': self.slug})
@property
def title(self):
return self.name
def todo_pre_save_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = unique_slug_generator(instance)
pre_save.connect(todo_pre_save_receiver, sender=Todo)
class Coupon(models.Model):
code = models.CharField(max_length=150, unique=True, blank=True)
discount = models.IntegerField(
validators=[MinValueValidator(0),
MaxValueValidator(100)])
starts = models.DateTimeField()
ends = models.DateTimeField()
active = models.BooleanField(default=True)
def __str__(self):
return self.code
def is_valid(self):
if Coupon.objects.filter(self__starts__lte=timezone.now(),
self__ends__gte=timezone.now()).exists():
self.active = True
else:
self.active = False
def save_code(sender, **kwargs):
c = Coupon.objects.filter(id=kwargs['instance'].id)
if not c.exists():
code = unique_code(kwargs['instance'])
kwargs['instance'].code = code
pre_save.connect(save_code, sender=Coupon)
is_active = models.BooleanField(default=True)
is_staff = models.BooleanField(default=False)
is_superuser = models.BooleanField(default=False)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['first_name', 'last_name',]
objects = MyAccountManager()
def __str__(self):
return self.email
# For checking permissions. to keep it simple all admin have ALL permissons
def has_perm(self, perm, obj=None):
return self.is_admin
def has_module_perms(self, app_label):
return True
@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_auth_token(sender, instance=None, created=False, **kwargs):
if created:
Token.objects.create(user=instance)
def get_username(sender, instance, *args, **kwargs):
if not instance.username:
instance.username = str(instance.first_name.replace(" ", "-").lower() + "-" +instance.last_name.replace(" ", "-").lower())
pre_save.connect(get_username, sender=Account)
db_table = 'django_site'
verbose_name = _('site')
verbose_name_plural = _('sites')
ordering = ('domain',)
def __str__(self):
return self.domain
def natural_key(self):
return (self.domain,)
def clear_site_cache(sender, **kwargs):
"""
Clear the cache (if primed) each time a site is saved or deleted.
"""
instance = kwargs['instance']
using = kwargs['using']
try:
del SITE_CACHE[instance.pk]
except KeyError:
pass
try:
del SITE_CACHE[Site.objects.using(using).get(pk=instance.pk).domain]
except (KeyError, Site.DoesNotExist):
pass
pre_save.connect(clear_site_cache, sender=Site)
pre_delete.connect(clear_site_cache, sender=Site)
slug = new_slug
qs = Project.objects.filter(slug=slug).order_by("-id")
exists = qs.exists()
if exists:
new_slug = '{}-{}'.format(slug, qs.first().id)
#recursive function in a case if slug already exists
return create_slug(instance, new_slug=new_slug)
return slug
def pre_save_project_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = create_slug(instance)
pre_save.connect(pre_save_project_receiver, sender=Project)
class Membership(models.Model):
user = models.ForeignKey(User,
null=True,
blank=True,
default=None,
related_name="memberships",
on_delete=models.CASCADE)
project = models.ForeignKey(Project,
null=False,
blank=False,
related_name="memberships",
on_delete=models.CASCADE)
date_joined = models.DateTimeField(null=False,
price = models.DecimalField(decimal_places=2,max_digits=8,default=99)
image = models.ImageField(upload_to=upload_image_path,null=True,blank=True)
#null = True you can use FileField to provide file max100MB -->kirr.co/e1133t
description = models.TextField()
featured = models.BooleanField(default=False)
active = models.BooleanField(default=True)
timestamp = models.DateTimeField(auto_now_add=True)
objects=ProductManager()
def get_absolute_url(self):
# return "/products/{slug}".format(slug=self.slug)
return reverse("products:detail",kwargs={'slug':self.slug})
def __str__(self):
return self.title #changes title name
@property
def name(self):
return self.title
# signals
def product_pre_save_receiver(sender,instance,*args,**kwargs):
if not instance.slug:
instance.slug = unique_slug_generator(instance)
pre_save.connect(product_pre_save_receiver,sender=Product)
decimal.Decimal(self.get_descuento() / 100) *
self.carrito.total).quantize(TWOPLACES)
print("Descuento: ", descuento)
return self.carrito.total + self.shipping_total - descuento
@property
def descripcion(self):
return 'Compra por ({}) productos '.format(
self.carrito.productos.count())
def update_total(self):
self.total = self.get_total()
self.save()
def get_descuento(self):
if self.codigo_promocion:
return self.codigo_promocion.descuento
return 0
def set_orden_id(sender, instance, *args, **kwargs):
if not instance.orden_id:
instance.orden_id = str(uuid.uuid4())
def set_total(sender, instance, *args, **kwargs):
instance.total = instance.get_total()
pre_save.connect(set_orden_id, sender=Orden)
pre_save.connect(set_total, sender=Orden)
def update_total(self):
cart_total = self.cart.total
shipping_total = self.shipping_total
new_total = math.fsum([cart_total, shipping_total])
formatted_total = format(new_total, '.2f')
self.total = formatted_total
self.save()
return new_total
def pre_save_create_order_id(sender, instance, *args, **kwargs):
if not instance.order_id:
instance.order_id = unique_order_id_generator(instance)
pre_save.connect(pre_save_create_order_id, sender=Order)
def post_save_cart_total(sender, instance, created, *args, **kwargs):
if not created:
cart_obj = instance
cart_total = cart_obj.total
cart_id = cart_obj.id
qs = Order.objects.filter(cart__id=cart_id)
if qs.count() == 1:
order_obj = qs.first()
order_obj.update_total()
post_save.connect(post_save_cart_total, sender=Cart)
from django.db import models
from django.utils.timezone import now
from .utils import unique_slug_generator
from django.db.models.signals import pre_save
class Genre(models.Model):
name = models.CharField('Name', max_length=100)
description = models.TextField('Description')
slug = models.SlugField(max_length=100, unique=True, blank=True)
def __str__(self):
return self.name
class Meta:
verbose_name = 'Genre'
verbose_name_plural = 'Genres'
def genre_pre_save_receiver(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = unique_slug_generator(instance)
pre_save.connect(genre_pre_save_receiver, sender=Genre)
if (instance.health != instance._old_health) or (instance.state != instance._old_state):
# Update the states as some objects are save many times.
# Even if an object is saved many time, we will send messages only when
# the state change.
instance._old_health = instance.health
instance._old_state = instance.state
# Create the message
data = {
"hostname": instance.hostname,
"health": instance.get_health_display(),
"state": instance.get_state_display(),
}
# Send the event
send_event(".worker", "lavaserver", data)
pre_delete.connect(testjob_pre_delete_handler, sender=TestJob, weak=False, dispatch_uid="testjob_pre_delete_handler")
# This handler is used for the notification and the events
post_init.connect(testjob_init_handler, sender=TestJob, weak=False, dispatch_uid="testjob_init_handler")
pre_save.connect(testjob_notifications, sender=TestJob, weak=False, dispatch_uid="testjob_notifications")
# Only activate theses signals when EVENT_NOTIFICATION is in use
if settings.EVENT_NOTIFICATION:
post_init.connect(device_init_handler, sender=Device, weak=False, dispatch_uid="device_init_handler")
post_save.connect(device_post_handler, sender=Device, weak=False, dispatch_uid="device_post_handler")
post_save.connect(testjob_post_handler, sender=TestJob, weak=False, dispatch_uid="testjob_post_handler")
post_init.connect(worker_init_handler, sender=Worker, weak=False, dispatch_uid="worker_init_handler")
post_save.connect(worker_post_handler, sender=Worker, weak=False, dispatch_uid="worker_post_handler")
from django.db import models
from django.conf import settings
from django.utils.text import slugify
from django.db.models.signals import pre_save, post_delete
from django.dispatch import receiver
class Tweet(models.Model):
body = models.TextField(max_length=240, null=False, blank=False)
date_published = models.DateTimeField(auto_now_add=True,
verbose_name="date published")
date_updated = models.DateTimeField(auto_now=True,
verbose_name="date updated")
author = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE)
slug = models.SlugField(blank=True, unique=True)
def __str__(self):
return self.body
def pre_save_tweet_receiver(sender, instance, **kwargs):
if not instance.slug:
instance.slug = slugify(instance.author.username + "-" + instance.body)
pre_save.connect(pre_save_tweet_receiver, sender=Tweet)
if new_slug is not None:
slug = new_slug
qs = Category.objects.filter(slug=slug).order_by('-id')
exists = qs.exists()
if exists:
new_slug = "%s-%s" % (slug, qs.first().id)
return create_slug(instance, new_slug=new_slug)
return slug
def pre_save_reciever(sender, instance, *args, **kwargs):
if not instance.slug:
instance.slug = create_slug(instance)
pre_save.connect(pre_save_reciever, sender=Category)
pre_save.connect(pre_save_reciever, sender=SubCategory)
pre_save.connect(pre_save_reciever, sender=Product)
# def create_subcat_slug(instance, new_slug=None):
# slug = slugify(instance.subcat_name)
# if new_slug is not None:
# slug = new_slug
# qs = Category.objects.filter(subcat_slug=slug).order_by('-id')
# exists = qs.exists()
# if exists:
# new_slug = "%s-%s" %(slug, qs.first().id)
# return create_subcat_slug(instance, new_slug=new_slug)
# return slug
