def constructQuery(self, context):
session= Session()
trusted=removeSecurityProxy(context)
parliament_id = self._get_parliament_id(context)
item_id = getattr(context, self.value_field, None)
trusted = removeSecurityProxy(context)
existing_item_ids = [assn.item_id for assn in trusted.values()]
if item_id:
query = session.query(domain.ParliamentaryItem).filter(
domain.ParliamentaryItem.parliamentary_item_id ==
item_id)
else:
query = session.query(domain.ParliamentaryItem).filter(
sql.and_(
sql.not_(domain.ParliamentaryItem.status.in_(
_assignable_state_ids
)
),
sql.not_(
domain.ParliamentaryItem.parliamentary_item_id.in_(
existing_item_ids
)
),
domain.ParliamentaryItem.parliament_id == parliament_id
)
)
return query
def get_sittings(self):
session = Session()
logged_in_user = get_db_user()
title = get_title_of_user(logged_in_user.user_id)
sittings = session.query(bungeni_domain.GroupSitting).join((domain.Assignment,
bungeni_domain.GroupSitting.sitting_id == domain.Assignment.sitting_id)) \
.filter(sql.and_(bungeni_domain.GroupSitting.status == 'draft_minutes',
domain.Assignment.staff_id == logged_in_user.user_id)).all()
for sitting in sittings:
if title == "Editor":
takes = session.query(domain.Take)\
.filter(sql.and_(domain.Take.editor_id == logged_in_user.user_id,
domain.Take.sitting_id == sitting.sitting_id)) \
.order_by(domain.Take.start_date).all()
elif title == "Reader":
takes = session.query(domain.Take)\
.filter(sql.and_(domain.Take.reader_id == logged_in_user.user_id,
domain.Take.sitting_id == sitting.sitting_id)) \
.order_by(domain.Take.start_date).all()
elif title == "Reporter":
takes = session.query(domain.Take)\
.filter(sql.and_(domain.Take.reporter_id == logged_in_user.user_id,
domain.Take.sitting_id == sitting.sitting_id)) \
.order_by(domain.Take.start_date).all()
for take in takes:
take.start_time = take.start_date - sitting.start_date
take.end_time = take.end_date - sitting.start_date
sitting.takes = takes
sit = session.query(domain.Sitting).get(sitting.sitting_id)
sitting.file = sit.media_path
sitting.name = sitting.group.short_name + str(sitting.start_date.strftime('%d-%B-%Y %H:%M'))
return sittings
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 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 getUserGroups(login_id, groups):
""" get group for users:
a) the groups defined by his user_group_memberships
b) the users who have him assigned as a delegation
c) the groups of the delegation user.
"""
if login_id not in groups:
groups.append(login_id)
session = Session()
db_user = session.query(domain.User).filter(domain.User.login == login_id).all()
if len(db_user) == 1:
user_id = db_user[0].user_id
query = (
session.query(domain.GroupMembership)
.filter(rdb.and_(domain.GroupMembership.user_id == user_id, domain.GroupMembership.active_p == True))
.options(eagerload("group"), lazyload("user"))
)
results = query.all()
for result in results:
if result.group.group_principal_id not in groups:
groups.append(result.group.group_principal_id)
results = delegation.get_user_delegations(user_id)
for result in results:
if result.login not in groups:
groups = groups + getUserGroups(result.login, groups)
return groups
def constructQuery(self, context):
session= Session()
trusted=removeSecurityProxy(context)
parliament_id = self._get_parliament_id(context)
trusted = removeSecurityProxy(context)
assigned_committee_ids = []
if IGroupGroupItemAssignment.providedBy(trusted):
committee_id = getattr(trusted, "group_id", None)
if committee_id:
query = session.query(domain.Committee).filter(
sql.and_(
domain.Committee.parent_group_id == parliament_id,
domain.Committee.group_id == committee_id
)
)
return query
else:
assigned_committee_ids = \
[ comm.group_id for comm in trusted.__parent__.values() ]
else:
assigned_committee_ids = \
[ comm.group_id for comm in trusted.values() ]
query = session.query(domain.Committee).filter(
sql.and_(
domain.Committee.status == 'active',
domain.Committee.parent_group_id == parliament_id,
sql.not_(
domain.Committee.group_id.in_(assigned_committee_ids)
)
)
)
return query
def update(self):
user_id = self.context.user_id
parliament_id = self.context.group_id
wf = capi.get_type_info("signatory").workflow
session = Session()
# add cosigned items
signed_pi_ids = [sgn.head_id for sgn in
session.query(domain.Signatory).filter(
sql.and_(domain.Signatory.user_id == user_id,
domain.Signatory.status.in_(
wf.get_state_ids(tagged=["public"])
),
)
).all()
]
if len(signed_pi_ids) > 0:
self.query = self.query.union(
session.query(domain.Doc).filter(
sql.and_(
domain.Doc.parliament_id == parliament_id,
domain.Doc.status.in_(self.states),
domain.Doc.doc_id.in_(
signed_pi_ids
)
)
)
)
self.query = self.query.order_by(
domain.Doc.doc_id.desc()
)
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:
sitting = trusted.__parent__
group_id = sitting.group_id
group_sitting_id = sitting.group_sitting_id
all_member_ids = sql.select([schema.user_group_memberships.c.user_id],
sql.and_(
schema.user_group_memberships.c.group_id == group_id,
schema.user_group_memberships.c.active_p == True))
attended_ids = sql.select([schema.group_sitting_attendance.c.member_id],
schema.group_sitting_attendance.c.group_sitting_id == group_sitting_id)
query = session.query(domain.User).filter(
sql.and_(domain.User.user_id.in_(all_member_ids),
~ domain.User.user_id.in_(attended_ids))).order_by(
domain.User.last_name,
domain.User.first_name,
domain.User.middle_name)
return query
def ActiveUsers(context, role=None):
session= Session()
terms = []
hansard_office = session.query(domain.Office).filter(domain.Office.office_type == 'H').all()
if len(hansard_office) == 0:
return vocabulary.SimpleVocabulary( terms )
if role == None:
return vocabulary.SimpleVocabulary( terms )
query = session.query(domain.GroupMembership).filter(
sql.and_(domain.GroupMembership.membership_type == 'officemember',
domain.GroupMembership.active_p == True,
domain.GroupMembership.group_id == hansard_office[0].office_id)
)
results = query.all()
for ob in results:
titles = [t.title_name.user_role_name for t in ob.member_titles]
if role in titles:
obj = ob.user
terms.append(
vocabulary.SimpleTerm(
value = getattr( obj, 'user_id'),
token = getattr( obj, 'user_id'),
title = getattr( obj, 'first_name') + getattr( obj, 'last_name'),
))
return vocabulary.SimpleVocabulary( terms )
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 __call__(self):
obj = self.request.form['obj[]']
session = Session()
if self.context.status == "draft_agenda":
for i in range(0,len(obj)):
sch = session.query(domain.ItemSchedule).get(obj[i])
setattr(sch, 'planned_order', i+1)
elif self.context.status == "draft_minutes":
for i in range(0,len(obj)):
sch = session.query(domain.ItemSchedule).get(obj[i])
setattr(sch, 'real_order', i+1)
session.flush()
def handle_restore(self, action, data):
site_url = ui_utils.url.absoluteURL(getSite(), self.request)
login = data.get("login", "")
email = data.get("email", "")
user = None
app = BungeniApp()
settings = EmailSettings(app)
session = Session()
if email:
user = session.query(User).filter(
User.email==email).first()
elif login:
user = session.query(User).filter(
User.login==login).first()
if user:
email = user.email
link = session.query(PasswordRestoreLink).filter(
PasswordRestoreLink.user_id==user.user_id).first()
if link:
if not link.expired():
self.status = _(u"This user's link is still active!")
return
else:
link = PasswordRestoreLink()
link.hash = hashlib.sha224(user.login +
SECRET_KEY +
str(datetime.datetime.now())).hexdigest()
link.expiration_date = datetime.datetime.now() + datetime.timedelta(1)
link.user_id = user.user_id
session.add(link)
mailer = getUtility(ISMTPMailer, name="bungeni.smtp")
self.message = _(u"Restore password link: ")\
+ "%s/reset_password?key=%s" % (site_url, link.hash)
self.message += u"\n\n"
self.message += _(u"This link will expire in 24 hours.")
text = ViewPageTemplateFile("templates/mail.pt")(self)
message = MIMEText(text)
message.set_charset("utf-8")
message["Subject"] = _(u"Bungeni password restoration")
message["From"] = settings.default_sender
mailer.send(settings.default_sender, email, str(message))
self.status = _(u"Email was sent!")
else:
self.status = _(u"User not found!")
def GET(self):
if "auth" in self.request.keys():
cols = [user.c.user_id]
if self.request["auth"] != "None":
cols.extend([user.c.password, user.c.salt])
session = Session()
connection = session.connection(domain.Group)
res = connection.execute(sa.select(cols,
sa.and_(
user.c.login == self.request["login"],
user.c.active_p == "A"
)))
uid_tuple = res.fetchone()
if not uid_tuple:
return None
if self.request["auth"] != "None":
return self.json_response(str(uid_tuple))
return self.json_response(uid_tuple[0])
elif "login" in self.request.keys():
session = Session()
usr = session.query(domain.User).filter(
sa.and_(
domain.User.login == self.request["login"],
domain.User.active_p == "A")
).one()
return self.json_response(usr)
elif "user_name" in self.request.keys():
session = Session()
user_values = session.query(domain.User).filter(
domain.User.login == self.request["user_name"]).all()
data = {}
if len(user_values) == 1:
b_user = user_values[0]
data = {
"combined_name": b_user.combined_name,
"email": b_user.email or u"",
"description": b_user.description or u"",
"notification": b_user.receive_notification or False,
}
return self.json_response(data)
else:
user_values = user.select(
[user.c.login], user.c.active_p == "A").execute()
if "user_manager_id" in self.request.keys():
plugin_id = self.request["user_manager_id"]
data = [dict(id=safeencode(r["login"]),
login=safeencode(r["login"]),
pluginid=plugin_id) for r in user_values]
else:
data = tuple([safeencode(r["login"]) for r in user_values])
return self.json_response(data)
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 handle_save(self, action, data):
report = domain.Report()
session = Session()
report.body_text = data["body_text"]
report.start_date = data["start_date"]
report.end_date = data["end_date"]
report.note = data["note"]
report.short_name = report.short_name = data["short_name"]
owner_id = get_db_user_id()
'''!+TODO(Miano, 18/08/2010) The admin user is currently not a db user
thus the line above returns None when the admin publishes a report.
to go around this if it returns None, just query the db for users
and set the owner id to be the first result'''
if owner_id is not None:
report.owner_id = owner_id
else:
query = session.query(domain.User)
results = query.all()
report.owner_id = results[0].user_id
# TODO get language from config
report.language = "en"
report.created_date = datetime.datetime.now()
report.group_id = self.context.group_id
session.add(report)
notify(ObjectCreatedEvent(report))
# !+INVALIDATE(mr, sep-2010)
container.invalidate_caches_for("Report", "add")
if "sittings" in data.keys():
try:
ids = data["sittings"].split(",")
for id_number in ids:
sit_id = int(id_number)
sitting = session.query(domain.GroupSitting).get(sit_id)
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
# !+INVALIDATE(mr, sep-2010) via an event...
container.invalidate_caches_for("SittingReport", "add")
except:
#if no sittings are present in report or some other error occurs
pass
session.commit()
if IGroupSitting.providedBy(self.context):
back_link = "./schedule"
elif ISchedulingContext.providedBy(self.context):
back_link = "./"
else:
raise NotImplementedError
self.request.response.redirect(back_link)
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 legislature(self):
"""Get the Legislature singleton instance -- ALWAYS call this from
anywhere in the code to retrieve the Legislature singleton.
Raises sqlalchemy.orm.exc.NoResultFound.
"""
from bungeni.alchemist import Session
from bungeni.models.domain import Legislature
session = Session()
if Legislature._instance is None:
session.query(Legislature).one() # this primes Legislature._instance
# merge to avoid sqlalchemy.orm.exc.DetachedInstanceError
session.merge(Legislature._instance)
assert Legislature._instance.group_id is not None # !+LEGISLATURE_SETUP
# retrieve the Legislature singleton by just "creating" a new one
return Legislature()
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 process_attendance(self):
session = Session()
trusted = removeSecurityProxy(self.context)
gs_id = trusted.sitting_id
for selection in self.get_selected():
member_id = selection.get("user_id")
if not member_id:
continue
at = selection.get("attendance_type")
if not at:
continue
member_id = int(member_id)
# check existing attendance record
query = session.query(SittingAttendance).filter(
sql.and_(SittingAttendance.member_id == member_id,
SittingAttendance.sitting_id == gs_id))
result = query.first()
if result is not None:
result.attendance_type = at
session.flush()
zope.event.notify(
zope.lifecycleevent.ObjectModifiedEvent(
result,
zope.lifecycleevent.Attributes(ISittingAttendance,
"attendance_type")))
else:
m_attendance = SittingAttendance()
m_attendance.sitting_id = gs_id
m_attendance.attendance_type = at
m_attendance.member_id = member_id
session.add(m_attendance)
session.flush()
zope.event.notify(
zope.lifecycleevent.ObjectCreatedEvent(m_attendance))
self.status = _("Updated attendance record")
def __call__(self, context=None):
query = self.constructQuery(context)
results = query.all()
terms = []
for ob in results:
terms.append(
vocabulary.SimpleTerm(
value = getattr(ob, 'user_id'),
token = getattr(ob, 'user_id'),
title = "%s %s" % (getattr(ob, 'first_name') ,
getattr(ob, 'last_name'))
))
user_id = getattr(context, self.value_field, None)
if user_id:
if len(query.filter(schema.users.c.user_id == user_id).all()) == 0:
session = Session()
ob = session.query(domain.User).get(user_id)
terms.append(
vocabulary.SimpleTerm(
value = getattr(ob, 'user_id'),
token = getattr(ob, 'user_id'),
title = "(%s %s)" % (getattr(ob, 'first_name') ,
getattr(ob, 'last_name'))
))
return vocabulary.SimpleVocabulary(terms)
def validate_venues(action, data, context, container):
"""A venue can only be booked for one sitting at once."""
errors = []
if interfaces.IGroupSitting.providedBy(context):
sitting = context
else:
sitting = None
venue_id = data.get('venue_id')
if venue_id is not None:
venue_id = long(venue_id)
session = Session()
svenue = session.query(domain.Venue).get(venue_id)
else:
return []
start = data.get('start_date')
end = data.get('end_date')
if not (start and end):
return []
for booking in venue.check_venue_bookings(start, end, svenue, sitting):
errors.append(
interface.Invalid(
_(u'Venue "$venue" already booked in this time slot',
mapping={'venue': booking.short_name}), "venue_id"))
return errors
def __call__(self, context=None):
query = self.constructQuery(context)
results = query.all()
tdict = {}
for ob in results:
tdict[getattr(ob.user, 'user_id')] = "%s %s" % (
getattr(ob.user, 'first_name'),
getattr(ob.user, 'last_name'))
user_id = getattr(context, 'replaced_id', None)
if user_id:
if len(query.filter(domain.GroupMembership.replaced_id == user_id).all()) == 0:
session = Session()
ob = session.query(domain.User).get(user_id)
tdict[getattr(ob, 'user_id')] = "%s %s" % (
getattr(ob, 'first_name'),
getattr(ob, 'last_name'))
terms = []
for t in tdict.keys():
terms.append(
vocabulary.SimpleTerm(
value = t,
token = t,
title = tdict[t]
))
return vocabulary.SimpleVocabulary(terms)
def constructQuery(self, context):
session = Session()
trusted = removeSecurityProxy(context)
parliament_id = self._get_parliament_id(context)
bill_id = getattr(context, self.value_field, None)
if bill_id:
query = session.query(domain.Bill).filter(
domain.Bill.parliamentary_item_id == bill_id)
else:
query = session.query(domain.Bill).filter(
sql.and_(
sql.not_(
domain.Bill.status.in_(
['draft', 'withdrawn', 'approved', 'rejected'])),
domain.Bill.parliament_id == parliament_id))
return query
def __call__(self, context=None):
query = self.constructQuery(context)
results = query.all()
terms = []
for ob in results:
terms.append(
vocabulary.SimpleTerm(
value=getattr(ob, 'user_id'),
token=getattr(ob, 'user_id'),
title="%s %s" %
(getattr(ob, 'first_name'), getattr(ob, 'last_name'))))
user_id = getattr(context, self.value_field, None)
if user_id:
if query.filter(
domain.GroupMembership.user_id == user_id).count() == 0:
# The user is not a member of this group.
# This should not happen in real life
# but if we do not add it her the view form will
# throw an exception
session = Session()
ob = session.query(domain.User).get(user_id)
terms.append(
vocabulary.SimpleTerm(
value=getattr(ob, 'user_id'),
token=getattr(ob, 'user_id'),
title="(%s %s)" %
(getattr(ob, 'first_name'), getattr(ob, 'last_name'))))
return vocabulary.SimpleVocabulary(terms)
def __call__(self, context=None):
query = self.constructQuery(context)
results = query.all()
terms = []
trusted = removeSecurityProxy(context)
ministry_id = getattr(trusted, self.value_field, None)
for ob in results:
obj = translate_obj(ob)
terms.append(
vocabulary.SimpleTerm(
value=getattr(obj, 'group_id'),
token=getattr(obj, 'group_id'),
title="%s - %s" %
(getattr(obj, 'short_name'), getattr(obj, 'full_name'))))
if ministry_id:
if query.filter(domain.Group.group_id == ministry_id).count() == 0:
session = Session()
ob = session.query(domain.Group).get(ministry_id)
obj = translate_obj(ob)
terms.append(
vocabulary.SimpleTerm(
value=getattr(obj, 'group_id'),
token=getattr(obj, 'group_id'),
title="%s - %s" % (getattr(
obj, 'short_name'), getattr(obj, 'full_name'))))
return vocabulary.SimpleVocabulary(terms)
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 __call__(self, context=None):
query = self.constructQuery(context)
results = query.all()
tdict = {}
for ob in results:
tdict[getattr(ob.user, 'user_id')] = "%s %s" % (
getattr(ob.user, 'first_name') ,
getattr(ob.user, 'last_name'))
user_id = getattr(context, 'replaced_id', None)
if user_id:
if len(query.filter(domain.GroupMembership.replaced_id == user_id).all()) == 0:
session = Session()
ob = session.query(domain.User).get(user_id)
tdict[getattr(ob, 'user_id')] = "%s %s" % (
getattr(ob, 'first_name') ,
getattr(ob, 'last_name'))
terms = []
for t in tdict.keys():
terms.append(
vocabulary.SimpleTerm(
value = t,
token = t,
title = tdict[t]
))
return vocabulary.SimpleVocabulary(terms)
def __call__(self, context=None):
query = self.constructQuery(context)
results = query.all()
terms = []
trusted=removeSecurityProxy(context)
ministry_id = getattr(trusted, self.value_field, None)
for ob in results:
obj = translate_obj(ob)
terms.append(
vocabulary.SimpleTerm(
value = getattr(obj, 'group_id'),
token = getattr(obj, 'group_id'),
title = "%s - %s" % (getattr(obj, 'short_name'),
getattr(obj, 'full_name'))
))
if ministry_id:
if query.filter(domain.Group.group_id == ministry_id).count() == 0:
session = Session()
ob = session.query(domain.Group).get(ministry_id)
obj = translate_obj(ob)
terms.append(
vocabulary.SimpleTerm(
value = getattr(obj, 'group_id'),
token = getattr(obj, 'group_id'),
title = "%s - %s" % (getattr(obj, 'short_name'),
getattr(obj, 'full_name'))
))
return vocabulary.SimpleVocabulary(terms)
def constructQuery(self, context):
session = Session()
parliament_id = self._get_parliament_id(context)
query = session.query(domain.Committee).filter(
sql.and_(domain.Committee.status == 'active',
domain.Committee.parent_group_id == parliament_id))
return query
def sendNotificationToMP(date):
"""
send a mail to the MP asking the question that the deadline
of the question is aproaching
"""
status = u"Question pending response" #q_state.response_pending
text = translate('notification_email_to_mp_question_pending_response',
target_language='en',
domain='bungeni.core',
default="Questions pending responses.")
session = Session()
qfilter = sql.and_(
(domain.Question.ministry_submit_date < date),
(domain.Question.status == status),
)
questions = session.query(domain.Question).filter(qfilter).all()
for question in questions:
mailto = _getMemberOfParliamentEmail(question)
if mailto and True: #!+NOTIFICATION_SETTINGS = True
msg = MIMEText(text)
msg['Subject'] = u'Questions pending response'
msg['From'] = prefs.getAdministratorsEmail()
msg['To'] = mailto
text = text + '\n' + question.subject + '\n'
print msg
# !+SENDMAIL(ah,18-03-2010)
#Mail sending is commented out below
dispatch(msg)
class ChangePasswordForm(form.FormBase):
form_fields = form.Fields(IChangePasswordForm)
prefix = ""
form_name = _(u"Change password")
# !+ only used here [ bungeni.ui.login.Login ] ?
template = NamedTemplate("alchemist.form")
def __init__(self, *args, **kwargs):
super(ChangePasswordForm, self).__init__(*args, **kwargs)
self.session = Session()
user_id = get_db_user_id(self.context)
self.user = self.session.query(User)\
.filter(User.user_id==user_id).first()
def __call__(self):
if IUnauthenticatedPrincipal.providedBy(self.request.principal):
self.request.response.redirect(
ui_utils.url.absoluteURL(getSite(), self.request) + "/login")
return super(ChangePasswordForm, self).__call__()
@form.action(_(u"Change password"))
def save_password(self, action, data):
password = data.get("pswd", "")
confirm_password = data.get("confirm_password", "")
if password:
if password != confirm_password:
self.status = _("Password confirmation failed")
return
self.user._password = password
self.status = _("Password changed")
def update(self):
""" Getting necessary items
"""
session = Session()
user = session.query(domain.User).filter(
domain.User.login == self.request.principal.id).first()
if user is None:
self.items = []
else:
# Taking latest change from each item
subscriptions = []
map(
lambda x: subscriptions.extend(
sorted(filter(
lambda change: change.action not in
[u'modified', u'added'], x.changes),
key=lambda x: x.date_audit,
reverse=True)[:1]), user.subscriptions)
# Soring all items by date
subscriptions.sort(key=lambda x: x.date_audit, reverse=True)
self.items = [{
'title': self.get_title(item),
'url': self.get_url(item),
'description': self.get_description(item)
} for item in subscriptions]
def validate_non_overlapping_sitting(action, data, context, container,
*fields):
start = data.get('start_date')
end = data.get('end_date', None)
if not fields:
fields = "start_date", "end_date"
session = Session()
group_id = container.__parent__.group_id
group = session.query(domain.Group).get(group_id)
sittings = group.sittings
for sitting in queries.get_sittings_between(sittings, start, end):
if context != sitting:
return [
interface.Invalid(
_(
u"One or more events would be scheduled for $F, which "
"overlaps with an existing sitting",
mapping={'F': datetimedict.fromdatetime(start)}),
*fields)
]
return []
def _get_ministry_items(self, ministry):
session = Session()
date_formatter = self.get_date_formatter("date", "long")
def _q_data_item(q):
item = {}
item["qid"] = "q_%s" % q.question_id
if q.question_number:
item["subject"] = u"Q %s %s (%s)" % (q.question_number,
q.short_name, q.status)
else:
item["subject"] = u"%s (%s)" % (q.short_name, q.status)
item["title"] = u"%s (%s)" % (q.short_name, q.status)
item["result_item_class"] = "workflow-state-%s" % q.status
item["url"] = url.set_url_context("questions/obj-%s" %
q.question_id)
item["status"] = misc.get_wf_state(q)
item["status_date"] = date_formatter.format(q.status_date)
item["owner"] = "%s %s" % (q.owner.first_name, q.owner.last_name)
item["type"] = _(q.type)
if type(q) == domain.Question:
item["to"] = q.ministry.short_name
else:
item["to"] = u""
return item
# prepare query for this ministry's questions
mq_query = session.query(domain.Question).filter(
sql.and_(domain.Question.ministry_id == ministry.group_id,
domain.Question.status.in_(self.states),
domain.Question.response_type.in_(self.response_types)))
return [_q_data_item(question) for question in mq_query.all()]
def validate_unique(self, action, data):
"""Validate unique.
Since this class always adds a single object, we can safely
return an empty list of errors.
"""
errors = []
dm = removeSecurityProxy(self.domain_model)
# find unique columns in data model.. TODO do this statically
mapper = sa.orm.class_mapper(dm)
ucols = list(unique_columns(mapper))
# query out any existing values with the same unique values,
session = Session()
# find data matching unique columns
ctx = removeSecurityProxy(self.context)
ctx_is_dm_instance = isinstance(ctx, dm) # !+when is this not true?
for key, col in ucols:
if key in data:
# on edit ignore new value if its the same as the previous value
if ctx_is_dm_instance and data[key] == getattr(ctx, key, None):
continue
value = session.query(dm).filter(col == data[key]).count()
if not value:
continue
errors.append(self.set_widget_error(key,
_(u"A record with this value already exists")))
return errors
def resolve(self, id):
class_path, oid = id.split('-', 1)
oid, lang = oid.split(":", 1)
domain_class = resolve.resolve(class_path)
session = Session()
value_key = container.valueKey(oid)
return session.query(domain_class).get(value_key)
def _get_members(self):
pg = removeSecurityProxy(self.context)
session = Session()
dkls = domain.PartyMember # !+domain.PoliticalGroupMember
return [ m for m in
session.query(dkls).filter(dkls.group_id == pg.group_id).all()
]
def get_user_subscriptions(self):
""" Getting user subscribed items
"""
session = Session()
user = session.query(domain.User).filter(
domain.User.login == self.request.principal.id).first()
return user.subscriptions
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 __call__(self, context=None):
query = self.constructQuery(context)
results = query.all()
trusted = removeSecurityProxy(context)
type_id = getattr(trusted, "attached_file_type_id", None)
terms = []
if type_id:
session = Session()
attached_file_type = session.query(
domain.AttachedFileType).get(type_id)
terms.append(
vocabulary.SimpleTerm(
value=getattr(attached_file_type, "attached_file_type_id"),
token=getattr(attached_file_type, "attached_file_type_id"),
title=getattr(attached_file_type,
"attached_file_type_name")))
return vocabulary.SimpleVocabulary(terms)
else:
for ob in results:
if ob.attached_file_type_name not in ["system"]:
terms.append(
vocabulary.SimpleTerm(
value=getattr(ob, "attached_file_type_id"),
token=getattr(ob, "attached_file_type_id"),
title=getattr(ob, "attached_file_type_name"),
))
return vocabulary.SimpleVocabulary(terms)
def get_group_member_ids(group_principal_name):
session = Session()
group = session.query(domain.Group).filter(
domain.Group.principal_name == group_principal_name).one()
if group:
return [member.user.login for member in group.group_members]
return []
def validateUnique(self, action, data):
"""Validate unique.
Since this class always adds a single object, we can safely
return an empty list of errors.
"""
errors = []
domain_model = removeSecurityProxy(self.getDomainModel())
# find unique columns in data model.. TODO do this statically
mapper = rdb.orm.class_mapper(domain_model)
ucols = list(ui.unique_columns(mapper))
# query out any existing values with the same unique values,
session = Session()
# find data matching unique columns
for key, col in ucols:
if key in data:
# on edit ignore new value if its the same as the previous value
if isinstance(self.context, domain_model) \
and data[key] == getattr(self.context, key, None):
continue
value = session.query(domain_model).filter(
col == data[key]).count()
if not value:
continue
widget = self.widgets[key]
error = formlib.form.WidgetInputError(
widget.name, widget.label,
_(u"A record with this value already exists"))
widget._error = error
errors.append(error)
return errors
def validateUnique(self, action, data):
"""Validate unique.
Since this class always adds a single object, we can safely
return an empty list of errors.
"""
errors = []
domain_model = removeSecurityProxy(self.getDomainModel())
# find unique columns in data model.. TODO do this statically
mapper = rdb.orm.class_mapper(domain_model)
ucols = list(ui.unique_columns(mapper))
# query out any existing values with the same unique values,
session = Session()
# find data matching unique columns
for key, col in ucols:
if key in data:
# on edit ignore new value if its the same as the previous value
if isinstance(self.context, domain_model) \
and data[key] == getattr(self.context, key, None):
continue
value = session.query(domain_model
).filter(col == data[key]).count()
if not value:
continue
widget = self.widgets[ key ]
error = formlib.form.WidgetInputError(
widget.name, widget.label,
_(u"Duplicate Value for Unique Field"))
widget._error = error
errors.append(error)
return errors
def sendNotificationToMP(date):
"""
send a mail to the MP asking the question that the deadline
of the question is aproaching
"""
status = u"Question pending response" #q_state.response_pending
text = translate('notification_email_to_mp_question_pending_response',
target_language='en',
domain='bungeni.core',
default="Questions pending responses.")
session = Session()
qfilter=sql.and_(
(domain.Question.ministry_submit_date < date ),
(domain.Question.status == status),
)
questions = session.query(domain.Question).filter(qfilter).all()
for question in questions:
mailto = _getMemberOfParliamentEmail(question)
if mailto and question.receive_notification:
msg = MIMEText(text)
msg['Subject'] = u'Questions pending response'
msg['From'] = prefs.getAdministratorsEmail()
msg['To'] = mailto
text = text + '\n' + question.subject + '\n'
print msg
# !+SENDMAIL(ah,18-03-2010)
#Mail sending is commented out below
dispatch(msg)
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 batch_serialize(type_key="*"):
"""Serialize all objects of `type_key` or all types if with a
wildcard(*) as the type key.
"""
#keep count of serialized objects for feedback
serialized_count = 0
#list of domain classes to be serialized
domain_models = []
if type_key == "*":
types_vocab = zope.component.getUtility(
schema.interfaces.IVocabularyFactory, "serializable_type")
for term in types_vocab():
if term.value == "*":
continue
info = capi.get_type_info(term.value)
domain_models.append(info.domain_model)
else:
info = capi.get_type_info(type_key)
if info.workflow:
domain_models.append(info.domain_model)
session = Session()
for domain_model in domain_models:
objects = session.query(domain_model).all()
map(queue_object_serialization, objects)
serialized_count += len(objects)
return serialized_count
def render(self, template=None):
if template is None:
template = self.template
if (not checkPermission(u"bungeni.sitting.Add", self.context)) or \
(IBusinessSectionLayer.providedBy(self.request)):
self.edit = False
else:
self.edit = True
session = Session()
venues = session.query(domain.Venue).all()
languages = get_all_languages()
session.close()
self.display_language = get_default_language()
if self.request.get("I18N_LANGUAGE"):
self.display_language = self.request.get("I18N_LANGUAGE")
#html is hardcoded in here because doing it in the template
#would have been a colossal pain
#TODO: FIX THIS
s = '<div class="dhx_cal_ltext" style="height:90px;">'
s += '<table>'
s += '<tr><td>Venue</td><td><select id="select_sitting_venue">'
for venue in venues:
s += '<option value="' + str(
venue.venue_id) + '">' + venue.short_name + '</option>'
s += '</select></td></tr>'
s += '<tr><td>Language</td><td><select id="select_sitting_lang">'
for lang in languages:
if lang == 'en':
s += '<option value="' + lang + '" selected>' + lang + '</option>'
else:
s += '<option value="' + lang + '">' + lang + '</option>'
s += '</select></td></tr></table></div>'
self.sitting_details_form = s
return template()
def get_items(self):
session = Session()
query = session.query(domain.ItemSchedule).join(
domain.GroupSitting).filter(self.group_sittings_filter).order_by(
schema.group_sittings.c.start_date).options(
eagerload("sitting"))
self.itemschedules = query.all()
def serialization_notifications_callback(channel, method, properties, body):
obj_data = simplejson.loads(body)
obj_type = obj_data.get("obj_type")
domain_model = getattr(domain, obj_type, None)
if domain_model:
obj_key = valueKey(obj_data.get("obj_key"))
session = Session()
obj = session.query(domain_model).get(obj_key)
if obj:
try:
publish_to_xml(obj)
except Exception, e:
notify_serialization_failure(SERIALIZE_FAILURE_TEMPLATE,
obj=obj, message=obj_data, error=e
)
channel.basic_ack(delivery_tag=method.delivery_tag)
else:
log.error("Could not query object of type %s with key %s. "
"Check database records - Rejecting message.",
domain_model, obj_key
)
#Reject the message
channel.basic_reject(delivery_tag=method.delivery_tag,
requeue=False
)
session.close()
def __str__(self):
item_id = self.context.item_id
base_url = ui_utils.url.absoluteURL(getSite(), self.request)
session = Session()
item = session.query(Doc).filter(Doc.doc_id==item_id).first()
return '%s/business/%ss/obj-%s/files/%s/' % (base_url, item.type,\
item_id, stringKey(self.context))
def validate_venues(action, data, context, container):
"""A venue can only be booked for one sitting at once."""
errors = []
if interfaces.ISitting.providedBy(context):
sitting = context
else:
sitting = None
venue_id = data.get('venue_id')
if venue_id is not None:
venue_id = long(venue_id)
session = Session()
svenue = session.query(domain.Venue).get(venue_id)
else:
return []
start = data.get('start_date')
end = data.get('end_date')
if not(start and end):
return []
for booking in venue.check_venue_bookings( start, end, svenue, sitting):
errors.append(
interface.Invalid(
_(u'Venue "$venue" already booked in this time slot',
mapping={'venue': booking.short_name}),
"venue_id"))
return errors
def handleSchedule(object, event):
""" move scheduled items from to be scheduled state to schedule when draft
agenda is finalised and vice versa
"""
session = Session()
s = removeSecurityProxy(object)
sitting = session.query(domain.GroupSitting).options(
eagerload("group_sitting_type"),
eagerload("item_schedule")).get(s.group_sitting_id)
schedulings = map(removeSecurityProxy, sitting.item_schedule)
if sitting.status == "draft_agenda":
for sch in schedulings:
if sch.item.type != "heading":
wfc = IWorkflowController(sch.item)
wf = wfc.workflow
next_state = get_states(sch.item.type,
tagged=["tobescheduled"])
for transition_id in wfc.getSystemTransitionIds():
t = wf.get_transition(transition_id)
if t.destination in next_state:
#TODO find out why firetransition fails for reschedule even
#when the user has requisite permissions
wfc.fireTransition(transition_id, check_security=False)
break
elif sitting.status == "published_agenda":
for sch in schedulings:
if sch.item.type != "heading":
wfc = IWorkflowController(sch.item)
wf = wfc.workflow
next_state = get_states(sch.item.type, tagged=["scheduled"])
for transition_id in wfc.getSystemTransitionIds():
t = wf.get_transition(transition_id)
if t.destination in next_state:
wfc.fireTransition(transition_id, check_security=False)
break
def validate_open_membership(obj,
domain_model,
user_id,
group_id=None,
parent_id=None,
with_parent=False):
session = Session()
query = session.query(domain_model).filter(
sql.expression.and_(domain_model.end_date == None,
domain_model.user_id == user_id))
if group_id:
query = query.filter(domain_model.group_id == group_id)
if with_parent:
query = query.filter(domain_model.parent_group_id == parent_id)
results = query.all()
if results:
if obj:
for result in results:
if result.membership_id == obj.membership_id:
continue
else:
yield result
else:
for result in results:
yield result
def validate_membership_in_interval(obj,
domain_model,
date,
user_id,
group_id=None,
parent_id=None,
with_parent=False):
""" validates the start end for a user in a group or over
all groups if group_id is not given
"""
session = Session()
query = session.query(domain_model).filter(
sql.expression.and_(
sql.expression.between(date, domain_model.start_date,
domain_model.end_date),
domain_model.user_id == user_id))
if group_id:
query = query.filter(domain_model.group_id == group_id)
if with_parent:
query = query.filter(domain_model.parent_group_id == parent_id)
results = query.all()
if results:
if obj:
for result in results:
if result.membership_id == obj.membership_id:
continue
else:
yield result
else:
for result in results:
yield result
def __call__(self, context=None):
query = self.constructQuery(context)
results = query.all()
terms = []
for ob in results:
terms.append(
vocabulary.SimpleTerm(
value = getattr(ob, 'user_id'),
token = getattr(ob, 'user_id'),
title = "%s %s" % (getattr(ob, 'first_name'),
getattr(ob, 'last_name'))
))
user_id = getattr(context, self.value_field, None)
if user_id:
if query.filter(domain.GroupMembership.user_id == user_id).count() == 0:
# The user is not a member of this group.
# This should not happen in real life
# but if we do not add it her the view form will
# throw an exception
session = Session()
ob = session.query(domain.User).get(user_id)
terms.append(
vocabulary.SimpleTerm(
value = getattr(ob, 'user_id'),
token = getattr(ob, 'user_id'),
title = "(%s %s)" % (getattr(ob, 'first_name'),
getattr(ob, 'last_name'))
))
return vocabulary.SimpleVocabulary(terms)
def _get_members(self):
session = Session()
return [ m for m in
session.query(domain.CommitteeMember).filter(
domain.CommitteeMember.group_id == self.context.committee_id
).all()
]
def __call__(self, context=None):
query = self.constructQuery(context)
results = query.all()
terms = []
for ob in results:
terms.append(
vocabulary.SimpleTerm(
value = getattr(ob, 'user_id'),
token = getattr(ob, 'user_id'),
title = "%s %s" % (getattr(ob, 'first_name'),
getattr(ob, 'last_name'))
))
user_id = getattr(context, self.value_field, None)
if user_id:
if len(query.filter(schema.users.c.user_id == user_id).all()) == 0:
session = Session()
ob = session.query(domain.User).get(user_id)
terms.append(
vocabulary.SimpleTerm(
value = getattr(ob, 'user_id'),
token = getattr(ob, 'user_id'),
title = "(%s %s)" % (getattr(ob, 'first_name'),
getattr(ob, 'last_name'))
))
return vocabulary.SimpleVocabulary(terms)
def batch_serialize(type_key="*"):
"""Serialize all objects of `type_key` or all types if with a
wildcard(*) as the type key.
"""
#keep count of serialized objects for feedback
serialized_count = 0
#list of domain classes to be serialized
domain_models = []
if type_key == "*":
types_vocab = zope.component.getUtility(
schema.interfaces.IVocabularyFactory, "serializable_type")
for term in types_vocab():
if term.value == "*":
continue
info = capi.get_type_info(term.value)
domain_models.append(info.domain_model)
else:
info = capi.get_type_info(type_key)
if info.workflow:
domain_models.append(info.domain_model)
session = Session()
for domain_model in domain_models:
objects = session.query(domain_model).all()
map(queue_object_serialization, objects)
serialized_count += len(objects)
return serialized_count
def serialization_notifications_callback(channel, method, properties, body):
obj_data = simplejson.loads(body)
obj_type = obj_data.get("obj_type")
domain_model = getattr(domain, obj_type, None)
if domain_model:
obj_key = valueKey(obj_data.get("obj_key"))
session = Session()
obj = session.query(domain_model).get(obj_key)
if obj:
try:
publish_to_xml(obj)
except Exception, e:
notify_serialization_failure(SERIALIZE_FAILURE_TEMPLATE,
obj=obj,
message=obj_data,
error=e)
channel.basic_ack(delivery_tag=method.delivery_tag)
else:
log.error(
"Could not query object of type %s with key %s. "
"Check database records - Rejecting message.", domain_model,
obj_key)
#Reject the message
channel.basic_reject(delivery_tag=method.delivery_tag,
requeue=False)
session.close()
def _get_members(self):
pg = removeSecurityProxy(self.context)
session = Session()
dkls = domain.PartyMember # !+domain.PoliticalGroupMember
return [ m for m in
session.query(dkls).filter(dkls.group_id == pg.group_id).all()
]
