def start_plan(cls, user, **options):
"""Start an invoicing plan for the given `user` on the database object
defined by `k` and `v`. Where `k` is the name of the field
used to select the plan (e.g. `'partner'` or `'journal'`) and
`v` is the value for that field.
This will either create a new plan, or check whether the
currently existing plan for this user was for the same
database object. If it was for another object, then clear all
items.
"""
try:
plan = cls.objects.get(user=user)
changed = False
for k, v in options.items():
if getattr(plan, k) != v:
changed = True
setattr(plan, k, v)
if 'today' not in options:
if plan.today != dd.today():
plan.today = dd.today()
changed = True
if changed:
plan.items.all().delete()
except cls.DoesNotExist:
plan = cls(user=user, **options)
plan.save()
return plan
def param_defaults(self, ar, **kw):
kw = super(MyExpiringUploads, self).param_defaults(ar, **kw)
kw.update(coached_by=ar.get_user())
kw.update(observed_event=dd.PeriodEvents.ended)
kw.update(start_date=dd.today())
kw.update(end_date=dd.today(365))
return kw
def get_data_rows(cls, ar):
home = cls.get_row_by_pk(ar, 0)
# ni = cls.get_navinfo(ar, home)
pv = ar.param_values
# date = pv.start_date or dd.today(ni['first'])
# last = pv.end_date or dd.today(ni['last'])
# start_date = dd.plugins.cal.beginning_of_time
# end_date = dd.plugins.cal.ignore_dates_after
if cls.navigation_mode == "day":
step = lambda x: x + ONE_DAY
delta = 7
elif cls.navigation_mode == "week":
step = lambda x: x + ONE_WEEK
delta = 7 * 2
elif cls.navigation_mode == "month":
step = lambda x: DurationUnits.months.add_duration(x, 1)
delta = 40
else:
step = lambda x: DurationUnits.years.add_duration(x, 1)
delta = 40
date = pv.start_date or dd.today(-delta)
last = pv.end_date or dd.today(delta)
while date <= last:
yield cls.get_row_by_pk(ar, date2pk(date))
date = step(date)
def func(fld, week, ar):
pv = ar.param_values
if pv is None:
return
qs = Event.objects.all()
qs = Event.calendar_param_filter(qs, pv)
offset = int(ar.rqdata.get('mk', 0)
or 0) if ar.rqdata else ar.master_instance.pk
today = dd.today()
current_date = dd.today(offset)
target_day = week[int(pc.value) - 1]
qs = qs.filter(start_date=target_day)
qs = qs.order_by('start_time')
chunks = [
E.p(e.obj2href(ar, e.colored_calendar_fmt(pv))) for e in qs
]
pk = date2pk(target_day)
daily, weekly, monthly = make_link_funcs(ar)
daily_link = daily(Day(pk), str(target_day.day))
if target_day == today:
daily_link = E.b(daily_link)
header_items = [daily_link]
header_items = gen_insert_button(cls, header_items, Event, ar,
target_day)
header = E.div(*header_items, align="center", CLASS="header")
return E.table(
E.tr(E.td(*[header, E.div(*join_elems(chunks))])),
CLASS="fixed-table cal-month-cell {} {} {}".format(
"current-month" if current_date.month
== target_day.month else "other-month",
"current-day" if target_day == today else "",
"cal-in-past" if target_day < today else ""))
def get_table_summary(self, obj, ar):
items = []
def add(title, flt):
links = []
sar = self.request(master_instance=obj, filter=flt)
# logger.info("20141009 %s", sar.data_iterator.query)
n = sar.get_total_count()
if n:
for i, ex in enumerate(sar):
txt = self.format_excerpt(ex)
if ex.build_time is not None:
txt += " (%s)" % naturaltime(ex.build_time)
links.append(ar.obj2html(ex, txt))
if i >= self.MORE_LIMIT:
# links.append(ar.href_to_request(sar, _("more")))
links.append('...')
break
items.append(E.li(title, " : ", *join_elems(links, sep=', ')))
# qs = sar.data_iterator
Q = models.Q
add(gettext("not printed"), Q(build_time__isnull=True))
add(gettext("Today"), Q(build_time__gte=dd.today() - ONE_DAY))
t7 = dd.today() - ONE_WEEK
add(gettext("Last week"),
Q(build_time__lte=dd.today(), build_time__gte=t7))
add(gettext("Older"), Q(build_time__lt=t7))
return E.ul(*items)
def get_request_queryset(cls, ar, **kwargs):
qs = super(Enrollable, cls).get_request_queryset(ar, **kwargs)
pv = ar.param_values
if pv.course:
qs = qs.filter(enrolments_by_pupil__course=pv.course)
qs = qs.filter(
Q(enrolments_by_pupil__start_date__isnull=True) |
Q(enrolments_by_pupil__start_date__lte=dd.today()))
qs = qs.filter(
Q(enrolments_by_pupil__end_date__isnull=True) |
Q(enrolments_by_pupil__end_date__gte=dd.today()))
qs = qs.distinct()
# qs = qs.filter(enrolments_by_pupil__course=pv.course)
# qs = qs.filter(
# enrolments_by_pupil__state__in=EnrolmentStates.filter(
# invoiceable=True))
if not pv.enrolment_state:
qs = qs.filter(
enrolments_by_pupil__state__in=EnrolmentStates.filter(
invoiceable=True))
# qs = qs.filter(
# enrolments_by_pupil__state=EnrolmentStates.confirmed)
if pv.enrolment_state:
qs = qs.filter(enrolments_by_pupil__state=pv.enrolment_state)
qs = qs.distinct()
return qs
def get_request_queryset(cls, ar):
qs = super(Pupil, cls).get_request_queryset(ar)
pv = ar.param_values
if pv.course:
qs = qs.filter(
Q(enrolments_by_pupil__start_date__isnull=True) |
Q(enrolments_by_pupil__start_date__lte=dd.today()))
qs = qs.filter(
Q(enrolments_by_pupil__end_date__isnull=True) |
Q(enrolments_by_pupil__end_date__gte=dd.today()))
qs = qs.distinct()
# qs = qs.filter(enrolments_by_pupil__course=pv.course)
# qs = qs.filter(
# enrolments_by_pupil__state__in=EnrolmentStates.filter(
# invoiceable=True))
qs = qs.filter(
enrolments_by_pupil__course=pv.course,
enrolments_by_pupil__state__in=EnrolmentStates.filter(
invoiceable=True))
# qs = qs.filter(
# enrolments_by_pupil__state=EnrolmentStates.confirmed)
if pv.partner_list:
qs = qs.filter(list_memberships__list=pv.partner_list)
return qs
def get_slave_summary(self, obj, ar):
items = []
def add(title, flt):
links = []
sar = self.request(master_instance=obj, filter=flt)
# logger.info("20141009 %s", sar.data_iterator.query)
n = sar.get_total_count()
if n:
for i, ex in enumerate(sar):
txt = self.format_excerpt(ex)
if ex.build_time is not None:
txt += " (%s)" % naturaltime(ex.build_time)
links.append(ar.obj2html(ex, txt))
if i >= self.MORE_LIMIT:
# links.append(ar.href_to_request(sar, _("more")))
links.append('...')
break
items.append(E.li(title, " : ", *join_elems(links, sep=', ')))
# qs = sar.data_iterator
Q = models.Q
add(_("not printed"), Q(build_time__isnull=True))
add(_("Today"), Q(build_time__gte=dd.today() - ONE_DAY))
t7 = dd.today() - ONE_WEEK
add(_("Last week"), Q(build_time__lte=dd.today(), build_time__gte=t7))
add(_("Older"), Q(build_time__lt=t7))
return E.ul(*items)
def start_plan(cls, user, **options):
"""Start an invoicing plan for the given `user` on the database object
defined by `k` and `v`. Where `k` is the name of the field
used to select the plan (e.g. `'partner'` or `'journal'`) and
`v` is the value for that field.
This will either create a new plan, or check whether the
currently existing plan for this user was for the same
database object. If it was for another object, then clear all
items.
"""
try:
plan = cls.objects.get(user=user)
changed = False
for k, v in options.items():
if getattr(plan, k) != v:
changed = True
setattr(plan, k, v)
if 'today' not in options:
if plan.today != dd.today():
plan.today = dd.today()
changed = True
if changed:
plan.items.all().delete()
except cls.DoesNotExist:
plan = cls(user=user, **options)
plan.save()
return plan
def param_defaults(self, ar, **kw):
kw = super(MyExpiringUploads, self).param_defaults(ar, **kw)
kw.update(coached_by=ar.get_user())
kw.update(observed_event=dd.PeriodEvents.ended)
kw.update(start_date=dd.today())
kw.update(end_date=dd.today(365))
return kw
def run_start_plan(cls, user, **options):
qs = cls.objects.filter(user=user)
num = qs.count()
if num == 1:
plan = qs.first()
changed = False
for k, v in options.items():
if getattr(plan, k) != v:
changed = True
setattr(plan, k, v)
if 'today' not in options:
if plan.today != dd.today():
plan.today = dd.today()
changed = True
if changed:
plan.reset_plan()
else:
if num > 1:
dd.logger.warning("Got {} {} for {}".format(
num, cls._meta.verbose_name_plural, user))
qs.delete()
plan = cls(user=user, **options)
plan.full_clean()
plan.save()
return plan
def get_request_queryset(cls, ar, **kwargs):
qs = super(Enrollable, cls).get_request_queryset(ar, **kwargs)
pv = ar.param_values
if pv.course:
qs = qs.filter(enrolments_by_pupil__course=pv.course)
qs = qs.filter(
Q(enrolments_by_pupil__start_date__isnull=True)
| Q(enrolments_by_pupil__start_date__lte=dd.today()))
qs = qs.filter(
Q(enrolments_by_pupil__end_date__isnull=True)
| Q(enrolments_by_pupil__end_date__gte=dd.today()))
qs = qs.distinct()
# qs = qs.filter(enrolments_by_pupil__course=pv.course)
# qs = qs.filter(
# enrolments_by_pupil__state__in=EnrolmentStates.filter(
# invoiceable=True))
if not pv.enrolment_state:
qs = qs.filter(
enrolments_by_pupil__state__in=EnrolmentStates.filter(
invoiceable=True))
# qs = qs.filter(
# enrolments_by_pupil__state=EnrolmentStates.confirmed)
if pv.enrolment_state:
qs = qs.filter(enrolments_by_pupil__state=pv.enrolment_state)
qs = qs.distinct()
return qs
def get_data_rows(cls, ar):
pv = ar.param_values
start_date = pv.start_date or dd.today(-7)
end_date = pv.end_date or dd.today(7)
d = end_date
while d > start_date:
yield cls.Row(ar, d)
d -= ONE_DAY
def on_create(self, ar):
super(Voucher, self).on_create(ar)
if self.entry_date is None:
if ar is None:
self.entry_date = dd.today()
else:
info = LedgerInfo.get_for_user(ar.get_user())
self.entry_date = info.entry_date or dd.today()
def this_year(self, obj, ar):
tbl = obj.get_doc_report()
AccountingPeriod = rt.models.ledger.AccountingPeriod
# print(20190924, year)
pv = dict()
if issubclass(tbl.model, PeriodRangeObservable):
pv.update(start_period=AccountingPeriod.get_default_for_date(dd.today().replace(month=1, day=1)))
pv.update(end_period=AccountingPeriod.get_default_for_date(dd.today().replace(month=12, day=31)))
return tbl.request(master_instance=obj, param_values=pv)
def get_request_queryset(cls, ar):
qs = super(Pupil, cls).get_request_queryset(ar)
pv = ar.param_values
if pv.show_members == dd.YesNo.no:
qs = qs.filter(
Q(member_until__isnull=True) | Q(member_until__lt=dd.today()))
elif pv.show_members == dd.YesNo.yes:
qs = qs.filter(Q(member_until__gte=dd.today()))
for k in ('ckk', 'raviva', 'lfv'):
v = pv['show_' + k]
if v:
qs = qs.filter(**{'is_' + k: v == dd.YesNo.yes})
return qs
def discount_changed(self, ar):
if not self.product:
return
tt = self.voucher.get_trade_type()
catalog_price = tt.get_catalog_price(self.product)
if catalog_price is None:
return
# assert self.vat_class == self.product.vat_class
rule = self.get_vat_rule()
if rule is None:
return
cat_rule = rt.modules.vat.VatRule.get_vat_rule(
get_default_vat_regime, self.get_vat_class(tt),
dd.plugins.countries.get_my_country(), dd.today())
if cat_rule is None:
return
if rule.rate != cat_rule.rate:
catalog_price = remove_vat(catalog_price, cat_rule.rate)
catalog_price = add_vat(catalog_price, cat_rule.rate)
if self.discount is None:
self.unit_price = myround(catalog_price)
else:
self.unit_price = myround(catalog_price *
(HUNDRED - self.discount) / HUNDRED)
self.unit_price_changed(ar)
def get_data_rows(self, ar):
# every row in this table is a "week", i.e. a list of seven datetime.date objects
delta_days = int(ar.rqdata.get('mk', 0)
or 0) if ar.rqdata else ar.master_instance.pk
current_day = dd.today() + timedelta(days=delta_days)
# weeks = [week[0].isocalendar()[1] for week in CALENDAR.monthdatescalendar(current_day.year, current_day.month)]
return CALENDAR.monthdatescalendar(current_day.year, current_day.month)
def quick_search_filter(model, search_text, prefix=''):
"""Overrides :meth:`lino.core.model.Model.quick_search_filter`.
Examples:
123 -> voucher number 123 in current year
123/2014 -> voucher number 123 in 2014
"""
# logger.info(
# "20160612 Voucher.quick_search_filter(%s, %r, %r)",
# model, search_text, prefix)
parts = search_text.split('/')
if len(parts) == 2:
kw = {
prefix + 'number': parts[0],
prefix + 'accounting_period__year': parts[1]}
return models.Q(**kw)
if search_text.isdigit() and not search_text.startswith('0'):
kw = {
prefix + 'number': int(search_text),
prefix + 'accounting_period__year':
FiscalYears.from_date(dd.today())}
return models.Q(**kw)
return super(Voucher, model).quick_search_filter(search_text, prefix)
def discount_changed(self, ar):
if not self.product:
return
tt = self.voucher.get_trade_type()
catalog_price = tt.get_catalog_price(self.product)
if catalog_price is None:
return
# assert self.vat_class == self.product.vat_class
rule = self.get_vat_rule()
if rule is None:
return
cat_rule = rt.modules.vat.VatRule.get_vat_rule(
get_default_vat_regime, self.get_vat_class(tt),
dd.plugins.countries.get_my_country(),
dd.today())
if cat_rule is None:
return
if rule.rate != cat_rule.rate:
catalog_price = remove_vat(catalog_price, cat_rule.rate)
catalog_price = add_vat(catalog_price, cat_rule.rate)
if self.discount is None:
self.unit_price = myround(catalog_price)
else:
self.unit_price = myround(
catalog_price * (HUNDRED - self.discount) / HUNDRED)
self.unit_price_changed(ar)
def full_clean(self, *args, **kwargs):
if self.user_id and not self.time_zone:
# can be removed when all production sites have migrated:
self.time_zone = self.user.time_zone or \
rt.models.about.TimeZones.default
if not settings.SITE.loading_from_dump:
if self.start_time is None:
self.set_datetime('start', timezone.now())
# value = timezone.now()
# if pytz:
# tz = pytz.timezone(self.get_timezone())
# value = value.astimezone(tz)
# self.start_time = value.time()
if self.start_date is None:
self.start_date = dd.today()
# if self.ticket_id is not None and self.faculty_id is None:
# self.faculty = self.ticket.faculty
if self.end_time is not None:
if self.end_date is None:
self.end_date = self.start_date
if self.ticket_id:
self.ticket.on_worked(self)
super(Session, self).full_clean(*args, **kwargs)
def get_request_queryset(self, ar):
# dd.logger.info("20160223 %s", self)
qs = super(Activities, self).get_request_queryset(ar)
if isinstance(qs, list):
return qs
if self._course_area is not None:
qs = qs.filter(line__course_area=self._course_area)
pv = ar.param_values
if pv.topic:
qs = qs.filter(line__topic=pv.topic)
flt = Q(enrolments_until__isnull=True)
flt |= Q(enrolments_until__gte=dd.today())
if pv.can_enroll == dd.YesNo.yes:
qs = qs.filter(flt)
elif pv.can_enroll == dd.YesNo.no:
qs = qs.exclude(flt)
qs = PeriodEvents.active.add_filter(qs, pv)
# if pv.start_date:
# # dd.logger.info("20160512 start_date is %r", pv.start_date)
# qs = PeriodEvents.started.add_filter(qs, pv)
# # qs = qs.filter(start_date__gte=pv.start_date)
# if pv.end_date:
# qs = PeriodEvents.ended.add_filter(qs, pv)
# # qs = qs.filter(end_date__lte=pv.end_date)
# dd.logger.info("20160512 %s", qs.query)
return qs
def run_from_ui(self, ar, **kw):
elem = ar.selected_rows[0]
as_attachment = elem.attach_to_email(ar)
m = rt.modules.outbox.Mail(
user=ar.get_user(),
date=dd.today(),
subject=elem.get_mailable_subject(),
owner=elem)
#~ if as_attachment:
m.body = elem.get_mailable_intro(ar)
m.full_clean()
m.save()
Recipient = rt.modules.outbox.Recipient
for t, p in elem.get_mailable_recipients():
r = Recipient(mail=m, type=t, partner=p)
r.full_clean()
r.save()
if as_attachment:
a = rt.modules.outbox.Attachment(mail=m, owner=elem)
a.save()
js = ar.renderer.instance_handler(ar, m)
kw.update(eval_js=js)
ar.success(**kw)
def discount_changed(self, ar=None):
if not self.product:
return
tt = self.voucher.get_trade_type()
catalog_price = tt.get_catalog_price(self.product)
if catalog_price is None:
return
# assert self.vat_class == self.product.vat_class
rule = self.get_vat_rule(tt)
if rule is None:
return
va = VatAreas.get_for_country()
cat_rule = VatRules.get_vat_rule(va, tt, get_default_vat_regime(),
self.vat_class, dd.today())
if cat_rule is None:
return
if rule.rate != cat_rule.rate:
catalog_price = remove_vat(catalog_price, cat_rule.rate)
catalog_price = add_vat(catalog_price, cat_rule.rate)
if self.discount is None:
self.unit_price = myround(catalog_price)
else:
self.unit_price = myround(catalog_price *
(HUNDRED - self.discount) / HUNDRED)
self.unit_price_changed(ar)
def unused_save(self, *args, **kwargs):
if not settings.SITE.loading_from_dump:
if self.start_date is None:
self.start_date = dd.today()
if self.start_time is None:
self.start_time = timezone.now().time()
super(Session, self).save(*args, **kwargs)
def get_request_queryset(cls, ar, **filter):
return [] # not needed for detail view
days = []
pv = ar.param_values
sd = pv.start_date or dd.today()
ed = pv.end_date or sd
if sd > ed:
return []
# while sd <= ed:
# days.append(sd)
# sd = sd + relativedelta(days=1)
if cls.reverse_sort_order:
step = -1
pk = date2pk(ed)
else:
pk = date2pk(sd)
step = 1
while True: # sd <= ed:
# print(20181229, sd)
d = cls.model(pk, ar)
if d.date > ed or d.date < sd:
return days
days.append(d)
pk += step
def objects():
Comment = rt.models.comments.Comment
User = rt.models.users.User
Comment.auto_touch = False
TXT = Cycler([
styled, table, lorem, short_lorem, breaking, cond_comment, plain1,
plain2
])
for model in rt.models_by_base(Commentable):
OWNERS = Cycler(model.objects.all())
if len(OWNERS) == 0:
return
now = datetime.datetime.combine(dd.today(-30), i2t(822))
if settings.USE_TZ:
now = make_aware(now)
DELTA = datetime.timedelta(minutes=34)
owner = OWNERS.pop()
for i in range(12):
for u in User.objects.all():
ses = BaseRequest(user=u)
# if owner.private:
# txt = "<p>Confidential comment</p>"
# else:
# txt = TXT.pop() # txt = "Hackerish comment"
obj = Comment(user=u, owner=owner, body=TXT.pop())
obj.on_create(ses)
obj.after_ui_create(ses)
obj.before_ui_save(ses)
obj.modified = now
yield obj
now += DELTA
if i % 3:
owner = OWNERS.pop()
def full_clean(self, *args, **kwargs):
if self.user_id and not self.time_zone:
# can be removed when all production sites have migrated:
self.time_zone = self.user.time_zone or \
rt.models.about.TimeZones.default
if not settings.SITE.loading_from_dump:
if self.start_time is None:
self.set_datetime('start', timezone.now())
# value = timezone.now()
# if pytz:
# tz = pytz.timezone(self.get_timezone())
# value = value.astimezone(tz)
# self.start_time = value.time()
if self.start_date is None:
self.start_date = dd.today()
# if self.ticket_id is not None and self.faculty_id is None:
# self.faculty = self.ticket.faculty
if self.end_time is not None:
if self.end_date is None:
self.end_date = self.start_date
if self.ticket_id:
self.ticket.on_worked(self)
super(Session, self).full_clean(*args, **kwargs)
def unused_save(self, *args, **kwargs):
if not settings.SITE.loading_from_dump:
if self.start_date is None:
self.start_date = dd.today()
if self.start_time is None:
self.start_time = timezone.now().time()
super(Session, self).save(*args, **kwargs)
def discount_changed(self, ar=None):
if not self.product:
return
tt = self.voucher.get_trade_type()
catalog_price = tt.get_catalog_price(self.product)
if catalog_price is None:
return
# assert self.vat_class == self.product.vat_class
rule = self.get_vat_rule(tt)
if rule is None:
return
va = VatAreas.get_for_country()
cat_rule = VatRules.get_vat_rule(
va, tt, get_default_vat_regime(), self.get_vat_class(tt),
dd.today())
if cat_rule is None:
return
if rule.rate != cat_rule.rate:
catalog_price = remove_vat(catalog_price, cat_rule.rate)
catalog_price = add_vat(catalog_price, cat_rule.rate)
if self.discount is None:
self.unit_price = myround(catalog_price)
else:
self.unit_price = myround(
catalog_price * (HUNDRED - self.discount) / HUNDRED)
self.unit_price_changed(ar)
def quick_search_filter(model, search_text, prefix=''):
"""Overrides :meth:`lino.core.model.Model.quick_search_filter`.
Examples:
123 -> voucher number 123 in current year
123/2014 -> voucher number 123 in 2014
"""
# logger.info(
# "20160612 Voucher.quick_search_filter(%s, %r, %r)",
# model, search_text, prefix)
parts = search_text.split('/')
if len(parts) == 2:
kw = {
prefix + 'number': parts[0],
prefix + 'accounting_period__year': parts[1]
}
return models.Q(**kw)
if search_text.isdigit() and not search_text.startswith('0'):
kw = {
prefix + 'number':
int(search_text),
prefix + 'accounting_period__year':
FiscalYears.from_date(dd.today())
}
return models.Q(**kw)
return super(Voucher, model).quick_search_filter(search_text, prefix)
def get_report(ar, today=None, weeksback=1, weeksforth=0, datefmt=dd.fds):
if not ar.user.profile.has_required_roles([SiteUser]):
return E.p()
if today is None:
today = dd.today()
start_date = today - ONE_DAY * today.weekday() - weeksback * SEVEN_DAYS
numweeks = weeksback + weeksforth + 1
days = dict()
cd = start_date
numdays = numweeks * 7
for i in range(numdays):
days[cd] = []
cd += ONE_DAY
end_date = cd
for r in REPORTERS:
r(days, ar, start_date, end_date)
headers = [E.th(Weekdays.choices[i][1], **ar.cellattrs) for i in range(7)]
rows = [E.tr(*headers)]
cd = start_date
for week in range(numweeks):
week = []
for weekday in range(7):
chunks = days[cd]
chunks.insert(0, datefmt(cd))
week.append(E.td(*chunks, **ar.cellattrs))
cd += ONE_DAY
rows.append(E.tr(*week))
# print 20150420, rows
return E.table(*rows, **ar.tableattrs)
def get_request_queryset(self, ar, **kwargs):
# dd.logger.info("20160223 %s", self)
qs = super(Activities, self).get_request_queryset(ar, **kwargs)
if isinstance(qs, list):
return qs
if self._course_area is not None:
qs = qs.filter(line__course_area=self._course_area)
pv = ar.param_values
if pv.topic:
qs = qs.filter(line__topic=pv.topic)
flt = Q(enrolments_until__isnull=True)
flt |= Q(enrolments_until__gte=dd.today())
if pv.can_enroll == dd.YesNo.yes:
qs = qs.filter(flt)
elif pv.can_enroll == dd.YesNo.no:
qs = qs.exclude(flt)
qs = PeriodEvents.active.add_filter(qs, pv)
qs = self.model.add_param_filter(
qs, show_exposed=pv.show_exposed)
# if pv.start_date:
# # dd.logger.info("20160512 start_date is %r", pv.start_date)
# qs = PeriodEvents.started.add_filter(qs, pv)
# # qs = qs.filter(start_date__gte=pv.start_date)
# if pv.end_date:
# qs = PeriodEvents.ended.add_filter(qs, pv)
# # qs = qs.filter(end_date__lte=pv.end_date)
# dd.logger.info("20160512 %s", qs.query)
return qs
def get_report(ar, today=None, weeksback=1, weeksforth=0, datefmt=dd.fds):
if not ar.user.user_type.has_required_roles([SiteUser]):
return E.p()
if today is None:
today = dd.today()
start_date = today - ONE_DAY * today.weekday() - weeksback * SEVEN_DAYS
numweeks = weeksback + weeksforth + 1
days = dict()
cd = start_date
numdays = numweeks * 7
for i in range(numdays):
days[cd] = []
cd += ONE_DAY
end_date = cd
for r in REPORTERS:
r(days, ar, start_date, end_date)
headers = [E.th(Weekdays.choices[i][1], **ar.cellattrs) for i in range(7)]
rows = [E.tr(*headers)]
cd = start_date
for week in range(numweeks):
week = []
for weekday in range(7):
chunks = days[cd]
chunks.insert(0, datefmt(cd))
week.append(E.td(*chunks, **ar.cellattrs))
cd += ONE_DAY
rows.append(E.tr(*week))
# print 20150420, rows
return E.table(*rows, **ar.tableattrs)
def func(fld, obj, ar):
# obj is the first day of the week to show
# pv = ar.param_values
today = dd.today()
# if pv is None:
# return
qs = cls.get_calendar_entries(ar, None)
# qs = Event.objects.all()
# qs = Event.calendar_param_filter(qs, pv)
mi = ar.master_instance
if mi is None:
return
target_day = cls.get_row_by_pk(ar, obj.pk + int(wd.value) - 1)
current_month = mi.date.month
nav = mi.planner
# offset = ar.master_instance.pk
# offset = int(ar.rqdata.get('mk', 0) or 0) if ar.rqdata else ar.master_instance.pk
# current_date = dd.today(offset)
# pk = offset + int(wd.value) - 1
# target_day = cls.get_row_by_pk(ar, pk)
# if target_day is None:
# return
# target_day = week[int(wd.value)-1]
qs = qs.filter(start_date=target_day.date)
qs = qs.order_by('start_time')
chunks = [
E.p(e.obj2href(ar, cls.get_calview_div(e, ar))) for e in qs
]
# pk = date2pk(target_day)
# nav.daily_view
# sar = ar.spawn_request(actor=actor, param_values=ar.param_values)
# rnd = settings.SITE.kernel.default_renderer
# def func(day, text):
# # day.navigation_mode = actor.navigation_mode
# return rnd.ar2button(sar, day, text, style="", icon_name=None, title=str(day))
#
daily = nav.daily_button_func(ar)
daily_link = daily(target_day, str(target_day.date.day))
if target_day.date == today:
daily_link = E.b(daily_link)
# header_items = [daily_link]
# header_items = Event.gen_insert_button(cls, header_items, ar, target_day)
header_items = [daily_link]
btn = ar.gen_insert_button(Events, start_date=target_day.date)
if btn:
header_items.append(btn)
header = E.div(*header_items, align="center", CLASS="header")
return E.table(
E.tr(E.td(*[header, E.div(*join_elems(chunks))])),
CLASS="fixed-table cal-month-cell {} {} {}".format(
"current-month" if current_month == target_day.date.month
else "other-month",
"current-day" if target_day.date == today else "",
"cal-in-past" if target_day.date < today else ""))
def param_defaults(self, ar, **kw):
mi = ar.master_instance
kw = super(TicketsBySite, self).param_defaults(ar, **kw)
kw.update(interesting_for=mi.partner)
kw.update(end_date=dd.today())
kw.update(observed_event=TicketEvents.todo)
return kw
def __init__(self, enr, max_date=None):
self.enrolment = enr
self.max_date = max_date or dd.today()
fee = enr.fee
# fee = enr.course.fee or enr.course.line.fee
if not fee:
return
if fee.min_asset is None:
self.invoiceable_fee = fee
return
# history = []
state_field = dd.plugins.invoicing.voucher_model._meta.get_field(
'state')
vstates = [s for s in state_field.choicelist.objects()
if not s.editable]
# self.invoicings = enr.get_invoicings(voucher__state__in=vstates)
self.invoicings = enr.invoicings.filter(voucher__state__in=vstates)
if enr.free_events:
self.invoiced_events += enr.free_events
for obj in self.invoicings:
if obj.product is not None:
self.invoiced_qty += obj.qty
if obj.product.number_of_events:
self.invoiced_events += int(
obj.qty * obj.product.number_of_events)
# history.append("".format())
# print("20160414", self.invoicings, self.invoiced_qty)
start_date = enr.start_date or enr.course.start_date
# print("20160414 a", fee.number_of_events)
if fee.number_of_events:
# print("20160414 b", start_date)
if not start_date:
return
qs = enr.course.events_by_course.filter(
start_date__gte=start_date,
start_date__lte=self.max_date,
state=rt.models.cal.EventStates.took_place)
if enr.end_date:
qs = qs.filter(start_date__lte=enr.end_date)
# Note that this query works only on the start_date of
# events. If we want to filter on end_date, then don't
# forget this field can be empty.
self.used_events = qs.order_by('start_date')
# print("20160414 c", self.used_events)
# used_events = qs.count()
# paid_events = invoiced_qty * fee.number_of_events
asset = self.invoiced_events - self.used_events.count()
else:
asset = self.invoiced_qty
# dd.logger.info("20160223 %s %s %s", enr, asset, fee.min_asset)
if self.enrolment.end_date \
and self.enrolment.end_date < self.max_date and asset >= 0:
# ticket #1040 : a participant who declared to stop before
# their asset got negative should not get any invoice for
# a next asset
return
if asset < fee.min_asset:
self.invoiceable_fee = fee
def get_change_observers(self):
for u in settings.SITE.user_model.objects.filter(
coaching_supervisor=True):
yield u
today = dd.today()
period = (today, today)
for obj in self.get_coachings(period):
yield obj.user
def get_request_queryset(cls, ar, **filter):
home = cls.get_row_by_pk(ar, 0)
ni = cls.get_navinfo(ar, home)
pv = ar.param_values
date = pv.start_date or dd.today(ni['first'])
last = pv.end_date or dd.today(ni['last'])
if cls.navigation_mode == "day":
step = lambda x: x + timedelta(days=1)
elif cls.navigation_mode == "week":
step = lambda x: x + timedelta(days=7)
else:
step = lambda x: DurationUnits.months.add_duration(x, 1)
while date <= last:
yield cls.get_row_by_pk(ar, date2pk(date))
date = step(date)
def ok(ar):
# subject = _("{0} state set to former")
# obj.emit_system_note(ar, obj, subject, body)
for co in qs:
# co.state = CoachingStates.ended
co.end_date = dd.today()
co.save()
doit(ar)
def __init__(self, offset=0, ar=None, navigation_mode=None, planner=None):
self.date = dd.today(offset)
self.pk = offset
self.ar = ar
self.navigation_mode = navigation_mode
if planner is not None:
assert isinstance(planner, Planner)
self.planner = planner
def working_objects():
# was previously in working
Company = rt.models.contacts.Company
# Vote = rt.models.votes.Vote
SessionType = rt.models.working.SessionType
Session = rt.models.working.Session
Ticket = rt.models.tickets.Ticket
User = rt.models.users.User
UserTypes = rt.models.users.UserTypes
# devs = (UserTypes.developer, UserTypes.senior)
devs = [p for p in UserTypes.items()
if p.has_required_roles([Worker])
and not p.has_required_roles([SiteAdmin])]
workers = User.objects.filter(user_type__in=devs)
WORKERS = Cycler(workers)
TYPES = Cycler(SessionType.objects.all())
# TICKETS = Cycler(Ticket.objects.all())
DURATIONS = Cycler([12, 138, 90, 10, 122, 209, 37, 62, 179, 233, 5])
# every fourth ticket is unassigned and thus listed in
# PublicTickets
# for i, t in enumerate(Ticket.objects.exclude(private=True)):
for i, t in enumerate(Ticket.objects.all()):
if i % 4:
t.assigned_to = WORKERS.pop()
yield t
for u in workers:
# VOTES = Cycler(Vote.objects.filter(user=u))
# TICKETS = Cycler(Ticket.objects.filter(assigned_to=u))
TICKETS = Cycler(Ticket.objects.filter())
# if len(VOTES) == 0:
# continue
for offset in (0, -1, -3, -4):
date = dd.demo_date(offset)
worked = Duration()
ts = datetime.datetime.combine(date, datetime.time(9, 0, 0))
for i in range(7):
obj = Session(
ticket=TICKETS.pop(),
session_type=TYPES.pop(), user=u)
obj.set_datetime('start', ts)
d = DURATIONS.pop()
worked += d
if offset < 0:
ts = DurationUnits.minutes.add_duration(ts, d)
obj.set_datetime('end', ts)
yield obj
if offset == 0 or worked > 8:
break
ServiceReport = rt.models.working.ServiceReport
welket = Company.objects.get(name="welket")
yield ServiceReport(
start_date=dd.today(-90), interesting_for=welket)
def working_objects():
# was previously in working
Company = rt.models.contacts.Company
# Vote = rt.models.votes.Vote
SessionType = rt.models.working.SessionType
Session = rt.models.working.Session
Ticket = rt.models.tickets.Ticket
User = rt.models.users.User
UserTypes = rt.models.users.UserTypes
# devs = (UserTypes.developer, UserTypes.senior)
devs = [
p for p in UserTypes.items() if p.has_required_roles([Worker])
and not p.has_required_roles([SiteAdmin])
]
workers = User.objects.filter(user_type__in=devs)
WORKERS = Cycler(workers)
TYPES = Cycler(SessionType.objects.all())
# TICKETS = Cycler(Ticket.objects.all())
DURATIONS = Cycler([12, 138, 90, 10, 122, 209, 37, 62, 179, 233, 5])
# every fourth ticket is unassigned and thus listed in
# PublicTickets
# for i, t in enumerate(Ticket.objects.exclude(private=True)):
for i, t in enumerate(Ticket.objects.all()):
if i % 4:
t.assigned_to = WORKERS.pop()
yield t
for u in workers:
# VOTES = Cycler(Vote.objects.filter(user=u))
# TICKETS = Cycler(Ticket.objects.filter(assigned_to=u))
TICKETS = Cycler(Ticket.objects.filter())
# if len(VOTES) == 0:
# continue
for offset in (0, -1, -3, -4):
date = dd.demo_date(offset)
worked = Duration()
ts = datetime.datetime.combine(date, datetime.time(9, 0, 0))
for i in range(7):
obj = Session(ticket=TICKETS.pop(),
session_type=TYPES.pop(),
user=u)
obj.set_datetime('start', ts)
d = DURATIONS.pop()
worked += d
if offset < 0:
ts = DurationUnits.minutes.add_duration(ts, d)
obj.set_datetime('end', ts)
yield obj
if offset == 0 or worked > 8:
break
ServiceReport = rt.models.working.ServiceReport
welket = Company.objects.get(name="welket")
yield ServiceReport(start_date=dd.today(-90), interesting_for=welket)
def param_defaults(self, ar, **kw):
kw = super(MyEntries, self).param_defaults(ar, **kw)
kw.update(user=ar.get_user())
kw.update(show_appointments=dd.YesNo.yes)
# kw.update(assigned_to=ar.get_user())
# logger.info("20130807 %s %s",self,kw)
kw.update(start_date=dd.today())
# kw.update(end_date=settings.SITE.today(14))
return kw
def myhandler(sender=None, watcher=None, request=None, **kwargs):
obj = watcher.watched
if obj.project is None:
return
recipients = []
period = (dd.today(), dd.today())
for c in obj.project.get_coachings(period, user__email__gt=''):
if c.user != request.user:
recipients.append(c.user.email)
if len(recipients) == 0:
return
context = dict(obj=obj, request=request)
subject = "Modification dans {obj}".format(**context)
tpl = rt.get_template('notes/note_updated.eml')
body = tpl.render(**context)
sender = request.user.email or settings.SERVER_EMAIL
# dd.logger.info("20150505 %s", recipients)
rt.send_email(subject, sender, body, recipients)
def param_defaults(self, ar, **kw):
kw = super(MyEvents, self).param_defaults(ar, **kw)
kw.update(user=ar.get_user())
kw.update(show_appointments=dd.YesNo.yes)
#~ kw.update(assigned_to=ar.get_user())
#~ logger.info("20130807 %s %s",self,kw)
kw.update(start_date=dd.today())
# kw.update(end_date=settings.SITE.today(14))
return kw
def func(fld, obj, ar):
# obj is a Plannable instance
qs = cls.get_calendar_entries(ar, obj)
delta_days = int(ar.rqdata.get('mk', 0)
or 0) if ar.rqdata else ar.master_instance.pk
# current_day = dd.today() + timedelta(days=delta_days)
delta_days += int(week_day.value) - dd.today().weekday() - 1
today = dd.today(delta_days)
# current_week_day = current_day + \
# timedelta(days=int(week_day.value) - current_day.weekday() - 1)
qs = qs.filter(start_date=today)
qs = qs.order_by('start_time')
if obj is cls.model.HEADER_ROW:
chunks = obj.get_header_chunks(ar, qs, today)
else:
chunks = obj.get_weekly_chunks(ar, qs, today)
return E.table(E.tr(E.td(E.div(*join_elems(chunks)))),
CLASS="fixed-table")
def start_plan(cls, user, **options):
try:
plan = cls.objects.get(user=user)
changed = False
for k, v in options.items():
if getattr(plan, k) != v:
changed = True
setattr(plan, k, v)
if 'today' not in options:
if plan.today != dd.today():
plan.today = dd.today()
changed = True
if changed:
plan.items.all().delete()
except cls.DoesNotExist:
plan = cls(user=user, **options)
plan.save()
return plan
def objects():
now = datetime.datetime.combine(dd.today(), i2t(548))
if settings.USE_TZ:
now = make_aware(now)
mt = rt.models.notify.MessageTypes.system
for u in rt.models.users.User.objects.all():
with translation.override(u.language):
yield rt.models.notify.Message.create_message(
u, body=_("The database has been initialized."),
created=now, message_type=mt, sent=now)
def get_checkdata_problems(self, obj, fix=False):
if obj.client_state == ClientStates.coached:
if obj.is_obsolete:
yield (False, _("Both coached and obsolete."))
if obj.client_state != ClientStates.coached:
today = dd.today()
period = (today, today)
qs = obj.get_coachings(period)
if qs.count():
yield (False, _("Not coached, but with active coachings."))
def course_choices(cls, course_area, request_date):
dd.logger.info("20160714 course_choices %s", course_area)
if request_date is None:
request_date = dd.today()
flt = Q(enrolments_until__isnull=True)
flt |= Q(enrolments_until__gte=request_date)
qs = rt.models.courses.Course.objects.filter(flt)
if course_area:
qs = qs.filter(line__course_area=course_area)
return qs
def course_choices(cls, course_area, request_date):
dd.logger.info("20160714 course_choices %s", course_area)
if request_date is None:
request_date = dd.today()
flt = Q(enrolments_until__isnull=True)
flt |= Q(enrolments_until__gte=request_date)
qs = rt.models.courses.Course.objects.filter(flt)
if course_area:
qs = qs.filter(line__course_area=course_area)
return qs
def get_places_sum(self, today=None, **flt):
Enrolment = rt.models.courses.Enrolment
PeriodEvents = rt.modules.system.PeriodEvents
qs = Enrolment.objects.filter(course=self, **flt)
rng = DatePeriodValue(today or dd.today(), None)
qs = PeriodEvents.active.add_filter(qs, rng)
# logger.info("20160502 %s", qs.query)
res = qs.aggregate(models.Sum('places'))
# logger.info("20140819 %s", res)
return res['places__sum'] or 0
def get_signers(self, today=None):
if today is None:
today = dd.today()
qs = rt.models.contacts.Role.objects.filter(
company=self).order_by('type')
qs = qs.filter(type__can_sign=True)
if with_roles_history:
qs = qs.filter(Q(start_date__isnull) | Q(start_date__lte=today))
qs = qs.filter(Q(end_date__isnull) | Q(end_date__gte=today))
return qs
def run_start_plan(cls, user, **options):
try:
plan = cls.objects.get(user=user)
changed = False
for k, v in options.items():
if getattr(plan, k) != v:
changed = True
setattr(plan, k, v)
if 'today' not in options:
if plan.today != dd.today():
plan.today = dd.today()
changed = True
if changed:
plan.reset_plan()
except cls.DoesNotExist:
plan = cls(user=user, **options)
plan.full_clean()
plan.save()
return plan
def get_places_sum(self, today=None, **flt):
Enrolment = rt.models.courses.Enrolment
PeriodEvents = rt.modules.system.PeriodEvents
qs = Enrolment.objects.filter(course=self, **flt)
rng = DatePeriodValue(today or dd.today(), None)
qs = PeriodEvents.active.add_filter(qs, rng)
# logger.info("20160502 %s", qs.query)
res = qs.aggregate(models.Sum('places'))
# logger.info("20140819 %s", res)
return res['places__sum'] or 0
def get_plausibility_problems(self, obj, fix=False):
if obj.client_state == ClientStates.coached:
if obj.is_obsolete:
yield (False, _("Both coached and obsolete."))
if obj.client_state != ClientStates.coached:
today = dd.today()
period = (today, today)
qs = obj.get_coachings(period)
if qs.count():
yield (False, _("Not coached, but with active coachings."))
def ok(ar):
for rec in recs:
p = Posting(
user=ar.user, owner=elem,
partner=rec,
date=dd.today(),
state=PostingStates.ready)
p.full_clean()
p.save()
kw.update(refresh=True)
ar.success(**kw)
def about_html(cls):
body = []
body.append(settings.SITE.welcome_html())
if settings.SITE.languages:
body.append(
E.p(
str(_("Languages")) + ": " + ', '.join(
[lng.django_code for lng in settings.SITE.languages])))
# print "20121112 startup_time", settings.SITE.startup_time.date()
def dtfmt(dt):
if isinstance(dt, float):
dt = datetime.datetime.fromtimestamp(dt)
# raise ValueError("Expected float, go %r" % dt)
return str(_("%(date)s at %(time)s")) % dict(
date=dd.fds(dt.date()), time=settings.SITE.strftime(dt.time()))
value = settings.SITE.startup_time
label = _("Server uptime")
body.append(
E.p(str(label), ' : ', E.b(dtfmt(value)),
' ({})'.format(settings.TIME_ZONE)))
if settings.SITE.is_demo_site:
s = str(_("This is a Lino demo site."))
body.append(E.p(s))
if settings.SITE.the_demo_date:
s = _("We are running with simulated date set to {0}.").format(
dd.fdf(settings.SITE.the_demo_date))
body.append(E.p(s))
body.append(E.p(str(_("Source timestamps:"))))
items = []
times = []
packages = set(['lino', 'django', 'atelier'])
for p in settings.SITE.installed_plugins:
packages.add(p.app_name.split('.')[0])
for src in packages:
label = src
value = codetime('%s.*' % src)
if value is not None:
times.append((label, value))
times.sort(key=lambda x: x[1])
for label, value in times:
items.append(E.li(str(label), ' : ', E.b(dtfmt(value))))
body.append(E.ul(*items))
body.append(
E.p("{} : {}".format(
_("Complexity factors"),
', '.join(analyzer.get_complexity_factors(dd.today())))))
return rt.html_text(E.div(*body))
