class GalleryList(models.Model):
PIC_CAT_CHOICES = (('Event', 'Event'), ('Summer', 'Summer'),
('Future', 'Future'), ('Building', 'Building'),
('About', 'About'), ('Volunteers', 'Volunteers'),
('Youth Leadership', 'Youth Leadership'), ('Gallary',
'Gallary'))
title = models.CharField(max_length=100)
gallery_image = ResizedImageField(size=[800, 530],
blank=False,
null=False,
upload_to='gallary_pics')
date_upload = models.DateTimeField(auto_now_add=True)
featured = models.BooleanField(default=True)
pic_cat = models.CharField(max_length=30,
choices=PIC_CAT_CHOICES,
default='Gallary')
def __str__(self):
return self.title
class Picture(models.Model):
restaurant = models.ForeignKey(Restaurant,
related_name='gallery',
on_delete=models.CASCADE)
image = ResizedImageField(size=[600, 600],
upload_to=gallery_component,
quality=95,
crop=['middle', 'center'],
keep_meta=False,
force_format='PNG')
name = models.CharField(max_length=100, default='')
description = models.TextField(blank=True, null=True, default='')
def __str__(self):
return self.name
def get_image(self):
return self.image.url
class Image(TimeStampedModel):
post = ForeignKey(Post, on_delete=CASCADE)
image = ResizedImageField(_("Upload Post Image"),
quality=75,
force_format='JPEG',
size=[1920, 1148],
crop=['middle', 'center'],
upload_to=blog_image_path,
null=True,
blank=True)
def __str__(self):
return self.post.title
class Meta:
managed = True
verbose_name = "Post Files"
verbose_name_plural = "Post Files"
ordering = ["-created"]
class Tag(models.Model):
alphanumeric = RegexValidator(r'^[0-9a-zA-Zぁ-んァ-ヶー一-龠]*$', '大小英数字+だけね')
name = models.CharField(_('タグ'),
max_length=150,
blank=True,
validators=[alphanumeric])
logo = ResizedImageField(_('logo'),
upload_to='tag/',
size=[200, 200],
crop=['middle', 'center'],
blank=True,
null=True)
def __str__(self):
return self.name
class Meta:
verbose_name = _('タグ')
verbose_name_plural = _('タグ')
class Post(models.Model):
tytul = models.CharField(max_length=60, blank=True)
opis = models.CharField(max_length=800, blank=True, null=True)
autor = models.ForeignKey(User, on_delete=models.CASCADE, default='')
data = models.DateTimeField(auto_now_add=True)
picture = ResizedImageField(size=[900, 700],
quality=40,
upload_to='gallery/',
blank=True)
category = models.CharField(max_length=100, blank=True)
city = models.CharField(max_length=100, blank=True)
def delete(self, *args, **kwargs):
if self.picture:
self.picture.delete()
super().delete(*args, **kwargs)
def __str__(self):
return str(self.autor) + ' - Post Id: ' + str(self.id)
class Post(models.Model):
title = models.CharField(max_length=100)
content = models.TextField()
date_posted = models.DateTimeField(default=timezone.now)
author = models.ForeignKey(User, on_delete=models.CASCADE)
image = ResizedImageField(
upload_to='image/', quality=75, crop=['middle', 'center'], size=[600, 300], blank=True, null=True)
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('post-detail', kwargs={'pk': self.pk})
# added for image per blog
def upload_image(self, filename):
return 'post/{}/{}'.format(self.title, filename)
class ProductImage(TimeStampedModel):
category = [
("thumbnail", "thumbnail"),
("other", "other"),
]
product = models.ForeignKey(Product,
related_name="images",
on_delete=models.CASCADE)
image = ResizedImageField(size=[120, 120], quality=75)
img_category = models.CharField(max_length=20,
choices=category,
default="other")
def __str__(self):
return "{} {}".format(self.product.name, self.img_category)
class Meta:
db_table = "product_images"
ordering = ["-created_at"]
class Story(models.Model):
title = models.CharField(max_length=100)
date_posted = models.DateTimeField(auto_now_add=True)
author = models.ForeignKey(User,
on_delete=models.CASCADE,
blank=True,
null=True,
related_name='author')
categories = models.ForeignKey(Category, on_delete=models.DO_NOTHING)
thumbnail = ResizedImageField(size=[500, 300],
upload_to='image',
blank=True,
null=True)
def __str__(self):
return self.title
class Meta:
verbose_name_plural = "Stories"
class Profile(models.Model):
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
user = models.OneToOneField(User, on_delete=models.CASCADE)
# USER DATA
profile_picture = ResizedImageField(blank=True, null=True, upload_to=rename_file)
birthdate = models.DateField(blank=True, null=True, default=None)
company_name = models.CharField(max_length=200, blank=True, default="")
#PAYMENT
paying_user = models.ForeignKey("Profile", on_delete=models.CASCADE, blank=True, null=True)
allow_postpaid = models.BooleanField(default=False)
commercial_account = models.BooleanField(default=False) # == mit mwst
discount_account = models.BooleanField(default=False) # z.b. < 16 Jahre
monthly_payment = models.BooleanField(default=False) # monatlich oder tagesaccount
prepaid_deposit = models.FloatField(default=0)
# ADDRESS
street = models.CharField(max_length=200, blank=True, default="")
postalcode = models.CharField(max_length=200, default="", blank=True)
city = models.CharField(max_length=200, blank=True, default="")
def __str__(self):
if self.company_name != "":
return "%s, %s. %s" % (self.company_name, self.user.first_name[0].upper(), self.user.last_name)
return "%s %s" % (self.user.first_name, self.user.last_name)
def get_current_token(self):
tokens = Token.objects.filter(enabled=True, profile=self)
if len(tokens) == 0:
return None
return tokens[0]
def is_underage(self):
if self.birthdate is None:
return False
return timezone.now().date() - self.birthdate < timedelta(days=365*18)
def get_paying_user(self):
if self.paying_user is None:
return self
return self.paying_user
class BusinessImage(DateModel):
category = [
("thumbnail", "thumbnail"),
("other", "other"),
("top_slideshow", "slideshow"),
]
business = models.ForeignKey(Business,
related_name="images",
on_delete=models.CASCADE)
image = ResizedImageField(size=[480, 350], quality=75)
img_category = models.CharField(max_length=20,
choices=category,
default="other")
def __str__(self):
return "{} {}".format(self.business.name, self.img_category)
class Meta:
db_table = "business_images"
class Astronaut(models.Model):
name = models.CharField(max_length=255)
birth_date = models.DateField(null=True, blank=True)
space_agency = models.ForeignKey(SpaceAgency, on_delete=models.CASCADE)
photo = ResizedImageField(size=[1200, 1200],
upload_to=upload_to,
null=True,
blank=True)
biography = models.TextField(null=True, blank=True)
class Meta:
verbose_name = 'Astronaut'
verbose_name_plural = 'Astronauts'
def __str__(self):
return '{}'.format(self.name)
class Article(models.Model):
title = models.CharField(max_length=200, blank=True, null=True)
author = models.CharField(max_length=100, blank=True, null=True)
pdf = models.FileField(upload_to="article_pdfs", blank=True, null=True)
article_image = ResizedImageField(
size=[1000, 550],
quality=100,
blank=True,
default="article_default.jpg",
upload_to="article_images",
)
date_posted = models.DateTimeField(auto_now_add=True)
class Meta:
verbose_name_plural = "Articles"
ordering = ["-date_posted"]
def __str__(self):
return self.title
class Motors(models.Model):
title = models.CharField(max_length=110, blank=True, null=True)
number = models.CharField(max_length=11, blank=True, null=True)
image = ResizedImageField(size=[300, 300],
quality=50,
upload_to='images/',
blank=True,
null=True,
verbose_name="وێنه")
status = models.BooleanField(default=False)
def __str__(self):
return str(self.title)
def __unicode__(self):
return
class Meta:
verbose_name_plural = "Motors"
class Photo(models.Model):
album = models.ForeignKey(Album, verbose_name='Дочерняя категория')
title = models.CharField(max_length=255,
blank=True,
default='',
verbose_name='Фото')
file = ResizedImageField(size=[800, 800],
crop=['middle', 'center'],
upload_to='Photogallery',
verbose_name='Фотографии')
order = models.CharField(max_length=100,
blank=True,
verbose_name='Порядок отображения(От 1 до..)',
default='')
class Meta:
verbose_name = "Фото"
verbose_name_plural = "Фото"
def image_img(self):
if self.file:
return u'<a href="{0}" target="_blank"><img src="{0}" width="200"/></a>'.format(
self.file.url)
else:
return '(Нет изображения)'
image_img.short_description = 'Картинка'
image_img.allow_tags = True
def delete(self, using=None):
try:
obj = Photo.objects.get(pk=self.pk)
obj.file.delete()
except (Photo.DoesNotExist, ValueError):
pass
super(Photo, self).delete()
def get_absolute_url(self):
return self.file.url
def __unicode__(self):
return self.title
class Profile(models.Model):
GENEROS = (
('M', 'Masculino'),
('F', 'Femenino'),
)
user = models.OneToOneField(User, on_delete=models.CASCADE)
recruited_date = models.DateField("Fecha de Contratacion",
null=True,
blank=True)
birth_date = models.DateField("Fecha de Nacimiento", null=True, blank=True)
gender = models.CharField("Genero",
choices=GENEROS,
max_length=144,
null=True,
blank=True)
job_title = models.CharField("Puesto",
max_length=144,
null=True,
blank=True)
department = models.CharField("Departamento",
max_length=144,
null=True,
blank=True)
phone = models.CharField("Telefono", max_length=144, null=True, blank=True)
address = models.CharField("Dirección",
max_length=255,
null=True,
blank=True)
photo = ResizedImageField(
"Foto",
upload_to=Helper.get_ImagePath_Profile,
quality=75,
blank=True,
keep_meta=False,
validators=[Helper.validate_Img_Extension, Helper.validate_Size])
reset_password = models.BooleanField("Reset Contraseña", default=True)
first_login = models.BooleanField("Primer Login", default=True)
def __unicode__(self):
return self.user.get_full_name()
class Post(models.Model):
STATUS = ((0, "Draft"), (1, "Publish"))
field = models.ForeignKey(Category, on_delete=models.CASCADE)
title = models.CharField(max_length=200, unique=True)
slug = models.SlugField(max_length=200, unique=True, null=False)
author = models.ForeignKey(User,
on_delete=models.CASCADE,
default=get_default_user)
content = RichTextUploadingField()
img = ResizedImageField(size=[1600, 1200],
upload_to="post_pics",
default="default.jpg")
created_on = models.DateTimeField(auto_now_add=True)
status = models.IntegerField(choices=STATUS, default=0)
objects = models.Manager()
tags = TaggableManager()
published = PublishedManager()
class Meta:
ordering = ["status", "-created_on"]
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("blog:post_detail", kwargs={"slug": self.slug})
@property
def get_thumbnail(self):
return get_thumbnailer(self.img)["avatar"].url
@property
def get_image(self):
return self.img.url
def recomended_posts(self):
tags = self.tags.values_list("id", flat=True)
posts = Post.published.filter(tags__in=tags).exclude(id=self.id)
posts = posts.annotate(same_tags=Count("tags")).order_by(
"-same_tags", "-created_on")
return posts
class Category(models.Model):
"""
Represents a product category.
"""
articlenr_start = models.CharField(blank=True,
null=True,
max_length=8,
verbose_name="Kategorienummer",
unique=True,
help_text="")
name = models.CharField(blank=False,
null=False,
max_length=255,
verbose_name="Kategoriebezeichnung")
description = models.TextField(blank=True,
null=True,
verbose_name="Beschreibung")
image = ResizedImageField(storage=fs,
size=[500, 500],
upload_to='stock/categories/',
blank=True,
null=True,
help_text='Product picture.')
color = models.CharField(
validators=[
RegexValidator(regex="^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$",
message="Must be a hexcode (e.g. #000 or #000000)",
code="invalid_hexcode")
],
help_text=
"Colour code to use for this category (hex value, i.e. #000 or #000000)",
blank=True,
null=True,
max_length=7)
history = HistoricalRecords()
def __str__(self):
return u"{}".format(self.name)
class Meta:
verbose_name_plural = "Categories"
ordering = ['articlenr_start', 'name']
class UserProfile(AbstractBaseUser, PermissionsMixin):
"""DB model for the users"""
date_format = '%d-%m-%Y %H:%M:%S'
nric_number = models.CharField(max_length=255, default='', unique=True)
name = models.CharField(max_length=255)
company = models.CharField(max_length=255, default='')
mobile_number = models.CharField(max_length=255, default='')
# photo = models.FileField(upload_to='photos/', default='', null=True)
photo = ResizedImageField(size=[640, 480],
upload_to='photos/',
blank=True,
null=True,
default='')
is_active = models.BooleanField(default=True)
is_staff = models.BooleanField(default=False)
is_pdpa_checked = models.BooleanField(default=False)
reg_date = models.DateField(default=timezone.now)
last_access_date = models.DateField(default=timezone.now)
objects = UserProfileManager()
USERNAME_FIELD = 'nric_number'
REQUIRED_FIELDS = ['name']
#calling image compression function before saving the data
def save(self, *args, **kwargs):
new_image = compress(self.photo)
self.photo = new_image
super().save(*args, **kwargs)
def get_full_name(self):
"""Get full name of the user"""
return self.name
def get_short_name(self):
"""Get short name of the user"""
return self.name
def __str__(self):
"""Render string in the admin"""
return self.name + ' - ' + self.nric_number
class Post(models.Model):
title = models.CharField(max_length=100)
overview = models.TextField()
content = HTMLField()
date_posted = models.DateTimeField(auto_now_add=True)
event_date = models.DateField(null=True,
blank=True,
help_text='YYYY-MM-DD')
sort = models.IntegerField(default=999)
author = models.ForeignKey(User, on_delete=models.CASCADE)
#view_count = models.IntegerField(default=0)
hit_count_generic = GenericRelation(
HitCount,
object_id_field='object_pk',
related_query_name='hit_count_generic_relation')
#thumbnail = models.ImageField()
thumbnail = ResizedImageField(size=[800, 530],
blank=False,
null=False,
upload_to='post_pics')
categories = models.ManyToManyField(Category)
previous_post = models.ForeignKey('self',
related_name='previous',
on_delete=models.SET_NULL,
blank=True,
null=True)
next_post = models.ForeignKey('self',
related_name='next',
on_delete=models.SET_NULL,
blank=True,
null=True)
featured = models.BooleanField(default=False)
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('post-detail', kwargs={'pk': self.pk})
@property
def number_of_comments(self):
return Comment.objects.filter(blogpost_connected=self).count()
class Student(models.Model):
first_name = models.CharField(max_length=255)
father_name = models.CharField(max_length=255)
surname = models.CharField(max_length=255)
grand_father_name = models.CharField(max_length=255)
mother_name = models.CharField(max_length=255)
full_name = models.CharField(max_length=255)
place_of_birth = models.CharField(max_length=255)
birth_date = models.DateField()
gender = models.CharField(max_length=255, choices=GENDER)
cell_phone = models.CharField(max_length=255, null=True, blank=True)
age = models.PositiveSmallIntegerField(null=True, blank=True)
the_class = models.ForeignKey(TheClass,
related_name='students',
on_delete=models.CASCADE)
classroom = models.ForeignKey(ClassRoom,
related_name='students',
on_delete=models.CASCADE)
nid_number = models.CharField(max_length=255, null=True, blank=True)
nationality = models.CharField(max_length=255,
default='ليبي',
choices=NATIONALITY)
image = ResizedImageField(size=[300, 300],
blank=True,
null=True,
upload_to=students_image_random_name)
objects = StudentManager()
def __str__(self):
return self.first_name
def get_absolute_url(self):
return reverse('students:detail', kwargs={'pk': self.pk})
def get_std_name(self):
return "{} {} {}".format(self.first_name, self.father_name,
self.surname)
def get_full_name(self):
return "{} {} {} {}".format(self.first_name, self.father_name,
self.grand_father_name, self.surname)
class Mall(TimeStampedModel):
name = models.CharField(u'쇼핑몰 이름', max_length=200)
thumbnail = ResizedImageField(
u'썸네일',
size=[900, 900],
quality=80,
null=True,
blank=True,
crop=['middle', 'center'],
upload_to='mall/%Y/%m/%d',
)
def __str__(self):
return self.name
def thumbnail_url(self):
if self.thumbnail and hasattr(self.thumbnail, 'url'):
return self.thumbnail.url
else:
return static('img/no-product-image.png')
class Image(models.Model):
post = models.ForeignKey('album.Calendar',
related_name='images',
on_delete=models.CASCADE)
description = models.TextField(blank=True)
image = ResizedImageField(size=[1600, 1200],
upload_to='calendar_image/%Y/%m')
thumbnail = ImageSpecField(
source='image',
processors=[ResizeToFill(700, 700)], # 처리할 작업 목룍
format='JPEG', # 최종 저장 포맷
options={'quality': 60}) # 저장 옵션
likes = models.ManyToManyField(settings.AUTH_USER_MODEL,
related_name='image_likes')
def __str__(self):
return str(self.pk) + ', ' + str(self.post.title) + '\'s image'
def total_likes(self):
return self.likes.count()
class Post(models.Model):
id_post = models.AutoField(primary_key=True)
title = models.CharField(max_length=500, null=False, default=None)
content = RichTextField()
image = ResizedImageField(size=[900, 400],
crop=['middle', 'center'],
upload_to='post')
category = models.ForeignKey(Category,
on_delete=models.SET_NULL,
null=True)
author = models.CharField(max_length=500, null=False, default=None)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def __str__(self):
return self.title
def plaintext(self):
soup = BeautifulSoup(self.content, 'html.parser')
return soup.text
class User(AbstractUser):
city = (
('Surat', 'Surat'),
('Bharuch', 'Bharuch'),
)
is_publisher = models.BooleanField(default=False)
is_customer = models.BooleanField(default=False)
phone = models.BigIntegerField(default=0,
validators=[
RegexValidator(regex='\d{10}',
message='invalid number',
code='invalid_number')
])
address = models.CharField(max_length=100, null=True)
city = models.CharField(max_length=20, null=True, choices=city)
logo = ResizedImageField(null=True, upload_to='logo/')
def __str__(self):
return str(self.username)
class Profile(models.Model):
user = models.OneToOneField(User,
on_delete=models.CASCADE,
related_name='profile')
nickname = models.CharField(max_length=30, verbose_name='Ник пользователя')
# resizing the picture to not break the html markup
profile_pic = ResizedImageField(size=[50, 64],
quality=100,
upload_to='avatars/%Y/%m/%d',
default='avatars/default_pic.png',
verbose_name='Аватар')
objects = ProfileManager()
def __str__(self):
return self.nickname
class Meta:
verbose_name = 'Пользователь'
verbose_name_plural = 'Пользователи'
class Business(models.Model):
user = models.OneToOneField(User,
related_name='business',
on_delete=models.CASCADE)
avatar = ResizedImageField(size=[250, 250],
quality=95,
crop=['middle', 'center'],
keep_meta=False,
upload_to=content_file_name,
blank=True,
null=True)
cf = models.CharField(max_length=16, unique=True)
birth_date = models.DateField()
city = models.CharField(max_length=50, blank=False)
address = models.CharField(max_length=150, blank=False)
n_civ = models.CharField(max_length=10, blank=False)
cap = models.IntegerField(
validators=[valids.RegexValidator(regex='[0-9]{5}')], blank=False)
phone = PhoneNumberField(
unique=True,
error_messages={'unique': 'Esiste già un utente con questo numero.'})
email_activated = models.BooleanField(default=False, auto_created=True)
activation_token = models.CharField(max_length=200, unique=True)
def __str__(self):
return self.user.username
def get_cf(self):
return self.cf.upper()
def get_image(self):
if not (self.avatar and hasattr(self.avatar, 'url')):
return settings.MEDIA_URL + 'placeholder/avatars/user.png'
else:
return self.avatar.url
class Meta:
verbose_name_plural = "Businesses"
class Moderators(models.Model):
def _moderator_photo_file(self, filename):
ext = file_extension(filename)
slug = slugify(self.name)
filename = f"{slug}-photo.{ext}"
return join('img', 'elections', 'moderators', self.slug, filename)
slug = models.SlugField(unique=True)
first_name = models.CharField(max_length=256,
verbose_name=_("Moderatoriaus vardas"))
last_name = models.CharField(max_length=256,
verbose_name=_("Moderatoriaus pavardė"))
photo = ResizedImageField(
blank=True,
null=True,
upload_to=_moderator_photo_file,
crop=['middle', 'center'],
size=[256, 256],
verbose_name=_("Moderatoriaus nuotrauka"),
)
@property
def name(self):
return f"{self.first_name} {self.last_name}"
class Meta:
verbose_name = _("Moderatorius")
verbose_name_plural = _("Moderatoriai")
ordering = ["last_name"]
def save(self,
force_insert=False,
force_update=False,
using=None,
update_fields=None):
self.slug = slugify(self.name)
super().save(force_insert, force_update, using, update_fields)
def __str__(self):
return self.name
class Images(models.Model):
image = ResizedImageField(size=[1280, 960],
upload_to='images/',
validators=[file_size])
team = models.ForeignKey("Teams",
on_delete=models.CASCADE,
blank=True,
null=True,
related_name='team_gallery')
post = models.ForeignKey("Post",
on_delete=models.CASCADE,
blank=True,
null=True,
related_name='post_gallery')
building = models.ForeignKey("BaseBuildings",
on_delete=models.CASCADE,
blank=True,
null=True,
related_name='buildings_gallery')
no_image = models.BooleanField(default=False)
class Meta:
ordering = (
'-id',
"image",
)
verbose_name_plural = "Galeria"
def save(self):
im = Image.open(self.image)
output = BytesIO()
im.save(output, format='WEBP', quality=80)
output.seek(0)
self.image = InMemoryUploadedFile(
output, 'ImageField', "%s.webp" % self.image.name.split('.')[0],
'image/webp', sys.getsizeof(output), None)
super(Images, self).save()
def __str__(self):
return str(self.id)
class Company(models.Model):
name = models.CharField(max_length=250)
tagline = models.CharField(max_length=250)
logo = ResizedImageField(size=[240, 144],
crop=['middle', 'center'],
quality=100,
upload_to=uploaded_location,
null=True,
blank=True)
description = models.TextField(null=True, blank=True)
facebook = models.CharField(max_length=250, null=True, blank=True)
instagram = models.CharField(max_length=250, null=True, blank=True)
twitter = models.CharField(max_length=250, null=True, blank=True)
linkedin = models.CharField(max_length=250, null=True, blank=True)
googleplus = models.CharField(max_length=250, null=True, blank=True)
def __str__(self):
return self.name
def get_absolute_url(self):
return "/company/%s/" % (self.id)
class ProductImages(models.Model):
# Set related_name to use backward relationships on ProductSerializer
product_id = models.ForeignKey(Products,
on_delete=models.CASCADE,
verbose_name='Producto',
related_name='images')
image = ResizedImageField(upload_to=product_image_path,
max_length=200,
size=[200, 200],
blank=True,
null=True,
verbose_name='Imágen')
date = models.DateTimeField(
auto_now=True, verbose_name='Fecha de Creación / Actualización')
def __str__(self):
return str('')
class Meta:
verbose_name = 'Imágen'
verbose_name_plural = 'Imágenes'
