class Migration(migrations.Migration):
dependencies = [
('fk', '0003_asrun'),
]
operations = [
migrations.AlterField(
model_name='scheduleitem',
name='duration',
field=DurationField(),
preserve_default=True,
),
migrations.AlterField(
model_name='video',
name='duration',
field=DurationField(),
preserve_default=True,
),
migrations.AlterField(
model_name='weeklyslot',
name='duration',
field=DurationField(),
preserve_default=True,
),
migrations.RunPython(duration_millisecond_to_microsecond),
]
class Stat(Model):
length = DurationField(default=0)
spoken = DurationField(default=0)
ad_count = IntegerField(default=0)
song_cat3 = IntegerField(default=0)
song_cat2 = IntegerField(default=0)
song_cat3_canadian = IntegerField(default=0)
song_cat2_canadian = IntegerField(default=0)
song_local = IntegerField(default=0)
def __str__(self):
return "Stat: (spoken: %s of %s), (local: %s of %s), (can2: %s of %s), (can3: %s of %s), (ads: %s)" % (
str(self.spoken), str(self.length), self.song_local, self.song_cat3
+ self.song_cat2, self.song_cat2_canadian, self.song_cat2,
self.song_cat3_canadian, self.song_cat3, self.ad_count)
class TicketProduct(Product):
ticket = models.ForeignKey(TicketType)
amount = models.PositiveIntegerField(
help_text=_("Amount of tickets included in this product."))
duration = DurationField(
blank=True,
null=True,
help_text=
_("Relative duration of the given product. For example 30 days, 90 days. If this is empty, you must insert expire date."
))
expires = models.DateField(
blank=True,
null=True,
help_text=
_("Absolute expiration date for the given product. For example 2014-12-31. If this is empty, you must insert duration."
))
class Meta:
pass
def clean(self):
if not (self.duration or self.expires):
raise ValidationError(
_("Ticket duration or absolute expire date must be set"))
def get_activator(self):
return TicketProductActivator()
class Other(Model):
spoken = BooleanField(
choices=((True, 'S'), (False, 'M')),
default=True,
)
description = CharField(max_length=120)
length = DurationField()
def cname(self):
return self.__class__.__name__
def __str__(self):
return "%s [%s]" % (self.description, str(self.length)[:7])
class Ticket(models.Model): #Model for Ticket Management System
user_id = models.ForeignKey(User)
topic_id = models.ForeignKey(Category)
message = models.TextField()
ticket_id = models.IntegerField()
file_uploads = models.FileField(upload_to='tickets/file', blank=True)
created_date_time = models.DateTimeField(auto_now_add=True)
overdue_date_time = models.DateTimeField(auto_now_add=True)
closed_date_time = models.DateTimeField(auto_now_add=True)
status = models.CharField(max_length=20) #open,closed,overdue
reopened_date_time = models.DateTimeField(auto_now_add=True)
topic_priority = models.CharField(max_length=20) #low,high
duration_for_reply = DurationField()
def __unicode__(self):
return self.user_id.username
class Ride(models.Model):
user = models.ForeignKey('riders.Teammate', verbose_name = 'teammate')
date = models.DateField('date', help_text = 'Date format: YYYY-MM-DD')
# TODO what if we made this a list of foreign keys for other riders?
buddies = models.CharField('ride buddies', max_length = 300)
miles = models.DecimalField('miles ridden', max_digits = 5, decimal_places = 2)
pace = models.DecimalField('average pace', max_digits = 3, decimal_places = 1)
duration = DurationField('time to complete ride', help_text = 'HH:MM:SS format')
comments = models.TextField('comments')
time_logged = models.DateTimeField('date logged', auto_now_add = True, blank = True, null = True)
# Method to create a new ride
def log(cls, user, date, buddies, miles, pace, duration, comments):
user_data = cls(user = user, date = date, buddies = buddies, miles = miles,
pace = pace, duration = duration, comments = comments)
return user_data
# Metadata for the visual names
class Meta:
verbose_name = 'ride'
verbose_name_plural = 'rides'
# Base method returns the teammate's name
def __unicode__(self):
# Returns the user foreign key, which calls __unicide__ in auth
return '%s, %d miles' % (self.user, self.miles)
# Methods to return model values
def get_miles(self):
# Returns the miles ridden
return self.miles
def get_date(self):
# Returns the date the ride was on
return self.date
def get_pace(self):
# Returns the pace for the ride
return self.pace
def get_duration(self):
# Returns the time it took to ride
return self.duration
def get_time_logged(self):
# Returns the time the ride was logged at
return self.time_logged
class StationID(Model):
spoken = BooleanField(
choices=((True, 'S'), (False, 'M')),
default=True,
)
description = CharField(max_length=120)
length = DurationField()
def cname(self):
return self.__class__.__name__
def __str__(self):
if self.spoken:
return "Spoken ID: %s %s" % (self.description, str(
self.length)[2:7])
else:
return "Musical ID: %s %s" % (self.description, str(
self.length)[2:7])
class Advertisement(Model):
advertiser = CharField(max_length=40)
length = DurationField()
spoken = BooleanField(
choices=((True, 'S'), (False, 'M')),
default=True,
)
# required by section 8.1.c.v
category = IntegerField(choices=((51, "Ad"), (52, "Sponsor ID"),
(53, "Promo")),
default=52)
def cname(self):
return self.__class__.__name__
def __str__(self):
return "%s, %s [%s]" % (self.get_category_display(), self.advertiser,
str(self.length)[2:7])
class WeeklySlot(models.Model):
DAY_OF_THE_WEEK = (
(0, _(u'Monday')),
(1, _(u'Tuesday')),
(2, _(u'Wednesday')),
(3, _(u'Thursday')),
(4, _(u'Friday')),
(5, _(u'Saturday')),
(6, _(u'Sunday')),
)
purpose = models.ForeignKey(SchedulePurpose, null=True, blank=True)
day = models.IntegerField(choices=DAY_OF_THE_WEEK, )
start_time = models.TimeField()
duration = DurationField()
class Meta:
ordering = ('day', 'start_time', 'pk')
@property
def end_time(self):
if not self.duration:
return self.start_time
return self.start_time + self.duration
def next_date(self, from_date=None):
if not from_date:
from_date = datetime.date.today()
days_ahead = self.day - from_date.weekday()
if days_ahead <= 0:
# target date already happened this week
days_ahead += 7
return from_date + datetime.timedelta(days_ahead)
def next_datetime(self, from_date=None):
next_date = self.next_date(from_date)
naive_dt = datetime.datetime.combine(next_date, self.start_time)
tz = pytz.timezone(settings.TIME_ZONE)
return tz.localize(naive_dt)
def __unicode__(self):
return (u"{day} {s.start_time} ({s.purpose})"
u"".format(day=self.get_day_display(), s=self))
class Response(models.Model):
"""
Response to a Survey. A Response is composed of multiple Answers
to Questions.
"""
objects = ResponseManager()
slug = models.SlugField()
created_at = models.DateTimeField(auto_now_add=True)
survey = models.ForeignKey(SurveyModel, null=True)
user = models.ForeignKey(AUTH_USER_MODEL, null=True)
time_spent = DurationField(default=0,
help_text="Total recorded time to complete the survey")
is_frozen = models.BooleanField(default=False,
help_text="When True, answers to that response cannot be updated.")
def __unicode__(self):
return self.slug
def get_answers_by_rank(self):
return self.answers.all().order_by('index') #pylint:disable=no-member
class Release(models.Model):
name = models.CharField(max_length=255, blank=False)
release_date = models.DateField(auto_now=False)
creator = models.ForeignKey('ReleaseCreator',
on_delete=models.PROTECT,
blank=False)
group_creator = models.ForeignKey('GroupCreator',
on_delete=models.PROTECT,
blank=False)
length = DurationField(blank=True)
cover_url = models.CharField(max_length=500, blank=True)
review = models.ForeignKey('Review',
on_delete=models.PROTECT,
blank=True,
null=True)
class Meta:
abstract = True
def __str__(self):
return self.name
class Scheduleitem(models.Model):
SCHEDULE_REASONS = (
(1, 'Legacy'),
(2, 'Administrative'),
(3, 'User'),
(4, 'Automatic'),
)
id = models.AutoField(primary_key=True)
default_name = models.CharField(max_length=255, blank=True)
video = models.ForeignKey(Video, null=True, blank=True)
schedulereason = models.IntegerField(blank=True, choices=SCHEDULE_REASONS)
starttime = models.DateTimeField()
duration = DurationField()
objects = ScheduleitemManager()
"""
def save(self, *args, **kwargs):
self.endtime = self.starttime + timeutils.duration
super(Scheduleitem, self).save(*args, **kwargs)
"""
class Meta:
db_table = u'ScheduleItem'
verbose_name = u'TX schedule entry'
verbose_name_plural = u'TX schedule entries'
def __unicode__(self):
t = self.starttime
s = t.strftime("%Y-%m-%d %H:%M:%S")
# format microsecond to hundreths
s += ".%02i" % (t.microsecond / 10000)
if self.video:
return str(s) + ": " + unicode(self.video)
else:
return str(s) + ": " + self.default_name
def endtime(self):
if not self.duration:
return self.starttime
return self.starttime + self.duration
class Song(Model):
title = CharField(max_length=40)
artist = CharField(max_length=40)
composer = CharField(max_length=40)
length = DurationField()
category_3 = BooleanField(default=False,
choices=((True, '3'), (False, '2')))
origin = CharField(max_length=3,
choices=(("Lcl", "Local"), ("Can", "Canadian"),
("Int", "International")),
default="Int")
hit = BooleanField(default=False)
# instrumental pieces must be marked! Do it here.
language = CharField(max_length=20, default="english")
def cname(self):
return self.__class__.__name__
def __str__(self):
return "%s (%s) [%s]" % (self.title, self.artist, str(
self.length)[2:7])
class TicketProductActivator(ProductActivator):
start = models.PositiveIntegerField(null=True)
end = models.PositiveIntegerField(null=True)
rider = models.ForeignKey(RiderInfo, null=True, blank=True)
duration = DurationField(blank=True, null=True)
def activate(self):
user = UserProfile.objects.find(
_getUserName(self.order.shipping_address_text))
if user:
self.rider = user.rider
for i in range(0, self.product.amount):
exp = None
if self.product.expires:
exp = self.product.expires
t = Ticket.objects.create(type=self.product.ticket,
owner=self.rider,
expires=exp)
if i == 0: self.start = t.id
if i == self.product.amount - 1: self.end = t.id
self.duration = self.product.duration
self.status = self.ACTIVATED
self.save()
class Lesson(CreatedMixin, Displayable):
#TODO: this model should probably have a slug
#title included thanks to displayable
teacher = models.ForeignKey(User, related_name='teaching')
image = models.FileField(upload_to=file_url("lessonimage"))
flavor_text = models.TextField(default="")
price = models.DecimalField(max_digits=20, decimal_places=2, null=True,
blank=True)
users_who_rated = models.ManyToManyField(User, through='LessonRating',
related_name='rated_lessons')
followers = models.ManyToManyField(User, related_name='lessons',
blank=True, null=True)
serving_size = models.IntegerField()
#tags = models.ChraField(max_length=128, default="")
prep_time = DurationField()
cooking_time = DurationField()
primary_ingredients = models.ManyToManyField(Ingredient, related_name='primary_lessons', blank=True)
course = models.ManyToManyField('Course', blank=True)
cuisine = models.ManyToManyField('Cuisine', blank=True)
restrictions = models.ManyToManyField("DietaryRestrictions", blank=True)
kind = models.SmallIntegerField(choices=((0, "Recipe"),
(1, "Technique")), default=0)
ingredients = models.ManyToManyField(Ingredient, through="LessonIngredient", related_name="lessons")
tools = models.ManyToManyField(Tool, through="LessonTool", related_name="lessons", blank=True)
video = models.ForeignKey(Video, related_name="lessons", null=True, blank=True)
class Meta():
unique_together = ('teacher', 'title')
@cached_property
def tags(self):
"""Grabs a list of the lessons dietary restrictions, cuisines, courses,
and primary ingredients from the database"""
primary_ingredients = self.primary_ingredients.all()
course = self.course.all()
cuisine = self.cuisine.all()
restrictions = self.restrictions.all()
#list it to prevent caching the generator
return list(chain(primary_ingredients, course, cuisine, restrictions))
@property
def rating(self):
#TODO: user proper rating algo. http://www.evanmiller.org/how-not-to-sort-by-average-rating.html
result = self.ratings.aggregate(avg=Avg('rating'))['avg']
if not result:
return 0
return int(result)
@property
def prep_in_min(self):
return int(max(self.prep_time.total_seconds() / 60, 1))
@property
def cook_in_min(self):
return int(max(self.cooking_time.total_seconds() / 60, 1))
def get_absolute_url(self):
return reverse("lesson_detail", kwargs={'lesson_id':self.id})
def __unicode__(self):
return self.title
class Video(models.Model):
id = models.AutoField(primary_key=True)
# Retire, use description instead
header = models.TextField(blank=True, null=True, max_length=2048)
name = models.CharField(max_length=255)
description = models.CharField(blank=True, null=True, max_length=2048)
# Code for editors' internal use
# production_code = models.CharField(null=True,max_length=255)
categories = models.ManyToManyField(Category)
editor = models.ForeignKey(User)
has_tono_records = models.BooleanField(default=False)
is_filler = models.BooleanField(default=False) # Find a better name?
publish_on_web = models.BooleanField(default=True)
# disabled = models.BooleanField() # Not migrated
# uploader = models.ForeignKey(User)
# Planned duration in milliseconds, probably not going to be used
# planned_duration = models.IntegerField()
# Time when it is to be published on web
# published_time = models.DateTimeField()
proper_import = models.BooleanField(default=False)
played_count_web = models.IntegerField(
default=0, help_text='Number of times it has been played')
created_time = models.DateTimeField(
auto_now_add=True,
null=True,
help_text='Time the program record was created')
updated_time = models.DateTimeField(
auto_now=True,
null=True,
help_text='Time the program record has been updated')
uploaded_time = models.DateTimeField(
blank=True,
null=True,
help_text='Time the original video for the program was uploaded')
framerate = models.IntegerField(
default=25000,
help_text='Framerate of master video in thousands / second')
organization = models.ForeignKey(Organization,
null=True,
help_text='Organization for video')
ref_url = models.CharField(blank=True,
max_length=1024,
help_text='URL for reference')
duration = DurationField(blank=True, null=True)
objects = VideoManager()
class Meta:
db_table = u'Video'
get_latest_by = 'uploaded_time'
def __unicode__(self):
return self.name
def is_public(self):
return self.publish_on_web and self.proper_import
def tags(self):
tags = []
if self.has_tono_records:
tags.append("tono")
if self.publish_on_web:
tags.append("www")
if self.is_filler:
tags.append("filler")
return ', '.join(tags)
def videofiles(self):
videofiles = VideoFile.objects.filter(video=self)
return videofiles
def category_list(self):
categories = self.categories.filter(video=self)
return categories
def schedule(self):
events = Scheduleitem.objects.filter(video=self)
return events
def first_broadcast(self):
events = Scheduleitem.objects.filter(video=self)
if events:
return events[0]
return None
def last_broadcast(self):
events = Scheduleitem.objects.filter(video=self)
if events:
return events[max(0, len(events) - 1)]
return None
def videofile_url(self, fsname):
videofile = self.videofile_set.get(format__fsname=fsname)
return videofile.location(relative=True)
def small_thumbnail_url(self):
format = FileFormat.objects.get(fsname="small_thumb")
try:
videofile = VideoFile.objects.get(video=self, format=format)
except ObjectDoesNotExist:
return "/static/default_small_thumbnail.png"
return settings.FK_MEDIA_URLPREFIX + videofile.location(relative=True)
def medium_thumbnail_url(self):
format = FileFormat.objects.get(fsname="medium_thumb")
try:
videofile = VideoFile.objects.get(video=self, format=format)
except ObjectDoesNotExist:
return "/static/default_medium_thumbnail.png"
return settings.FK_MEDIA_URLPREFIX + videofile.location(relative=True)
def large_thumbnail_url(self):
format = FileFormat.objects.get(fsname="large_thumb")
try:
videofile = VideoFile.objects.get(video=self, format=format)
except ObjectDoesNotExist:
return "/static/default_large_thumbnail.png"
return settings.FK_MEDIA_URLPREFIX + videofile.location(relative=True)
def old_id(self):
format = FileFormat.objects.get(fsname="broadcast")
videofile = VideoFile.objects.get(video=self, format=format)
return videofile.old_filename.split('/')[0]
def ogv_url(self):
url = settings.FK_MEDIA_URLPREFIX + self.videofile_url("theora")
return url
def mp4_url(self):
url = settings.FK_MEDIA_URLPREFIX + self.videofile_url("mp4")
return url
def get_absolute_url(self):
return reverse('vod-video-detail', kwargs={'video_id': self.id})
class TestModel(models.Model):
duration_field = DurationField()
class TestDefaultModel(models.Model):
duration_field = DurationField(default=DEFAULT_DURATION)
class TestNullableModel(models.Model):
duration_field = DurationField(null=True, blank=True)