def create( self, message, manual = False ):
"""Store the existing state of the adapted context as a new
version."""
version = self.domain_model()
context = self.__parent__
trusted = removeSecurityProxy(context)
# set values on version from context
self._copyFields(trusted, version)
# content domain ids are typically not in the interfaces
# manually inspect and look for one, by hand to save on the new version
mapper = orm.object_mapper(trusted)
version.content_id = mapper.primary_key_from_instance(trusted)[0]
version.status = None
version.manual = manual
# we rely on change handler to attach the change object to the version
event.notify(
interfaces.VersionCreated(context, self, version, message))
session = Session()
session.add(version)
version.context = context
event.notify(ObjectCreatedEvent(version))
return version
def getQuestionWorkflowTrail(question):
"""Return tha trail of workflow states traversed by the question.
Depends on the <ParliamentaryItem>Change.notes attribute being filled
with a serialized python dict containing entries for the workflow's
transition's (source, destination) states.
"""
# !+ note, another way to do it is via raw-SQL:
# but, replace all such raw-sql with SA-based fetching.
#item_id = context.parliamentary_item_id
#from bungeni.ui.utils import queries, statements
#sql_timeline = statements.sql_question_timeline
#timeline_changes = queries.execute_sql(sql_timeline, item_id=item_id)
session = Session()
wf_changes = session.query(domain.QuestionChange
).filter(domain.QuestionChange.content_id==question.question_id
).filter(domain.QuestionChange.action=="workflow"
).order_by(domain.QuestionChange.date).all()
states = []
for wfc in wf_changes:
if wfc.notes:
xtras = eval(wfc.notes)
for xtra in xtras:
states.append(xtra.get("destination"))
return states
def main(argv=None):
"""
run this as a cron job and execute all
time based transitions
"""
db = create_engine('postgres://localhost/bungeni', echo=False)
component.provideUtility( db, IDatabaseEngine, 'bungeni-db' )
model.metadata.bind = db
session = Session()
component.provideAdapter(
bungeni.core.workflows.states.WorkflowState,
(bungeni.core.interfaces.IBungeniContent,))
component.provideAdapter(
bungeni.core.workflows.question.QuestionWorkflowAdapter,
(domain.Question,))
component.provideAdapter(
ore.workflow.workflow.WorkflowInfo,
(domain.Question,))
component.provideHandler(
bungeni.core.workflows.question.workflowTransitionEventDispatcher)
# add autitor for time based transitions
#component.provideAdapter(
# (bungeni.core.interfaces.IAuditable, bungeni.core.interfaces.IQuestion, ),
# (domain.Question, ))
#component.provideAdapter( audit.objectModified,
#(domain.Question, bungeni.core.interfaces.IAuditable, ))
deferAdmissibleQuestions()
session.flush()
session.commit()
def render(self, template=None):
if template is None:
template = self.template
if checkPermission(u"bungeni.sitting.Add", self.context):
self.edit = True
else:
self.edit = False
session = Session()
venues = session.query(domain.Venue).all()
languages = get_all_languages()
session.close()
#defaults to english
self.display_language = 'en'
if self.request.get('I18N_LANGUAGES'):
self.display_language = self.request.get('I18N_LANGUAGES')
#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 description(self):
session =Session()
context = session.merge(removeSecurityProxy(self.context))
return _(u"Sitting scheduled for '$group' ($start to $end)",
mapping={'group': context.group.short_name,
'start': context.start_date.strftime('%Y-%m-%d %H:%M'),
'end': context.end_date.strftime('%H:%M')})
def get_group(self):
try:
group = self.context.get_group()
except:
session = Session()
group = session.query(models.domain.Group).get(self.context.group_id)
return group
def handle_cancel(self, action, data):
"""Cancelling redirects to the listing."""
session = Session()
if not self._next_url:
self._next_url = url.absoluteURL(self.__parent__, self.request)
self.request.response.redirect(self._next_url)
session.close()
def description(self):
session =Session()
context = session.merge(removeSecurityProxy(self.context))
sitting = context.sitting
return _(u"Scheduled for sitting ($start to $end)",
mapping={'start': sitting.start_date,
'end': sitting.end_date})
def title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
time = context.sitting_time
if time is not None:
return "%s (%s)" % (_(u"Discussion"), context.sitting_time)
return _(u"Discussion")
def get_available_resources( start, end ):
"""get all resources that are not booked for a sitting
in the given time period
"""
assert( type(start) == datetime.datetime )
assert( type(end) == datetime.datetime )
session = Session()
#start_end={'start': start, 'end':end}
sql_booked_resources = """
SELECT resources.resource_id AS resources_resource_id
FROM resources JOIN resourcebookings
ON resources.resource_id = resourcebookings.resource_id
JOIN group_sittings
ON resourcebookings.sitting_id = group_sittings.sitting_id
WHERE group_sittings.start_date BETWEEN :start AND :end
OR group_sittings.end_date BETWEEN :start AND :end
OR :start BETWEEN group_sittings.start_date AND group_sittings.end_date
OR :end BETWEEN group_sittings.start_date AND group_sittings.end_date
"""
sql_resources = """
SELECT resources_1.resource_id AS resources_1_resource_id
FROM resources AS resources_1
WHERE resources_1.resource_id NOT IN ( %s )
""" % sql_booked_resources
connection = session.connection( domain.Resource )
query = connection.execute(rdb.text(sql_resources), start=start, end=end)
resources= query.fetchall()
#session.close()
return resources
def _updateAnnotation(self):
"""Updates an annotation."""
params = {}
params.update(self.request)
params.update(parse_qsl(self.request['QUERY_STRING']))
annotation = self.getAnnotation(params['id'])
if not annotation or annotation.quote_author != \
self.getAuthenticatedUser():
self.request.response.setStatus('BadRequest')
return
session = Session()
# if params.has_key('link'):
# if params['link'].startswith("http://"):
# annotation.hyper_link = params['link']
# params.pop('link')
# else:
# if annotation.hyper_link:
# annotation.hyper_link = ''
for key in annotations_table.c.keys():
value = params.get(key, None)
if not value:
continue
setattr(annotation, key, value)
session.commit()
self.request.response.setStatus('NoContent')
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 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.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)
),
schema.sittings.c.venue_id == venue.venue_id)
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 get_offices_held_for_user_in_parliament(user_id, parliament_id):
""" get the Offices (functions/titles) held by a user in a parliament """
session = Session()
connection = session.connection(domain.Group)
group_ids = get_all_group_ids_in_parliament(parliament_id)
offices_held = rdb.select([schema.groups.c.short_name,
schema.groups.c.full_name,
schema.groups.c.type,
schema.user_role_types.c.user_role_name,
schema.role_titles.c.start_date,
schema.role_titles.c.end_date,
schema.user_group_memberships.c.start_date,
schema.user_group_memberships.c.end_date,
],
from_obj=[
rdb.join(schema.groups, schema.user_group_memberships,
schema.groups.c.group_id == schema.user_group_memberships.c.group_id
).outerjoin(
schema.role_titles, schema.user_group_memberships.c.membership_id==
schema.role_titles.c.membership_id).outerjoin(
schema.user_role_types,
schema.role_titles.c.title_name_id ==
schema.user_role_types.c.user_role_type_id)],
whereclause =
rdb.and_(
schema.groups.c.group_id.in_(group_ids),
schema.user_group_memberships.c.user_id == user_id),
order_by = [schema.user_group_memberships.c.start_date,
schema.user_group_memberships.c.end_date,
schema.role_titles.c.start_date,
schema.role_titles.c.end_date]
)
o_held = connection.execute(offices_held)
return o_held
def handle_delete(self, action, data):
session = Session()
sitting_id = self.context.__parent__.sitting_id
sch = session.query(domain.ItemSchedule).filter(sql.and_(model_schema.items_schedule.c.sitting_id == sitting_id, model_schema.items_schedule.c.item_id == data['item_id'])).all()
for i in sch:
session.delete(i)
self.request.response.redirect(self.next_url)
def ActiveUsers(context, role=None):
session= Session()
terms = []
transcription_office = session.query(domain.Office).filter(domain.Office.office_type == 'V').all()
if len(transcription_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 == transcription_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 isItemScheduled(item_id):
session = Session()
active_question_filter = rdb.and_( schema.items_schedule.c.item_id == item_id,
schema.items_schedule.c.active == True)
item_schedule = session.query(domain.ItemSchedule).filter(active_question_filter)
results = item_schedule.all()
return (len(results) >= 1)
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 _getItems(self, ministry):
session = Session()
date_formatter = self.request.locale.dates.getFormatter('date', 'short')
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'] = '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 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(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.c.ministry_submit_date < date ),
(domain.Question.c.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
def title(self):
session =Session()
context = session.merge(removeSecurityProxy(self.context))
return "%s - %s" %(
#self.context.type.capitalize(),
context.short_name,
context.full_name)
def update(self):
"""
refresh the query
"""
session = Session()
motions = session.query(domain.Motion).filter(domain.Motion.status == self.state)
self.query = motions
def delete_subobjects(self):
"""Delete subobjects.
1) For category maintenance, move the scheduling to the bottom
of the container.
2) Delete any discussion items that have been associated to
this scheduling.
"""
try:
field = self.request.form['field']
except:
import pdb; pdb.set_trace()
reorder_form = ItemScheduleReorderForm(self.context, self.request)
container = copy.copy(removeSecurityProxy(self.context.__parent__))
subset_query = container.subset_query
container.subset_query = sql.and_(
subset_query,
container.domain_model.planned_order > self.context.planned_order)
for i in range(len(container) * 2):
reorder_form.handle_move.success({'mode': 'down', 'field': field})
container.subset_query = subset_query
count = 0
session = Session()
unproxied = removeSecurityProxy(self.context)
for key, discussion in unproxied.discussions.items():
del unproxied.discussions[key]
session.delete(discussion)
count += 1
#session.close()
return count
def update(self):
"""refresh the query
"""
session = Session()
qfilter = ( domain.Question.status == self.state )
questions = session.query(domain.Question).filter(qfilter)
self.query = questions
def getPropertiesForUser(self, user, request=None):
"""Get property values for a user or group.
Returns a dictionary of values or a PropertySheet.
"""
view_name = createViewName('getPropertiesForUser', user)
cached_info = self.ZCacheable_get(view_name=view_name)
if cached_info is not None:
return MutablePropertySheet(self.id, **cached_info)
data = None
session = Session()
if user.isGroup():
groups = session.query(domain.Group).filter(
domain.Group.group_principal_id == user.getUserName()).all()
if len(groups) == 1:
group = groups[0]
data = {
'title' : group.short_name or u"",
'description' : group.description or u"",
}
else:
users = session.query(domain.User).filter(
domain.User.login == user.getUserName()).all()
if len(users) == 1:
b_user = users[0]
data = {
'fullname' : u"%s %s" %(b_user.first_name, b_user.last_name),
'email' : b_user.email or u"",
'description' : b_user.description or u"",
'notification': b_user.recieve_notification or False,
}
if data:
self.ZCacheable_set(data, view_name=view_name)
sheet = MutablePropertySheet(self.id, **data)
return sheet
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 handle_search( self, action, data ):
"""
search the other end point of m2m relationship for rows to
associate.
"""
self.state = 'search'
d = core.constructQuery( self.form_fields, self.domain_model, data )
context = proxy.removeSecurityProxy( self.context )
mapper = orm.class_mapper( self.domain_model )
instance_pkey = mapper.primary_key_from_instance
pkey = mapper.primary_key[0]
query = Session().query( self.domain_model)
query = query.filter(
rdb.not_(
pkey.in_(
[ ob.id for ob in getattr( context, self.property_name) ]
) )
)
if not d:
self.results = query.all()
return
self.results = query.filter( *(d.values())).all()
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(ParliamentaryItem).filter(ParliamentaryItem.registry_number==reg_number).count()
if num != 0:
errors.append(zope.interface.Invalid(
_("This regisrty number is already taken.")))
return errors
def _getItems(self, ministry):
session = Session()
date_formatter = date.getLocaleFormatter(self.request, "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 handle_delete(self, action, data):
session = Session()
sitting = session.query(domain.GroupSitting).get(data["ids"])
session.delete(sitting)
session.commit()
self.request.response.setHeader('Content-type', 'text/xml')
return '<data><action type="deleted" sid="'+str(data["ids"])+'" tid="'+str(sitting.sitting_id)+'" /></data>'
def __call__(self):
self.request.response.setHeader('Content-type', 'application/pdf')
self.request.response.setHeader(
'Content-disposition', 'inline;filename="' +
removeSecurityProxy(self.report.report_type) + "_" +
removeSecurityProxy(self.report.start_date).strftime('%Y-%m-%d') +
'.pdf"')
session = Session()
report = session.query(domain.Report).get(self.report.report_id)
d = dict([(f.file_title, f.file_data) for f in report.attached_files])
if "pdf" not in d.keys():
params = {}
params['body_text'] = self.cleanupText()
openofficepath = getUtility(IOpenOfficeConfig).getPath()
renderer = Renderer(self.odt_file,
params,
self.tempFileName,
pythonWithUnoPath=openofficepath)
renderer.run()
f = open(self.tempFileName, 'rb')
doc = f.read()
f.close()
os.remove(self.tempFileName)
attached_file = domain.AttachedFile()
attached_file.file_title = "pdf"
attached_file.file_data = doc
attached_file.language = report.language
report.attached_files.append(attached_file)
notify(ObjectCreatedEvent(attached_file))
session.add(report)
session.commit()
return doc
else:
return d["pdf"].__str__()
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.report_type = data['report_type']
report.short_name = data['report_type']
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
report.language = "en"
report.created_date = datetime.datetime.now()
report.group_id = self.context.group_id
session.add(report)
notify(ObjectCreatedEvent(report))
ids = data["sittings"].split(",")
for id in ids:
try:
sit_id = int(id)
except:
continue
sitting = session.query(domain.GroupSitting).get(sit_id)
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
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 get_current_parliament(date=None):
"""Return the parliament for a given date (or the current for no date)
"""
def getFilter(date):
return sql.or_(
sql.between(date, schema.groups.c.start_date,
schema.groups.c.end_date),
sql.and_(schema.groups.c.start_date <= date,
schema.groups.c.end_date == None))
if not date:
date = datetime.date.today()
session = Session()
query = session.query(domain.Parliament).filter(getFilter(date))
try:
return query.one()
except:
pass #XXX raise(_(u"inconsistent data: none or more than one parliament found for this date"))
def __call__(self):
context = proxy.removeSecurityProxy(self.context)
self.domain_model = context.domain_model
self.domain_interface = queryModelInterface(self.domain_model)
self.domain_annotation = queryModelDescriptor(self.domain_interface)
session = Session()
self.set_size = 0
self.fields = list(getFields(self.context))
start, limit = self.getOffsets()
batch = self.getBatch(start, limit)
data = dict(length=self.set_size,
start=start,
recordsReturned=len(batch),
sort=self.request.get('sort'),
dir=self.request.get('dir', "asc"),
nodes=batch)
session.close()
return simplejson.dumps(data)
def validate_date_in_interval(obj, domain_model, date):
session = Session()
query = session.query(domain_model).filter(
sql.expression.between(date, domain_model.start_date,
domain_model.end_date))
results = query.all()
if results:
if obj:
# the object itself can overlap
for result in results:
if stringKey(result) == stringKey(obj):
continue
else:
yield result
else:
# all results indicate an error
for result in results:
yield result
def get_items(self):
session = Session()
where_clause = sql.and_(
schema.sittings.c.status.in_(get_states(
"groupsitting", tagged=["public"])),
sql.between(
schema.sittings.c.start_date,
self.start_date,
self.end_date))
query = session.query(domain.ItemSchedule).join(
domain.GroupSitting
).filter(
where_clause).order_by(schema.sittings.c.start_date).options(
eagerload('sitting'), eagerload('item'),
eagerload('sitting.sitting_type'),
lazyload('item.owner'))
self.itemschedules = query.all()
def get_transcripts(self):
session = Session()
transcripts = session.query(domain.Transcript).filter(
domain.Transcript.sitting_id == self.context.sitting_id).order_by(
domain.Transcript.start_date)
#import pdb; pdb.set_trace()
ts = []
for transcript in transcripts:
t = removeSecurityProxy(transcript)
t.edit_url = ""
if t.person_id is not None:
t.user = get_user(t.person_id)
hours, remainder = divmod(
(t.start_date - self.context.start_date).seconds, 3600)
minutes, seconds = divmod(remainder, 60)
t.start_play = "%s:%s:%s" % (hours, minutes, seconds)
ts.append(t)
return ts
def update(self):
session = Session()
query = session.query(
domain.User).filter(domain.User.login == self.request.principal.id)
results = query.all()
if len(results) == 1:
user = results[0]
else:
user = None
settings = interfaces.IBungeniUserSettings(user, None)
if settings is None:
raise SyntaxError("User Settings Only For Database Users")
self.adapters = {
interfaces.IBungeniUserSettings: settings,
interfaces.IUser: user
}
super(UserSettings, self).update()
def __call__(self, timestamp=None):
session = Session()
if timestamp is None:
# start the week on the first weekday (e.g. Monday)
date = utils.datetimedict.fromdate(datetime.date.today())
else:
try:
timestamp = float(timestamp)
except:
raise TypeError("Timestamp must be floating-point (got %s)" %
timestamp)
date = utils.datetimedict.fromtimestamp(timestamp)
if misc.is_ajax_request(self.request):
rendered = self.render(date, template=self.ajax)
rendered = self.render(date)
session.close()
return rendered
def __init__(self, context, request, view, manager):
self.context = context
self.request = request
self.__parent__ = context.__parent__
self.manager = manager
self.query = None
md = queryModelDescriptor(domain.MemberOfParliament)
self.form_fields = md.fields
session = Session()
trusted = removeSecurityProxy(self.context)
user_id = self.context.user_id
parliament_id = trusted.group.parent_group_id
self.query = session.query(domain.MemberOfParliament).filter(
sql.and_(
domain.MemberOfParliament.user_id == user_id,
domain.MemberOfParliament.group_id == parliament_id)).order_by(
domain.MemberOfParliament.start_date.desc())
self.for_display = self.query.count() > 0
def enumerateGroups(self,
id=None,
exact_match=False,
sort_by=None,
max_results=None,
**kw):
""" see IGroupEnumeration """
session = Session()
if id is None:
clause = None
elif isinstance(id, (list, tuple)) and exact_match:
statements = []
for i in id:
statements.append(domain.Group.group_principal_id == i)
clause = rdb.or_(*statements)
elif isinstance(id, (list, tuple)) and not exact_match:
clause = rdb.or_(
*(map(domain.Group.group_principal_id.contains, id)))
elif not exact_match:
clause = domain.Group.group_principal_id.contains(id)
else:
clause = domain.Group.group_principal_id == id
query = session.query(domain.Group).filter(
rdb.and_(clause, domain.Group.status == 'active'))
if clause:
query = query.filter(clause)
if sort_by:
assert sort_by in ('group_id', 'short_name')
query = query.order_by(getattr(schema.groups.c, sort_by))
if exact_match:
max_results = 1
if max_results is not None and isinstance(max_results, int):
query = query.limit(max_results)
return [
dict(id=r.group_principal_id, title=r.short_name, plugin=self.id)
for r in query.all()
]
def update(self):
"""
refresh the query
"""
session = Session()
bills = session.query(domain.Bill).filter(domain.Bill.status.in_( [
bill_wf_state[u"gazetted"].id,
bill_wf_state[u"first_reading"].id ,
bill_wf_state[u"first_reading_postponed"].id,
bill_wf_state[u"second_reading"].id,
bill_wf_state[u"second_reading_postponed"].id,
bill_wf_state[u"whole_house_postponed"].id,
bill_wf_state[u"house_pending"].id,
bill_wf_state[u"report_reading_postponed"].id,
bill_wf_state[u"report_reading"].id,
bill_wf_state[u"third_reading"].id,
bill_wf_state[u"third_reading_postponed"].id
] ))
self.query = bills
def handle_edit_action(self, action, data):
super(One2OneEdit, self).handle_edit_action.success(data)
value = self.adapters[self.model_schema]
# XXX we need better detection.. alternative is trying to use
# something like an object modified event handler...
if self.status.startswith('Updated'):
# save or update if modified.
Session().save_or_update(value)
# associate to self
setattr(self.context, self.property_name, value)
def getActiveItemSchedule(parliamentary_item_id):
"""Get active itemSchedule instances for parliamentary item.
Use may also be to get scheduled dates e.g.
for item_schedule in getActiveItemSchedule(parliamentary_item_id)
# item_schedule.item_status, item_schedule.item
s = item_schedule.sitting
s.start_date, s.end_date, s.status
"""
session = Session()
active_filter = rdb.and_(
schema.items_schedule.c.item_id==parliamentary_item_id,
schema.items_schedule.c.active==True)
item_schedule = session.query(domain.ItemSchedule).filter(active_filter)
results = item_schedule.all()
sorted_results = [ (r.sitting.start_date, r) for r in results ]
sorted_results = sorted(sorted_results)
sorted_results.reverse()
return [ r for (d, r) in sorted_results ]
def getBatch(self, start=0, limit=20, order_by=None):
context = proxy.removeSecurityProxy(self.context)
mapper = orm.class_mapper(self.domain_model)
listing_class = getattr(self.domain_model, 'listings_class', None)
context_parent = proxy.removeSecurityProxy(context.__parent__)
try:
p_mapper = orm.class_mapper(context_parent.__class__)
pk = p_mapper.primary_key_from_instance(context_parent)[0]
except orm.exc.UnmappedClassError:
pk = None
l_query = None
if listing_class:
session = Session()
self.domain_model = listing_class
l_query = session.query(listing_class)
if listing_class and pk:
# if we substituted a foreign key in our listing class with
# clear text we have to adjust our modifier accordingly
# '_fk_' + field name is the convention
if hasattr(listing_class, '_fk_' + context.constraints.fk):
modifier = getattr(listing_class,
'_fk_' + context.constraints.fk) == pk
else:
modifier = getattr(listing_class, context.constraints.fk) == pk
l_query = l_query.filter(modifier)
query = get_query(self.context, self.request, l_query,
self.domain_model)
# fetch the nodes from the container
public_wfstates = getattr(self.domain_annotation, 'public_wfstates',
None)
if public_wfstates:
query = query.filter(self.domain_model.status.in_(public_wfstates))
ud_filter = self.getFilter()
if ud_filter != '':
query = query.filter(ud_filter)
self.set_size = query.count()
order_by = self.getSort()
if order_by:
query = query.order_by(order_by)
query = query.limit(limit).offset(start)
nodes = query.all()
batch = self._jsonValues(nodes, self.fields, self.context)
return batch
def current_sittings_query(self, date):
session = removeSecurityProxy(self.context)
group_id = session.parliament_id
start_date = session.start_date
if start_date.month < date.month:
start_date = datetime.date(date.year, date.month, 1)
end_date = session.end_date
if end_date:
if end_date.month > date.month:
end_date = date + relativedelta.relativedelta(day=31)
else:
end_date = date + relativedelta.relativedelta(day=31)
session = Session()
s_filter = sql.and_(
domain.GroupSitting.group_id == group_id,
sql.between(domain.GroupSitting.start_date, start_date, end_date))
return session.query(domain.GroupSitting).filter(s_filter).order_by(
domain.GroupSitting.start_date)
def assignRolesToPrincipal(self, roles, principal_id, setting=True):
if self._uid(principal_id) is None and self._gid(principal_id) is None:
return
session = Session()
connection = session.connection(domain.Group)
if setting is True:
# delete global mappings
connection.execute(
security_schema.principal_role_map.delete().where(
rdb.and_(
security_schema.principal_role_map.c.principal_id ==
principal_id,
security_schema.principal_role_map.c.object_id == None,
security_schema.principal_role_map.c.object_type ==
None)))
# update existing
connection.execute(
security_schema.principal_role_map.update().where(
rdb.and_(
security_schema.principal_role_map.c.principal_id ==
principal_id,
security_schema.principal_role_map.c.object_type ==
None, security_schema.principal_role_map.c.object_id ==
None)).values(setting=False))
# insert new global mappings
for role_id in tuple(roles):
connection.execute(
security_schema.principal_role_map.insert().values(
principal_id=principal_id,
role_id=role_id,
setting=setting,
object_type=None,
object_id=None))
# remove from roles so other plugins won't attempt to
# assign as well
roles.remove(role_id)
return True
def principalInfo(self, id):
# short circuit evaluation of these, defer to global definitions
if id in ('zope.Everybody', 'zope.Anybody'):
return None
User = IAlchemistUser(self)
results = Session().query(User).filter_by(login=id).all()
if len(results) != 1: # unique index on column
return None
user = results[0]
return self._makeInfo(user)
def __iter__(self):
unwrapped = removeSecurityProxy(self.context)
mapper = orm.object_mapper(unwrapped)
primary_key = mapper.primary_key_from_instance(unwrapped)[0]
assignments = Session().query(GroupAssignment).filter_by(
item_id=primary_key)
# object_type = unwrapped.__class__.__name__ )
for i in assignments:
yield i
def getDayClass(self, Date):
"""
return the class settings for that calendar day
"""
css_class = ""
if self.Date.month != Date.month:
css_class = css_class + "other-month "
if Date < datetime.date.today():
css_class = css_class + "past-date "
if Date == datetime.date.today():
css_class = css_class + "current-date "
if Date.weekday() in prefs.getWeekendDays():
css_class = css_class + "weekend-date "
session = Session()
query = session.query(domain.HoliDay).filter(domain.HoliDay.holiday_date == Date)
results = query.all()
if results:
css_class = css_class + "holyday-date "
#session.close()
return css_class.strip()
def _uid(self, login, auth=False):
cols = [schema.users.c.user_id]
if auth:
cols.extend([schema.users.c.password, schema.users.c.salt])
session = Session()
connection = session.connection(domain.Group)
res = connection.execute(
rdb.select(
cols,
rdb.and_(schema.users.c.login == login,
schema.users.c.active_p == 'A')))
uid_tuple = res.fetchone()
if not uid_tuple:
return None
if auth:
return uid_tuple
return uid_tuple[0]
def get_unavailable_resources(start, end):
"""
get all resources 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))
query = session.query(BookedResources).filter(b_filter)
resources = query.all()
#session.close()
return resources
def add_metadata(self, environ, identity):
login_id = identity.get('repoze.who.userid')
user_id = get_user_id(login_id)
groups = None
if user_id is not None:
groups = tuple(self.get_groups(user_id))
admin_select = select([schema.admin_users],
schema.users.c.user_id == user_id)
session = Session()
result = session.connection().execute(admin_select)
if result.fetchone():
groups = groups + ('zope.manager', )
identity.update({
'email':
user.email,
'title':
u"%s, %s" % (user.last_name, user.first_name),
'groups':
groups,
})
def POST(self):
session = Session()
setting = simplejson.loads(self.request["setting"])
roles = simplejson.loads(self.request["roles"])
principal_id = simplejson.loads(self.request["principal_id"])
connection = session.connection(domain.Group)
# insert new global mappings
for role_id in tuple(roles):
connection.execute(
security_schema.principal_role_map.insert().values(
principal_id=principal_id,
role_id=role_id,
setting=setting,
object_type=None,
object_id=None))
# remove from roles so other plugins won't attempt to
# assign as well
roles.remove(role_id)
def get_available_translations(context):
""" returns a dictionary of all
available translations (key) and the object_id
of the object (value)"""
trusted = removeSecurityProxy(context)
class_name = trusted.__class__.__name__
try:
mapper = orm.object_mapper(trusted)
pk = getattr(trusted, mapper.primary_key[0].name)
session = Session()
query = session.query(domain.ObjectTranslation).filter(
sql.and_(domain.ObjectTranslation.object_id == pk,
domain.ObjectTranslation.object_type ==
class_name)).distinct().values('lang', 'object_id')
return dict(query)
except:
return {}
def main(argv=None):
"""
run this as a cron job and execute all
time based transitions
"""
db = create_engine('postgres://localhost/bungeni', echo=False)
component.provideUtility( db, IDatabaseEngine, 'bungeni-db' )
model.metadata.bind = db
session = Session()
sendAllNotifications()
def endChildGroups(group):
""" upon dissolution of a parliament for all committees,
offices and political groups of this parliament the end date is
set
or upon dissolution of a government for all ministries
of this government the end date is set
(in order to be able to dissolve those groups)"""
def _end_parliament_group(group_class, parent_id, end_date):
groups = session.query(group_class).filter(
rdb.and_(group_class.status == 'active',
group_class.parent_group_id == parliament_id)).all()
for group in groups:
if group.end_date == None:
group.end_date = end_date
return groups
session = Session()
end_date = group.end_date
assert (end_date != None)
if interfaces.IParliament.providedBy(group):
parliament_id = group.parliament_id
committees = _end_parliament_group(domain.Committee, parliament_id,
end_date)
for committee in committees:
yield committee
offices = _end_parliament_group(domain.Office, parliament_id, end_date)
for office in offices:
yield office
political_groups = _end_parliament_group(domain.PoliticalGroup,
parliament_id, end_date)
for political_group in political_groups:
yield political_group
elif interfaces.IGovernment.providedBy(group):
government_id = group.group_id
ministries = session.query(domain.Ministry).filter(
rdb.and_(domain.Ministry.status == 'active',
domain.Ministry.parent_group_id == government_id)).all()
for ministry in ministries:
if ministry.end_date == None:
ministry.end_date = end_date
yield ministry
def GET(self):
session = Session()
ugm = user_group_memberships
user_values = session.query(domain.User).filter(
rdb.and_(
users.c.user_id == ugm.c.user_id,
groups.c.group_id == ugm.c.group_id,
domain.Group.group_principal_id == self.request["group_id"],
ugm.c.active_p == True)).all()
return self.json_response([r.login for r in user_values])
values = [
r.group_principal_id for r in session.query(domain.Group).filter(
rdb.and_(
users.c.login == self.request["principal_id"],
user_group_memberships.c.user_id == users.c.user_id,
groups.c.group_id == user_group_memberships.c.group_id,
groups.c.status == 'active',
user_group_memberships.c.active_p == True)).all()
]
return self.json_response(values)
def GET(self):
session = Session()
connection = session.connection(domain.Group)
plugin_id = self.request["plugin_id"]
mappings = connection.execute(
rdb.select([security_schema.principal_role_map.c.role_id]))
role_ids = []
for (role_id, ) in mappings:
role_ids.append(role_id)
role_ids = []
for (role_id, ) in mappings:
role_ids.append(role_id)
return self.json_response([{
'id': role_id,
'pluginid': plugin_id,
} for role_id in role_ids])
return self.json_response(mappings)
