def get_absolute_url(self): try: from django.db.models import permalink return permalink('simpletext_detail_view_name', [str(self.id)]) except ImportError: from django.urls import reverse return reverse('simpletext_detail_view_name', args=[str(self.id)])
def register(cls, admin_cls): cls.add_to_class('category', models.ForeignKey('articles.Category', verbose_name=_('category'))) cls._meta.unique_together += [('category', 'slug')] @classmethod def get_urlpatterns(cls): from articles.modules.category import views return patterns('', url(r'^(?P<category_url>[a-z0-9_/-]+/)articles/(?P<slug>[a-z0-9_-]+)/$', views.CategoryArticleDetail.as_view(), name="article_detail"), url(r'^(?P<category_url>[a-z0-9_/-]+/)articles/$', views.CategoryArticleList.as_view(), name='article_category'), url(r'^$', views.CategoryArticleList.as_view(), name='article_index'), ) cls.get_urlpatterns = get_urlpatterns def get_absolute_url(self): return ('article_detail', (), { 'category_url': self.category.local_url, 'slug': self.slug, }) cls.get_absolute_url = models.permalink(get_absolute_url) if admin_cls: admin_cls.add_extension_options('category')
def __init__(self, model, **kwargs): self.model = model for k, v in kwargs.items(): setattr(self, k, v) if not hasattr(self.model, 'get_absolute_url'): # Add a simple primary key based URL to the model if it does not have one yet info = self.model._meta.app_label, self.model._meta.module_name self.model.get_absolute_url = models.permalink(lambda self: ( '%s_%s_detail' % info, (self.pk,), {}))
def __init__(self, model, **kwargs): self.model = model for key, value in kwargs.items(): if not hasattr(self, key): raise TypeError('%s() received an invalid keyword %r' % ( self.__class__.__name__, key)) setattr(self, key, value) if not hasattr(self.model, 'get_absolute_url'): # Add a simple primary key based URL to the model if it does not have one yet info = self.model._meta.app_label, self.model._meta.module_name self.model.get_absolute_url = models.permalink(lambda self: ( '%s_%s_detail' % info, (self.pk,), {}))
class Notice(models.Model): recipient = models.ForeignKey(USER_MODEL, related_name="recieved_notices", verbose_name=_("recipient")) sender = models.ForeignKey(USER_MODEL, null=True, related_name="sent_notices", verbose_name=_("sender")) message = models.TextField(_('message')) notice_type = models.ForeignKey(NoticeType, verbose_name=_('notice type')) added = models.DateTimeField(_('added'), auto_now_add=True) unseen = models.BooleanField(_('unseen'), default=True) archived = models.BooleanField(_('archived'), default=False) on_site = models.BooleanField(_('on site')) related_object_id = models.IntegerField(_('related object'), null=True) objects = NoticeManager() def __unicode__(self): return self.message def archive(self): self.archived = True self.save() def is_unseen(self): """ returns value of self.unseen but also changes it to false. Use this in a template to mark an unseen notice differently the first time it is shown. """ unseen = self.unseen if unseen: self.unseen = False self.save() return unseen class Meta: ordering = ["-added"] verbose_name = _("notice") verbose_name_plural = _("notices") def get_absolute_url(self): return reverse("notification_notice", args=[str(self.pk)]) def get_absolute_url(self): return ("notification_notice", [str(self.pk)]) get_absolute_url = models.permalink(get_absolute_url)
class Link(models.Model): title = models.CharField(max_length=250) description = models.TextField(blank=True) description_html = models.TextField(blank=True) url = models.URLField(unique=True) posted_by = models.ForeignKey(User) pub_date = models.DateTimeField(default=datetime.datetime.now) slug = models.SlugField(unique_for_date='pub_date') tags = TagField() enable_comments = models.BooleanField(default=True) post_elsewhere = models.BooleanField('Post to Delicious', default=True) via_name = models.CharField( 'Via', max_length=250, blank=True, help_text= 'The name of the person whose site you spottedthelinkon.Optional.') via_url = models.URLField( 'Via URL', blank=True, help_text='The URL of the site where you spotted the link.Optional.') class Meta: ordering = ['-pub_date'] def __unicode__(self): return self.title def save(self): if self.description: self.description_html = markdown(self.description) if not self.id and self.post_elsewhere: import pydelicious from django.utils.encoding import smart_str pydelicious.add(settings.DELICIOUS_USER, settings.DELICIOUS_PASSWORD, smart_str(self.url), smart_str(self.title), smart_str(self.tags)) super(Link, self).save() def get_absolute_url(self): return ('wolf_link_detail', (), { 'year': self.pub_date.strftime('%Y'), 'month': self.pub_date.strftime('%b').lower(), 'day': self.pub_date.strftime('%d'), 'slug': self.slug }) get_absolute_url = models.permalink(get_absolute_url)
class Brand(models.Model, TranslatedObjectMixin): """A product brand""" site = models.ForeignKey(Site) slug = models.SlugField(_("Slug"), unique=True, help_text=_("Used for URLs")) products = models.ManyToManyField(Product, blank=True, verbose_name=_("Products"), through='BrandProduct') ordering = models.IntegerField(_("Ordering")) active = models.BooleanField(default=True) objects = BrandManager() def _active_categories(self): return [cat for cat in self.categories.all() if cat.has_content()] active_categories = property(fget=_active_categories) def _translation(self): return self._find_translation() translation = property(fget=_translation) def _get_absolute_url(self): return ('satchmo_brand_view', None, {'brandname': self.slug}) get_absolute_url = models.permalink(_get_absolute_url) def active_products(self): return self.products.filter(site=self.site, active=True) def has_categories(self): return self.active_categories().count() > 0 def has_content(self): return self.has_products() or self.has_categories() def has_products(self): return self.active_products().count() > 0 def __unicode__(self): return u"%s" % self.slug class Meta: ordering = ('ordering', 'slug') verbose_name = _('Brand') verbose_name_plural = _('Brands')
class VisitEvent(RealEstateAppBaseModel): property_fk = models.ForeignKey('propertys.Property') visitor_fk = models.ForeignKey('visitcalendar.Visitor') date_visit = models.DateTimeField( _('Date of visit'), unique=True, default=datetime.now(), help_text=_('Entry with a init of date publicashion')) slug = models.SlugField( _('slug'), unique=True, help_text=_('Automatically built from the caption. A slug is a short ' 'label generally used in URLs.'), ) objects = RealEstateManager() class Meta: app_label = 'visitcalendar' db_table = 'real_estate_app_apps_visitcalendar_visitevent' get_latest_by = 'date_visit' ordering = ('date_visit', ) verbose_name = _('Visit') verbose_name_plural = _('Visits') def __unicode__(self): try: return u'%s' % self.date_visit.strftime( settings.DATETIME_INPUT_FORMATS[0]) except IndexError: return u'%s' % self.date_visit.strftime('%Y-%m-%d %H:%M:%S') else: raise def _visitor(self): return self.visitor_first_name + ' ' + self.visitor_last_name visitor = property(_visitor) def _get_absolute_url(self): return ('visitcalendar-detail', None, { 'slug': str(self.slug), }) get_absolute_url = permalink(_get_absolute_url)
class Message(models.Model): """ A private message from user to user """ subject = models.CharField(_("Subject"), max_length=120) body = models.TextField(_("Body")) sender = models.ForeignKey(AUTH_USER_MODEL, related_name='sent_messages', verbose_name=_("Sender")) recipient = models.ForeignKey(AUTH_USER_MODEL, related_name='received_messages', null=True, blank=True, verbose_name=_("Recipient")) parent_msg = models.ForeignKey('self', related_name='next_messages', null=True, blank=True, verbose_name=_("Parent message")) sent_at = models.DateTimeField(_("sent at"), null=True, blank=True) read_at = models.DateTimeField(_("read at"), null=True, blank=True) replied_at = models.DateTimeField(_("replied at"), null=True, blank=True) sender_deleted_at = models.IntegerField(_("Sender deleted at"), null=True, blank=True) recipient_deleted_at = models.DateTimeField(_("Recipient deleted at"), null=True, blank=True) # trash_status = models.IntegerField(_("trash_status"),null=True) provider_sent_status = models.IntegerField(_("provider_sent_status"),null=True) buyer_display_status = models.IntegerField(_("buyer_display_status"),null=True) provider_display_status = models.IntegerField(_("provider_display_status"),null=True) objects = MessageManager() def new(self): """returns whether the recipient has read the message or not""" if self.read_at is not None: return False return True def replied(self): """returns whether the recipient has written a reply to this message""" if self.replied_at is not None: return True return False def __unicode__(self): return self.subject def get_absolute_url(self): return ('messages_detail', [self.id]) get_absolute_url = models.permalink(get_absolute_url) def save(self, **kwargs): if not self.id: self.sent_at = timezone.now() super(Message, self).save(**kwargs) class Meta: ordering = ['-sent_at'] verbose_name = _("Message") verbose_name_plural = _("Messages")
class Feedback(models.Model): type = models.ForeignKey(Type, verbose_name=_("Type")) title = models.CharField(_("Title"), max_length=500) description = models.TextField( _("Description"), blank=True, help_text=_('This wiill be viewable by other people - ' 'do not include any private details such as ' 'passwords or phone numbers here.')) anonymous = models.BooleanField(_("Anonymous"), blank=True, help_text=_('Do not show who sent this')) private = models.BooleanField( _("Private"), blank=True, help_text=_('Hide from public pages. Only site administrators ' 'will be able to view and respond to this.')) user = models.ForeignKey(User, blank=True, null=True, verbose_name=_("User")) created = models.DateTimeField(auto_now_add=True, blank=True, null=True, verbose_name=_("Created at")) status = models.ForeignKey(Status, verbose_name=_("Status")) duplicate = models.ForeignKey('self', null=True, blank=True, verbose_name=_("Duplicate")) def save(self, *args, **kwargs): try: self.status except: try: default = Status.objects.get(default=True) except: default = Status.objects.filter()[0] self.status = default super(Feedback, self).save() def get_absolute_url(self): return ('djangovoice_item', (self.id, )) get_absolute_url = models.permalink(get_absolute_url) def __unicode__(self): return self.title
class Category(models.Model): title = models.CharField(max_length=250, help_text='Keep within 250 Chars') slug = models.SlugField(unique=True) description = models.TextField() class Meta: verbose_name_plural = "Categories" def __unicode__(self): return self.title def get_absolute_url(self): return ('DJPlus_category_detail', ('slug'), {'slug': self.slug}) get_absolute_url = models.permalink(get_absolute_url)
class Category(models.Model): title = models.CharField(max_length=200) slug = models.SlugField() class Meta: ordering = ('title',) verbose_name = ('category') verbose_name_plural = ('categories') def __unicode__(self): return self.title def get_absolute_url(self): return 'leon_category', None, {'slug': self.slug} get_absolute_url = models.permalink(get_absolute_url)
class HashTag(models.Model): name = models.TextField(max_length=50, blank=False, null=False) def __str__(self): return "#%s" % self.name class Meta: db_table = 'hashtag' verbose_name = 'Hashtag' verbose_name_plural = 'Hashtags' def get_absolute_url(self): return ('hashtag', None, {'hashtag': str(self.name)}) get_absolute_url = models.permalink(get_absolute_url)
class UserProfile(models.Model): firstName = models.CharField(max_length=100, verbose_name="First Name") lastName = models.CharField(max_length=100, verbose_name="Last Name") location = models.CharField(max_length=100, verbose_name="Current Location") email = models.EmailField() phoneNum = models.IntegerField(max_length=100, verbose_name="Phone Number") user = models.OneToOneField(User, parent_link=True) def get_absolute_url(self): return ('profiles_profile_detail', (), { 'username': self.user.username }) get_absolute_url = models.permalink(get_absolute_url)
class Knot(models.Model): author = models.ManyToManyField(User, related_name="author_knots", help_text="Authors of post.") title = models.CharField(_('title'), max_length=44, help_text="Post title.") slug = models.SlugField(_('slug'), blank=True, unique=True, help_text="Post slug (auto generated).") short_url = models.CharField(_('short'), max_length=100, blank=True, help_text="Short link for sharing.") tagline = models.CharField(_('tagline'), max_length=160, blank=True, help_text="Post tagline, a short, catchy sentence.") blurb = models.CharField(_('blurb'), max_length=250, blank=True, help_text="Post blurb, a quick overview.") date = models.DateTimeField(_('date published'), help_text="Date published.") strand_a = models.ForeignKey(Strand, related_name='strand_a') strand_b = models.ForeignKey(Strand, related_name='strand_b') body = models.TextField(_('body'), blank=True, help_text="Post body.") style = models.TextField(_('style'), blank=True, help_text="Post style (JSON string).") notes = models.TextField(_('notes'), blank=True, help_text="Post notes.") published = models.BooleanField(_('published'), blank=True, help_text="Is post published?") allow_comments = models.BooleanField(_('allow comments'), help_text="Can people comment?") allow_rss = models.BooleanField(_('allow rss'), help_text="Can the knot be included in RSS feeds?") location = models.ManyToManyField(Location, null=True, blank=True, related_name="location", help_text="Associated locations.") license = models.ForeignKey(License, null=True, blank=True, related_name="license", help_text="License applied to post.") def save(self): if not self.slug: slug = defaultfilters.slugify( self.title ) try: existing = Knot.objects.get(slug=slug) except Knot.DoesNotExist: pass else: slug = '%s-%s' % (slug, (existing.count() + 1)) self.slug=slug while not self.short_url: count = Knot.objects.count() if count < 1: count = 1 short_url = ''.join(random_alphanumeric(int(math.log(count,62))+1)) if short_url not in RESERVED_WORDS: try: existing = Knot.objects.get(short_url=short_url) except Knot.DoesNotExist: self.short_url = short_url super( Knot, self ).save() def __unicode__(self): return u'%s' % self.title def get_absolute_url(self): return ('display_knot', [str(self.slug)]) get_absolute_url = models.permalink(get_absolute_url)
class Code_base(models.Model): program_name = models.CharField(max_length=50, core=True) version = models.CharField(max_length=40, core=True) compile_options = models.CharField(max_length=100) def __str__(self): return "%s v.%s" % (self.program_name, self.version) def get_absolute_url(self): return ('relay.warnings.views.code_detail', [str(self.id)]) get_absolute_url = permalink(get_absolute_url) class Admin: # Admin options go here pass
class Category(models.Model): title = models.CharField(max_length=200) slug = models.SlugField() class Meta: verbose_name = '分类' verbose_name_plural = '分类' ordering = ('title', ) def __str__(self): return self.title def get_absolut_url(self): return ('dpress_category', None, {'category': self.slug}) get_absolut_url = models.permalink(get_absolut_url)
class UserProfile(models.Model): user = models.ForeignKey(User, unique=True) telefono = PhoneNumberField() def __unicode__(self): if self.user.first_name and self.user.last_name: return self.user.first_name + " " + self.user.last_name else: return self.user.username def get_absolute_url(self): return ('profiles_profile_detail', (), { 'username': self.user.username }) get_absolute_url = models.permalink(get_absolute_url)
def __init__(self, model, **kwargs): self.model = model for key, value in kwargs.items(): if not hasattr(self, key): raise TypeError('%s() received an invalid keyword %r' % ( self.__class__.__name__, key)) setattr(self, key, value) if not hasattr(self.model, 'get_absolute_url'): # Add a simple primary key based URL to the model if it does not # have one yet self.model.get_absolute_url = models.permalink( lambda self: ( '%s_%s_detail' % app_model_label(self), (self.pk,), {}))
class UserProfile(models.Model): """Additional information about a User.""" user = AutoOneToOneField('auth.User', verbose_name=_('User'), related_name='profile') whitelisted = models.BooleanField(_('Whitelisted'), default=False) banned = models.BooleanField(_('Banned'), default=False) homepage = models.CharField(_('Homepage'), max_length=100, blank=True) allow_ads = models.BooleanField( _('See paid advertising'), help_text=_('If unchecked, you will still see community ads.'), default=True, ) allow_email = models.BooleanField( _('Allow email'), help_text=_('Show your email on VCS contributions.'), default=True, ) def __str__(self): return (ugettext("%(username)s's profile") % { 'username': self.user.username }) def get_absolute_url(self): return ('profiles_profile_detail', (), { 'username': self.user.username }) get_absolute_url = models.permalink(get_absolute_url) def get_contribution_details(self): """ Get the line to put into commits to attribute the author. Returns a tuple (name, email) """ if self.user.first_name and self.user.last_name: name = '{} {}'.format(self.user.first_name, self.user.last_name) else: name = self.user.username if self.allow_email: email = self.user.email else: email = STANDARD_EMAIL return (name, email)
class Conversation(models.Model): id = models.IntegerField(primary_key=True, editable=False) title = models.CharField(max_length=500, blank=True) conversation_text = models.TextField() pub_date = models.DateTimeField(default=datetime.datetime.now) user = models.ForeignKey(User) class Meta: ordering = ['-pub_date'] def save(self): try: self.conversationline_set.all().delete() except: pass api = get_user_api(self.user.username) if api: if not self.id: post = api.write_conversation( title=self.title, conversation=self.conversation_text) self.id = post['id'] super(Conversation, self).save() lines = self.conversation_text.split('\n') for line in lines: c = ConversationLine(conversation=self, line=line) c.save() def __unicode__(self): if self.title: return "%s (Conversation)" % self.title else: return "Conversation" def get_absolute_url(self): return ('djumblr_conversation_detail', (), { 'year': self.pub_date.strftime("%Y"), 'month': self.pub_date.strftime("%b").lower(), 'day': self.pub_date.strftime("%d"), 'id': self.id }) get_absolute_url = models.permalink(get_absolute_url) def shared_display(self): return display_tumbl(self, "djumblr/display/conversation.html")
class Category(models.Model): title = models.CharField(_('title'), max_length=200) slug = models.SlugField(_('slug')) class Meta: verbose_name = _('category') verbose_name_plural = _('categorys') ordering = ('title',) def __unicode__(self): return self.title def get_absolute_url(self): return ('dpress_category', None, { 'category': self.slug }) get_absolute_url = models.permalink(get_absolute_url)
class Run(models.Model): time_of_run = models.DateTimeField(editable=True, auto_now_add=True) code = models.ForeignKey(Code_base, limit_choices_to={}) changes_to_analysis = models.TextField(core=True) analysis_settings = models.TextField(core=True) def __str__(self): return str(self.code) + " " + str(self.time_of_run) def get_absolute_url(self): return ('relay.warnings.views.run_detail', [str(self.id)]) get_absolute_url = permalink(get_absolute_url) class Admin: list_display = ('id', 'code', 'time_of_run') list_filter = ('code', 'time_of_run')
class Message(models.Model): """ A private message from user to user """ subject = models.CharField(_("Subject"), max_length=120) body = models.TextField(_("Body")) sender = models.ForeignKey(User, related_name='sent_messages', verbose_name=_("Sender")) recipient = models.ForeignKey(User, related_name='received_messages', null=True, blank=True, verbose_name=_("Recipient")) parent_msg = models.ForeignKey('self', related_name='next_messages', null=True, blank=True, verbose_name=_("Parent message")) sent_at = models.DateTimeField(_("sent at"), null=True, blank=True) read_at = models.DateTimeField(_("read at"), null=True, blank=True) replied_at = models.DateTimeField(_("replied at"), null=True, blank=True) sender_deleted_at = models.DateTimeField(_("Sender deleted at"), null=True, blank=True) recipient_deleted_at = models.DateTimeField(_("Recipient deleted at"), null=True, blank=True) objects = MessageManager() def new(self): """returns whether the recipient has read the message or not""" if self.read_at is not None: return False return True def replied(self): """returns whether the recipient has written a reply to this message""" if self.replied_at is not None: return True return False def __unicode__(self): return self.subject def get_absolute_url(self): return ('messages_detail', [self.id]) get_absolute_url = models.permalink(get_absolute_url) def save(self, force_insert=False, force_update=False): if not self.id: self.sent_at = datetime.datetime.now() super(Message, self).save(force_insert, force_update) class Meta: db_table = "messages_message" ordering = ['-sent_at'] verbose_name = _("Message") verbose_name_plural = _("Messages")
class Post(models.Model, PictureMixin): user = models.ForeignKey(User, on_delete=models.CASCADE) pub_date = models.DateTimeField(default=timezone_now()) text = models.TextField() notifications = GenericRelation( Notification, content_type_field='action_object_content_type_id', object_id_field='action_object_object_id') pictures = GenericRelation(UploadedFile, content_type_field='content_type_id', object_id_field='object_pk') comments_set = GenericRelation( PictureComment, content_type_field='content_type', object_id_field='object_pk', ) tags = models.ManyToManyField(HashTag) def __str__(self): return "%s posted %s on %s" % (self.user, self.text, self.pub_date) class Meta: db_table = 'user_post' verbose_name = 'post' verbose_name_plural = 'posts' def save(self, *args, **kwargs): # first must save the object before we can use the many_to_many field super(Post, self).save(*args, **kwargs) link_hashtags_to_model(self.text, self, self.user) notify_on_mention(self.text, self, self.user) # generate thumbnail picture version if self.pictures is not None: for p in self.pictures.all(): p.create_thumbnail() def delete(self, *args, **kwargs): super(Post, self).delete(*args, **kwargs) delete.alters_data = True def get_absolute_url(self): return ('post_detail', None, {'post': str(self.pk)}) get_absolute_url = models.permalink(get_absolute_url)
class UserProfile(models.Model): """Additional information about a User. """ user = models.ForeignKey(User, verbose_name=_('User'), unique=True, related_name='profile') whitelisted = models.BooleanField(_('Whitelisted')) homepage = models.CharField(_('Homepage'), max_length=100, blank=True) allow_email = models.BooleanField(_('Allow email'), help_text=_('Show your email on VCS ' 'contributions.'), default=True) def __unicode__(self): return (ugettext("%(username)s's profile") % { 'username': self.user.username }) def get_form(self): from .forms import UserProfileForm return UserProfileForm(instance=self) def get_absolute_url(self): return ('profiles_profile_detail', (), { 'username': self.user.username }) get_absolute_url = models.permalink(get_absolute_url) def get_contribution_details(self): """ Gets the line to put into commits to attribute the author. Returns a tuple (name, email) """ if self.user.first_name and self.user.last_name: name = '%s %s' % (self.user.first_name, self.user.last_name) else: name = self.user.username if self.allow_email: email = self.user.email else: email = STANDARD_EMAIL return (name, email)
class Notice(models.Model): user = models.ForeignKey(User, verbose_name=_('user'), blank=True, null=True) email = models.EmailField(max_length=96, blank=True, null=True) message = models.TextField(_('message')) notice_type = models.ForeignKey(NoticeType, verbose_name=_('notice type')) added = models.DateTimeField(_('added'), default=datetime.datetime.now) unseen = models.BooleanField(_('unseen'), default=True) archived = models.BooleanField(_('archived'), default=False) on_site = models.BooleanField(_('on site')) objects = NoticeManager() def __unicode__(self): return self.message def archive(self): self.archived = True self.save() def is_unseen(self): """ returns value of self.unseen but also changes it to false. Use this in a template to mark an unseen notice differently the first time it is shown. """ unseen = self.unseen if unseen: self.unseen = False self.save() return unseen class Meta: ordering = ["-added"] verbose_name = _("notice") verbose_name_plural = _("notices") def get_absolute_url(self): return ("notification_notice", [str(self.pk)]) get_absolute_url = models.permalink(get_absolute_url)
class Link(models.Model): # Metadata. enable_comments = models.BooleanField(default=True) post_elsewhere = models.BooleanField('Post to Delicious', default=True, help_text='If checked, this link will be posted both to your blog and your del.icio.us account.') posted_by = models.ForeignKey(User) pub_date = models.DateTimeField(default=datetime.datetime.now) slug = models.SlugField(unique_for_date='pub_date', help_text='Must be unique for the publication date.') title = models.CharField(max_length=250) # The actual link bits. description = models.TextField(blank=True) via_name = models.CharField('Via', max_length=250, blank=True, help_text='The name of the person whose site you spotted the link on. Optional.') via_url = models.URLField('Via URL', blank=True, help_text='The URL of the site where you spotted the link. Optional.') tags = TagField() url = models.URLField(unique=True) class Meta: ordering = ['-pub_date'] def __unicode__(self): return self.title def save(self, force_insert=False, force_update=False): if not self.id and self.post_elsewhere: import pydelicious from django.utils.encoding import smart_str pydelicious.add(settings.DELICIOUS_USER, settings.DELICIOUS_PASSWORD, smart_str(self.url), smart_str(self.title), smart_str(self.tags)) #if self.description: # self.description_html = markdown(self.description) super(Link, self).save() def get_absolute_url(self): return ('zeus_link_detail', (), { 'year': self.pub_date.strftime('%Y'), 'month': self.pub_date.strftime('%b').lower(), 'day': self.pub_date.strftime('%d'), 'slug': self.slug }) get_absolute_url = models.permalink(get_absolute_url)
class BrandCategory(models.Model, TranslatedObjectMixin): """A category within a brand""" slug = models.SlugField(_("Slug"), help_text=_("Used for URLs")) brand = models.ForeignKey(Brand, related_name="categories") products = models.ManyToManyField(Product, blank=True, verbose_name=_("Products"), through='BrandCategoryProduct') ordering = models.IntegerField(_("Ordering")) active = models.BooleanField(default=True) objects = BrandCategoryManager() def _translation(self): return self._find_translation() translation = property(fget=_translation) def _get_absolute_url(self): return ('satchmo_brand_category_view', None, { 'brandname': self.brand.slug, 'catname': self.slug }) get_absolute_url = models.permalink(_get_absolute_url) def active_products(self): return self.products.filter(site=self.brand.site).filter(active=True) def has_categories(self): return False def has_content(self): return self.active_products() def has_products(self): return self.active_products().count > 0 def __unicode__(self): return u"%s: %s" % (self.brand.slug, self.slug) class Meta: ordering = ('ordering', 'slug') verbose_name = _('Brand Category') verbose_name_plural = _('Categories')
class Week(models.Model): #date must be unique #and when users involved, user+date combo #is what must be unique date = models.DateField() name = models.CharField(max_length=100, editable=False) days = models.ManyToManyField(Day, editable=False) slug = models.SlugField(unique=True, editable=False) class Meta: pass def __unicode__(self): return self.name def save(self, force_insert=False, force_update=False): """ if date != monday: date = the previous monday name = self.date to self.date+6 """ #If self.date is not a Monday, then make it a Monday date = self.date weekday = date.weekday() if weekday != 0: a_monday = date - datetime.timedelta(days=weekday) self.date = a_monday start_of_week = self.date end_of_week = self.date + datetime.timedelta(days=6) self.name = "%s to %s" % ( start_of_week.strftime('%a %b %d, %Y'), end_of_week.strftime('%a %b %d, %Y'), ) self.slug = slugify(self.date.strftime('%a %b %d, %Y')) super(Week, self).save(force_insert, force_update) def get_absolute_url(self): return ('mealweek_week_detail', (), {'slug': self.slug}) get_absolute_url = models.permalink(get_absolute_url)
class Photo(models.Model): id = models.IntegerField(primary_key=True, editable=False) source = models.URLField(blank=True) photo = models.ImageField(upload_to="/photos", blank=True) caption = models.TextField(blank=True) click_through_url = models.URLField(blank=True) pub_date = models.DateTimeField(default=datetime.datetime.now) user = models.ForeignKey(User) class Meta: ordering = ['-pub_date'] def save(self): api = get_user_api(self.user.username) if api: if not self.id: if self.source: post = api.write_photo( source=self.source, caption=self.caption, click_through_url=self.click_through_url) elif self.photo: post = api.write_photo( data=open(self.photo), caption=self.caption, click_through_url=self.click_through_url) self.id = post['id'] super(Photo, self).save() def __unicode__(self): return "Photo" def get_absolute_url(self): return ('djumblr_photo_detail', (), { 'year': self.pub_date.strftime("%Y"), 'month': self.pub_date.strftime("%b").lower(), 'day': self.pub_date.strftime("%d"), 'object_id': self.id }) get_absolute_url = models.permalink(get_absolute_url) def shared_display(self): return display_tumbl(self, "djumblr/display/photo.html")
class Profile(models.Model): GENDER_CHOICES = (('M', _('Male')), ('F', _('Female')),) USER_CHOICES = ( ('User', _('User')), ('Agent', _('Agent')), ('Contact', _('Contact'))) user = models.OneToOneField(User, on_delete=models.CASCADE) about = models.TextField(_('about'), max_length=500, blank=True, default='') gender = models.CharField(_('gender'), max_length=5, choices=GENDER_CHOICES, null=True, default='M') url = models.URLField(_('website'), blank=True) location = models.CharField(_('location'), max_length=150, blank=True, default='') phone = models.CharField(max_length=20, null=True, blank=True, default='') city = models.CharField(max_length=100, default='', null=True, blank=True) country = models.CharField(max_length=100, default='', null=True, blank=True) image = models.ImageField(_('photo'), upload_to='upload/user_images', default="upload/blog_photos/amor-590x336.jpg", max_length=1024) image_thumbnail = ImageSpecField(source="image", processors=[SmartResize(100, 100)], format="PNG", options={'quality': 60}) image_big_thumbnail = ImageSpecField(source="image", processors=[SmartResize(200, 200)], format="PNG", options={'quality': 60}) image_pin = ImageSpecField(source="image", processors=[SmartResize(32, 32)], format="PNG", options={'quality': 60}) image_comment_thumb = ImageSpecField(source="image", processors=[SmartResize(45, 45)], format="PNG", options={'quality': 60}) profile_type = models.CharField(_('Type'), max_length=15, choices=USER_CHOICES, default='User') pub_date = models.DateTimeField(auto_now_add=True) update_date = models.DateTimeField(auto_now=True) is_influencer = models.BooleanField(_('influencer'), default=False, help_text='This user is a content provider and can be followed by other users') class Meta: verbose_name_plural = _('User profiles') def __str__(self): if self.user.get_full_name(): return self.user.get_full_name() return self.user.username def get_absolute_url(self): return ('profile_detail', (), {'username': self.user.username}) get_absolute_url = models.permalink(get_absolute_url)
class Language(models.Model): name = models.CharField(max_length=50, unique=True) slug = models.SlugField(editable=False) def save(self, **kwargs): if not self.id: self.slug = slugify(self.name) super(Language, self).save(kwargs) def get_absolute_url(self): return ('mloss.software.views.list.software_by_language', (), { 'slug': self.slug }) get_absolute_url = models.permalink(get_absolute_url) def __unicode__(self): return unicode(self.name)
class TutorialCategory(models.Model): name = models.CharField(max_length=200) def __unicode__(self): return self.name def get_absolute_url(self): return ('resources_tutorial_category', (), { 'id': self.id, }) get_absolute_url = models.permalink(get_absolute_url) class Meta: verbose_name_plural = "Tutorial Categories" ordering = [ 'name', ]
def get_absolute_url(self): return('coltrane_link_detail', (), { 'year': self.pub_date.strftime('%Y'), 'month': self.pub_date.strftime('%b').lower(), 'day': self.pub_date.strftime('%d'), 'slug': self.slug }) get_absolute_url = models.permalink(get_absolute_url)
from django.db import models from django.utils.translation import ugettext_lazy as _ from django.contrib.auth.models import User from django.db.models.signals import post_save from thumbs import ImageWithThumbsField import lifestream.models # short_name is a user's first name and last initial User.short_name = property(lambda self: "%s %s." % (self.first_name, self.last_name[0:1])) User.get_absolute_url = models.permalink(lambda self: ('account_view', (), { 'username': self.username, })) DEFAULT_PROFILE_IMAGE_PATH = 'profile_images/default_breakout_profile_image.png' class UserProfile(models.Model): GENDER_CHOICES = ( ('M', 'Male'), ('F', 'Female'), ) created_on = models.DateTimeField(auto_now_add=True) updated_on = models.DateTimeField(auto_now=True) user = models.ForeignKey(User) profile_image = ImageWithThumbsField(max_length=400, upload_to='profile_images', sizes=((48, 48), (64, 64), (200, 200)), default=ImageWithThumbsField(DEFAULT_PROFILE_IMAGE_PATH)) age = models.PositiveSmallIntegerField(blank=True, null=True) gender = models.CharField(max_length=1, choices=GENDER_CHOICES, blank=True, null=True) occupation = models.CharField(max_length=100, blank=True, null=True) twitter_access_token = models.CharField(max_length=500, blank=True, null=True) twitter_user = models.ForeignKey(lifestream.models.TwitterUser, related_name='twitter_user', blank=True, null=True) class Meta:
template = get_template(template_src) context = Context(context_dict) html = template.render(context) result = StringIO.StringIO() pdf = pisa.pisaDocument(StringIO.StringIO(html.encode("utf-8")), result) if not pdf.err: response = HttpResponse(result.getvalue(), mimetype='application/pdf') response['Content-Disposition'] = 'attachment; filename=report.pdf' return response return HttpResponse('We had some errors<pre>%s</pre>' % escape(html)) def help(request): if request.method == "POST": if request.POST['clickedButton'] == "export_pdf": return render_to_response("base.html", context_instance=RequestContext(request)) return render_to_response("help.html", context_instance=RequestContext(request)) def thanks(request): return render_to_response('thanks.html', context_instance=RequestContext(request)) def topdf(request): return render_to_pdf('app/list_org.html',{ 'pagesize': 'A4'}) #method routes to the view ``profiles.views.profile_detail``, passing the username @models.permalink def get_absolute_url(self): return ('profiles_profile_detail', (), { 'username': self.user.username }) get_absolute_url = models.permalink(get_absolute_url)
def get_absolute_url(self): """ Needed for the profiles application, returns a url ref """ return 'profiles_profile_detail', (), { 'username': self.user.username } get_absolute_url = models.permalink(get_absolute_url)
from django.contrib.sites.models import Site from django.contrib.comments.models import Comment from django.contrib.comments.signals import comment_will_be_posted from django.contrib.comments.moderation import CommentModerator, moderator # Fetch a Site object so it would know where you were running the development # server. Whenever you're running with this database and settings file, you # can get that Site object. # current_site = Site.objects.get_current() # akismet_api = Akismet(key=settings.AKISMET_API_KEY, # blog_url="http://%s/" %Site.objects.get_current().domain) Tag.get_absolute_url = models.permalink( lambda self: ('coltrane_all_items_by_tag', (), {'tag': self.name.lower()})) # ------------------------------------------------------------------------------ # Content, Links etc # ------------------------------------------------------------------------------ class Location(models.Model): title = models.CharField(max_length=250, help_text='Maximum 250 characters.') slug = models.SlugField(unique=True, help_text=""" Suggested value automatically generated from title. Must be unique.""")
def _model(data, fields=()): """ Models. Will respect the `fields` and/or `exclude` on the handler (see `typemapper`.) """ ret = { } handler = self.in_typemapper(type(data), self.anonymous) get_absolute_uri = False if handler or fields: v = lambda f: getattr(data, f.attname) if not fields: """ Fields was not specified, try to find teh correct version in the typemapper we were sent. """ mapped = self.in_typemapper(type(data), self.anonymous) get_fields = set(mapped.fields) exclude_fields = set(mapped.exclude).difference(get_fields) if 'absolute_uri' in get_fields: get_absolute_uri = True if not get_fields: get_fields = set([ f.attname.replace("_id", "", 1) for f in data._meta.fields ]) # sets can be negated. for exclude in exclude_fields: if isinstance(exclude, basestring): get_fields.discard(exclude) elif isinstance(exclude, re._pattern_type): for field in get_fields.copy(): if exclude.match(field): get_fields.discard(field) else: get_fields = set(fields) met_fields = self.method_fields(handler, get_fields) for f in data._meta.local_fields: if f.serialize and not any([ p in met_fields for p in [ f.attname, f.name ]]): if not f.rel: if f.attname in get_fields: ret[f.attname] = _any(v(f)) get_fields.remove(f.attname) else: if f.attname[:-3] in get_fields: ret[f.name] = _fk(data, f) get_fields.remove(f.name) for mf in data._meta.many_to_many: if mf.serialize and mf.attname not in met_fields: if mf.attname in get_fields: ret[mf.name] = _m2m(data, mf) get_fields.remove(mf.name) # try to get the remainder of fields for maybe_field in get_fields: if isinstance(maybe_field, (list, tuple)): model, fields = maybe_field inst = getattr(data, model, None) if inst: if hasattr(inst, 'all'): ret[model] = _related(inst, fields) elif callable(inst): if len(inspect.getargspec(inst)[0]) == 1: ret[model] = _any(inst(), fields) else: ret[model] = _model(inst, fields) elif maybe_field in met_fields: # Overriding normal field which has a "resource method" # so you can alter the contents of certain fields without # using different names. ret[maybe_field] = _any(met_fields[maybe_field](data)) else: maybe = getattr(data, maybe_field, None) if maybe: if callable(maybe): if len(inspect.getargspec(maybe)[0]) == 1: ret[maybe_field] = _any(maybe()) else: ret[maybe_field] = _any(maybe) else: handler_f = getattr(handler or self.handler, maybe_field, None) if handler_f: ret[maybe_field] = _any(handler_f(data)) else: for f in data._meta.fields: ret[f.attname] = _any(getattr(data, f.attname)) fields = dir(data.__class__) + ret.keys() add_ons = [k for k in dir(data) if k not in fields] for k in add_ons: ret[k] = _any(getattr(data, k)) # resouce uri if self.in_typemapper(type(data), self.anonymous): handler = self.in_typemapper(type(data), self.anonymous) if hasattr(handler, 'resource_uri'): url_id, fields = handler.resource_uri() ret['resource_uri'] = permalink( lambda: (url_id, (getattr(data, f) for f in fields) ) )() if hasattr(data, 'get_api_url') and 'resource_uri' not in ret: try: ret['resource_uri'] = data.get_api_url() except: pass # absolute uri if hasattr(data, 'get_absolute_url') and get_absolute_uri: try: ret['absolute_uri'] = data.get_absolute_url() except: pass return ret
def __new__(cls, name, bases, attrs): cls = super(BMFModelBase, cls).__new__(cls, name, bases, attrs) parents = [b for b in bases if isinstance(b, BMFModelBase)] if not parents: # If this is the ModelBase-Class itself - do nothing return cls if cls._meta.abstract: # Don't do anything on abstract models return cls # make bmf-attributes cls._bmfmeta = BMFOptions(cls, cls._meta, getattr(cls, 'BMFMeta', None)) if type(cls._meta.permissions) is not tuple: cls._meta.permissions = tuple(cls._meta.permissions) # generate permissions if not cls._bmfmeta.only_related: cls._meta.permissions += ( ('view_' + cls._meta.model_name, u'Can view %s' % cls.__name__), ) if cls._bmfmeta.can_clone: cls._meta.permissions += ( ('clone_' + cls._meta.model_name, u'Can clone %s' % cls.__name__), ) if cls._bmfmeta.has_comments: cls._meta.permissions += ( ('comment_' + cls._meta.model_name, u'Can comment on %s' % cls.__name__), ) if cls._bmfmeta.has_files: cls._meta.permissions += ( ('addfile_' + cls._meta.model_name, u'Can add files to %s' % cls.__name__), ) # add field: workflow field if cls._bmfmeta.has_workflow: try: field = cls._meta.get_field(cls._bmfmeta.workflow_field_name) if not isinstance(field, WorkflowField): raise ImproperlyConfigured( '%s is not a WorkflowField in %s' % ( cls._bmfmeta.workflow_field_name, cls.__name__ ) ) except (models.FieldDoesNotExist, AppRegistryNotReady): field = WorkflowField(workflow=cls._bmfmeta.workflow_cls) field.contribute_to_class(cls, cls._bmfmeta.workflow_field_name) # add field: modified try: cls._meta.get_field('modified') except (models.FieldDoesNotExist, AppRegistryNotReady): field = models.DateTimeField( _("Modified"), auto_now=True, editable=False, null=True, blank=False, ) field.contribute_to_class(cls, 'modified') # add field: created try: cls._meta.get_field('created') except (models.FieldDoesNotExist, AppRegistryNotReady): field = models.DateTimeField( _("Created"), auto_now_add=True, editable=False, null=True, blank=False, ) field.contribute_to_class(cls, 'created') # add field: modified by try: cls._meta.get_field('modified_by') except (models.FieldDoesNotExist, AppRegistryNotReady): field = models.ForeignKey( getattr(settings, 'AUTH_USER_MODEL', 'auth.User'), verbose_name=_("Modified by"), null=True, blank=True, editable=False, related_name="+", on_delete=models.SET_NULL ) field.contribute_to_class(cls, 'modified_by') # add field: created by try: cls._meta.get_field('created_by') except (models.FieldDoesNotExist, AppRegistryNotReady): field = models.ForeignKey( getattr(settings, 'AUTH_USER_MODEL', 'auth.User'), verbose_name=_("Created by"), null=True, blank=True, editable=False, related_name="+", on_delete=models.SET_NULL ) field.contribute_to_class(cls, 'created_by') # TODO add model from app config try: cls._meta.get_field('djangobmf_activity') except (models.FieldDoesNotExist, AppRegistryNotReady): field = GenericRelation( "djangobmf.Activity", content_type_field='parent_ct', object_id_field='parent_id', ) field.contribute_to_class(cls, 'djangobmf_activity') # TODO add model from app config try: cls._meta.get_field('djangobmf_notification') except (models.FieldDoesNotExist, AppRegistryNotReady): field = GenericRelation( "djangobmf.Notification", content_type_field='watch_ct', object_id_field='watch_id', ) field.contribute_to_class(cls, 'djangobmf_notification') # instancemethod: bmfget_project def bmfget_project(self): """ The result of this value is currently used by the document-management system to connect the file uploaded to this model with a project instance Default: None """ return None setattr(cls, 'bmfget_project', bmfget_project) # instancemethod: bmfget_customer def bmfget_customer(self): """ The result of this value is currently used by the document-management system to connect the file uploaded to this model with a customer instance Default: None """ return None setattr(cls, 'bmfget_customer', bmfget_customer) # instancemethod: bmfmodule_detail def bmfmodule_detail(self): """ A permalink to the default view of this model in the BMF-System """ return ('%s:detail' % self._bmfmeta.namespace_detail, (), {"pk": self.pk}) setattr(cls, 'bmfmodule_detail', models.permalink(bmfmodule_detail)) # instancemethod: get_absolute_url def get_absolute_url(self): return self.bmfmodule_detail() setattr(cls, 'get_absolute_url', get_absolute_url) # classmethod: bmfmodule_list def bmfmodule_list(cls, manager="all"): """ """ return ('%s:get' % cls._bmfmeta.namespace_api, (), {"manager": manager}) setattr(cls, 'bmfmodule_list', classmethod(models.permalink(bmfmodule_list))) if cls._bmfmeta.clean: if not hasattr(cls, 'bmf_clean') and not cls._meta.abstract: raise ImproperlyConfigured('%s has not a bmf_clean method' % (cls.__name__)) # add history signals for this model add_signals(cls) if cls._bmfmeta.has_workflow: def post_init_workflow(sender, instance, *args, **kwargs): workflow = getattr(instance, instance._bmfmeta.workflow_field_name) workflow.set_django_object(instance) instance._bmfmeta.workflow = workflow signals.post_init.connect(post_init_workflow, sender=cls, weak=False) if cls._bmfmeta.observed_fields: def post_init_observed_fields(sender, instance, *args, **kwargs): if instance.pk: for key in instance._bmfmeta.observed_fields: instance._bmfmeta.changelog[key] = getattr(instance, key) signals.post_init.connect(post_init_observed_fields, sender=cls, weak=False) # # add signals from base-classes # if hasattr(cls,'pre_save'): # if isinstance(cls.pre_save, types.FunctionType): # signals.pre_save.connect(cls.pre_save, sender=cls, weak=False) # if hasattr(cls,'post_init'): # if isinstance(cls.post_init, types.FunctionType): # signals.post_init.connect(cls.post_init, sender=cls, weak=False) if hasattr(cls, 'post_save'): """ @staticmethod def post_save(sender, instance, created, raw, *args, **kwargs): pass """ if isinstance(cls.post_save, types.FunctionType): signals.post_save.connect(cls.post_save, sender=cls, weak=False) if hasattr(cls, 'post_delete'): """ @staticmethod def post_delete(sender, instance, *args, **kwargs): pass """ if isinstance(cls.post_delete, types.FunctionType): signals.post_delete.connect(cls.post_delete, sender=cls, weak=False) return cls
def get_absolute_url(self): return ('profiles_profile_detail', (), {'username': self.user.username }) get_absolute_url = models.permalink(get_absolute_url)
def get_absolute_url(self): return ('gallery_detail', (), {'slug': self.slug}) get_absolute_url = models.permalink(get_absolute_url)
name = models.CharField(blank=True, max_length=80) initials = models.CharField(blank=True, max_length=10) url = models.URLField(_('url'), blank=True, verify_exists=False) last_checked = models.DateTimeField(_('last checked'), blank=True, null=True) polling_rate = models.IntegerField(_('polling rate'), blank=True, null=True, default=15) class Meta: ordering = ['-last_checked',] verbose_name, verbose_name_plural = _('feed'), _('feeds') def __unicode__(self): return self.name def _get_absolute_url(self): return ('feed_detail', (), {}) get_absolute_url = permalink(_get_absolute_url) class TwitterAccount(models.Model): """A Twitter account is fed by multiple twitter feeds""" username = models.CharField(_('username'), blank=True, max_length=80) password = models.CharField(_('password'), blank=True, max_length=80) philter = models.CharField(_('filter'), help_text='Only messages containing this phrase will be passed on to the twitter account. For multiple phrases, seperate them by a comma.', blank=True, max_length=80) philter_replies = models.BooleanField(_('filter replies'), help_text="Tick this box to filter @replies automatically", default=True) minimum_datetime = models.DateTimeField(_('minimum datetime'), help_text='Do not smash tweets that occured before this date/time', blank=True, null=True) strip_tags = models.BooleanField(_('strip tags'), default=False) prepend_names = models.BooleanField(_('prepend names'), help_text="Tick this box to prepend the names of the individual twitter accounts to the smashed message", default=True) append_tags = models.BooleanField(_('append tags'), help_text="Take all tags and put them at the end", default=True) append_initials = models.BooleanField(_('append initials'), help_text="Append the author initials to the end", default = False) active = models.BooleanField(_('active'), default=True) feeds = models.ManyToManyField(Feed)