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})
