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 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_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 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 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_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))