class Profile(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile') location = models.CharField(max_length=50) email = models.EmailField() phone = models.IntegerField( validators=[MinValueValidator(1), MaxValueValidator(10)]) avatar = CloudinaryField('Image') def __str__(self): return self.user.username def save_image(self): self.save() def delete_image(self): self.delete() @classmethod def update(cls, id, value): cls.objects.filter(id=id).update(avatar=value)
class BlogPost(models.Model): """ model class for blog post """ title = models.CharField(max_length=500, blank=True) body = QuillField() block_quote = models.CharField(max_length=1000, null=True, blank=False) image = CloudinaryField('image', null=True, blank=True, max_length=2000) category = models.ForeignKey(Category, on_delete=models.CASCADE, null=True, blank=True) author = models.ForeignKey(CustomUser, on_delete=models.CASCADE, null=True, blank=True) slug = models.CharField(max_length=200, null=True, blank=True) date_created = models.DateTimeField(default=timezone.now) last_updated = models.DateTimeField(default=timezone.now) def __str__(self): return self.title @property def share_url(self): return settings.BASE_URL + 'blog/' + str(self.id) def save(self, *args, **kwargs): """ :return: """ self.last_updated = datetime.now() super().save(*args, **kwargs) def __unicode__(self): try: public_id = self.image.public_id except AttributeError: public_id = '' return f"Photo {self.title} {public_id}" def get_absolute_url(self): return reverse('blog_detail', args=[str(self.id)])
class People(models.Model): username=models.CharField(max_length=20) #firstname=models.CharField(max_length=50) #lastname=models.CharField(max_length=50) users=models.ForeignKey(User,related_name="post_user",on_delete=models.CASCADE) description=models.TextField(max_length=100,blank=True,null=True,default="No Description Available") #profile=models.ImageField(upload_to='pics',blank=True,default="profiles/default.jpg") profile=CloudinaryField('profile') likes=models.BooleanField(default=False) no_down=models.IntegerField(default=0,blank=True) likes_users=models.ManyToManyField(User,related_name='blog_post',blank=True) follow=models.ForeignKey(follow,related_name="follow",on_delete=models.CASCADE,default=1) def __str__(self): return str(self.pk) + " | " + self.username def get_absolute_url(self): return reverse("listing", kwargs={'my_username': self.username}) def get_absolute_urls(self): return reverse("specific-view", kwargs={'pk':self.pk}) def get_likes_url(self): return reverse("liked", kwargs={"pk": self.pk}) def counters(self): return self.likes_users.count() def down_counts(self): self.no_down+=1 return self.no_down def reverse_obj(self): obj=People.objects.all()[::-1] return obj def likedusers(self): a=self.likes_users.all() #lis=[str(i) for i in a] #return lis return a def get_username(self): u=User.objects.all() lis=[str(i) for i in u] return lis
class Product(models.Model): # LINK TO USER user = models.ForeignKey(User, on_delete=models.CASCADE) # NAME OF PRODUCT name = models.CharField(max_length=60, blank=False) # COMPANY NAME company = models.CharField(max_length=60, default="Private Company", blank=False) # CATEGORY THE PRODUCT BELONG TO CATEGORY = [ ('Business-Wear', 'Business-Wear'), ('Casual-Wear', 'Casual-Wear'), ('Footwear', 'Footwear'), ('Accessories', 'Accessories'), ] category = models.CharField(max_length=15, choices=CATEGORY, default='Business-Wear', blank=False) # DESCRIPTION FOR THE PRODUCT description = models.TextField(max_length=255) # CURRENT STOCK QUANTITY stock_qty = models.IntegerField(blank=False) # ORIGINAL PRICING OF PRODUCT TO BE SOLD price = models.DecimalField(blank=False, max_digits=5, decimal_places=2) # COVER IMAGE cover = CloudinaryField() def __str__(self): return (self.name)
class Profile(models.Model): profile_photo = CloudinaryField('image') profile_bio = models.TextField(blank=True) user = models.OneToOneField(User, on_delete=models.CASCADE) followers = models.ManyToManyField('self', related_name='followers', blank=True) following = models.ManyToManyField('self', related_name='following', blank=True) #save a profile def save_profile(self): self.save() def update_profile_bio(self, new_bio): self.profile_bio = new_bio self.save() def update_profile_photo(self, new_photo): self.profile_photo = new_photo self.save() def delete_profile(self): self.delete() @classmethod def get_user_profile(cls, userid): user_profile = cls.objects.get(user=userid) return user_profile def search_user_profile(search_term): user_profiles = User.objects.filter(username__icontains=search_term) return user_profiles def __str__(self): return self.user.username
class Project(models.Model): title = models.CharField(max_length=150) details = models.TextField() url = models.URLField(max_length=500) user = models.ForeignKey(User, on_delete=models.CASCADE, null=True) image = CloudinaryField('image') vote = models.IntegerField(default=0) published = models.DateTimeField(auto_now_add=True, blank=True, null=True) def __str__(self): return f'{self.title} Project' def save_project(self): self.save() @classmethod def all_images(cls): images = Project.objects.all() return images @classmethod def one_image(cls, project): project = cls.objects.get(id=project) return project @classmethod def search_project(cls, search_term): results = cls.objects.filter(title__icontains=search_term) return results def delete_project(self): self.delete() class Meta: db_table = 'projects' ordering = ['-id']
class Image(models.Model): image = CloudinaryField('image') name = HTMLField() caption = HTMLField() likes = models.ManyToManyField(User, related_name='image_post') post_date = models.DateTimeField(auto_now_add=True) profile = models.ForeignKey(Profile, on_delete=models.DO_NOTHING) user = models.ForeignKey(User, on_delete=models.DO_NOTHING) def __str__(self): return self.name class Meta: ordering = ['-name'] def save_image(self): self.save() def delete_image(self): self.delete() @classmethod def get_image_by_id(cls, id): image = cls.objects.get(id=id) return image def total_likes(self): return self.likes.count() @classmethod def get_image_by_id(cls, id): images = cls.objects.get(id=id) return images @classmethod def update_image(cls, id, image): cls.objects.filter(id=id).update(image=image)
class Image(models.Model): image_name = models.CharField(max_length=30) image_description = models.TextField() image = CloudinaryField('image') image_location = models.ForeignKey('Location', on_delete=models.CASCADE) image_category = models.ForeignKey('Category', on_delete=models.CASCADE) def save_image(self): self.save() def delete_image(self): self.delete() def update_image(self, Name=None, category=None): self.image_name = Name if Name else self.Name self.image_category = category if category else self.image_category self.save() def __str__(self): return self.image_name @classmethod def search_by_image_category(cls, search_term): images = cls.objects.filter( image_category__category_name__icontains=search_term) return images @classmethod def images(cls): images = cls.objects.all() return images @classmethod def filterimageByLocation(cls, location): location = cls.objects.filter( image_location__location_name=location).all() return location
class Image(models.Model): image = CloudinaryField('image') image_name = models.CharField(max_length=60) image_caption = models.CharField(max_length=60) profile = models.ForeignKey(Profile, on_delete=models.CASCADE) likes = models.ForeignKey(Like, null=True) comments = models.ForeignKey(Comment, on_delete=models.CASCADE, null=True, blank=True) def __str__(self): return self.image_name def save_image(self): self.save() @classmethod def get_image(cls, id): image = Image.objects.filter(id=id) return image @classmethod def get_post(cls, jina): images = Image.objects.filter(profile__name__username__icontains=jina) return images @classmethod def delete_image(cls, id): image = Image.objects.filter(id=id) image.delete() @classmethod def update_caption(cls, id, cap): image = Image.objects.filter(id=id) image.update(image_caption=cap) return image
class CloudinaryFile(CloudinaryFileResource): file = CloudinaryField( _('file'), type=settings.CLOUDINARY_TYPE, resource_type='raw', folder=settings.FILES_UPLOAD_TO ) display_name = models.CharField(_('display name'), max_length=255, blank=True) class Meta(CloudinaryFileResource.Meta): verbose_name = _('file') verbose_name_plural = _('files') def get_file(self) -> Optional[CloudinaryFieldFile]: if not self.file: return None return CloudinaryFieldFile(self.file, checksum=self.checksum) def set_file(self, value): self.file = value def get_file_field(self) -> CloudinaryField: return self._meta.get_field('file') def save(self, *args, **kwargs): if not self.pk and not self.display_name: self.display_name = self.basename super().save(*args, **kwargs) def as_dict(self) -> Dict[str, Any]: return { **super().as_dict(), 'name': self.display_name, 'file_info': '({ext}, {size})'.format( ext=self.extension, size=filesizeformat(self.size) ), }
class Image(models.Model): image_name = models.CharField(max_length =60) image_description = models.TextField() location = models.ForeignKey(Location,on_delete=models.CASCADE) category = models.ForeignKey(Category,on_delete=models.CASCADE) image = CloudinaryField('image') def save_image(self): self.save() def delete_image(self): self.delete() class Meta: ordering = ['image_name'] @classmethod def get_all_images(cls): images = cls.objects.all() return images @classmethod def update_image(cls, id, value): cls.objects.filter(id=id).update(image=value) @classmethod def get_image_by_id(cls,id): image = cls.objects.filter(id= id).all() return image @classmethod def filter_by_location(cls,search_term): locations = cls.objects.filter(location__location_name__icontains=search_term) return locations @classmethod def search_by_category(cls,search_term): categories = cls.objects.filter(category__category_name__icontains=search_term) return categories
class Photos(models.Model): name = models.CharField(max_length =30) description = models.CharField(max_length =150) category = models.ManyToManyField(Category) location = models.ManyToManyField(Location) image = CloudinaryField('image') class Meta: ordering = ['name',] def _str_(self): return self.name @classmethod def search_by_category(cls, category): photos = cls.objects.filter(category__name__icontains=category) return photos @classmethod def update_photo(cls, id, value): cls.objects.filter(id=id).update(image=value) @classmethod def get_photo_by_id(cls, id): photo = cls.objects.filter(id=id).all() return photo @classmethod def filter_by_location(cls, location): photo = Photos.objects.filter(location__name=location).all() return photo def save_photo(self): self.save() def delete_photo(self): self.delete()
class Event(TimeStampModel): title = models.CharField(max_length=100, verbose_name=_('Titre')) slug = models.SlugField(blank=True) start_date = models.DateField(verbose_name=_('Date de debut'), blank=True) end_date = models.DateField(verbose_name=_('Date de fin'), blank=True) start_time = models.TimeField(verbose_name=_('Heure de debut'), blank=True) end_time = models.TimeField(verbose_name=_('Heure de Fin'), blank=True) description = models.TextField(verbose_name='Description', blank=True) location = models.CharField(max_length=50, verbose_name=_('Lieu'), blank=True) location_city = models.CharField( max_length=50, verbose_name=_('Ville'), default='Yaoundé') # event_type = models.CharField( # max_length=10, # choices=(('online', 'Online'), ('outline', 'Outline')), # verbose_name = 'Type de L\'événement' # ) expired = models.BooleanField(default=False, verbose_name=_('Expiré')) creator = models.ForeignKey( User, on_delete=models.CASCADE, related_name='events') image = CloudinaryField( resource_type='image', blank=True, null=True, verbose_name=cover_image) published = models.BooleanField(default=True, verbose_name=_('Publier')) galery = models.ForeignKey( Galery, verbose_name='Joindre un album photos', blank=True, null=True, on_delete=models.CASCADE) # organizer = models.ManyToManyField(User) registration = models.ManyToManyField( User, blank=True, related_name='register_events', verbose_name=_('Inscris')) def __str__(self): return self.title def get_absolute_url(self): return reverse('com:event-detail', kwargs={'pk': self.pk}) class Meta: verbose_name = 'Agenda' verbose_name_plural = 'Agendas'
class Projects(models.Model): author = models.ForeignKey(User, on_delete=models.CASCADE, blank=True) image = CloudinaryField('image') description = models.TextField() created_date = models.DateTimeField(default=timezone.now) title = models.CharField(max_length=255) link = models.URLField() author_profile = models.ForeignKey(Profile, on_delete=models.CASCADE, default='1', blank=True) def save_project(self): self.save() def __str__(self): return f'{self.author} Post' class Meta: db_table = 'project' ordering = ['-created_date'] def delete_project(self): self.delete() @classmethod def search_projects(cls, search_term): project = cls.objects.filter(title__icontains=search_term) return project @classmethod def get_project(cls, id): try: project = Projects.objects.get(pk=id) except ObjectDoesNotExist: raise Http404() return Project
class Photo(models.Model): image = CloudinaryField('image') name = models.CharField(max_length =30) description = models.TextField() location = models.ForeignKey(Location, on_delete= models.SET_NULL, null= True) category = models.ForeignKey(Category, on_delete= models.CASCADE, default='') def __str__(self): return self.name def save_image(self): self.save def delete_image(self): self.delete @classmethod def images(cls): images = cls.objects.all() return images @classmethod def update_image(cls, id, image): images = cls.objects.filter(id=id).update(image = image) @classmethod def get_image_by_id(cls, id): image = cls.objects.get(id = id) @classmethod def search_image(cls, search_term): images = cls.objects.filter(category__category__icontains=search_term) return images @classmethod def filter_by_location(cls,location): images = cls.objects.filter(location__location= location)
class Tutorial(models.Model): title = models.CharField(max_length=100) description = models.TextField() image = image = CloudinaryField('images/', blank=True) content = HTMLField() Author = models.CharField(max_length=20) pub_date = models.DateTimeField(auto_now_add=True) updated_date = models.DateTimeField(auto_now_add=True) Published = models.BooleanField() Unpublished = models.BooleanField(default=False) url = models.CharField(max_length=50, default='www.github.com') user = models.ForeignKey(User, on_delete=models.CASCADE) class Meta: ordering = ['-pub_date'] def save_tutorial(self): self.save() def delete_tutorial(self): self.delete() @classmethod def get_all_tutorials(cls): tutorials = cls.objects.all() return tutorials def __str__(self): return self.title def get_absolute_url(self): return reverse('index') @classmethod def search_by_title(cls, search_term): tutorials = cls.objects.filter(title__icontains=search_term) return tutorials
class Product(models.Model): category = models.ForeignKey(Category, on_delete=models.CASCADE) subCategory = models.ForeignKey(SubCategory, on_delete=models.CASCADE) itemName = models.CharField(null=False, max_length=15) itemShortDesc = models.CharField(max_length=60) itemDetail = models.CharField(max_length=50) MRP = models.IntegerField(blank=True, null=True) #MRP = models.ForeignKey(PriceList, on_delete=models.CASCADE) discount = models.IntegerField(blank=True, null=True) sellMRP = models.IntegerField(blank=True, null=True) quantity = models.IntegerField(default=0) #imageUrl = models.ImageField(upload_to='product') imageUrl = CloudinaryField('image') orderId = models.CharField(max_length=10) weight = models.DecimalField(decimal_places=2, max_digits=8) def image_tag(self): return mark_safe('<img src="%s" width="150" height="150" />' % (self.imageUrl.url)) image_tag.short_description = 'Image' def __str__(self): return self.itemName
class CustomUser(AbstractUser): username = models.CharField(max_length=30, unique=True) first_name = models.CharField(max_length=30) last_name = models.CharField(max_length=30) password = models.CharField(max_length=100) email = models.CharField(max_length=100, unique=True) date_of_birth = models.DateField(default='2000-01-03') avatar = CloudinaryField('image') phone_number = models.CharField(max_length=30, unique=True, null=True) followers = models.ManyToManyField('CustomUser', related_name='user_follower', blank=True) following = models.ManyToManyField('CustomUser', related_name='user_following', blank=True) city = models.CharField(max_length=100) country = models.CharField(max_length=50) tags = models.ManyToManyField('events.Tag') def get_username(self): return str(self.username) def __unicode__(self): return self.username def __str__(self): return self.username
class Payment(models.Model): """handles cash inflows and outflows""" paid_by = models.ForeignKey(User, on_delete=models.CASCADE) account = models.ForeignKey(Account, on_delete=models.CASCADE) company = models.ForeignKey(Company, on_delete=models.CASCADE) date_added = models.DateTimeField(auto_now_add=True) """ receipt = models.ImageField(upload_to='receipts/%Y/%m/%d/') #can be used with dropbox setting """ ## Points to a Cloudinary image , needed for deploy receipt = CloudinaryField('image', default='media/uploads/image.png') transaction_id = models.AutoField(primary_key=True) LOAN_REPAYMENT = 'LP' GRANT = 'GT' SUBSCRIPTION = 'SP' Payment_Choices = ( (LOAN_REPAYMENT, 'Loan_repayment'), (GRANT, 'Grant'), (SUBSCRIPTION, 'Subscription'), ) payment_type = models.CharField( max_length=20, choices=Payment_Choices, default='notSet', ) payment_amount = models.PositiveIntegerField() def __str__(self): """Return a string representation of the model.""" return str(self.transaction_id)
class Image(models.Model): image = CloudinaryField('image', null=True) image_name = models.CharField(max_length=30) image_caption = models.CharField(max_length=50) likes = models.PositiveIntegerField(default=0) dislikes = models.IntegerField(default=0) comments = models.CharField(max_length=500, null=True, blank=True) posted_on = models.DateTimeField(auto_now_add=True) profile = models.ForeignKey(Profile, on_delete=models.CASCADE) def __str__(self): return self.image_name def save_image(self): self.save() def delete_image(self): self.delete() @classmethod def update_caption(cls, id, caption): cls.objects.filter(id=id).update(image_caption=caption) updated_caption = cls.objects.get(id=id) return updated_caption
class Image(models.Model): name = models.CharField(max_length=30) image = CloudinaryField('image', null=True) description = models.TextField() location = models.ForeignKey(Location, on_delete=models.CASCADE) category = models.ForeignKey(Category, on_delete=models.CASCADE) def save_image(self): self.save() def delete_image(self): Image.objects.get(id=self.id).delete() def update_image(self, val): Image.objects.filter(id=self.id).update(name=val) @classmethod def get_image_by_id(cls, image_id): return cls.objects.get(ide=image_id) @classmethod def get_images(cls): return cls.objects.all() @classmethod def search_image(cls, category): searched_image = cls.objects.filter(category__name__icontains=category) return searched_image @classmethod def filter_by_location(cls, location): img_location = Location.objects.get(name=location) return cls.objects.filter(location_id=img_location.id) def __str__(self): return self.name
class Image(models.Model): image = CloudinaryField('image') description = models.TextField() author = models.CharField(max_length=55, default='admin') date = models.DateTimeField(auto_now_add=True) name = models.CharField(max_length=55) category = models.ForeignKey(Category, on_delete=models.CASCADE) location = models.ForeignKey(Location, on_delete=models.CASCADE) def save_image(self): self.save() def delete_image(self): self.delete() @classmethod def update_image(cls, id, value): cls.objects.filter(id=id).update(image=value) @classmethod def get_image_by_id(cls, id): image = cls.objects.filter(id=id).all() return image @classmethod def search_by_category(cls, category): images = cls.objects.filter(category__name__contains=category) return images @classmethod def filter_by_location(cls, location): image_location = Image.objects.filter(location__name=location).all() return image_location def __str__(self): return self.name
class Item(models.Model): title = models.CharField(max_length = 100,unique = True) price = models.FloatField() discount_price = models.FloatField(default = 0,blank = True,null = True) category = models.CharField(choices = CATEGORY_CHOICES,max_length = 2) label= models.CharField(choices = LABEL_CHOICES,max_length = 2) slug = models.SlugField(verbose_name = "Tag",unique = True) description = models.TextField() image = CloudinaryField("image") artist = models.ForeignKey(Artist,on_delete = models.CASCADE,null = True) user = models.ForeignKey(settings.AUTH_USER_MODEL,on_delete = models.CASCADE,null = True) date = models.DateTimeField(default=timezone.now) likes = models.ManyToManyField(settings.AUTH_USER_MODEL,related_name='likes' , blank =True) def __str__(self): return self.title def all_likes(self): return self.likes.count() def get_absolute_url(self): return reverse("core:product",kwargs = {'slug':self.slug}) def get_add_to_cart_url(self): return reverse("core:add-to-cart",kwargs = {'slug':self.slug}) def get_remove_from_cart_url(self): return reverse("core:remove-from-cart",kwargs = {'slug':self.slug}) def get_with(self): return self.price - self.discount_price @classmethod def search_by_title(cls,search_term): item = cls.objects.filter(title__icontains=search_term) return item
class Image(models.Model): image = CloudinaryField('image') name = models.CharField(max_length=30) description = models.CharField(max_length=100) category = models.ForeignKey(Category,on_delete=models.CASCADE) location = models.ForeignKey(Location,on_delete=models.CASCADE) def __str__(self): return self.name def save_image(self): self.save() def delete_image(self): self.delete() @classmethod def update_image(cls,id): cls.objects.filter(id=id).update(image) @classmethod def get_image_by_id(cls,id): image = cls.objects.filter(id=id).all() return image @classmethod def search_image(cls,category): images = cls.objects.filter(category__name__icontains=category) return images @classmethod def filter_by_location(cls, location): image_location = Image.objects.filter(location__name=location).all() return image_location
class Book(models.Model): id = models.UUIDField( primary_key=True, default=uuid.uuid4, editable=False ) title = models.CharField(max_length=200) author = models.CharField(max_length=200) price = models.DecimalField(max_digits=6, decimal_places=2) cover = CloudinaryField('image') description = models.CharField(max_length=4000, blank=True) class Meta: permissions = [ ('special_status', 'Can read all books'), ] def __str__(self): return self.title def get_absolute_url(self): return reverse('book_detail', kwargs={'pk': str(self.pk)})
class Image(models.Model): imageName = models.CharField(max_length=30) imageDescription = models.CharField(max_length=30) imageLocation = models.ForeignKey(Location, on_delete=models.CASCADE) imageCategory = models.ForeignKey(Category, on_delete=models.CASCADE) image = CloudinaryField('images') def saveImage(self): self.save() def deleteImage(self): self.delete() @classmethod def updateImage(cls, id, value): cls.objects.filter(id=id).update(image=value) @classmethod def getimageById(cls, id): image = cls.objects.filter(id=id).all() return image @classmethod def searchImage(cls, category): category = cls.objects.filter( imageCategory__categoryName__icontains=category) return category @classmethod def filterimageByLocation(cls, location): location = cls.objects.filter( imageLocation__locationName=location).all() return location def __str__(self): return self.imageName
class Image(models.Model): image = CloudinaryField() image_name= models.CharField(max_length = 250) image_location=models.ForeignKey(Location) image_category=models.ForeignKey(Category) def __str__(self): return self.image_name def save_image(self): Image.image_list.append(self) def delete_image(self): Image.image_list.remove(self) @classmethod def search_by_category(cls,search_term): images = cls.objects.filter(image_category__icontains=search_term) return images # @classmethod # def search_image(cls, category): # images = cls.objects.filter(image_description__icontains=category) # return images # @classmethod # def search_by_name(cls,search_term): # images = cls.objects.filter(image_name__icontains = search_term) # return images @classmethod def filter_by_location(cls,location): locations = cls.objects.filter(image_location__icontains = image_Location) return images
class Post(models.Model): image = models.ImageField(upload_to='posts/') name = models.CharField(max_length=250, blank=True) caption = models.CharField(max_length=250, blank=True) likes = models.ManyToManyField( User, related_name='likes', blank=True, ) user = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='posts') created = models.DateTimeField(auto_now_add=True, null=True) image = CloudinaryField('image') class Meta: ordering = ["-pk"] def get_absolute_url(self): return f"/post/{self.id}" @property def get_all_comments(self): return self.comments.all() def save_image(self): self.save() def delete_image(self): self.delete() def total_likes(self): return self.likes.count() def __str__(self): return f'{self.user.name} Post'
class User(AbstractBaseUser, PermissionsMixin): email = models.EmailField(_('email address'), unique=True) first_name = models.CharField(_('first name'), max_length=30, blank=True) last_name = models.CharField(_('last name'), max_length=30, blank=True) date_joined = models.DateTimeField(_('date joined'), auto_now_add=True) is_active = models.BooleanField(_('active'), default=True) is_staff = models.BooleanField(default=False) avatar = CloudinaryField('avatar', null=True, blank=True) objects = UserManager() USERNAME_FIELD = 'email' REQUIRED_FIELDS = [] class Meta: verbose_name = _('user') verbose_name_plural = _('users') def get_full_name(self): ''' Returns the first_name plus the last_name, with a space in between. ''' full_name = '%s %s' % (self.first_name, self.last_name) return full_name.strip() def get_short_name(self): ''' Returns the short name for the user. ''' return self.first_name def email_user(self, subject, message, from_email=None, **kwargs): ''' Sends an email to this User. ''' send_mail(subject, message, from_email, [self.email], **kwargs)
class Artigo(models.Model): titulo = models.CharField('Título', max_length=100) manchete = models.CharField('Manchete', max_length=200) autor = models.ForeignKey(Autor, on_delete=models.CASCADE) categoria = models.ForeignKey(Categoria, on_delete=models.PROTECT) slug = models.SlugField('Identificador Google', max_length=100, help_text='identificador baseado no titulo', unique=True) descricao = models.TextField('Descrição') data_publicacao = models.DateTimeField('Data Publicação', auto_now_add=True) imagem_home = CloudinaryField('Imagem na Home Page', blank=True, null=True) class Meta: verbose_name = 'Artigo' verbose_name_plural = 'Artigos' ordering = ['-data_publicacao'] def __str__(self): return self.titulo def get_absolute_url(self): return reverse('blog:artigo', kwargs={'slug': self.slug})