def _query(self, **kw):
session = Session()
user = utils.get_login_user()
reverse = True if (kw.get("sort_dir", "desc") == "desc") else False
results = []
domain_status = self.item_status_filter(kw)
for domain_class, status in domain_status.iteritems():
if IDoc.implementedBy(domain_class):
query = session.query(domain_class).filter(
domain_class.status.in_(status)
).enable_eagerloads(False).join(
domain.UserSubscription).filter(
domain.UserSubscription.principal_id == user.user_id)
query = self.filter_group(query, domain_class, kw)
query = self.filter_title(query, domain_class, kw)
#filter on status_date
query = self.filter_status_date(query, domain_class, kw)
query = self.order_query(query, domain_class, kw, reverse)
results.extend(query.all())
count = len(results)
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)
return (results, count)
def __call__(self):
session = Session()
try:
parameters = self.process_parameters()
except OAuthException as e:
return bad_request(self.context, self.request, e)
authorization_token = parameters["authorization_token"]
if parameters["grant_type"] == "authorization_code":
authorization_token.expiry = datetime.now()
access_token = domain.OAuthAccessToken()
access_token.access_token = get_key()
access_token.authorization_token = authorization_token
t_delta = timedelta(seconds=capi.oauth_access_token_expiry_time())
access_token.expiry = datetime.now() + t_delta
session.add(access_token)
session.flush()
data = {
"access_token": access_token.access_token,
"token_type": "bearer",
"expires_in": capi.oauth_access_token_expiry_time(),
"refresh_token": access_token.authorization_token.refresh_token
}
misc.set_json_headers(self.request)
return simplejson.dumps(data)
def update(self):
user_id = self.context.user_id
parliament_id = self.context.group_id
session = Session()
# add cosigned items
signed_pi_ids = [
sgn.item_id for sgn in session.query(domain.Signatory).filter(
sql.and_(
domain.Signatory.user_id == user_id,
domain.Signatory.status.in_(
get_states("signatory", tagged=["public"])),
)).all()
]
if len(signed_pi_ids) > 0:
self.query = self.query.union(
session.query(domain.ParliamentaryItem).filter(
sql.and_(
domain.ParliamentaryItem.parliament_id ==
parliament_id,
domain.ParliamentaryItem.status.in_(self.states),
domain.ParliamentaryItem.parliamentary_item_id.in_(
signed_pi_ids))))
self.query = self.query.order_by(
domain.ParliamentaryItem.parliamentary_item_id.desc())
def title_member(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
mp_user = None
try:
mp_user = session.query(domain.MemberOfParliament).filter(
domain.MemberOfParliament.user_id == context.user_id).one()
except NoResultFound:
#this user has no associated MP record
pass
except MultipleResultsFound:
# this should not happen
log.error("Multiple MP objects found for : %s", context.__str__())
finally:
if mp_user is None:
return self.title
dc_constituency = IDCDescriptiveProperties(mp_user.constituency)
return _(
"member_title_with_constituency",
default=u"Member of Parliament for ${constituency} (${member})",
mapping={
"constituency": dc_constituency.title,
"member": self.title
})
def constructQuery(self, context):
session = Session()
trusted = removeSecurityProxy(context)
user_id = getattr(trusted, self.value_field, None)
if user_id:
query = session.query(
domain.User).filter(domain.User.user_id == user_id).order_by(
domain.User.last_name, domain.User.first_name,
domain.User.middle_name)
return query
else:
parliament_id = self._get_parliament_id(trusted)
if parliament_id:
query = session.query(MemberOfParliament).filter(
sql.and_(MemberOfParliament.group_id == parliament_id,
MemberOfParliament.active_p == True)).order_by(
MemberOfParliament.last_name,
MemberOfParliament.first_name,
MemberOfParliament.middle_name)
else:
query = session.query(domain.User).order_by(
domain.User.last_name, domain.User.first_name,
domain.User.middle_name)
return query
def GET(self):
session = Session()
if "name" in self.request.keys():
group_values = session.query(domain.Group).filter(
sa.and_(domain.Group.status == "active",
domain.Group.principal_name == self.request["name"])
).all()
data ={}
if len(group_values) == 1:
group = group_values[0]
data = {
"principal_name": group.principal_name,
"groupid" : group.principal_name,
"title" : group.short_name or u"",
"description" : group.description or u"",
}
return self.json_response(data)
elif "user_name" in self.request.keys():
group_values = session.query(domain.Group).filter(
domain.Group.principal_name == self.request["user_name"]).all()
data ={}
if len(group_values) == 1:
group = group_values[0]
data = {
"groupid" : group.principal_name,
"title" : group.short_name or u"",
"description" : group.description or u"",
}
return self.json_response(data)
else:
group_values = [
(r.principal_name) for
r in session.query(domain.Group).filter
(domain.Group.status == "active").all()
]
return self.json_response(group_values)
def deactivateGroupMembers(group):
""" upon dissolution of a group all group members
are deactivated and get the end date of the group"""
session = Session()
group_id = group.group_id
end_date = group.end_date
assert(end_date != None)
connection = session.connection(domain.Group)
connection.execute(
schema.user_group_memberships.update().where(
rdb.and_(
schema.user_group_memberships.c.group_id == group_id,
schema.user_group_memberships.c.active_p == True
)
).values(active_p=False)
)
connection.execute(
schema.user_group_memberships.update().where(
rdb.and_(
schema.user_group_memberships.c.group_id == group_id,
schema.user_group_memberships.c.end_date == None
)
).values(end_date=end_date)
)
def deactivateGroupMemberTitles(group):
group_members = rdb.select([schema.user_group_memberships.c.user_id],
schema.user_group_memberships.c.group_id == group_id)
connection.execute(
schema.member_titles.update().where(
rdb.and_(
schema.member_titles.c.membership_id.in_(group_members),
schema.member_titles.c.end_date == None
)
).values(end_date=end_date)
)
deactivateGroupMemberTitles(group)
def handle_save(self, action, data):
session = Session()
trusted = removeSecurityProxy(self.context)
sitting = session.query(domain.GroupSitting).get(trusted.sitting_id)
if sitting.hansard.media_paths is None:
media_paths = domain.HansardMediaPaths()
media_paths.web_optimised_video_path = data[
'web_optimised_video_path']
media_paths.audio_only_path = data['audio_only_path']
media_paths.high_quality_video_path = data[
'high_quality_video_path']
media_paths.hansard_id = sitting.hansard.hansard_id
session.add(media_paths)
else:
sitting.hansard.media_paths.web_optimised_video_path = data[
'web_optimised_video_path']
sitting.hansard.media_paths.audio_only_path = data[
'audio_only_path']
sitting.hansard.media_paths.high_quality_video_path = data[
'high_quality_video_path']
session.update(sitting)
session.commit()
self._next_url = absoluteURL(self.context, self.request) + "/hansard"
self.request.response.redirect(self._next_url)
def _query(self):
principal = get_principal()
roles = get_principal_roles(principal)
#Add bungeni.Owner to the roles
roles.append("bungeni.Owner")
workspace_tabs = component.getUtility(IWorkspaceTabsUtility)
domain_status = {}
for role in roles:
dom_stat = workspace_tabs.getDomainAndStatuses(role, self.__name__)
if dom_stat:
for key in dom_stat.keys():
if key in domain_status.keys():
domain_status[key].extend(dom_stat[key])
else:
domain_status[key] = dom_stat[key]
session = Session()
results = []
for domain_class in domain_status.keys():
query = session.query(domain_class).filter(
domain_class.status.in_(domain_status[domain_class]))
results.extend(query.all())
results.sort(key=lambda x: x.status_date, reverse=True)
for result in results:
yield result
def query(self):
items_query = Session().query(self.domain_class)
if not IScheduleText.implementedBy(self.domain_class):
items_query = items_query.filter(
self.domain_class.status.in_(self.filter_states)
)
if len(self.item_filters):
for (key, value) in self.item_filters.iteritems():
column = getattr(self.domain_class, key)
#!+SCHEDULING(mb, Jan-2011) extend query spec to include sql filters
if "date" in key:
if "|" in value:
start, end = value.split("|")
if start and end:
expression = sql.between(column, start, end)
elif start:
expression = (column>=value)
elif end:
expression = (column<=value)
else:
continue
else:
expression = (column==value)
else:
expression = (column==value)
items_query = items_query.filter(expression)
if self.group_filter and not IScheduleText.implementedBy(self.domain_class):
if hasattr(self.domain_class, "parliament_id") and self.group_id:
items_query = items_query.filter(
self.domain_class.parliament_id==self.group_id
)
elif hasattr(self.domain_class, "group_id") and self.group_id:
items_query = items_query.filter(
self.domain_class.group_id==self.group_id
)
return tuple(items_query)
def handle_update(self, action, data):
session = Session()
self.template_data = []
sitting = domain.GroupSitting()
sitting = session.query(domain.GroupSitting).get(data["ids"])
sitting.start_date = data["start_date"].replace(tzinfo=None)
sitting.end_date = data["end_date"].replace(tzinfo=None)
if "language" in data.keys():
sitting.language = data["language"]
if "venue" in data.keys():
sitting.venue_id = data["venue"]
sitting.short_name = data.get("short_name", None)
sitting.activity_type = data.get("activity_type", None)
sitting.meeting_type = data.get("meeting_type", None)
sitting.convocation_type = data.get("convocation_type", None)
# set extra data needed by template
session.flush()
notify(ObjectModifiedEvent(sitting))
self.template_data.append({"group_sitting_id": sitting.group_sitting_id,
"action": "inserted",
"ids": data["ids"]})
session.flush()
self.request.response.setHeader('Content-type', 'text/xml')
return self.xml_template()
def saveDiscussions(self):
session = Session()
new_record_keys = []
domain_model = removeSecurityProxy(self.context.domain_model)
for record in self.data:
discussion_text = record.get("body_text", "")
object_id = record.get("object_id", None)
if object_id:
current_record = removeSecurityProxy(
self.context.get(getItemKey(object_id))
)
current_record.body_text = discussion_text
session.add(current_record)
session.flush()
notify(ObjectModifiedEvent(current_record))
new_record_keys.append(stringKey(current_record))
else:
new_record = domain_model(
body_text = discussion_text,
language = get_default_language()
)
new_record.scheduled_item = removeSecurityProxy(
self.context.__parent__
)
session.add(new_record)
session.flush()
notify(ObjectCreatedEvent(new_record))
new_record_keys.append(stringKey(new_record))
records_to_delete = [
removeSecurityProxy(self.context.get(key))
for key in self.context.keys() if key not in new_record_keys
]
map(session.delete, records_to_delete)
map(lambda deleted:notify(ObjectRemovedEvent(deleted)),
records_to_delete
)
def check_venue_bookings(start, end, venue, sitting=None):
"""
return all sittings (but sitting if given) a venue is booked for
in the period
"""
assert (type(start) == datetime.datetime)
assert (type(end) == datetime.datetime)
session = Session()
b_filter = sql.and_(
sql.or_(
sql.between(schema.sitting.c.start_date, start, end),
sql.between(schema.sitting.c.end_date, start, end),
sql.between(start, schema.sitting.c.start_date,
schema.sitting.c.end_date),
sql.between(end, schema.sitting.c.start_date,
schema.sitting.c.end_date)),
schema.sitting.c.venue_id == venue.venue_id)
if sitting:
if sitting.sitting_id:
b_filter = sql.and_(
b_filter, schema.sitting.c.sitting_id != sitting.sitting_id)
query = session.query(BookedVenue).filter(b_filter)
venues = query.all()
return venues
def get_available_venues(start, end, sitting=None):
"""get all venues that are not booked for a sitting
(but sitting if given)
in the given time period
SQL:
SELECT *
FROM venues
WHERE venues.venue_id NOT IN (SELECT sitting.venue_id
FROM sitting
WHERE (sitting.start_date BETWEEN '2000-01-01' AND '2000-01-02'
OR sitting.end_date BETWEEN '2000-01-01' AND '2000-01-02'
OR '2000-01-01' BETWEEN sitting.start_date AND sitting.end_date
OR '2000-01-02' BETWEEN sitting.start_date AND sitting.end_date)
AND sitting.venue_id IS NOT NULL)
"""
session = Session()
query = session.query(domain.Venue)
b_filter = sql.and_(
sql.or_(
sql.between(schema.sitting.c.start_date, start, end),
sql.between(schema.sitting.c.end_date, start, end),
sql.between(start, schema.sitting.c.start_date,
schema.sitting.c.end_date),
sql.between(end, schema.sitting.c.start_date,
schema.sitting.c.end_date)),
schema.sitting.c.venue_id != None)
if sitting:
if sitting.sitting_id:
b_filter = sql.and_(
b_filter, schema.sitting.c.sitting_id != sitting.sitting_id)
query = query.filter(
sql.not_(
schema.venues.c.venue_id.in_(
sql.select([schema.sitting.c.venue_id]).where(b_filter))))
venues = query.all()
return venues
def validate(self, action, data):
# submitted data is actually updated in following call to super.validate
# !+PASTDATAENTRY(mr, jun-2011) enhancement? see Issue 612 Comment 6:
# unrequire, allow active_date=None,
# get_effective_active_date -> last workflow non-None active_date
errors = super(WorkflowActionViewlet, self).validate(action, data)
if "date_active" in data.keys():
min_date_active = self.get_min_date_active()
if data.get("date_active") < min_date_active:
errors.append(zope.interface.Invalid(
_("Active Date is in the past.")))
elif data.get("date_active") > datetime.datetime.now():
errors.append(zope.interface.Invalid(
_("Active Date is in the future.")))
if "registry_number" in data.keys():
reg_number = data.get("registry_number")
if reg_number:
session = Session()
num = session.query(Doc
).filter(Doc.registry_number==reg_number).count()
if num != 0:
errors.append(zope.interface.Invalid(
"This registry number is already taken."))
return errors
def handle_publish(self, action, data):
self.generated_content = self.generateContent(data)
if not hasattr(self.context, "group_id"):
context_group_id = ISchedulingContext(self.context).group_id
else:
context_group_id = self.context.group_id
report = domain.Report(
short_title=self.title,
start_date=self.start_date,
end_date=self.end_date,
body=self.generated_content,
owner_id=get_db_user_id(), # !+GROUP_AS_OWNER
language=self.language,
group_id=context_group_id
)
session = Session()
session.add(report)
session.flush()
notify(ObjectCreatedEvent(report))
self.status = _(u"Report has been processed and saved")
return self.template()
def get_unavailable_venues( start, end, sitting = None ):
"""
get all venues that are booked
in the given time period
"""
assert( type(start) == datetime.datetime )
assert( type(end) == datetime.datetime )
session = Session()
b_filter = sql.or_(
sql.between(schema.sittings.c.start_date, start, end),
sql.between(schema.sittings.c.end_date, start, end),
sql.between(start, schema.sittings.c.start_date,
schema.sittings.c.end_date),
sql.between(end, schema.sittings.c.start_date,
schema.sittings.c.end_date)
)
if sitting:
if sitting.sitting_id:
b_filter = sql.and_(b_filter,
schema.sittings.c.sitting_id != sitting.sitting_id)
query = session.query(BookedVenue).filter(b_filter)
venues = query.all()
#session.close()
return venues
def title_member(self):
context = _merged(self.context)
mp_user = None
try:
mp_user = Session().query(domain.MemberOfParliament).filter(
domain.MemberOfParliament.user_id == context.user_id).one()
except NoResultFound:
#this user has no associated MP record
pass
except MultipleResultsFound:
# this should not happen
log.error("Multiple MP objects found for : %s", context.__str__())
finally:
if mp_user is None:
return self.title
if mp_user.representation:
return _("member_title_with_representation",
default=u"Member of Parliament for ${representation}"
" (${member})",
mapping={
"representation": mp_user.representation,
"member": self.title
})
return self.title
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 title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return self.translate(context, "title_name")
def mover(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return translate_i18n(
IDCDescriptiveProperties(context.owner).title_member)
def description(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return u"%s (%s)" % (context.file_name, context.file_mimetype)
def uri(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return (context.uri or "") if hasattr(context, "uri") else ""
def description(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return u"%s %s to %s" % (translate_i18n(
_(u"Covers")), context.start_date.strftime('%Y-%m-%d'),
context.end_date.strftime('%Y-%m-%d'))
def title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return context.file_title
def title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return u'%s: %s - %s' % (self.translate(
context, "short_name"), context.start_date, context.end_date)
def title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return '%s - %s ' % (self.translate(context.item, "short_name"),
self.translate(context.group, "short_name"))
def title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return '%s - %i' % (self.translate(context.constituency,
"name"), context.date.year)
def description(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return self.translate(context, "full_name")
def status(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return translate_i18n(misc.get_wf_state(context))
