class Deployments(dd.Table):
model = 'deploy.Deployment'
parameters = mixins.ObservedDateRange(show_closed=dd.YesNo.field(
blank=True,
default=dd.YesNo.as_callable('no'),
help_text=_("Show deployments on closed milestones.")))
params_layout = "start_date end_date show_closed"
stay_in_grid = True
detail_layout = dd.DetailLayout("""
milestone
wish_type
ticket
remark
""",
window_size=(50, 15))
@classmethod
def unused_get_request_queryset(self, ar):
qs = super(Deployments, self).get_request_queryset(ar)
pv = ar.param_values
cls = dd.plugins.tickets.milestone_model.workflow_state_field.choicelist
closed = cls.filter(invoiceable=True)
if pv.show_closed == dd.YesNo.no:
qs = qs.filter(milestone__state__in=closed)
# qs = qs.filter(milestone__closed=False)
elif pv.show_closed == dd.YesNo.yes:
qs = qs.exclude(milestone__state__in=closed)
# qs = qs.filter(milestone__closed=True)
return qs
def setup_parameters(cls, params):
params.update(
mixins.ObservedDateRange(
user=dd.ForeignKey(settings.SITE.user_model,
verbose_name=_("Managed by"),
blank=True,
null=True),
event_type=dd.ForeignKey('cal.EventType',
blank=True,
null=True),
room=dd.ForeignKey('cal.Room', blank=True, null=True),
project=dd.ForeignKey(settings.SITE.project_model,
blank=True,
null=True),
assigned_to=dd.ForeignKey(settings.SITE.user_model,
verbose_name=_("Assigned to"),
blank=True,
null=True),
state=EntryStates.field(blank=True),
# unclear = models.BooleanField(_("Unclear events"))
observed_event=EventEvents.field(blank=True),
show_appointments=dd.YesNo.field(_("Appointments"),
blank=True),
presence_guest=dd.ForeignKey(dd.plugins.cal.partner_model,
verbose_name=_("Guest"),
blank=True,
null=True)))
if settings.SITE.project_model:
params['project'].help_text = format_lazy(
_("Show only entries having this {project}."),
project=settings.SITE.project_model._meta.verbose_name)
return params
class CompaniesWithEntryTypes(dd.VentilatingTable, Companies):
label = _("Companies with Entry Types")
hide_zero_rows = True
parameters = mixins.ObservedDateRange()
params_layout = "start_date end_date"
editable = False
auto_fit_column_widths = True
@classmethod
def param_defaults(cls, ar, **kw):
kw = super(CompaniesWithEntryTypes, cls).param_defaults(ar, **kw)
kw.update(end_date=settings.SITE.today())
return kw
@classmethod
def get_ventilated_columns(self):
def w(et):
# return a getter function for a RequestField on the given
# EntryType.
def func(fld, obj, ar):
#~ mi = ar.master_instance
#~ if mi is None: return None
pv = dict(
start_date=ar.param_values.start_date,
end_date=ar.param_values.end_date)
if et is not None:
pv.update(entry_type=et)
pv.update(company=obj, user=ar.get_user())
return Entries.request(param_values=pv)
return func
for et in EntryType.objects.all():
yield dd.RequestField(w(et), verbose_name=str(et))
yield dd.RequestField(w(None), verbose_name=_("Total"))
class PeriodTable(dd.Table):
parameters = mixins.ObservedDateRange(observed_event=PeriodEvents.field(
blank=True))
params_layout = "start_date end_date observed_event"
@classmethod
def get_request_queryset(self, ar, **filter):
qs = super(PeriodTable, self).get_request_queryset(ar, **filter)
pv = ar.param_values
ce = pv.observed_event
if ce:
qs = ce.add_filter(qs, pv)
return qs
class Entries(dd.Table):
model = Entry
detail_layout = """
id user date company
subject
body
"""
insert_layout = """
user date company
subject
"""
parameters = mixins.ObservedDateRange(
entry_type=dd.ForeignKey(
EntryType, blank=True, null=True,
help_text=_("Show only entries of this type.")),
company=dd.ForeignKey(Company,
blank=True, null=True,
help_text=_("Show only entries of this company.")),
user=dd.ForeignKey(
settings.SITE.user_model,
blank=True, null=True,
help_text=_("Show only entries by this user.")))
params_layout = """
user start_date end_date
company entry_type
"""
@classmethod
def get_request_queryset(cls, ar):
qs = super(Entries, cls).get_request_queryset(ar)
if ar.param_values.end_date:
qs = qs.filter(date__lte=ar.param_values.end_date)
if ar.param_values.start_date:
qs = qs.filter(date__gte=ar.param_values.start_date)
if ar.param_values.user:
qs = qs.filter(user=ar.param_values.user)
if ar.param_values.entry_type:
qs = qs.filter(entry_type=ar.param_values.entry_type)
if ar.param_values.company:
qs = qs.filter(company=ar.param_values.company)
return qs
@classmethod
def param_defaults(cls, ar, **kw):
kw = super(Entries, cls).param_defaults(ar, **kw)
kw.update(user=ar.get_user())
return kw
class Excerpts(dd.Table):
# label = _("Excerpts history")
icon_name = 'script'
required_roles = dd.login_required((ExcerptsUser, OfficeOperator))
model = 'excerpts.Excerpt'
detail_layout = ExcerptDetail()
insert_layout = """
excerpt_type project
company contact_person
"""
column_names = ("id excerpt_type owner project "
"company language build_time *")
# order_by = ['-build_time', 'id']
order_by = ['-id']
auto_fit_column_widths = True
allow_create = False
parameters = mixins.ObservedDateRange(
excerpt_type=dd.ForeignKey('excerpts.ExcerptType',
blank=True,
null=True),
pcertifying=dd.YesNo.field(_("Certifying excerpts"), blank=True))
params_layout = """
start_date end_date pcertifying
user excerpt_type"""
# simple_parameters = ['user', 'excerpt_type']
@classmethod
def get_simple_parameters(cls):
s = list(super(Excerpts, cls).get_simple_parameters())
s.append('excerpt_type')
return s
@classmethod
def get_request_queryset(cls, ar):
qs = super(Excerpts, cls).get_request_queryset(ar)
pv = ar.param_values
if pv.pcertifying == dd.YesNo.yes:
qs = qs.filter(excerpt_type__certifying=True)
elif pv.pcertifying == dd.YesNo.no:
qs = qs.filter(excerpt_type__certifying=False)
return qs
class Bookings(dd.Table):
required_roles = dd.login_required(OfficeStaff)
model = 'rooms.Booking'
#~ order_by = ['date','start_time']
detail_layout = BookingDetail()
insert_layout = """
start_date start_time end_time
room event_type
company contact_person
"""
column_names = "start_date company room *"
order_by = ['start_date']
parameters = mixins.ObservedDateRange(
company=dd.ForeignKey('contacts.Company', blank=True, null=True),
state=BookingStates.field(blank=True),
)
params_layout = """company state"""
@classmethod
def get_simple_parameters(cls):
s = list(super(Bookings, cls).get_simple_parameters())
s.append('company')
return s
# simple_parameters = 'company state'.split()
@classmethod
def get_request_queryset(self, ar, **filter):
qs = super(Bookings, self).get_request_queryset(ar, **filter)
if isinstance(qs, list):
return qs
# for n in self.simple_param_fields:
# v = ar.param_values.get(n)
# if v:
# qs = qs.filter(**{n: v})
# #~ print 20130530, qs.query
return qs
@classmethod
def get_title_tags(self, ar):
for t in super(Bookings, self).get_title_tags(ar):
yield t
class Uploads(dd.Table):
model = 'uploads.Upload'
required_roles = dd.login_required((OfficeUser, OfficeOperator))
column_names = "file type user owner description *"
order_by = ['-id']
detail_layout = dd.DetailLayout("""
file user
volume:10 library_file:40
upload_area type description
owner
""",
window_size=(80, 'auto'))
insert_layout = """
type
description
file
volume library_file
user
"""
parameters = mixins.ObservedDateRange(
# user=dd.ForeignKey(
# 'users.User', blank=True, null=True,
# verbose_name=_("Uploaded by")),
upload_type=dd.ForeignKey('uploads.UploadType', blank=True, null=True))
params_layout = "start_date end_date user upload_type"
# simple_parameters = ['user']
@classmethod
def get_request_queryset(cls, ar, **filter):
qs = super(Uploads, cls).get_request_queryset(ar, **filter)
pv = ar.param_values
if pv.user:
qs = qs.filter(user=pv.user)
if pv.upload_type:
qs = qs.filter(type=pv.upload_type)
return qs
class Enrolments(dd.Table):
_course_area = None
required_roles = dd.login_required((CoursesUser, CoursesTeacher))
# debug_permissions=20130531
model = 'courses.Enrolment'
stay_in_grid = True
parameters = mixins.ObservedDateRange(
author=dd.ForeignKey(
settings.SITE.user_model, blank=True, null=True),
state=EnrolmentStates.field(blank=True, null=True),
course_state=CourseStates.field(
_("Course state"), blank=True, null=True),
participants_only=models.BooleanField(
_("Participants only"),
help_text=_(
"Hide cancelled enrolments. "
"Ignored if you specify an explicit enrolment state."),
default=True),
)
params_layout = """start_date end_date author state \
course_state participants_only"""
order_by = ['request_date']
column_names = 'request_date course course__state pupil workflow_buttons user *'
# hidden_columns = 'id state'
insert_layout = """
request_date user
course pupil
remark
"""
detail_layout = "courses.EnrolmentDetail"
@classmethod
def get_known_values(self):
if self._course_area is not None:
return dict(course_area=self._course_area)
return dict()
@classmethod
def create_instance(self, ar, **kw):
if self._course_area is not None:
kw.update(course_area=self._course_area)
# dd.logger.info("20160714 %s", kw)
return super(Enrolments, self).create_instance(ar, **kw)
@classmethod
def get_actor_label(self):
if self._course_area is not None:
return self._course_area.text
return super(Enrolments, self).get_actor_label()
@classmethod
def get_request_queryset(self, ar, **kwargs):
qs = super(Enrolments, self).get_request_queryset(ar, **kwargs)
if isinstance(qs, list):
return qs
pv = ar.param_values
if pv.author is not None:
qs = qs.filter(user=pv.author)
if pv.state:
qs = qs.filter(state=pv.state)
else:
if pv.participants_only:
qs = qs.exclude(state=EnrolmentStates.cancelled)
if pv.course_state:
qs = qs.filter(course__state=pv.course_state)
if pv.start_date or pv.end_date:
qs = PeriodEvents.active.add_filter(qs, pv)
# if pv.start_date is None or pv.end_date is None:
# period = None
# else:
# period = (pv.start_date, pv.end_date)
# if period is not None:
# qs = qs.filter(dd.inrange_filter('request_date', period))
return qs
@classmethod
def get_title_tags(self, ar):
for t in super(Enrolments, self).get_title_tags(ar):
yield t
if ar.param_values.state:
yield str(ar.param_values.state)
elif not ar.param_values.participants_only:
yield str(_("Also ")) + str(EnrolmentStates.cancelled.text)
if ar.param_values.course_state:
yield str(
settings.SITE.models.courses.Course._meta.verbose_name) \
+ ' ' + str(ar.param_values.course_state)
if ar.param_values.author:
yield str(ar.param_values.author)
class Activities(dd.Table):
_course_area = None
required_roles = dd.login_required((CoursesUser, CoursesTeacher))
model = 'courses.Course'
detail_layout = 'courses.CourseDetail'
insert_layout = """
line teacher
name start_date
"""
column_names = "start_date name line teacher room workflow_buttons *"
# order_by = ['start_date']
# order_by = 'line__name room__name start_date'.split()
# order_by = ['name']
order_by = ['-start_date', '-start_time']
auto_fit_column_widths = True
parameters = mixins.ObservedDateRange(
line=dd.ForeignKey('courses.Line', blank=True, null=True),
topic=dd.ForeignKey('courses.Topic', blank=True, null=True),
teacher=dd.ForeignKey(
teacher_model, verbose_name=teacher_label,
blank=True, null=True),
# user=dd.ForeignKey(
# settings.SITE.user_model,
# blank=True, null=True),
show_exposed=dd.YesNo.field(
_("Exposed"), blank=True,
help_text=_("Whether to show rows in an exposed state")),
state=CourseStates.field(blank=True),
can_enroll=dd.YesNo.field(blank=True),
)
params_layout = """topic line user teacher state
room can_enroll:10 start_date end_date show_exposed"""
# simple_parameters = 'line teacher state user'.split()
@dd.chooser()
def line_choices(cls):
# dd.logger.info("20181104 line_choices %s", cls)
qs = rt.models.courses.Line.objects.all()
if cls._course_area:
qs = qs.filter(course_area=cls._course_area)
return qs
@classmethod
def create_instance(cls, ar, **kw):
# dd.logger.info("20160714 %s", kw)
obj = super(Activities, cls).create_instance(ar, **kw)
if cls._course_area is not None:
obj.course_area = cls._course_area
qs = rt.models.courses.Line.objects.filter(
course_area=cls._course_area)
if qs.count() == 1:
obj.line = qs[0]
return obj
@classmethod
def get_actor_label(self):
if self._course_area is not None:
return self._course_area.text
return super(Activities, self).get_actor_label()
@classmethod
def get_simple_parameters(cls):
s = list(super(Activities, cls).get_simple_parameters())
s.append('line')
s.append('teacher')
# s.append('state')
# s.add('user')
return s
@classmethod
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
@classmethod
def get_title_tags(self, ar):
for t in super(Activities, self).get_title_tags(ar):
yield t
if ar.param_values.topic:
yield str(ar.param_values.topic)
class Movements(dd.Table):
model = 'ledger.Movement'
required_roles = dd.login_required(LedgerUser)
column_names = 'value_date voucher_link description \
debit credit match_link cleared *'
sum_text_column = 2
order_by = ['id']
editable = False
parameters = mixins.ObservedDateRange(
year=dd.ForeignKey('ledger.FiscalYear', blank=True),
journal_group=JournalGroups.field(blank=True),
partner=dd.ForeignKey('contacts.Partner', blank=True, null=True),
project=dd.ForeignKey(dd.plugins.ledger.project_model,
blank=True,
null=True),
account=dd.ForeignKey('ledger.Account', blank=True, null=True),
journal=JournalRef(blank=True),
cleared=dd.YesNo.field(_("Show cleared movements"), blank=True))
params_layout = """
start_period end_period start_date end_date cleared
journal_group journal year project partner account"""
@classmethod
def get_request_queryset(cls, ar, **kwargs):
qs = super(Movements, cls).get_request_queryset(ar, **kwargs)
pv = ar.param_values
if pv.cleared == dd.YesNo.yes:
qs = qs.filter(cleared=True)
elif pv.cleared == dd.YesNo.no:
qs = qs.filter(cleared=False)
if pv.start_date:
qs = qs.filter(value_date__gte=pv.start_date)
if pv.end_date:
qs = qs.filter(value_date__lte=pv.end_date)
# if ar.param_values.partner:
# qs = qs.filter(partner=ar.param_values.partner)
# if ar.param_values.paccount:
# qs = qs.filter(account=ar.param_values.paccount)
if pv.year:
qs = qs.filter(voucher__accounting_period__year=pv.year)
if pv.journal_group:
qs = qs.filter(voucher__journal__journal_group=pv.journal_group)
if pv.journal:
qs = qs.filter(voucher__journal=pv.journal)
return qs
@classmethod
def get_sum_text(self, ar, sums):
bal = sums['debit'] - sums['credit']
return _("Balance {1} ({0} movements)").format(ar.get_total_count(),
bal)
@classmethod
def get_simple_parameters(cls):
p = list(super(Movements, cls).get_simple_parameters())
p.append('partner')
p.append('project')
# p.append('journal_group')
# p.append('year')
p.append('account')
return p
@classmethod
def get_title_tags(cls, ar):
for t in super(Movements, cls).get_title_tags(ar):
yield t
pv = ar.param_values
if pv.journal is not None:
yield pv.journal.ref
if pv.journal_group is not None:
yield str(pv.journal_group)
if pv.year is not None:
yield str(pv.year)
if pv.cleared == dd.YesNo.no:
yield str(_("only uncleared"))
elif pv.cleared == dd.YesNo.yes:
yield str(_("only cleared"))
@dd.displayfield(_("Description"))
def description(cls, self, ar):
# raise Exception("20191003")
if ar is None:
return ''
elems = []
elems.append(ar.obj2html(self.account))
voucher = self.voucher.get_mti_leaf()
if voucher is not None:
elems.extend(voucher.get_movement_description(self, ar))
if self.project:
elems.append(ar.obj2html(self.project))
return E.p(*join_elems(elems, " / "))
class Tickets(dd.Table):
required_roles = dd.login_required(Searcher)
# label = _("All tickets")
# required_roles = set() # also for anonymous
model = 'tickets.Ticket'
order_by = ["-id"]
focus_on_quick_search = True
column_names = 'id summary:50 user:10 #topic #faculty ' \
'workflow_buttons:30 #site:10 #project:10 *' # Site commented to not disturbe care
detail_layout = 'tickets.TicketDetail'
insert_layout = """
summary
end_user
"""
# insert_layout = dd.InsertLayout("""
# # reporter #product
# summary
# description
# """, window_size=(70, 20))
detail_html_template = "tickets/Ticket/detail.html"
parameters = mixins.ObservedDateRange(
observed_event=TicketEvents.field(blank=True),
# topic=dd.ForeignKey('topics.Topic', blank=True, ),
site=dd.ForeignKey(site_model, blank=True),
end_user=dd.ForeignKey(
end_user_model,
verbose_name=_("End user"),
blank=True,
null=True,
help_text=_("Only rows concerning this end user.")),
assigned_to=dd.ForeignKey(
# end_user_model,
settings.SITE.user_model,
verbose_name=_("Assigned_to"),
blank=True,
null=True,
help_text=_("Only tickets with this user assigned.")),
not_assigned_to=dd.ForeignKey(
# end_user_model,
settings.SITE.user_model,
verbose_name=_("Not assigned to"),
blank=True,
null=True,
help_text=_("Only that this user is not assigned to.")),
interesting_for=dd.ForeignKey(
'contacts.Partner',
verbose_name=_("Interesting for"),
blank=True,
null=True,
help_text=_("Only tickets interesting for this partner.")),
deployed_to=dd.ForeignKey(milestone_model, blank=True, null=True),
# project=dd.ForeignKey(
# 'tickets.Project',
# blank=True, null=True),
state=TicketStates.field(blank=True,
help_text=_("Only rows having this state.")),
priority=Priorities.field(
_("Priority"),
blank=True,
help_text=_("Only rows having this priority.")),
show_assigned=dd.YesNo.field(_("Assigned"), blank=True),
show_deployed=dd.YesNo.field(_("Deployed"),
blank=True,
help_text=_(
"Whether to show tickets with at "
"least one deployment")),
show_active=dd.YesNo.field(_("Active"), blank=True),
show_todo=dd.YesNo.field(_("To do"), blank=True),
has_site=dd.YesNo.field(_("Has site"), blank=True),
show_private=dd.YesNo.field(_("Private"), blank=True),
has_ref=dd.YesNo.field(_("Has reference"), blank=True),
last_commenter=dd.ForeignKey(
settings.SITE.user_model,
verbose_name=_("Commented Last"),
blank=True,
null=True,
help_text=_("Only tickets that have this use commenting last.")),
not_last_commenter=dd.ForeignKey(
settings.SITE.user_model,
verbose_name=_("Not Commented Last"),
blank=True,
null=True,
help_text=_(
"Only tickets where this use is not the last commenter.")),
subscriber=dd.ForeignKey(
settings.SITE.user_model,
verbose_name=_("Site Subscriber"),
blank=True,
null=True,
help_text=
_("Limit tickets to tickets that have a site this user is subscribed to."
)))
params_layout = """
user end_user assigned_to not_assigned_to interesting_for site state priority deployed_to
#has_site show_assigned show_active show_deployed show_todo show_private
start_date end_date observed_event #topic has_ref"""
# simple_parameters = ('reporter', 'assigned_to', 'state', 'project')
@classmethod
def get_simple_parameters(cls):
for p in super(Tickets, cls).get_simple_parameters():
yield p
yield 'end_user'
yield 'state'
# yield 'project'
# yield 'topic'
yield 'site'
yield 'priority'
yield 'last_commenter'
if not dd.is_installed('votes'):
yield 'assigned_to'
@classmethod
def get_queryset(self, ar, **filter):
qs = super(Tickets, self).get_queryset(ar, **filter)
return qs.select_related(
'user',
'assigned_to', # 'project',
'duplicate_of',
'end_user')
@classmethod
def get_request_queryset(self, ar):
qs = super(Tickets, self).get_request_queryset(ar)
pv = ar.param_values
if pv.observed_event:
qs = pv.observed_event.add_filter(qs, pv)
if pv.interesting_for:
qs = qs.filter(Q(site__company=pv.interesting_for))
if dd.is_installed('votes'):
if pv.assigned_to:
# qs = qs.filter(
# Q(votes_by_ticket__user=pv.assigned_to) |
# Q(votes_by_ticket__end_user=pv.assigned_to)).distinct()
qs = qs.filter(votes_by_ticket__user=pv.assigned_to).distinct()
if pv.not_assigned_to:
# print(20170318, self, qs.model, pv.not_assigned_to)
# qs = qs.exclude(
# Q(votes_by_ticket__user_id=pv.not_assigned_to.id) |
# Q(votes_by_ticket__end_user_id=pv.not_assigned_to.id))
qs = qs.exclude(votes_by_ticket__user=pv.not_assigned_to)
if pv.show_assigned == dd.YesNo.no:
qs = qs.filter(vote__isnull=False).distinct()
elif pv.show_assigned == dd.YesNo.yes:
qs = qs.filter(vote__isnull=True).distinct()
else:
# NB: assigned_to is a simple parameter field
if pv.not_assigned_to:
qs = qs.exclude(assigned_to=pv.not_assigned_to)
if pv.show_assigned == dd.YesNo.no:
qs = qs.filter(assigned_to__isnull=False)
elif pv.show_assigned == dd.YesNo.yes:
qs = qs.filter(assigned_to__isnull=True)
if pv.deployed_to:
# qs = qs.filter(
# Q(votes_by_ticket__user=pv.assigned_to) |
# Q(votes_by_ticket__end_user=pv.assigned_to)).distinct()
qs = qs.filter(
deployments_by_ticket__milestone=pv.deployed_to).distinct()
if pv.show_deployed == dd.YesNo.no:
qs = qs.exclude(deployments_by_ticket__isnull=False)
elif pv.show_deployed == dd.YesNo.yes:
qs = qs.filter(deployments_by_ticket__isnull=False)
active_states = TicketStates.filter(active=True)
if pv.show_active == dd.YesNo.no:
qs = qs.exclude(state__in=active_states)
elif pv.show_active == dd.YesNo.yes:
qs = qs.filter(state__in=active_states)
todo_states = TicketStates.filter(show_in_todo=True)
if pv.show_todo == dd.YesNo.no:
qs = qs.exclude(state__in=todo_states)
elif pv.show_todo == dd.YesNo.yes:
qs = qs.filter(state__in=todo_states)
if pv.has_site == dd.YesNo.no:
qs = qs.filter(site__isnull=True)
elif pv.has_site == dd.YesNo.yes:
qs = qs.filter(site__isnull=False)
# if pv.show_standby == dd.YesNo.no:
# qs = qs.filter(standby=False)
# elif pv.show_standby == dd.YesNo.yes:
# qs = qs.filter(standby=True)
if pv.show_private == dd.YesNo.no:
qs = qs.filter(private=False)
elif pv.show_private == dd.YesNo.yes:
qs = qs.filter(private=True)
if pv.has_ref == dd.YesNo.yes:
qs = qs.filter(ref__isnull=False)
elif pv.has_ref == dd.YesNo.no:
qs = qs.filter(ref__isnull=True)
# print 20150512, qs.query
# 1253
# the following caused a RuntimeWarning and was useless since
# the same filter is applied by
# pv.observed_event.add_filter(qs, pv) above: if
# pv.start_date: qs = qs.filter(created__gte=pv.start_date) if
# pv.end_date: qs = qs.filter(created__lte=pv.end_date)
if pv.not_last_commenter:
qs = qs.exclude(last_commenter=pv.not_last_commenter)
if pv.subscriber:
sqs = rt.models.tickets.Subscription.objects.filter(
user=pv.subscriber)
subscribed_sites = sqs.values_list('site')
qs = qs.filter(site__in=subscribed_sites)
return qs
@classmethod
def get_title_tags(self, ar):
for t in super(Tickets, 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)
class Meetings(dd.Table):
"""Base table for all Meetings.
"""
required_roles = dd.login_required((OfficeUser, ))
model = 'meetings.Meeting'
detail_layout = MeetingDetail()
insert_layout = dd.InsertLayout("""name
ref room
start_date
""",
window_size=(
40,
10,
))
column_names = "start_date name ref site room workflow_buttons *"
# order_by = ['start_date']
# order_by = 'line__name room__name start_date'.split()
# order_by = ['name']
order_by = ['-start_date', '-start_time']
auto_fit_column_widths = True
parameters = mixins.ObservedDateRange(
user=dd.ForeignKey(settings.SITE.user_model, blank=True, null=True),
show_active=dd.YesNo.field(
_("Active"),
blank=True,
help_text=_("Whether to show rows in some active state")),
state=MeetingStates.field(blank=True),
member=dd.ForeignKey(
dd.resolve_model('contacts.Partner'),
verbose_name=_("Member"),
blank=True,
help_text=_("Show rows that this person is a member")),
)
params_layout = """user room state show_active member
start_date end_date """
# simple_parameters = 'line teacher state user'.split()
@classmethod
def create_instance(self, ar, **kw):
# dd.logger.info("20160714 %s", kw)
obj = super(Meetings, self).create_instance(ar, **kw)
# if self._course_area is not None:
# obj.course_area = self._course_area
return obj
@classmethod
def get_request_queryset(self, ar, **kwargs):
# dd.logger.info("20160223 %s", self)
qs = super(Meetings, self).get_request_queryset(ar, **kwargs)
if isinstance(qs, list):
return qs
pv = ar.param_values
qs = self.model.add_param_filter(qs, show_active=pv.show_active)
if pv.state:
qs = qs.filter(state=pv.state)
if pv.member:
sqs = rt.models.stars.Star.for_model('meetings.Meeting',
user=pv.member)
stared_ticket_ids = sqs.values_list('owner_id')
qs = qs.filter(pk__in=stared_ticket_ids)
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
class Coachings(dd.Table):
required_roles = dd.login_required(CoachingsStaff)
model = 'coachings.Coaching'
parameters = mixins.ObservedDateRange(
coached_by=dd.ForeignKey(
'users.User',
blank=True, null=True,
verbose_name=_("Coached by"),
help_text="""Nur Begleitungen dieses Benutzers."""),
and_coached_by=dd.ForeignKey(
'users.User',
blank=True, null=True,
verbose_name=_("and by"),
help_text="""... und auch Begleitungen dieses Benutzers."""),
observed_event=dd.PeriodEvents.field(
blank=True, default=dd.PeriodEvents.as_callable('active')),
primary_coachings=dd.YesNo.field(
_("Primary coachings"),
blank=True, help_text="""Accompagnements primaires."""),
coaching_type=dd.ForeignKey(
'coachings.CoachingType',
blank=True, null=True,
help_text="""Nur Begleitungen dieses Dienstes."""),
ending=dd.ForeignKey(
'coachings.CoachingEnding',
blank=True, null=True,
help_text="""Nur Begleitungen mit diesem Beendigungsgrund."""),
)
params_layout = """
start_date end_date observed_event coached_by and_coached_by
primary_coachings coaching_type ending
"""
params_panel_hidden = True
#~ @classmethod
#~ def param_defaults(self,ar,**kw):
#~ kw = super(Coachings,self).param_defaults(ar,**kw)
#~ D = datetime.date
#~ kw.update(start_date = D.today())
#~ kw.update(end_date = D.today())
#~ return kw
@classmethod
def get_request_queryset(self, ar, **filter):
qs = super(Coachings, self).get_request_queryset(ar, **filter)
pv = ar.param_values
coaches = []
for u in (pv.coached_by, pv.and_coached_by):
if u is not None:
coaches.append(u)
if len(coaches):
qs = qs.filter(user__in=coaches)
ce = pv.observed_event
if ce is not None:
qs = ce.add_filter(qs, pv)
if pv.primary_coachings == dd.YesNo.yes:
qs = qs.filter(primary=True)
elif pv.primary_coachings == dd.YesNo.no:
qs = qs.filter(primary=False)
if pv.coaching_type is not None:
qs = qs.filter(type=pv.coaching_type)
if pv.ending is not None:
qs = qs.filter(ending=pv.ending)
return qs
@classmethod
def get_title_tags(self, ar):
for t in super(Coachings, self).get_title_tags(ar):
yield t
pv = ar.param_values
if pv.observed_event:
yield six.text_type(pv.observed_event)
if pv.coached_by:
s = six.text_type(self.parameters['coached_by'].verbose_name) + \
' ' + six.text_type(pv.coached_by)
if pv.and_coached_by:
s += " %s %s" % (six.text_type(_('and')),
pv.and_coached_by)
yield s
if pv.primary_coachings:
yield six.text_type(self.parameters['primary_coachings'].verbose_name) \
+ ' ' + six.text_type(pv.primary_coachings)
@classmethod
def get_create_permission(self, ar):
"""Reception clerks can see coachings, but cannot modify them nor add
new ones.
"""
if not ar.get_user().user_type.has_required_roles([CoachingsUser]):
#if not ar.get_user().user_type.coaching_level:
return False
return super(Coachings, self).get_create_permission(ar)