def _query(self, **kw):
principal = get_principal()
roles = get_workspace_roles()
group_roles_domain_status = self.item_status_filter(kw, roles)
session = Session()
results = []
count = 0
for domain_class, status in group_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)
)
if kw.get("filter_short_name", None):
column = self.title_column(domain_class)
query = query.filter(
"""(lower(%s) LIKE '%%%s%%')""" %
(column, kw["filter_short_name"].lower())
)
# The first page of the results is loaded the most number of times
# The limit on the query below optimises for when no filter has
# been applied by limiting the number of results returned.
if (not kw.get("start", 0) and not kw.get("sort_on", None)):
count = count + query.count()
query = query.order_by(domain_class.status_date).limit(
kw.get("limit", 25))
results.extend(query.all())
object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
for domain_class, status in object_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status))
if kw.get("filter_short_name", None):
column = self.title_column(domain_class)
query = query.filter(
"""(lower(%s) LIKE '%%%s%%')""" %
(column, kw["filter_short_name"])
)
if (not kw.get("start", 0) and not kw.get("sort_on", None)):
count = count + query.count()
query = query.order_by(domain_class.status_date).limit(
kw.get("limit", 25))
for obj in query.all():
prm = IPrincipalRoleMap(obj)
for obj_role in OBJECT_ROLES:
if (prm.getSetting(obj_role, principal.id) == Allow and
obj not in results):
results.append(obj)
break
# Sort items
if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
rev = True if (kw.get("sort_dir") == "desc") else False
results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
reverse=rev)
if (kw.get("start", 0) and kw.get("sort_on", None)):
count = len(results)
return (results, count)
def _do_save(self, data):
group_role_changed = False
prm = IPrincipalRoleMap(get_group_privilege_extent_context(self.context))
if (data["group_role"] != self.context.group_role):
if prm.getSetting(self.context.group_role, self.context.principal_name) == Allow:
group_role_changed = True
unset_group_local_role(self.context)
formlib.form.applyChanges(self.context, self.form_fields, data)
if group_role_changed:
set_group_local_role(self.context)
notify(ObjectModifiedEvent(self.context))
def _do_save(self, data):
group_role_changed = False
prm = IPrincipalRoleMap(get_group_context(self.context))
if (data["group_role"] != self.context.group_role):
if (prm.getSetting(self.context.group_role,
self.context.principal_name) == Allow):
group_role_changed = True
unset_group_local_role(self.context)
formlib.form.applyChanges(self.context, self.form_fields, data)
if group_role_changed:
set_group_local_role(self.context)
notify(ObjectModifiedEvent(self.context))
def _query(self, **kw):
principal = common.get_request_principal()
roles = get_workspace_roles()
group_roles_domain_status = self.item_status_filter(kw, roles)
session = Session()
results = []
count = 0
reverse = True if (kw.get("sort_dir", "desc") == "desc") else False
for domain_class, status in group_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
#filter on title
query = self.filter_title(query, domain_class, kw)
#filter on status_date
query = self.filter_status_date(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
results.extend(query.all())
for obj_role in ROLES_DIRECTLY_DEFINED_ON_OBJECTS:
object_roles_domain_status = self.item_status_filter(
kw, [obj_role])
for domain_class, status in object_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
#filter on title
query = self.filter_title(query, domain_class, kw)
#filter on status_date
query = self.filter_status_date(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
for obj in query.all():
if obj in results:
continue
prm = IPrincipalRoleMap(obj)
if (prm.getSetting(obj_role, principal.id) == Allow):
results.append(
contained(obj, self, self.string_key(obj)))
results = [
item for item in results
if checkPermission(view_permission(item),
contained(item, self, self.string_key(item)))
]
# Sort items
if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
reverse=reverse)
count = len(results)
if not (kw.get("filter_title", None) or kw.get("filter_type", None)
or kw.get("filter_status", None)
or kw.get("filter_status_date", None)):
self.set_tab_count(principal.id, count)
return (results, count)
def _query(self, **kw):
principal = get_principal()
roles = get_workspace_roles()
group_roles_domain_status = self.item_status_filter(kw, roles)
session = Session()
results = []
count = 0
first_page = not kw.get("start", 0)
reverse = True if (kw.get("sort_dir", "desc") == "desc") else False
for domain_class, status in group_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)
)
#filter on title
query = self.filter_query(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
# The first page of the results is loaded the most number of times
# The limit on the query below optimises for when no filter has
# been applied by limiting the number of results returned.
if first_page:
count = count + query.count()
query = query.limit(kw.get("limit", 25))
results.extend(query.all())
object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
for domain_class, status in object_roles_domain_status.iteritems():
object_roles_results = []
query = session.query(domain_class).filter(
domain_class.status.in_(status)
)
#filter on title
query = self.filter_query(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
for obj in query.all():
prm = IPrincipalRoleMap(obj)
for obj_role in OBJECT_ROLES:
if (prm.getSetting(obj_role, principal.id) == Allow and
obj not in results):
object_roles_results.append(obj)
break
if first_page:
count = count + len(object_roles_results)
results.extend(object_roles_results)
# Sort items
if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
reverse=reverse)
if not first_page:
count = len(results)
return (results, count)
def _query(self, **kw):
principal = utils.get_principal()
roles = get_workspace_roles()
group_roles_domain_status = self.item_status_filter(kw, roles)
session = Session()
results = []
count = 0
reverse = True if (kw.get("sort_dir", "desc") == "desc") else False
for domain_class, status in group_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
#filter on title
query = self.filter_title(query, domain_class, kw)
#filter on status_date
query = self.filter_status_date(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
results.extend(query.all())
for obj_role in ROLES_DIRECTLY_DEFINED_ON_OBJECTS:
object_roles_domain_status = self.item_status_filter(
kw, [obj_role])
for domain_class, status in object_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
#filter on title
query = self.filter_title(query, domain_class, kw)
#filter on status_date
query = self.filter_status_date(query, domain_class, kw)
# Order results
query = self.order_query(query, domain_class, kw, reverse)
for obj in query.all():
if obj in results:
continue
prm = IPrincipalRoleMap(obj)
if (prm.getSetting(obj_role, principal.id) == Allow):
results.append(
contained(obj, self, self.string_key(obj)))
results = [item for item in results if checkPermission(
view_permission(item), contained(item, self, self.string_key(item)))]
# Sort items
if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
reverse=reverse)
count = len(results)
if not (kw.get("filter_title", None) or
kw.get("filter_type", None) or
kw.get("filter_status", None) or
kw.get("filter_status_date", None)
):
self.set_tab_count(principal.id, count)
return (results, count)
def _query(self, **kw):
principal = get_principal()
roles = get_workspace_roles()
group_roles_domain_status = self.item_status_filter(kw, roles)
session = Session()
results = []
count = 0
for domain_class, status in group_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status))
if kw.get("filter_short_name", None):
column = self.title_column(domain_class)
query = query.filter("""(lower(%s) LIKE '%%%s%%')""" %
(column, kw["filter_short_name"].lower()))
# The first page of the results is loaded the most number of times
# The limit on the query below optimises for when no filter has
# been applied by limiting the number of results returned.
if (not kw.get("start", 0) and not kw.get("sort_on", None)):
count = count + query.count()
query = query.order_by(domain_class.status_date).limit(
kw.get("limit", 25))
results.extend(query.all())
object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
for domain_class, status in object_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status))
if kw.get("filter_short_name", None):
column = self.title_column(domain_class)
query = query.filter("""(lower(%s) LIKE '%%%s%%')""" %
(column, kw["filter_short_name"]))
if (not kw.get("start", 0) and not kw.get("sort_on", None)):
count = count + query.count()
query = query.order_by(domain_class.status_date).limit(
kw.get("limit", 25))
for obj in query.all():
prm = IPrincipalRoleMap(obj)
for obj_role in OBJECT_ROLES:
if (prm.getSetting(obj_role, principal.id) == Allow
and obj not in results):
results.append(obj)
break
# Sort items
if (kw.get("sort_on", None) and kw.get("sort_dir", None)):
rev = True if (kw.get("sort_dir") == "desc") else False
results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
reverse=rev)
if (kw.get("start", 0) and kw.get("sort_on", None)):
count = len(results)
return (results, count)
def extend_results_for_roles(roles):
domain_status = self.item_status_filter(kw, roles)
OBJECT_ROLES = [
role for role in roles if role in ROLES_DIRECTLY_DEFINED_ON_OBJECTS ]
for domain_class, status in domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
query = self.filter_group(query, domain_class, kw)
query = self.filter_title(query, domain_class, kw)
query = self.filter_status_date(query, domain_class, kw)
query = self.order_query(query, domain_class, kw, reverse)
for obj in query.all():
if obj in results:
continue
if OBJECT_ROLES:
prm = IPrincipalRoleMap(obj)
if not prm.getSetting(obj_role, principal_id) == Allow:
continue
results.append(contained(obj, self, self.string_key(obj)))
def _query(self, **kw):
principal = get_principal()
roles = get_workspace_roles(principal)
group_roles_domain_status = self.item_status_filter(kw, roles)
session = Session()
results = []
for domain_class, status in group_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)
)
if kw.get("filter_short_name", None):
column = self.title_column(domain_class)
query = query.filter(
"""(lower(%s) LIKE '%%%s%%')""" %
(column, kw["filter_short_name"].lower())
)
results.extend(query.all())
object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
for domain_class, status in object_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status))
if kw.get("filter_short_name", None):
column = self.title_column(domain_class)
query = query.filter(
"""(lower(%s) LIKE '%%%s%%')""" %
(column, kw["filter_short_name"])
)
for obj in query.all():
prm = IPrincipalRoleMap(obj)
for obj_role in OBJECT_ROLES:
if (prm.getSetting(obj_role, principal.id) == Allow and
obj not in results
):
results.append(obj)
break
# Sort items
if kw.get("sort_on", None):
if kw.get("sort_dir", None):
rev = True if (kw.get("sort_dir") == "desc") else False
results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
reverse=rev)
return results
def extend_results_for_roles(roles):
domain_status = self.item_status_filter(kw, roles)
OBJECT_ROLES = [
role for role in roles
if role in ROLES_DIRECTLY_DEFINED_ON_OBJECTS
]
for domain_class, status in domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status)).enable_eagerloads(False)
query = self.filter_group(query, domain_class, kw)
query = self.filter_title(query, domain_class, kw)
query = self.filter_status_date(query, domain_class, kw)
query = self.order_query(query, domain_class, kw, reverse)
for obj in query.all():
if obj in results:
continue
if OBJECT_ROLES:
prm = IPrincipalRoleMap(obj)
if not prm.getSetting(obj_role, principal_id) == Allow:
continue
results.append(contained(obj, self, self.string_key(obj)))
def _query(self, **kw):
principal = get_principal()
roles = get_workspace_roles(principal)
group_roles_domain_status = self.item_status_filter(kw, roles)
session = Session()
results = []
for domain_class, status in group_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status))
if kw.get("filter_short_name", None):
column = self.title_column(domain_class)
query = query.filter("""(lower(%s) LIKE '%%%s%%')""" %
(column, kw["filter_short_name"].lower()))
results.extend(query.all())
object_roles_domain_status = self.item_status_filter(kw, OBJECT_ROLES)
for domain_class, status in object_roles_domain_status.iteritems():
query = session.query(domain_class).filter(
domain_class.status.in_(status))
if kw.get("filter_short_name", None):
column = self.title_column(domain_class)
query = query.filter("""(lower(%s) LIKE '%%%s%%')""" %
(column, kw["filter_short_name"]))
for obj in query.all():
prm = IPrincipalRoleMap(obj)
for obj_role in OBJECT_ROLES:
if (prm.getSetting(obj_role, principal.id) == Allow
and obj not in results):
results.append(obj)
break
# Sort items
if kw.get("sort_on", None):
if kw.get("sort_dir", None):
rev = True if (kw.get("sort_dir") == "desc") else False
results.sort(key=lambda x: getattr(x, str(kw.get("sort_on"))),
reverse=rev)
return results
class UserAssignmentView(forms.common.BaseForm):
"""View for user assignments. Allows users with adequate permissions
to edit the assignments
"""
form_fields = []
render = ViewPageTemplateFile("templates/assignment.pt")
def __init__(self, context, request):
self._assignable_roles = []
self.principal = utils.common.get_request_principal()
self.context_roles = common.get_context_roles(context, self.principal)
self.context = removeSecurityProxy(context)
self.prm = IPrincipalRoleMap(self.context)
super(UserAssignmentView, self).__init__(context, request)
def __call__(self):
self.update()
return self.render()
def get_object_type_info(self):
return capi.get_type_info(self.context.__class__)
def get_config_roles(self, role_type):
ti = self.get_object_type_info()
workflow = ti.workflow
if workflow.has_feature("user_assignment"):
feature = None
for f in workflow.features:
if f.name == "user_assignment":
feature = f
if feature:
if role_type == "assigner":
return capi.schema.qualified_roles(
feature.params["assigner_roles"])
elif role_type == "assignable":
return capi.schema.qualified_roles(
feature.params["assignable_roles"])
return []
def assignable_roles(self):
"""Returns a list of role ids that this user can assign to
"""
if self._assignable_roles:
return self._assignable_roles
# the assigner roles that this user has
assigner_roles = []
# all the assigner roles that are in the workflow config
config_assigner_roles = self.get_config_roles("assigner")
for c_a_role in config_assigner_roles:
role = getUtility(IRole, c_a_role)
if role.id in self.context_roles:
assigner_roles.append(role.id)
# the assignable roles that this user can assign to
assignable_roles = []
# all the assignable roles that are in the workflow config
config_assignable_roles = self.get_config_roles("assignable")
# Only assign to roles that have the same parent or are children
# of assigner roles that this user has
for assigner_role in assigner_roles:
assigner_role_annt = ISubRoleAnnotations(
getUtility(IRole, assigner_role))
if assigner_role_annt.is_sub_role:
for c_assignable_role in config_assignable_roles:
c_assignable_role_annt = ISubRoleAnnotations(
getUtility(IRole, c_assignable_role))
if (c_assignable_role_annt.parent ==
assigner_role_annt.parent):
assignable_roles.append(c_assignable_role)
else:
for c_assignable_role in config_assignable_roles:
if (c_assignable_role in assigner_role_annt.sub_roles):
assignable_roles.append(c_assignable_role)
self._assignable_roles = assignable_roles
return self._assignable_roles
def can_edit(self, action=None):
return checkPermission("bungeni.user_assignment.Edit", self.context)
@property
def columns(self):
return [
column.GetterColumn(
title=_("user name"),
getter=lambda i, f: i.get("title")
),
column.GetterColumn(
title=_("assigned"),
getter=lambda i, f: i,
cell_formatter=lambda g, i, f: \
'<input type="checkbox" name="%s" %s %s/>' % (
i["name"],
i["is_assigned"] and ' checked="checked"' or "",
not i["editable"] and ' disabled="disabled"' or "")
)
]
@property
def checkbox_prefix(self):
return "assignment_users"
def make_id(self, role_id, user_login_id):
return ".".join((self.checkbox_prefix, role_id, user_login_id))
def user_is_assigned(self, user_login, role_id):
if self.prm.getSetting(role_id, user_login) == Allow:
return True
return False
def role_listing(self, role_id, editable):
listing = []
users = common.get_users(role_id)
if not users:
return _("No users available for this role.")
for user in users:
data = {}
data["title"] = IDCDescriptiveProperties(user).title
data["name"] = self.make_id(user.login, role_id)
data["is_assigned"] = self.user_is_assigned(user.login, role_id)
data["editable"] = editable
listing.append(data)
formatter = TableFormatter(self.context,
self.request,
listing,
prefix="assignment",
columns=self.columns)
formatter.updateBatching()
return formatter()
def update(self):
self.tables = []
assignable_roles = self.assignable_roles()
for role_id in assignable_roles:
if role_id in assignable_roles:
editable = True
else:
editable = False
self.tables.append({
"title": getUtility(IRole, role_id).title,
"table": self.role_listing(role_id, editable)
})
forms.common.BaseForm.update(self)
def get_selected(self):
selected = [
(k[len(self.checkbox_prefix) + 1:].split(".")[0].decode("base64"),
k[len(self.checkbox_prefix) + 1:].split(".")[1].decode("base64"))
for k in self.request.form.keys()
if k.startswith(self.checkbox_prefix) and self.request.form.get(k)
]
return selected
def process_assignment(self):
for role_id in self.assignable_roles():
for user in common.get_users(role_id):
key = self.make_id(user.login, role_id)
if key in self.request.form.keys():
self.prm.assignRoleToPrincipal(role_id, user.login)
else:
self.prm.unsetRoleForPrincipal(role_id, user.login)
@formlib.form.action(label=_("Save"), name="save", condition=can_edit)
def handle_save(self, action, data):
self.process_assignment()
next_url = url.absoluteURL(self.context, self.request)
self.request.response.redirect(next_url)
@formlib.form.action(label=_("Cancel"), name="", condition=can_edit)
def handle_cancel(self, action, data):
next_url = url.absoluteURL(self.context, self.request)
self.request.response.redirect(next_url)
class GenerateDebateRecordTakes(BungeniBrowserView, ui.BaseForm):
"""View to generate takes
"""
form_fields = []
template = NamedTemplate("alchemist.subform")
def __init__(self, context, request):
if IDebateTakeContainer.providedBy(context):
self.context = removeSecurityProxy(context).__parent__
else:
self.context = removeSecurityProxy(context)
self.prm = IPrincipalRoleMap(self.context)
self.request = request
#super(GenerateDebateRecordTakes, self).__init__(context, request)
def get_take_duration(self):
return component.getUtility(IDebateRecordConfig).get_take_duration()
def get_transcriber_role(self):
return component.getUtility(IDebateRecordConfig).get_transcriber_role()
def get_transcribers(self):
transcribers = []
transcriber_role = self.get_transcriber_role()
users = common.get_local_users_for_subrole(transcriber_role)
for user in users:
if self.user_is_assigned(user.login, transcriber_role):
transcribers.append(user)
return transcribers
def user_is_assigned(self, user_login, role_id):
if self.prm.getSetting(role_id, user_login) == Allow:
return True
return False
def get_take_name(self, take_count):
take_name_prefix = ""
b_take_count = take_count
while (take_count / 26):
take_count = take_count / 26
take_name_prefix = take_name_prefix + chr(64 + take_count)
return take_name_prefix + chr(65 + (b_take_count % 26))
def has_no_takes(self, action=None):
return False if len(self.context.debate_takes) > 0 else True
@formlib.form.action(label=_("Generate takes"),
name="generate",
condition=has_no_takes)
def handle_generate_takes(self, action, data):
transcribers = self.get_transcribers()
next_url = url.absoluteURL(self.context, self.request)
if not transcribers:
return self.request.response.redirect(next_url + "/takes")
sitting = self.context.sitting
take_time_delta = datetime.timedelta(seconds=self.get_take_duration())
current_end_time = sitting.start_date
current_start_time = sitting.start_date
take_count = 0
session = Session()
while current_end_time < sitting.end_date:
take = domain.DebateTake()
take.debate_record_id = self.context.debate_record_id
take.start_date = current_start_time
if ((current_end_time + take_time_delta) > sitting.end_date):
current_end_time = sitting.end_date
else:
current_end_time = current_end_time + take_time_delta
current_start_time = current_end_time + datetime.timedelta(
seconds=1)
take.end_date = current_end_time
take.transcriber_id = transcribers[take_count %
len(transcribers)].user_id
take.debate_take_name = self.get_take_name(take_count)
take_count = take_count + 1
session.add(take)
session.flush()
return self.request.response.redirect(next_url + "/takes")
class UserAssignmentView(forms.common.BaseForm):
"""View for user assignments. Allows users with adequate permissions
to edit the assignments
"""
form_fields = []
render = ViewPageTemplateFile("templates/assignment.pt")
def __init__(self, context, request):
self._assignable_roles = []
self.principal = utils.common.get_request_principal()
self.context_roles = common.get_context_roles(
context, self.principal)
self.context = removeSecurityProxy(context)
self.prm = IPrincipalRoleMap(self.context)
super(UserAssignmentView, self).__init__(context, request)
def __call__(self):
self.update()
return self.render()
def get_object_type_info(self):
return capi.get_type_info(self.context.__class__)
def get_config_roles(self, role_type):
ti = self.get_object_type_info()
workflow = ti.workflow
if workflow.has_feature("user_assignment"):
feature = None
for f in workflow.features:
if f.name == "user_assignment":
feature = f
if feature:
if role_type == "assigner":
return capi.schema.qualified_roles(feature.params["assigner_roles"])
elif role_type == "assignable":
return capi.schema.qualified_roles(feature.params["assignable_roles"])
return []
def assignable_roles(self):
"""Returns a list of role ids that this user can assign to
"""
if self._assignable_roles:
return self._assignable_roles
# the assigner roles that this user has
assigner_roles = []
# all the assigner roles that are in the workflow config
config_assigner_roles = self.get_config_roles("assigner")
for c_a_role in config_assigner_roles:
role = getUtility(IRole, c_a_role)
if role.id in self.context_roles:
assigner_roles.append(role.id)
# the assignable roles that this user can assign to
assignable_roles = []
# all the assignable roles that are in the workflow config
config_assignable_roles = self.get_config_roles("assignable")
# Only assign to roles that have the same parent or are children
# of assigner roles that this user has
for assigner_role in assigner_roles:
assigner_role_annt = ISubRoleAnnotations(
getUtility(IRole, assigner_role))
if assigner_role_annt.is_sub_role:
for c_assignable_role in config_assignable_roles:
c_assignable_role_annt = ISubRoleAnnotations(
getUtility(IRole, c_assignable_role))
if (c_assignable_role_annt.parent ==
assigner_role_annt.parent):
assignable_roles.append(c_assignable_role)
else:
for c_assignable_role in config_assignable_roles:
if (c_assignable_role in assigner_role_annt.sub_roles):
assignable_roles.append(c_assignable_role)
self._assignable_roles = assignable_roles
return self._assignable_roles
def can_edit(self, action=None):
return checkPermission("bungeni.user_assignment.Edit", self.context)
@property
def columns(self):
return [
column.GetterColumn(
title=_("user name"),
getter=lambda i, f: i.get("title")
),
column.GetterColumn(
title=_("assigned"),
getter=lambda i, f: i,
cell_formatter=lambda g, i, f: \
'<input type="checkbox" name="%s" %s %s/>' % (
i["name"],
i["is_assigned"] and ' checked="checked"' or "",
not i["editable"] and ' disabled="disabled"' or "")
)
]
@property
def checkbox_prefix(self):
return "assignment_users"
def make_id(self, role_id, user_login_id):
return ".".join(
(self.checkbox_prefix, role_id, user_login_id))
def user_is_assigned(self, user_login, role_id):
if self.prm.getSetting(role_id, user_login) == Allow:
return True
return False
def role_listing(self, role_id, editable):
listing = []
users = common.get_users(role_id)
if not users:
return _("No users available for this role.")
for user in users:
data = {}
data["title"] = IDCDescriptiveProperties(user).title
data["name"] = self.make_id(user.login, role_id)
data["is_assigned"] = self.user_is_assigned(user.login, role_id)
data["editable"] = editable
listing.append(data)
formatter = TableFormatter(
self.context, self.request, listing, prefix="assignment",
columns=self.columns)
formatter.updateBatching()
return formatter()
def update(self):
self.tables = []
assignable_roles = self.assignable_roles()
for role_id in assignable_roles:
if role_id in assignable_roles:
editable = True
else:
editable = False
self.tables.append(
{"title": getUtility(IRole, role_id).title,
"table": self.role_listing(role_id, editable)})
forms.common.BaseForm.update(self)
def get_selected(self):
selected = [
(k[len(self.checkbox_prefix) + 1:].split(".")[0].decode("base64"),
k[len(self.checkbox_prefix) + 1:].split(".")[1].decode("base64"))
for k in self.request.form.keys()
if k.startswith(self.checkbox_prefix) and self.request.form.get(k)
]
return selected
def process_assignment(self):
for role_id in self.assignable_roles():
for user in common.get_users(role_id):
key = self.make_id(user.login, role_id)
if key in self.request.form.keys():
self.prm.assignRoleToPrincipal(role_id, user.login)
else:
self.prm.unsetRoleForPrincipal(role_id, user.login)
@formlib.form.action(label=_("Save"), name="save", condition=can_edit)
def handle_save(self, action, data):
self.process_assignment()
next_url = url.absoluteURL(self.context, self.request)
self.request.response.redirect(next_url)
@formlib.form.action(label=_("Cancel"), name="", condition=can_edit)
def handle_cancel(self, action, data):
next_url = url.absoluteURL(self.context, self.request)
self.request.response.redirect(next_url)
class DebateRecordTakes(BungeniBrowserView, forms.common.BaseForm):
"""View to generate takes
"""
form_fields = []
render = ViewPageTemplateFile("templates/debate-takes.pt")
def __init__(self, context, request):
self.context = removeSecurityProxy(context)
self.prm = IPrincipalRoleMap(self.context)
super(DebateRecordTakes, self).__init__(context, request)
def __call__(self):
self.update()
self.listing = self.formatted_listing()
return self.render()
def columns(self):
date_formatter = date.getLocaleFormatter(common.get_request(),
"dateTime", "medium")
listing_columns = [
column.GetterColumn(
title=_("Take start time"),
getter=lambda i,f: date_formatter.format(i.start_date)
),
column.GetterColumn(
title=_("Take end time"),
getter=lambda i,f: date_formatter.format(i.end_date)
),
column.GetterColumn(
title=_("Take name"),
getter=lambda i,f: i.debate_take_name
),
column.GetterColumn(
title=_("Take transcriber"),
getter=lambda i,f: IDCDescriptiveProperties(i.user).title
),
]
return listing_columns
def formatted_listing(self):
formatter = TableFormatter(self.context, self.request,
self.context.debate_takes, columns=self.columns()
)
formatter.updateBatching()
return formatter()
def get_take_duration(self):
return component.getUtility(IDebateRecordConfig).get_take_duration()
def get_transcriber_role(self):
return component.getUtility(IDebateRecordConfig).get_transcriber_role()
def get_transcribers(self):
transcribers = []
transcriber_role = self.get_transcriber_role()
users = common.get_users(transcriber_role)
for user in users:
if self.user_is_assigned(user.login, transcriber_role):
transcribers.append(user)
return transcribers
def user_is_assigned(self, user_login, role_id):
if self.prm.getSetting(role_id, user_login) == Allow:
return True
return False
def get_take_name(self, take_count):
take_name_prefix = ""
b_take_count = take_count
while (take_count / 26):
take_count = take_count / 26
take_name_prefix = take_name_prefix + chr(64+take_count)
return take_name_prefix + chr(65+(b_take_count%26))
def has_no_takes(self, action=None):
return False if len(self.context.debate_takes) > 0 else True
@formlib.form.action(label=_("Generate takes"), name="generate",
condition=has_no_takes)
def handle_generate_takes(self, action, data):
transcribers = self.get_transcribers()
sitting = self.context.sitting
take_time_delta = datetime.timedelta(seconds=self.get_take_duration())
current_end_time = sitting.start_date
current_start_time = sitting.start_date
take_count = 0
session = Session()
while current_end_time < sitting.end_date:
take = domain.DebateTake()
take.debate_record_id = self.context.debate_record_id
take.start_date = current_start_time
if ((current_end_time + take_time_delta) > sitting.end_date):
current_end_time = sitting.end_date
else:
current_end_time = current_end_time + take_time_delta
current_start_time = current_end_time + datetime.timedelta(
seconds=1)
take.end_date = current_end_time
take.transcriber_id = transcribers[
take_count % len(transcribers)].user_id
take.debate_take_name = self.get_take_name(take_count)
take_count = take_count+1
session.add(take)
session.flush()
next_url = url.absoluteURL(self, self.request)
self.request.response.redirect(next_url)
class GenerateDebateRecordTakes(BungeniBrowserView, ui.BaseForm):
"""View to generate takes
"""
form_fields = []
template = NamedTemplate("alchemist.subform")
def __init__(self, context, request):
if IDebateTakeContainer.providedBy(context):
self.context = removeSecurityProxy(context).__parent__
else:
self.context = removeSecurityProxy(context)
self.prm = IPrincipalRoleMap(self.context)
self.request = request
#super(GenerateDebateRecordTakes, self).__init__(context, request)
def get_take_duration(self):
return component.getUtility(IDebateRecordConfig).get_take_duration()
def get_transcriber_role(self):
return component.getUtility(IDebateRecordConfig).get_transcriber_role()
def get_transcribers(self):
transcribers = []
transcriber_role = self.get_transcriber_role()
users = common.get_local_users_for_subrole(transcriber_role)
for user in users:
if self.user_is_assigned(user.login, transcriber_role):
transcribers.append(user)
return transcribers
def user_is_assigned(self, user_login, role_id):
if self.prm.getSetting(role_id, user_login) == Allow:
return True
return False
def get_take_name(self, take_count):
take_name_prefix = ""
b_take_count = take_count
while (take_count / 26):
take_count = take_count / 26
take_name_prefix = take_name_prefix + chr(64 + take_count)
return take_name_prefix + chr(65 + (b_take_count % 26))
def has_no_takes(self, action=None):
return False if len(self.context.debate_takes) > 0 else True
@formlib.form.action(label=_("Generate takes"), name="generate",
condition=has_no_takes)
def handle_generate_takes(self, action, data):
transcribers = self.get_transcribers()
next_url = url.absoluteURL(self.context, self.request)
if not transcribers:
return self.request.response.redirect(next_url + "/takes")
sitting = self.context.sitting
take_time_delta = datetime.timedelta(seconds=self.get_take_duration())
current_end_time = sitting.start_date
current_start_time = sitting.start_date
take_count = 0
session = Session()
while current_end_time < sitting.end_date:
take = domain.DebateTake()
take.debate_record_id = self.context.debate_record_id
take.start_date = current_start_time
if ((current_end_time + take_time_delta) > sitting.end_date):
current_end_time = sitting.end_date
else:
current_end_time = current_end_time + take_time_delta
current_start_time = current_end_time + datetime.timedelta(
seconds=1)
take.end_date = current_end_time
take.transcriber_id = transcribers[
take_count % len(transcribers)].user_id
take.debate_take_name = self.get_take_name(take_count)
take_count = take_count + 1
session.add(take)
session.flush()
return self.request.response.redirect(next_url + "/takes")
class DebateRecordTakes(BungeniBrowserView, forms.common.BaseForm):
"""View to generate takes
"""
form_fields = []
render = ViewPageTemplateFile("templates/debate-takes.pt")
def __init__(self, context, request):
self.context = removeSecurityProxy(context)
self.prm = IPrincipalRoleMap(self.context)
super(DebateRecordTakes, self).__init__(context, request)
def __call__(self):
self.update()
self.listing = self.formatted_listing()
return self.render()
def columns(self):
date_formatter = date.getLocaleFormatter(common.get_request(),
"dateTime", "medium")
listing_columns = [
column.GetterColumn(
title=_("Take start time"),
getter=lambda i, f: date_formatter.format(i.start_date)),
column.GetterColumn(
title=_("Take end time"),
getter=lambda i, f: date_formatter.format(i.end_date)),
column.GetterColumn(title=_("Take name"),
getter=lambda i, f: i.debate_take_name),
column.GetterColumn(
title=_("Take transcriber"),
getter=lambda i, f: IDCDescriptiveProperties(i.user).title),
]
return listing_columns
def formatted_listing(self):
formatter = TableFormatter(self.context,
self.request,
self.context.debate_takes,
columns=self.columns())
formatter.updateBatching()
return formatter()
def get_take_duration(self):
return component.getUtility(IDebateRecordConfig).get_take_duration()
def get_transcriber_role(self):
return component.getUtility(IDebateRecordConfig).get_transcriber_role()
def get_transcribers(self):
transcribers = []
transcriber_role = self.get_transcriber_role()
users = common.get_users(transcriber_role)
for user in users:
if self.user_is_assigned(user.login, transcriber_role):
transcribers.append(user)
return transcribers
def user_is_assigned(self, user_login, role_id):
if self.prm.getSetting(role_id, user_login) == Allow:
return True
return False
def get_take_name(self, take_count):
take_name_prefix = ""
b_take_count = take_count
while (take_count / 26):
take_count = take_count / 26
take_name_prefix = take_name_prefix + chr(64 + take_count)
return take_name_prefix + chr(65 + (b_take_count % 26))
def has_no_takes(self, action=None):
return False if len(self.context.debate_takes) > 0 else True
@formlib.form.action(label=_("Generate takes"),
name="generate",
condition=has_no_takes)
def handle_generate_takes(self, action, data):
transcribers = self.get_transcribers()
sitting = self.context.sitting
take_time_delta = datetime.timedelta(seconds=self.get_take_duration())
current_end_time = sitting.start_date
current_start_time = sitting.start_date
take_count = 0
session = Session()
while current_end_time < sitting.end_date:
take = domain.DebateTake()
take.debate_record_id = self.context.debate_record_id
take.start_date = current_start_time
if ((current_end_time + take_time_delta) > sitting.end_date):
current_end_time = sitting.end_date
else:
current_end_time = current_end_time + take_time_delta
current_start_time = current_end_time + datetime.timedelta(
seconds=1)
take.end_date = current_end_time
take.transcriber_id = transcribers[take_count %
len(transcribers)].user_id
take.debate_take_name = self.get_take_name(take_count)
take_count = take_count + 1
session.add(take)
session.flush()
next_url = url.absoluteURL(self, self.request)
self.request.response.redirect(next_url)
