class Post(models.Model):
author = models.ForeignKey('auth.User')
title = models.CharField(max_length = 200)
text = models.TextField()
blog_image = models.ImageField( upload_to="images",
default = "images/bbb_logo_square.png")
post_video = EmbedVideoField(null=True, blank = True)
create_date = models.DateTimeField(default = timezone.now)
published_date = models.DateTimeField(blank = True, null = True)
def publish(self):
self.published_date = timezone.now()
self.save()
def approve_comments(self):
return self.comments.filter(approved_comment = True)
def get_absolute_url(self):
return reverse("BetterBeerBlog:post_detail", kwargs={'pk':self.pk})
def __str__(self):
return self.title
class Blog(models.Model):
author = models.ForeignKey(User,
on_delete=models.CASCADE,
null=True,
blank=False)
title = models.CharField(max_length=1000, blank=False)
slug = models.CharField(max_length=1000, blank=False)
image = models.ImageField(blank=True)
video = EmbedVideoField(blank=True)
description = RichTextUploadingField(blank=True)
created_at = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
publish = models.BooleanField(blank=True, default=None, null=True)
class Meta:
ordering = ["-created_at"]
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("detail", args=[self.slug])
class Level(models.Model):
key_level = models.CharField('Level of Key Club?', max_length = 100)
name = models.CharField('Name of Project', max_length=100)
logo = models.ImageField(upload_to='projects/',verbose_name="Logo of Organization")
bkgnd_photo = models.ImageField(upload_to='projects/',verbose_name="Background Photo")
def_short2 = RichTextUploadingField(verbose_name="Short Description of Organization")
video = EmbedVideoField(verbose_name="Video of Organization")
extend_desc2 = RichTextUploadingField(verbose_name="Extensive Description")
fundrs_goal = models.IntegerField('Fundraising Goal')
slug = models.SlugField(blank=True)
def __str__(self):
return self.key_level
def get_absolute_url(self):
return reverse('projects:detail',kwargs={'level_id':self.id,'slug':self.slug,})
def save(self):
self.logo = compress(self.logo)
self.bkgnd_photo = compress(self.bkgnd_photo)
self.slug = slugify(self.name)
super(Level, self).save()
class Meta:
verbose_name = "Key Club Project"
verbose_name_plural= "Key Club Projects"
class Article(models.Model):
article_title = models.CharField(max_length=250, verbose_name=u"Название статьи")
article_date = models.DateTimeField(verbose_name=u"Дата публикации статьи")
# article_number = models.IntegerField(default=0, verbose_name="Номер статьи", blank=True, null=True)
# article_likes = models.IntegerField(default=0, verbose_name="Лайки")
article_tag = models.ManyToManyField(Tag, related_name="tags", related_query_name="tags", verbose_name=u"Теги")
article_category = TreeForeignKey(Category, related_name="articles", verbose_name=u"Категории", default="", blank=True)
article_author = TreeForeignKey(Author, related_name="autor", max_length=200, verbose_name="Автор статьи", blank=True, default="")
short_text_ru = RichTextUploadingField(blank=True, verbose_name=u"Короткое описание RU")
short_text_en = RichTextUploadingField(blank=True, verbose_name=u"Короткое описание EN")
video = models.CharField(max_length=250, blank=True, verbose_name=u"Видео id в кратком описании")
image = ThumbnailerImageField(upload_to=make_upload_path, blank=True, verbose_name=u"Изображение")
full_text_ru = RichTextUploadingField(blank=True, verbose_name=u"Полное описание RU")
full_text_en = RichTextUploadingField(blank=True, verbose_name=u"Полное описание EN")
article_video = EmbedVideoField(verbose_name=u'Видео', blank=True, help_text='URL video', null=True)
video_published = models.BooleanField( blank=True, default="")
text_published = models.BooleanField( blank=True, default="")
video_only = models.BooleanField( blank=True, default="")
written_only = models.BooleanField( blank=True, default="")
slug = models.CharField(max_length=250, blank=True, verbose_name=u"Урл")
class Meta:
db_table = 'article'
verbose_name = "Статья"
verbose_name_plural = "Статьи"
ordering = ['article_date']
def __unicode__(self):
return self.article_title
def pic_slug(self):
if self.slug:
return u'<img src="%s" width="70"/>' % self.slug
else:
return '(none)'
pic_slug.short_description = u'Картинка статьи'
pic_slug.allow_tags = True
class Movie(models.Model):
title = models.CharField('Название', max_length=128)
description = models.TextField('Описание')
poster = models.ImageField('Постер', upload_to=image_folder)
year = models.PositiveIntegerField('Дата выхода', default=2020)
country = models.ManyToManyField(Country, verbose_name='страна', related_name='film_country')
director = models.ManyToManyField(Participant, verbose_name='режиссер', related_name='film_director')
actors = models.ManyToManyField(Participant, verbose_name='актеры', related_name='film_actor')
genres = models.ManyToManyField(Genre, verbose_name='жанры')
budget = models.PositiveIntegerField('Бюджет', default=0, help_text='в долларах')
category = models.ForeignKey(Category, verbose_name='Категория', on_delete=models.SET_NULL, null=True)
url = models.SlugField(max_length=128, unique=True)
video = EmbedVideoField(blank=True, verbose_name='Видео')
kinopoisk = models.CharField('ID_Kinopoisk', default='0', max_length=8)
draft = models.BooleanField('Черновик', default=False)
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("movie_detail", kwargs={"slug": self.url})
@property
def ratings(self):
rating = {'kinopoisk': 'n/a', 'imdb': 'n/a'}
response = requests.get(f'https://rating.kinopoisk.ru/{self.kinopoisk}.xml')
tree = ElementTree.fromstring(response.content)
for attr in tree:
if attr.tag == 'kp_rating':
rating['kinopoisk'] = attr.text
elif attr.tag == 'imdb_rating':
rating['imdb'] = attr.text
return rating
class Meta:
verbose_name = 'Фильм'
verbose_name_plural = 'Фильмы'
ordering = ['-year']
class Notes(models.Model):
author = models.ForeignKey(User, on_delete=models.CASCADE)
Subject = models.ForeignKey(Subjects, on_delete=models.CASCADE)
year = models.CharField(choices=LIST_YEARS, default=1, max_length=100)
sem = models.CharField(choices=LIST_SEM, default=4, max_length=100)
dept = models.ForeignKey(Dept, on_delete=models.CASCADE)
chapter_name = models.CharField(max_length=1000)
topic_name = models.CharField(max_length=1000)
video_clip_url = EmbedVideoField(blank=True, default="")
PDF_url = models.FileField(upload_to="notes", blank=True)
date = models.DateTimeField(default=timezone.now)
slug_c = models.SlugField(null=True, blank=True)
slug_t = models.SlugField(null=True, blank=True)
notes = RichTextUploadingField(null=True, blank=True)
def __str__(self):
return self.Subject.short_name
def save(self, *args, **kwargs):
if self.slug_c == None and self.slug_t == None:
slug1 = slugify(self.chapter_name)
slug2 = slugify(self.topic_name)
has_slug = Notes.objects.filter(slug_c=slug1,
slug_t=slug2).exists()
count = 1
while has_slug:
count += 1
slug1 = slugify(self.chapter_name) + '-' + str(count)
slug2 = slugify(self.topic_name) + '-' + str(count)
has_slug = Notes.objects.filter(slug_c=slug1,
slug_t=slug2).exists()
self.slug_c = slug1
self.slug_t = slug2
super().save(*args, **kwargs)
def get_absolute_url(self):
return reverse("dashboard")
class OldGames(models.Model):
title = models.CharField(max_length=250)
slug = models.SlugField(max_length=250, default="")
created = models.DateField(blank=True, null=True)
body = models.TextField()
image = models.ImageField("Изображение", upload_to="media/")
image2 = models.ImageField("Изображение1",
upload_to="media/",
null="True",
blank="True")
image3 = models.ImageField("Изображение2",
upload_to="media/",
null="True",
blank="True")
video = EmbedVideoField(null="True", blank="True", verbose_name="video")
publish = models.DateTimeField(default=timezone.now)
def get_absolute_url(self):
return reverse('project:about_old_game',
args=[self.publish.year, self.publish.day, self.slug])
def __str__(self):
return self.title
class Post(models.Model):
title = models.CharField(max_length=100)
datetime_posted = models.DateTimeField(default=timezone.now)
url = models.URLField(blank=True, null=True)
author = models.ForeignKey(User, on_delete=models.CASCADE)
day = models.ForeignKey(Day, on_delete=models.CASCADE)
postpic = models.ImageField( upload_to='post_pics',blank=True, null=True)
postvideo = EmbedVideoField(blank=True, null=True)
post_text = models.TextField(blank=True, null=True)
alt_text = models.CharField(max_length=600, default=None, null=True, blank=True)
is_private = models.BooleanField(default=False)
anything_else = models.CharField(max_length=250, default=None, null=True, blank=True)
def get_absolute_url(self):
return reverse('post-detail', kwargs={'pk':self.pk})
def __str__(self):
return ("Post " + str(self.id) + " " + str(self.title))
def clean(self):
super().clean()
if (not self.postpic) and (not self.url) and (not self.postvideo) and (not self.post_text):
raise forms.ValidationError("You must specify an image to upload, a webpage URL, a soundcloud/youtube/vimeo link or a Text post!")
class Entry(models.Model):
title = models.CharField(max_length=200)
video = EmbedVideoField(default="")
body = models.TextField()
slug = models.SlugField(max_length=200, unique=True)
publish = models.BooleanField(default=False)
created = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
tags = models.ManyToManyField(Tag)
entry_id = models.UUIDField(default=uuid.uuid4, editable=False)
objects = EntryQuerySet.as_manager()
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("entry_detail", kwargs={"slug": self.slug})
class Meta:
verbose_name = "Blog Entry"
verbose_name_plural = "Blog Entries"
ordering = ["-created"]
class Post(models.Model):
title = models.CharField(max_length=255, verbose_name='Заголовок')
slug = models.SlugField(max_length=255, verbose_name='url', unique=True)
author = models.CharField(max_length=100, verbose_name='Автор')
content = models.TextField(blank=True)
created_at = models.DateTimeField(auto_now_add=True, verbose_name='Опубликовано')
photo = models.ImageField(upload_to = 'photos/%Y/%m%d', blank=True, verbose_name='Фото')
views = models.IntegerField(default=0, verbose_name='Количество просмотров')
category = models.ForeignKey(Category, on_delete=models.PROTECT,
related_name='posts', verbose_name='Категория')
tags = models.ManyToManyField(Tag, blank = True, related_name='posts', verbose_name='Теги')
video = EmbedVideoField(default='')
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('post', kwargs={"slug": self.slug})
class Meta:
ordering = ['-created_at']
verbose_name = 'Новость'
verbose_name_plural = 'Новости'
class LinkedVideos(models.Model):
author = models.ForeignKey(User, on_delete=models.CASCADE)
title = models.CharField(max_length=200)
text = models.TextField()
link = EmbedVideoField()
image = models.ImageField(upload_to='img', blank=False)
published_date = models.DateTimeField(default=timezone.now)
post_label_choices = [
('er_hist', 'Eritrean Histories'),
('er_cult', 'Eritrean Culture'),
('er_polt', 'Politics'),
('er_peop', 'People'),
('er_tech', 'Technology'),
('other', 'Other'),
]
post_label = models.CharField(max_length=200,
null=True,
blank=True,
choices=post_label_choices)
def __str__(self):
return self.title
class YoutubePlaylistItem(models.Model):
'''
A model that keep track of videos' playlist then
indicates in which category (see below list) the
playlist belongs to.
-- title : title of the playlist
-- category : category to which belongs the playlist
'''
CATEGORY_TYPE = [
('SEERAH', 'Seerah'),
('TAWHID', 'Tawhid'),
('HADITHS', 'Hadiths'),
('KHUTBA', 'Khutba'),
('FIQH', 'Fiqh'),
('TAFSIR', 'Tafsir'),
('BAYANE', 'Bayane')
]
category = models.CharField(max_length=10, choices=CATEGORY_TYPE)
playlist = models.ForeignKey(YoutubePlaylist, on_delete=models.CASCADE)
playlistUrl = EmbedVideoField()
class Post(models.Model):
STATUS = (
(0,'borrador'),
(1,'publicado')
)
id = models.UUIDField(primary_key=True, default=uuid.uuid4, help_text="id del Post")
titulo = models.CharField(max_length=200,unique=True)
autor = models.ForeignKey(User,on_delete=models.CASCADE,related_name='blog_posts')
update_on= models.DateTimeField(auto_now=True)
imagen = models.ImageField(upload_to='post_image/%Y/%m/%d',blank=True)
video = EmbedVideoField(blank=True)
content = models.TextField()
create_on = models.DateTimeField(auto_now_add=True)
status = models.IntegerField(choices=STATUS,default=0)
class Meta:
ordering = ['-create_on']
def get_absolute_url(self):
return reverse('blog:post_detail', kwargs={'id':self.id})
def __str__(self):
return self.titulo
class Webtext(models.Model):
TYPES = [
(1, 'Homepage tekst'),
(50, 'Game intro tekst'),
(100, 'Footer tekst'),
]
parameter = models.PositiveIntegerField(choices=TYPES)
content = RichTextField('inhoud', blank=True)
image = models.ImageField('afbeelding', blank=True)
video = EmbedVideoField(
blank=True,
help_text='Plak hier een YouTube, Vimeo, of SoundCloud link')
#button = models.CharField('button', max_length=255, blank=True)
#hyperlink = models.CharField(max_length=255, blank=True)
def __str__(self):
return self.get_parameter_display()
class Meta:
verbose_name = 'Webtekst'
verbose_name_plural = 'Webteksten'
ordering = ['parameter']
class Song(models.Model):
# song name
name = models.CharField(max_length=100)
# song length
length = models.DurationField()
# song artists
artists = models.ForeignKey("artists.Artist", related_name="song")
# song url
video = EmbedVideoField(verbose_name='My video',
help_text='This is a help text')
# song time
year_released = models.DateField(max_length=8, auto_now=True)
play_count = models.IntegerField(default=0)
# song rate number
count = models.IntegerField(default=0)
# song rate score
score = models.IntegerField(default=0)
class Meta:
ordering = ["name"]
def __str__(self):
return self.name
def __unicode__(self):
return self.name
def get_artist_names(self):
return self.artists.name
def get_absolute_url(self):
return reverse("songs:song_detail", kwargs={"id": self.pk})
def get_average_rate(self):
return str(1.0 * self.score / self.count if self.count != 0 else 0.0)
class Concert(models.Model):
presented_by = models.CharField(max_length=100, default="Foggy Notions")
in_association_with = models.CharField(max_length=200,
null=True,
blank=True)
artist = models.CharField(max_length=200, default="Artist")
artist_one = models.CharField(max_length=200, null=True, blank=True)
venue = models.CharField(max_length=100, default="Venue")
date_one = models.DateField()
date_two = models.DateField(null=True, blank=True)
date_three = models.DateField(null=True, blank=True)
original_date = models.DateField(null=True, blank=True)
rescheduled_to = models.DateField(null=True, blank=True)
rescheduled_to_1 = models.DateField(null=True, blank=True)
rescheduled_to_2 = models.DateField(null=True, blank=True)
time = models.TimeField()
tickets = models.URLField(max_length=1024, null=True, blank=True)
tickets_1 = models.URLField(max_length=1024, null=True, blank=True)
tickets_2 = models.URLField(max_length=1024, null=True, blank=True)
content = models.TextField()
image_url = models.URLField(max_length=1024, null=True, blank=True)
image = models.ImageField(null=True, blank=True)
video = EmbedVideoField(null=True, blank=True)
artist_website = models.URLField(max_length=1024, null=True, blank=True)
artist_website_one = models.URLField(max_length=1024,
null=True,
blank=True)
slug = models.SlugField(null=False)
date_posted = models.DateTimeField(default=timezone.now)
publish = models.DateTimeField(auto_now=False, auto_now_add=False)
author = models.ForeignKey(User, on_delete=models.CASCADE)
def __str__(self):
return self.artist
class Meta:
ordering = ['date_one']
class Post(models.Model):
title = models.CharField(max_length=248, unique=True)
slug = models.SlugField(max_length=248, unique=True)
author = models.ForeignKey(User,
on_delete=models.CASCADE,
related_name='blog_posts')
updated_on = models.DateTimeField(auto_now=True)
content = models.TextField()
created_on = models.DateTimeField(auto_now_add=True)
status = models.IntegerField(choices=STATUS, default=0)
image = models.ImageField(upload_to='images/', blank=True, null=True)
video = EmbedVideoField(blank=True, verbose_name='Видео')
tags = TaggableManager()
count_views = models.IntegerField(default=0)
likes = models.IntegerField(default=0)
dislikes = models.IntegerField(default=0)
class Meta:
ordering = ['-created_on']
verbose_name = 'Пост'
verbose_name_plural = 'Посты'
def __str__(self):
return self.title
class Home(models.Model):
class Meta():
db_table = 'home'
verbose_name_plural = "Статич страницы"
verbose_name = "Главная страница"
home_title = models.CharField(null=True, blank=True,max_length=200)
home_text = RichTextField(null=True, blank=True,)
home_date = models.DateField(null=True, blank=True)
home_image = models.ImageField(null=True, blank=True,upload_to="images/",
verbose_name=u'Изображение',)
video = EmbedVideoField(null=True, blank=True,verbose_name=u'видео')
def __unicode__(self):
return self.home_title
def bit_home (self):
if self.home_image:
return u'<img src="%s" width="70"/>'% self.home_image.url
else:
return u'(none)'
bit_home.short_descriptio = u'Изображение'
bit_home.allow_tags = True
class VideoDownloading(models.Model):
title = models.CharField(u'Заголовок', max_length=120, default='')
url = models.CharField(u'Ссылка',
max_length=200,
help_text=u'Вводить только URL-страницы',
default='')
notes = models.TextField(u'Заметки',
help_text=u'Заметки',
blank=True,
null=True)
video = EmbedVideoField(
u'Загрузить видео',
blank=True,
help_text=
u'Заходим на страницу видео-Поделиться-Встроить-Копируем link, содержащий строку embeded'
)
created = models.DateTimeField(default=timezone.now)
def __unicode__(self):
return self.title
class Meta:
verbose_name = u'Видеообзор'
verbose_name_plural = u'Видеообзоры'
class RecursosEdp(models.Model):
# edp = models.ForeignKey(Edp, verbose_name='Edp', related_name='recursos', on_delete=models.CASCADE)
edp = models.OneToOneField(Edp,
verbose_name='Edp',
related_name='recursos',
on_delete=models.CASCADE)
video_embedded = EmbedVideoField(blank=True, null=True)
texto = models.TextField('Texto', blank=True)
recebe_texto = models.BooleanField('Responder texto ?', default=False)
recebe_video_embedded = models.BooleanField(
'Responder com videos do youtube?', default=False)
recebe_video = models.BooleanField('Responder com video?', default=False)
recebe_imagem = models.BooleanField('Responder com imagem ?',
default=False)
video = models.FileField(upload_to='video/',
storage=upload_storage,
default="media/none.mp4")
created_at = models.DateTimeField('Criado em', auto_now_add=True)
updated_at = models.DateTimeField('Atualizado em', auto_now=True)
def __str__(self):
return self.edp.titulo
def iniciar(self):
self.save()
@models.permalink
def get_absolute_url(self):
return ('edp:detalhe_edp', (), {'slug': self.slug})
class Meta:
verbose_name = 'Recurso Estrutura Digital de Aprendizagem'
verbose_name_plural = 'Recursos Estruturas Digital de Aprendizagem'
ordering = ['created_at']
class Product(models.Model):
class Meta():
ordering = ['-product_title']
db_table = 'product'
verbose_name_plural = 'Товары'
verbose_name = 'Товар'
product_title = models.CharField(max_length=200, verbose_name='Название товара')
product_price = models.CharField(max_length=200, verbose_name='Цена')
product_img = models.ImageField(null=True, blank=True, upload_to="img/", verbose_name='Изображения', help_text="350x200")
product_video = EmbedVideoField(null=True, blank=True, verbose_name=u'Видео')
product_text = RichTextField(null=True, blank=True, verbose_name='Описание товара')
author = models.ForeignKey(Author, max_length=150, verbose_name='Имя автор')
product_like = models.IntegerField(default=0)
category = TreeForeignKey(Category, related_name='cat', verbose_name='Категория товара')
brands = models.ForeignKey(Brands, related_name='brands', related_query_name='brands', verbose_name=u'Бренды')
product_stock = models.PositiveIntegerField(verbose_name="На складе")
product_available = models.BooleanField(default=True, verbose_name="Доступен")
product_created = models.DateTimeField(auto_now_add=True)
product_updated = models.DateTimeField(auto_now=True)
keywords = models.ManyToManyField(Keywords, related_name='keywords', related_query_name='keyword', verbose_name=u'Теги')
#discaunt = models.ManyToManyField(Discount, related_query_name='discount', verbose_name=u'Скидки')
def __unicode__(self):
return self.product_title
def __str__(self):
return self.product_title
def bit(self):
if self.product_img:
return u'<img src="%s" width="70"/>' % self.product_img.url
else:
return '(none)'
bit.short_description = u'Изображение'
bit.allow_tags = True
class Video(models.Model):
"""
"""
titulo = models.CharField(verbose_name=_("Título"), max_length=100)
video = EmbedVideoField(_("Video Url"))
content_type = models.ForeignKey(ContentType,
verbose_name=_("Tipo"),
on_delete=models.CASCADE,
null=True,
related_name="content_type_video")
object_id = models.PositiveIntegerField(default=1,
verbose_name=_("Objeto"))
content_object = GenericForeignKey('content_type', 'object_id')
class Meta:
verbose_name = _("Video")
verbose_name_plural = _("Videos")
def __unicode__(self):
return self.titulo
def __str__(self):
return self.titulo
class VideoAsset(CommonAsset):
"""
A video asset for a project.
"""
video = EmbedVideoField(
help_text='Optional. Copy and paste the video URL into this field.',
default='',
blank=True
)
caption = models.TextField(
help_text='Optional. Plain text only.',
default='',
blank=True
)
def get_video_id(self):
"""
Get the video id for video referenced.
"""
video = detect_backend(self.video)
video_id = video.get_code()
return video_id
def get_video_thumbnail_url(self):
"""
Get the thumbnail for the video at size 3400 x 1500 in jpg format.
"""
video = detect_backend(self.video)
orig_thumbnail_url = video.get_thumbnail_url().split('_')
new_thumbnail_url = (
'{}_{}'.format(orig_thumbnail_url[0], '3400x1500.jpg')
)
return new_thumbnail_url
def __str__(self):
return '{} / video'.format(self.name)
class Post(models.Model):
image = models.ImageField(upload_to='', blank=True)
author = models.ForeignKey('auth.User', on_delete=models.CASCADE)
avatar = models.ImageField(upload_to='static/img', blank=True)
title = models.CharField(max_length=200)
video = EmbedVideoField(blank=True, null=True)
description = models.TextField()
additional_information = models.TextField(blank=True, null=True)
created_date = models.DateTimeField(default=timezone.now)
price = models.CharField(max_length=200)
published_date = models.DateTimeField(blank=True, null=True)
def publish(self):
self.published_date = timezone.now()
self.save()
def approve_comments(self):
return self.comments.filter(approved_comment=True)
def get_absolute_url(self):
return reverse('primary:post_detail', kwargs={'pk': self.pk})
def __str__(self):
return self.title
class Video(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
title = models.CharField(max_length=255)
slug = models.SlugField(max_length=255, null=False, unique=True)
video = EmbedVideoField()
date = models.DateTimeField(auto_now_add=True)
author = models.ForeignKey(
get_user_model(),
on_delete=models.CASCADE,
)
class Meta():
ordering = ['-date']
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('video_detail', kwargs={'slug': self.slug})
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.title)
return super().save(*args, **kwargs)
class Video(models.Model):
title = models.CharField(max_length=100)
url = EmbedVideoField()
added = models.DateTimeField(auto_now_add=True)
class Item(models.Model):
video = EmbedVideoField() # same like models.URLField()
class Item(models.Model):
video = EmbedVideoField()
name = models.CharField(max_length=300)
class Note(LikeableObjectMixin, BaseTaggableObjectModel):
EMPTY_TITLE_PLACEHOLDER = '---'
SORT_FIELDS_ALIASES = [
('title', 'title'),
('creator', 'creator'),
('created', 'created'),
]
text = models.TextField(_('Text'))
video = EmbedVideoField(blank=True, null=True)
facebook_post_id = models.CharField(_('Facebook Share'),
max_length=255,
null=True,
blank=True)
timeline_template = 'cosinnus_note/v2/dashboard/timeline_item.html'
class Meta(BaseTaggableObjectModel.Meta):
ordering = ['-created', 'title']
verbose_name = _('Note Item')
verbose_name_plural = _('Note Items')
def __init__(self, *args, **kwargs):
super(Note, self).__init__(*args, **kwargs)
self._meta.get_field('creator').verbose_name = _('Author')
def save(self, *args, **kwargs):
created = bool(self.pk) == False
# take the first youtube url from the textand save it as a video link
self.video = None
for url in self.urls:
if 'youtube.com' in url or 'youtu.be' in url:
self.video = url
break
super(Note, self).save(*args, **kwargs)
if created:
session_id = uuid1().int
group_followers_except_creator_ids = [
pk for pk in self.group.get_followed_user_ids()
if not pk in [self.creator_id]
]
group_followers_except_creator = get_user_model().objects.filter(
id__in=group_followers_except_creator_ids)
cosinnus_notifications.followed_group_note_created.send(
sender=self,
user=self.creator,
obj=self,
audience=group_followers_except_creator,
session_id=session_id)
cosinnus_notifications.note_created.send(
sender=self,
user=self.creator,
obj=self,
audience=get_user_model().objects.filter(
id__in=self.group.members).exclude(id=self.creator.pk),
session_id=session_id,
end_session=True)
def get_icon(self):
""" Returns the font-awesome icon specific to this object type """
return 'fa-quote-right'
def get_absolute_url(self):
kwargs = {'group': self.group, 'slug': self.slug}
return group_aware_reverse('cosinnus:note:note', kwargs=kwargs)
def get_edit_url(self):
kwargs = {'group': self.group, 'slug': self.slug}
return group_aware_reverse('cosinnus:note:update', kwargs=kwargs)
def get_delete_url(self):
kwargs = {'group': self.group, 'slug': self.slug}
return group_aware_reverse('cosinnus:note:delete', kwargs=kwargs)
def get_facebook_post_url(self):
""" If this post has been posted to facebook and its id is known, returns the URL to the facebook post.
@return: A string URL to a facebook post or None """
if self.facebook_post_id:
try:
return FACEBOOK_POST_URL % tuple(
self.facebook_post_id.split('_'))
except:
if settings.DEBUG:
raise
return None
def get_readable_title(self):
""" Returns either the title if set, or the text of this news post """
return self.title if not self.title == self.EMPTY_TITLE_PLACEHOLDER else truncatechars(
self.text, 40)
@classmethod
def get_current(self, group, user):
""" Returns a queryset of the current upcoming events """
qs = Note.objects.filter(group=group)
# mix in reflected objects
if "%s.%s" % (self._meta.app_label, self._meta.model_name
) in settings.COSINNUS_REFLECTABLE_OBJECTS:
mixin = MixReflectedObjectsMixin()
qs = mixin.mix_queryset(qs, self._meta.model, group)
if user:
qs = filter_tagged_object_queryset_for_user(qs, user)
return qs
@classmethod
def get_current_for_portal(self):
""" Returns a queryset of the current Notes for this portal """
qs = Note.objects.filter(group__portal=CosinnusPortal.get_current())
return qs
@cached_property
def video_id(self):
""" Returns the video id from a URL as such:
http://www.youtube.com/watch?v=CENF14Iloxw&hq=1
"""
video = self.video
if video:
# remove a single trailing space, that can exist because of markdown, and is never used in an actual URL
if video.endswith(')'):
video = video[:-1]
match = re.search(r'[?&]v=([a-zA-Z0-9-_]+)[^a-zA-Z0-9-_]', video)
if not match:
match = re.search(r'youtu.be/([a-zA-Z0-9-_]+)(&|$)', video)
if match:
vid = match.groups()[0]
return vid
return None
@property
def video_thumbnail(self):
vid = self.video_id
ret = None
if vid:
ret = 'http://img.youtube.com/vi/%s/hqdefault.jpg' % vid
return ret
@property
def urls(self):
""" Returns a list of all URLs contained in the note's text """
return re.findall(
'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',
self.text)
@property
def short_text(self):
return truncatechars(self.text, 100)
def get_comment_post_url(self):
return group_aware_reverse('cosinnus:note:comment',
kwargs={
'group': self.group,
'note_slug': self.slug
})
class Film(models.Model):
LANGUAGE = (('Украинский', 'Украинский'), ('Английски', 'Английский'),
('Русский', 'Русский'))
TYPE = (('Аниме', 'Аниме'), ('Мультфильм', 'Мультфильм'), ('Фильм',
'Фильм'))
title = models.CharField('Название фильма', max_length=255)
original_title = models.CharField('Оригинальное название',
max_length=255,
null=True,
blank=True)
country = models.CharField('Название страны', max_length=255, null=True)
description = models.TextField('Описание фильма', blank=True)
director = models.CharField('Продюссер', max_length=255, null=True)
main_image = models.ImageField(upload_to='images/film_poster')
image1 = models.ImageField('Первое изображение',
upload_to='images/film_images')
image2 = models.ImageField('Второе изображение',
upload_to='images/film_images/')
image3 = models.ImageField('Третее изображение',
upload_to='images/film_images/')
image4 = models.ImageField('Четвёртое изображение',
upload_to='images/film_images/')
image5 = models.ImageField('Пятое изображение',
upload_to='images/film_images/')
trailer_link = EmbedVideoField('')
two_d = models.BooleanField('2Д', null=False)
three_d = models.BooleanField('3Д', null=False)
i_max = models.BooleanField('I_MAX', null=False)
duration = models.IntegerField('Длительность фильма (минуты)')
first_night = models.DateField('Дата премьеры')
language = models.CharField('', choices=LANGUAGE, max_length=55, null=True)
type = models.CharField('', choices=TYPE, max_length=55, null=True)
seo = models.ForeignKey(SEO,
on_delete=models.CASCADE,
verbose_name='SEO блок',
null=True)
def save(self, *args, **kwargs):
if not self.seo:
self.seo = SEO.objects.create()
super(Film, self).save(*args, **kwargs)
def __str__(self):
return self.title
def get_absolute_image(self):
return os.path.join('/media', self.main_image.name)
def get_image1(self):
return os.path.join('/media', self.image1.name)
def get_image2(self):
return os.path.join('/media', self.image2.name)
def get_image3(self):
return os.path.join('/media', self.image3.name)
def get_image4(self):
return os.path.join('/media', self.image4.name)
def get_image5(self):
return os.path.join('/media', self.image5.name)
def get_absolute_url(self):
return f'film/list'
def file_list(self):
return [
self.main_image, self.image1, self.image2, self.image3,
self.image4, self.image5
]
def get_string_duration(self):
d = self.duration
r = ""
h = d // 60
m = d % 60
if h > 0:
r += f"{h} часов"
if m > 0:
r += f"{m} минут"
return r if r else "Не указанно"
