def setup_vat_workflow(sender=None, **kw):
if False:
VoucherStates.registered.add_transition(
_("Register"), required_states='draft', icon_name='accept')
VoucherStates.draft.add_transition(
_("Deregister"), required_states="registered", icon_name='pencil')
elif False:
VoucherStates.registered.add_transition(
# unichr(0x25c6), # ◆
_("Register"),
help_text=_("Register"),
required_states='draft')
VoucherStates.draft.add_transition(
_("Deregister"),
# unichr(0x25c7), # ◇
help_text=_("Deregister"),
required_roles=dd.login_required(LedgerStaff),
required_states="registered")
else:
VoucherStates.registered.add_transition(
# unichr(0x25c6), # ◆
# _("Register"),
# help_text=_("Register"),
required_states='draft')
VoucherStates.draft.add_transition(
# unichr(0x25c7), # ◇
# _("Deregister"),
# help_text=_("Deregister"),
required_roles=dd.login_required(LedgerStaff),
required_states="registered cancelled")
VoucherStates.cancelled.add_transition(
# unichr(0x25c6), # ◆
# _("Cancel"),
# help_text=_("Cancel"),
required_states='draft')
class AllVouchers(Vouchers):
required_roles = dd.login_required(LedgerStaff)
class AccountingPeriods(dd.Table):
required_roles = dd.login_required(LedgerStaff)
model = 'ledger.AccountingPeriod'
order_by = ["ref", "start_date", "year"]
column_names = "ref start_date end_date year state remark *"
class TakeAuthorship(dd.Action):
"""
You declare to become the fully responsible user for this database
object.
Accordingly, this action is available only when you are not
already fully responsible. You are fully responsible when (1)
:attr:`Assignable.user` is set to *you* **and** (2)
:attr:`Event.assigned_to` is *not empty*.
Basically anybody can take any event, even if it is not assigned
to them.
New since 20160814 : I think that the Take action has never been
really used. The original use case is when a user creates an
apointment for their colleague: that colleague goes to assigned_to
and is invited to "take" the appointment which has been agreed for
him.
"""
label = _("Take")
show_in_workflow = True
show_in_bbar = False
# This action modifies the object, but we don't tell Lino about it
# because we want that even non-manager users can run it on
# objects authored by others.
# readonly = False
required_roles = dd.login_required(AuthorshipTaker)
button_text = u"\u2691"
# def get_action_permission(self, ar, obj, state):
# # new since 20160814
# if obj.get_author() == ar.get_user():
# return False
# # if obj.assigned_to != ar.get_user():
# # return False
# # if obj.get_author() == ar.get_user():
# # if obj.assigned_to is None:
# # return False
# # elif obj.assigned_to != ar.get_user():
# # return False
# return super(TakeAuthorship,
# self).get_action_permission(ar, obj, state)
def run_from_ui(self, ar, **kw):
obj = ar.selected_rows[0]
# obj is an Assignable
def ok(ar):
obj.set_author(ar.get_user())
# obj.user = ar.get_user()
obj.assigned_to = None
#~ kw = super(TakeAuthorship,self).run(obj,ar,**kw)
obj.save()
ar.set_response(refresh=True)
ar.confirm(ok,
_("You take responsibility for {}.").format(obj),
_("Are you sure?"))
class DailyPlannerRows(dd.Table):
# used for configuring the planner rows
model = 'calview.DailyPlannerRow'
column_names = "seqno designation start_time end_time"
required_roles = dd.login_required(OfficeStaff)
class ExperiencesByFunction(Experiences):
required_roles = dd.login_required(CareerUser)
master_key = 'function'
order_by = ["start_date"]
class StudiesByPerson(HistoryByPerson, Studies):
required_roles = dd.login_required(CareerUser)
column_names = 'type content start_date end_date duration_text school country \
state education_level *'
insert_layout = """
class StudiesByLevel(Studies):
required_roles = dd.login_required(CareerUser)
master_key = 'education_level'
class AllExcerpts(Excerpts):
required_roles = dd.login_required(ExcerptsStaff)
column_names = ("id excerpt_type owner project "
"company language build_time *")
class Excerpt(TypedPrintable, UserAuthored, Controllable,
mixins.ProjectRelated, ContactRelated, Mailable, Postable):
manager_roles_required = dd.login_required(OfficeStaff)
# manager_level_field = 'office_level'
allow_cascaded_delete = "owner"
class Meta:
app_label = 'excerpts'
abstract = dd.is_abstract_model(__name__, 'Excerpt')
verbose_name = _("Excerpt")
verbose_name_plural = _("Excerpts")
excerpt_type = dd.ForeignKey('excerpts.ExcerptType')
body_template_content = BodyTemplateContentField(_("Body template"))
language = dd.LanguageField()
# if dd.is_installed('outbox'):
# mails_by_owner = dd.ShowSlaveTable('outbox.MailsByController')
def get_body_template(self):
"""Return the body template to use for this excerpt."""
owner = self.owner
# owner is None e.g. if is a broken GFK
if owner is not None:
assert self.__class__ is not owner.__class__
tplname = owner.get_body_template()
if tplname:
return tplname
return self.excerpt_type.body_template
def get_body_template_filename(self):
tplname = self.get_body_template()
if not tplname:
return None
mc = self.excerpt_type.content_type.model_class()
tplgroup = mc.get_template_group()
return rt.find_config_file(tplname, tplgroup)
def get_body_template_name(self):
tplname = self.get_body_template()
if not tplname:
return None
mc = self.excerpt_type.content_type.model_class()
tplgroup = mc.get_template_group()
return tplgroup + '/' + tplname
def disabled_fields(self, ar):
rv = super(Excerpt, self).disabled_fields(ar)
rv = rv | set(['excerpt_type', 'project'])
if self.build_time:
rv |= self.PRINTABLE_FIELDS
return rv
def __str__(self):
if self.build_time:
return str(naturaltime(self.build_time))
# return _("%(owner)s (printed %(time)s)") % dict(
# owner=self.owner, time=naturaltime(self.build_time))
return gettext("Unprinted %s #%s") % (self._meta.verbose_name, self.pk)
def get_mailable_type(self):
return self.excerpt_type
def get_mailable_subject(self):
return str(self.owner) # .get_mailable_subject()
def get_template_groups(self):
ptype = self.get_printable_type()
if ptype is None:
raise Exception("20140520 Must have excerpt_type.")
grp = ptype.content_type.model_class().get_template_group()
return [grp, u'excerpts']
def filename_root(self):
# mainly because otherwise we would need to move files around on
# existing sites
et = self.excerpt_type
if et is None or not et.certifying:
return super(Excerpt, self).filename_root()
assert et.certifying
o = self.owner
if o is None:
return super(Excerpt, self).filename_root()
name = o._meta.app_label + '.' + o.__class__.__name__
if not et.primary:
name += '.' + str(et.pk)
name += '-' + str(o.pk)
return name
def get_print_templates(self, bm, action):
"""When printing a certifying excerpt, the controlling database object
gets a chance to decide which template to use.
Overrides
:meth:`lino.modlib.printing.Printable.get_print_templates`.
"""
et = self.excerpt_type
if et is not None and et.certifying:
if isinstance(self.owner, Certifiable):
tpls = self.owner.get_excerpt_templates(bm)
if tpls is not None:
# print("20190506 Excerpt.get_print_templates()", tpls)
return tpls
return super(Excerpt, self).get_print_templates(bm, action)
# ptype = self.get_printable_type()
# # raise Exception("20150710 %s" % self.owner)
# if ptype is not None and ptype.template:
# return [ptype.template]
# # return [bm.get_default_template(self)]
# return [dd.plugins.excerpts.get_default_template(bm, self.owner)]
# def get_recipient(self):
# rec = super(Excerpt, self).get_recipient()
# if rec is None and hasattr(self.owner, 'recipient'):
# return self.owner.recipient
# return rec
# recipient = property(get_recipient)
def get_printable_type(self):
return self.excerpt_type
def get_print_language(self):
return self.language
@dd.chooser()
def excerpt_type_choices(cls, owner):
# logger.info("20150702 %s", owner)
qs = rt.models.excerpts.ExcerptType.objects.order_by('name')
if owner is None:
# e.g. when choosing on the *parameter* field
# return qs.filter(content_type__isnull=True)
return qs.filter()
ct = ContentType.objects.get_for_model(owner.__class__)
return qs.filter(content_type=ct)
@property
def date(self):
"Used in templates"
if self.build_time:
return self.build_time.date()
return dd.today()
@property
def time(self):
"Used in templates"
if self.build_time:
return self.build_time.time()
return timezone.now()
@dd.virtualfield(dd.HtmlBox(_("Preview")))
def preview(self, ar):
if ar is None or self.owner is None:
# body templates should not need to test whether obj is defined
return ''
lang = self.get_print_language() or \
settings.SITE.DEFAULT_LANGUAGE.django_code
with translation.override(lang):
ctx = self.get_printable_context(ar)
return ar.html_text(ctx['body'])
def before_printable_build(self, bm):
super(Excerpt, self).before_printable_build(bm)
if self.owner is not None:
return self.owner.before_printable_build(bm)
def get_printable_context(self, ar=None, **kw):
"""Adds a series of names to the context used when rendering printable
documents. Extends
:meth:`lino.core.model.Model.get_printable_context`.
"""
if self.owner is not None:
kw = self.owner.get_printable_context(ar, **kw)
kw = super(Excerpt, self).get_printable_context(**kw)
kw.update(obj=self.owner)
kw.update(excerpt=self)
body = ''
# logger.info("20180114 get_printable_context() %s", self)
if self.excerpt_type_id is not None:
etype = self.excerpt_type
if etype.backward_compat:
kw.update(this=self.owner)
tplname = self.get_body_template_name()
# logger.info("20180114 tplname is %s -",
# tplname)
if tplname and ar is not None:
body = settings.SITE.plugins.jinja.render_jinja(
ar, tplname, kw)
# env = settings.SITE.plugins.jinja.renderer.jinja_env
# template = env.get_template(tplname)
# # logger.info("body template %s (%s)", tplname, template)
# body = ar.render_jinja(template, **kw)
# logger.info("20160311 body template %s -> %s",
# tplname, body)
kw.update(body=body)
return kw
@classmethod
def on_analyze(cls, site):
cls.PRINTABLE_FIELDS = dd.fields_list(
cls, "project excerpt_type "
"body_template_content "
"company contact_person language "
"user build_method")
super(Excerpt, cls).on_analyze(site)
class AreaUploads(Uploads):
required_roles = dd.login_required((OfficeUser, OfficeOperator))
stay_in_grid = True
# _upload_area = UploadAreas.general
display_mode = 'summary'
# 20180119
# @classmethod
# def get_known_values(self):
# return dict(upload_area=self._upload_area)
# @classmethod
# def get_actor_label(self):
# if self._upload_area is not None:
# return self._upload_area.text
# return self._label or self.__name__
@classmethod
def format_row_in_slave_summary(self, ar, obj):
"""almost as unicode, but without the type
"""
return obj.description or filename_leaf(obj.file.name) \
or str(obj.id)
@classmethod
def get_table_summary(self, obj, ar):
if obj is None:
return
UploadType = rt.models.uploads.UploadType
# Upload = rt.models.uploads.Upload
elems = []
types = []
perm = ar.get_user().user_type.has_required_roles(self.required_roles)
qs = UploadType.objects.all()
if isinstance(obj, UploadController):
area = obj.get_upload_area()
if area is not None:
qs = qs.filter(upload_area=area)
else:
raise Exception("A {} is not an UploadController!".format(
obj.__class__))
for ut in qs:
sar = ar.spawn(
self, master_instance=obj,
known_values=dict(type_id=ut.id))
# logger.info("20140430 %s", sar.data_iterator.query)
files = []
for m in sar:
text = self.format_row_in_slave_summary(ar, m)
if text is None:
continue
edit = ar.obj2html(
m, text, # _("Edit"),
# icon_name='application_form',
title=_("Edit metadata of the uploaded file."))
if m.file.name:
show = ar.renderer.href_button(
settings.SITE.build_media_url(m.file.name),
# u"\u21A7", # DOWNWARDS ARROW FROM BAR (↧)
# u"\u21E8",
u"\u21f2", # SOUTH EAST ARROW TO CORNER (⇲)
style="text-decoration:none;",
# _(" [show]"), # fmt(m),
target='_blank',
# icon_name=settings.SITE.build_static_url(
# 'images/xsite/link'),
# icon_name='page_go',
# style="vertical-align:-30%;",
title=_("Open the uploaded file in a new browser window"))
# logger.info("20140430 %s", tostring(e))
files.append(E.span(edit, ' ', show))
else:
files.append(edit)
if perm and ut.wanted \
and (ut.max_number < 0 or len(files) < ut.max_number):
btn = self.insert_action.request_from(
sar, master_instance=obj,
known_values=dict(type_id=ut.id)).ar2button()
if btn is not None:
files.append(btn)
if len(files) > 0:
chunks = (str(ut), ': ') + tuple(join_elems(files, ', '))
types.append(chunks)
# logger.info("20140430 %s", [tostring(e) for e in types])
# elems += [str(ar.bound_action.action.__class__), " "]
if ar.bound_action.action.window_type == "d":
if len(types) == 0:
elems.append(E.ul(E.li(str(ar.no_data_text))))
else:
elems.append(E.ul(*[E.li(*chunks) for chunks in types]))
else:
if len(types) == 0:
elems.append(str(ar.no_data_text))
elems.append(" / ")
else:
for chunks in types:
elems.extend(chunks)
elems.append(" / ")
elems.append(obj.show_uploads.as_button_elem(ar))
# ba = self.find_action_by_name("show_uploads")
return E.div(*elems)
class MyUploads(My, Uploads):
required_roles = dd.login_required((OfficeUser, OfficeOperator))
column_names = "file description user owner *"
class AllUploads(Uploads):
use_as_default_table = False
required_roles = dd.login_required(OfficeStaff)
class Subscriptions(dd.Table):
required_roles = dd.login_required(OfficeStaff)
model = 'cal.Subscription'
order_by = ['calendar__name']
class AllEntries(Events):
required_roles = dd.login_required(Explorer)
params_layout = """
class Events(dd.Table):
model = 'cal.Event'
# required_roles = dd.login_required((OfficeUser, CalendarGuest))
required_roles = dd.login_required(OfficeStaff)
column_names = 'when_text:20 user summary event_type id *'
# hidden_columns = """
# priority access_class transparent
# owner created modified
# description
# sequence auto_type build_time owner owner_id owner_type
# end_date end_time
# """
order_by = ["start_date", "start_time", "id"]
detail_layout = 'cal.EventDetail'
insert_layout = 'cal.EventInsert'
detail_html_template = "cal/Event/detail.html"
params_panel_hidden = True
# ~ next = NextDateAction() # doesn't yet work. 20121203
# fixed_states = set(EntryStates.filter(fixed=True))
# pending_states = set([es for es in EntryStates if not es.fixed])
# pending_states = set(EntryStates.filter(fixed=False))
params_layout = "user event_type room project presence_guest"
# 20190620
# @classmethod
# def setup_parameters(cls, params):
# cls.params_layout = rt.models.cal.Event.params_layout
# params = rt.models.cal.Event.setup_parameters(params)
# return super(Events, cls).setup_parameters(params)
@classmethod
def get_table_summary(cls, obj, ar):
# print("20181121 get_table_summary", cls)
return get_calendar_summary(cls, obj, ar)
# @classmethod
# def get_request_queryset(self, ar, **kwargs):
# # print("20181121a get_request_queryset", self)
# qs = super(Events, self).get_request_queryset(ar, **kwargs)
# pv = ar.param_values
# return rt.models.cal.Event.calendar_param_filter(qs, pv)
@classmethod
def get_title_tags(self, ar):
for t in super(Events, self).get_title_tags(ar):
yield t
pv = ar.param_values
if pv.start_date or pv.end_date:
yield daterange_text(pv.start_date, pv.end_date)
if pv.state:
yield str(pv.state)
if pv.event_type:
yield str(pv.event_type)
# if pv.user:
# yield str(pv.user)
if pv.room:
yield str(pv.room)
if settings.SITE.project_model is not None and pv.project:
yield str(pv.project)
if pv.assigned_to:
yield str(self.parameters['assigned_to'].verbose_name) \
+ ' ' + str(pv.assigned_to)
@classmethod
def apply_cell_format(self, ar, row, col, recno, td):
"""
Enhance today by making background color a bit darker.
"""
if row.start_date == settings.SITE.today():
td.set('bgcolor', "#bbbbbb")
@classmethod
def param_defaults(self, ar, **kw):
kw = super(Events, self).param_defaults(ar, **kw)
kw.update(start_date=settings.SITE.site_config.hide_events_before)
return kw
class StudiesByCountry(Studies):
required_roles = dd.login_required(CareerUser)
master_key = 'country'
class CivilStates(dd.ChoiceList):
required_roles = dd.login_required(dd.SiteStaff)
verbose_name = _("Civil state")
verbose_name_plural = _("Civil states")
class StudiesByType(Studies):
required_roles = dd.login_required(CareerUser)
master_key = 'type'
column_names = 'school person content start_date end_date \
class AllStars(Stars):
required_roles = dd.login_required(dd.SiteStaff)
class ExperiencesBySector(Experiences):
required_roles = dd.login_required(CareerUser)
master_key = 'sector'
order_by = ["start_date"]
class TaskStates(dd.Workflow):
verbose_name_plural = _("Task states")
required_roles = dd.login_required(dd.SiteStaff)
app_label = 'cal'
class AllLanguageKnowledges(LanguageKnowledges):
required_roles = dd.login_required(CareerStaff)
class SiteSearch(dd.VirtualTable):
required_roles = dd.login_required(SiteSearcher)
label = _("Search")
column_names = "description matches"
# _site_search_tables = []
# @classmethod
# def register(cls, t):
# assert t not in cls._site_search_tables
# cls._site_search_tables.append(t)
# disabled_models = set()
# @classmethod
# def disable_model(cls, m):
# cls.disabled_models.add(m)
@classmethod
def get_data_rows(cls, ar):
if ar.quick_search is None or len(ar.quick_search) < 2:
return
user_type = ar.get_user().user_type
# for model in rt.models_by_base(Searchable):
for model in get_models():
# if model not in cls.disabled_models:
if model.show_in_site_search:
t = model.get_default_table()
# for t in cls._site_search_tables:
if not t.get_view_permission(user_type):
continue
sar = t.request(
parent=ar, quick_search=ar.quick_search)
for obj in sar:
yield obj
@dd.displayfield(_("Description"))
def description(self, obj, ar):
elems = []
elems.append(ar.obj2html(obj))
# elems.append(u" ({})".format(obj._meta.verbose_name))
elems += (" (", str(obj._meta.verbose_name), ")")
return E.p(*elems)
@dd.displayfield(_("Matches"))
def matches(self, obj, ar):
def bold(mo):
return "<b>{}</b>".format(mo.group(0))
matches = {}
for w in ar.quick_search.split():
char_search = True
lst = None
if w.startswith("#") and w[1:].isdigit():
w = w[1:]
char_search = False
if w.isdigit():
i = int(w)
for de in obj.quick_search_fields_digit:
if de.value_from_object(obj) == i:
# if getattr(obj, fn) == int(w):
matches.setdefault(de, w)
if char_search:
for de in obj.quick_search_fields:
s = matches.get(de, None) or str(de.value_from_object(obj))
r, count = re.subn(w, bold, s, flags=re.IGNORECASE)
if count:
matches[de] = r
chunks = []
for de in obj.quick_search_fields + obj.quick_search_fields_digit:
lst = matches.get(de, None)
if lst:
chunks.append(de.name + ":" + lst)
from lxml import etree
s = ', '.join(chunks)
s = "<span>" + s + "</span>"
try:
return etree.fromstring(s)
except Exception as e:
raise Exception("{} : {}".format(e, s))
class Authored(Printable):
class Meta(object):
abstract = True
# author_field_name = None
manager_roles_required = dd.login_required(SiteStaff)
def get_author(self):
return self.user
# return getattr(self, self.author_field_name)
def set_author(self, user):
raise NotImplementedError()
def on_duplicate(self, ar, master):
"""The default behaviour after duplicating is to change the author to
the user who requested the duplicate.
"""
if ar and ar.user:
self.set_author(ar.user)
super(Authored, self).on_duplicate(ar, master)
def get_row_permission(self, ar, state, ba):
"""Only "managers" can edit other users' work.
See also :attr:`manager_roles_required`.
"""
if not super(Authored, self).get_row_permission(ar, state, ba):
return False
if ar and ba.action.select_rows:
user = ar.get_user()
author = self.get_author()
if author != ar.user \
and (ar.subst_user is None or author != ar.subst_user) \
and not user.user_type.has_required_roles(
self.manager_roles_required):
return ba.action.readonly
return True
@classmethod
def on_analyze(cls, site):
if hasattr(cls, 'manager_level_field'):
raise ChangedAPI("{0} has a manager_level_field".format(cls))
super(Authored, cls).on_analyze(site)
# no longer needed after 20170826
# @classmethod
# def setup_parameters(cls, **fields):
# """Adds the :attr:`user` filter parameter field."""
# fld = cls._meta.get_field('user')
# fields.setdefault(
# 'user', models.ForeignKey(
# 'users.User', verbose_name=fld.verbose_name,
# blank=True, null=True))
# return super(Authored, cls).setup_parameters(**fields)
@classmethod
def get_simple_parameters(cls):
for p in super(Authored, cls).get_simple_parameters():
yield p
yield 'user' # cls.author_field_name)
def get_print_language(self):
u = self.get_author()
if u is None or not u.language:
return super(Authored, self).get_print_language()
return u.language
class AllMembers(Members):
required_roles = dd.login_required(ContactsStaff)
class AllMovements(Movements):
required_roles = dd.login_required(LedgerStaff)
class ListTypes(dd.Table):
required_roles = dd.login_required(ContactsStaff)
model = 'lists.ListType'
column_names = 'designation *'
class PaymentTerms(dd.Table):
required_roles = dd.login_required(LedgerStaff)
model = 'ledger.PaymentTerm'
order_by = ["ref"]
column_names = "ref name months days end_of_month worker *"
detail_layout = """
class KnowledgesByLanguage(LanguageKnowledges):
master_key = 'language'
column_names = "entry_date person native spoken written cef_level *"
required_roles = dd.login_required(CareerUser)
class AllTrainings(Trainings):
"""Show all :class:`Training` instances.
"""
required_roles = dd.login_required(CareerStaff)
from lino_xl.lib.xl.user_types import * from lino.api import dd, rt from lino_xl.lib.polls.roles import PollsUser AllPolls = rt.models.polls.AllPolls AllPolls.required_roles = dd.login_required(PollsUser)
