class Lesson(models.Model):
SEMESTER_CHOICES = ((1, u'Осенний'), (0, u'Весенний'))
SEMI_CHOICES = ((1, u'Первый'), (2, u'Второй'))
WEEK_CHOICES = ((None, u''), (True, u'Нечетная'), (False, u'Четная'))
TYPE_CHOICES = ((0, u'Лекция'), (1, u'Практика'), (2, u'Лабораторная работа'))
DAY_OF_WEEK_CHOICES = WEEKDAYS.items()
PAIR_TIME = (
(1, (datetime.time(8, 30), datetime.time(10, 00))),
(2, (datetime.time(10, 15), datetime.time(11, 45))),
(3, (datetime.time(12, 00), datetime.time(13, 30))),
(4, (datetime.time(14, 15), datetime.time(15, 45))),
(5, (datetime.time(16, 00), datetime.time(17, 30))),
(6, (datetime.time(17, 40), datetime.time(19, 05))),
(7, (datetime.time(19, 15), datetime.time(20, 40))),
)
NPAIR_CHOICES = [(i, '%s - %s' % time) for i, time in PAIR_TIME]
semester = models.SmallIntegerField(u'Семестр', choices=SEMESTER_CHOICES)
semi = models.SmallIntegerField(u'Полусеместр', choices=SEMI_CHOICES)
week = models.NullBooleanField(u'Неделя', choices=WEEK_CHOICES)
day = models.SmallIntegerField(u'День недели', choices=DAY_OF_WEEK_CHOICES)
group = models.ForeignKey(Group, related_name='lessons')
npair = models.IntegerField(u'Номер пары', choices=NPAIR_CHOICES)
subject = models.ForeignKey(Subject, verbose_name=u'Предмет', null=True)
type = models.CharField(u'Тип занятия', max_length=300, null=True)
professor = models.ForeignKey(Professor, verbose_name=u'Преподаватель', null=True)
room = models.CharField(u'Аудитория', max_length=30, blank=True, null=True, default='')
def __unicode__(self):
return u'%s %d, %s' % (self.get_day_display(), self.npair, self.subject)
@property
def time(self):
return dict(self.PAIR_TIME)[self.npair]
@property
def location(self):
if not self.room:
return ''
addresses = {u'Р': u'ул. Мира, 32, Екатеринбург, Свердловская область'}
address = addresses.get(self.room[0], '')
return u'{}, {}'.format(self.room, address).strip()
def event(self, user, date):
e, created = Event.objects.get_or_create(user=user, lesson=self, date=date)
return e
@property
def siblings(self):
queryset = Lesson.objects.filter(semester=self.semester, semi=self.semi, week=self.week, day=self.day)
if self.room:
return queryset.filter(room=self.room, npair=self.npair)
def get_weekday_properties():
dayabbrs = WEEKDAYS_ABBR.values() * 2
daynames = WEEKDAYS.values() * 2
weekday_names = []
weekday_abbrs = []
first_dow = standardise_first_dow(formats.get_format('FIRST_DAY_OF_WEEK'))
for i in range(first_dow, first_dow + 7):
weekday_names.append(daynames[i])
weekday_abbrs.append(dayabbrs[i])
return weekday_names, weekday_abbrs
def get_days(self, start_date):
days = []
for key, value in WEEKDAYS.items():
date = start_date + datetime.timedelta(key)
field = 'broadcast_date'
days.append({'name': value,
'index': key,
'date': date,
'datefilter': '%(field)s__year=%(year)s&%(field)s__month=%(month)s&%(field)s__day=%(day)s' % {
'field': field,
'year': date.year,
'month': date.month,
'day': date.day,
},
})
return days
def get_days(self, start_date):
days = []
for key, value in WEEKDAYS.items():
date = start_date + datetime.timedelta(key)
field = 'broadcast_date'
days.append({
'name': value,
'index': key,
'date': date,
'datefilter':
'%(field)s__year=%(year)s&%(field)s__month=%(month)s&%(field)s__day=%(day)s'
% {
'field': field,
'year': date.year,
'month': date.month,
'day': date.day,
},
})
return days
def render(self, name, value, attrs=None):
super().render(name, value, attrs)
flat_attrs = flatatt(attrs)
context = {
'name':
name,
'attrs':
flat_attrs,
'id':
attrs['id'],
'closeText':
_("Close"),
'currentText':
_("Today"),
'dayNames':
mark_safe(list2str((str(item[1]) for item in WEEKDAYS.items()))),
'dayNamesMin':
mark_safe(
list2str((str(item[1]) for item in WEEKDAYS_ABBR.items()))),
'dayNamesShort':
mark_safe(
list2str((str(item[1]) for item in WEEKDAYS_ABBR.items()))),
'firstDay':
mark_safe('"' + str(WEEKDAYS[settings.FIRST_DAY_OF_WEEK]) + '"'),
'isRTL':
str(get_language_bidi()).lower(),
'monthNames':
mark_safe(list2str((str(item[1]) for item in MONTHS.items()))),
'monthNamesShort':
mark_safe(list2str((str(item[1]) for item in MONTHS_3.items()))),
'nextText':
mark_safe('"' + str(_('Next')) + '"'),
'prevText':
mark_safe('"' + str(_('Previous')) + '"'),
'weekHeader':
mark_safe('"' + str(_('Wk')) + '"'),
}
template = get_template('users/datetimepicker.html')
return template.render(context)
def test_day_names_property(self):
for obj in self.objects:
assert_equal(obj.day_names, WEEKDAYS.values())
assert_equal(obj.day_names[0], 'Monday')
assert_equal(obj.day_names[6], 'Sunday')
from django.db import models
from django.utils.dates import WEEKDAYS
from django.utils.translation import ugettext_lazy as _
from django.utils.encoding import smart_unicode
SMALL_INT = models.PositiveSmallIntegerField
WEEKDAY_CHOICES = sorted(WEEKDAYS.iteritems())
class Scalendar(models.Model):
name = models.CharField(max_length=512, verbose_name=_("name"))
workdays = SMALL_INT(default=31, verbose_name=_("work-days"))
firstweekday = SMALL_INT(choices=WEEKDAY_CHOICES, default=0, verbose_name=_("week begins on"))
class Meta:
verbose_name = _("calendar")
verbose_name_plural = _("calendars")
def __unicode__(self):
return smart_unicode(self.name)
def _is_workday(self, day_index):
""" Returns True if the day is set as working day in self.workdays """
return bool(self.workdays & (1 << day_index))
def is_workday(self, date_obj):
""" Given a datetime.date object, returns True if this day is a workday
according to the current Scalendar. Otherwise, returns False. """
result = self._is_workday(date_obj.weekday())
exceptions = self.exceptions.filter(date__lte=date_obj, end_date__gte=date_obj)
if exceptions.count():
result = (exceptions[0].working == True)
from django.db import models
from django.utils.dates import WEEKDAYS
from django.utils.translation import ugettext as _
from django.conf import settings
from colorful.fields import RGBColorField
from datetime import datetime, date, time, timedelta
from math import ceil
from antxetamedia.structure.models import Node
weekdays = WEEKDAYS.items()
class Colored(models.Model):
class Meta:
abstract = True
name = models.CharField(_('name'), max_length=100)
color = RGBColorField(_('color'))
def __unicode__(self):
return self.name
class Producer(Colored):
class Meta:
verbose_name = _('producer')
verbose_name_plural = _('producers')
class Category(Colored):
from django.utils.dates import WEEKDAYS_ABBR as _WEEKDAYS_ABBR, WEEKDAYS as _WEEKDAYS
from django.utils.translation import ugettext_lazy as _
def weekday_name(iso_number):
"""Return the weekday name for the given ISO weekday number or a blank string."""
try:
return _WEEKDAYS[iso_number - 1]
except IndexError:
return u""
WEEKDAYS = tuple([_WEEKDAYS[i] for i in sorted(_WEEKDAYS.keys())])
WEEKDAYS_ABBR = tuple([_WEEKDAYS_ABBR[i] for i in sorted(_WEEKDAYS_ABBR.keys())])
WEEKDAYS_SINGLE_LETTER = (_('M'), _('T'), _('W'), _('R'), _('F'), _('S'), _('U'))
#REMINDER_TYPES = dict(REMINDER_TYPE_CHOICES)
REMINDER_DATE_CHOICES = [
('YEAR', 'Annually on a month/day'),
('SEM', 'Semesterly on a week/weekday'),
]
#REMINDER_DATES = dict(REMINDER_DATE_CHOICES)
STATUS_CHOICES = [
('A', 'Active'),
('D', 'Deleted'),
]
ROLE_BLACKLIST = ['FAC', 'SESS', 'COOP']
WEEKDAY_CHOICES = [(str(n), w) for n, w in WEEKDAYS.items()]
MONTH_CHOICES = [(str(n), w) for n, w in MONTHS.items()]
MAX_LATE = 7 # max days late we'll tolerate sending a reminder in the worst case
MESSAGE_EARLY_CREATION = 14 # how many days before the reminder we bother creating the ReminderMessage
HISTORY_RETENTION = 365 # number of days to keep record of ReminderMessages that were sent
REMINDER_HTML_TEMPLATE = Template('''
${content_html}
<p style="font-size: smaller; border-top: 1px solid black;">
You received this message because of a reminder in ${coursys}. It is sent ${when}, to ${who}.
You can <a href="${url}">review this reminder</a> (including editing or deleting it).
</p>
''')
from django.db import models
from django.utils.dates import WEEKDAYS
from django.utils.translation import ugettext_lazy as _
from django.utils.encoding import smart_unicode
SMALL_INT = models.PositiveSmallIntegerField
WEEKDAY_CHOICES = sorted(WEEKDAYS.iteritems())
class Scalendar(models.Model):
name = models.CharField(max_length=512, verbose_name=_("name"))
workdays = SMALL_INT(default=31, verbose_name=_("work-days"))
firstweekday = SMALL_INT(choices=WEEKDAY_CHOICES,
default=0,
verbose_name=_("week begins on"))
class Meta:
verbose_name = _("calendar")
verbose_name_plural = _("calendars")
def __unicode__(self):
return smart_unicode(self.name)
def _is_workday(self, day_index):
""" Returns True if the day is set as working day in self.workdays """
return bool(self.workdays & (1 << day_index))
def is_workday(self, date_obj):
""" Given a datetime.date object, returns True if this day is a workday
according to the current Scalendar. Otherwise, returns False. """
result = self._is_workday(date_obj.weekday())
def __init__(self, attrs=None, format=None, datepicker_class='datepicker',
params=None):
params = params or {}
attrs = attrs or {}
class_attr = attrs.get('class', datepicker_class)
if datepicker_class not in class_attr:
attrs.update({
'class': '{0} {1}'.format(class_attr, datepicker_class),
'readonly': True,
})
else:
attrs.update({
'class': 'datepicker',
'readonly': True,
})
super(DatePickerWidget, self).__init__(attrs, format)
self.params = {
'changeMonth': True,
'changeYear': True,
'yearRange': '2000:2050',
}
self.regional = {
'closeText': _('Close'),
'prevText': _('Previous'),
'nextText': _('Next'),
'currentText': _('Current'),
'monthNames': map(unicode, MONTHS_ALT.values()),
'monthNamesShort': map(unicode, MONTHS_AP.values()),
'dayNames': map(unicode, WEEKDAYS.values()),
'dayNamesShort': map(unicode, WEEKDAYS_ABBR.values()),
'dayNamesMin': map(unicode, WEEKDAYS_ABBR.values()),
'isRTL': get_language_bidi(),
# weekHeader
# dateFormat
# firstDay
# showMonthAfterYear
# yearSuffix
}
# Update the datepicker parameters
self.params.update(params)
pattern = re.compile(
r'(?<!\w)(' + '|'.join(PYTHON_TO_DATEPICKER_FORMAT.keys()) + r')\b'
)
if params.get('beforeShowDay'):
raise NotImplementedError(
u'beforeShowDay is not supported. Please add the function to '
u'the template.'
)
if not params.get('dateFormat'):
self.params.update({
'dateFormat': pattern.sub(
lambda x: PYTHON_TO_DATEPICKER_FORMAT[x.group()],
self.format
)
})
import datetime
min_date = self.params.get('minDate')
if min_date:
if isinstance(min_date, datetime.date):
self.params.update({
'minDate': self.params['minDate'].strftime(
format=self.format
)
})
elif isinstance(min_date, datetime.datetime):
self.params.update({
'maxDate': min_date.strftime(
format=self.format
)
})
max_date = self.params.get('maxDate')
if max_date:
if isinstance(max_date, datetime.date):
self.params.update({
'maxDate': max_date.strftime(
format=self.format
)
})
elif isinstance(max_date, datetime.datetime):
self.params.update({
'maxDate': max_date.strftime(
format=self.format
)
})
#REMINDER_TYPES = dict(REMINDER_TYPE_CHOICES)
REMINDER_DATE_CHOICES = [
('YEAR', 'Annually on a month/day'),
('SEM', 'Semesterly on a week/weekday'),
]
#REMINDER_DATES = dict(REMINDER_DATE_CHOICES)
STATUS_CHOICES = [
('A', 'Active'),
('D', 'Deleted'),
]
ROLE_BLACKLIST = ['FAC', 'SESS', 'COOP']
WEEKDAY_CHOICES = [(str(n), w) for n, w in WEEKDAYS.items()]
MONTH_CHOICES = [(str(n), w) for n, w in MONTHS.items()]
MAX_LATE = 7 # max days late we'll tolerate sending a reminder in the worst case
MESSAGE_EARLY_CREATION = 14 # how many days before the reminder we bother creating the ReminderMessage
HISTORY_RETENTION = 365 # number of days to keep record of ReminderMessages that were sent
REMINDER_HTML_TEMPLATE = Template('''
${content_html}
<p style="font-size: smaller; border-top: 1px solid black;">
You received this message because of a reminder in ${coursys}. It is sent ${when}, to ${who}.
You can <a href="${url}">review this reminder</a> (including editing or deleting it).
</p>
''')
