def update(self):
session = Session()
members = self._get_members()
user_mp_id_map = dict(
[
(
m.user_id,
session.query(domain.MemberOfParliament)
.filter(domain.MemberOfParliament.user_id == m.user_id)
.one()
.membership_id,
)
for m in members
]
)
formatter = self.get_date_formatter("date", "long")
self.items = [
{
"fullname": m.user.fullname,
"url": "/members/current/obj-%s/" % (user_mp_id_map[m.user_id]),
"start_date": m.start_date and formatter.format(m.start_date) or None,
"end_date": m.end_date and formatter.format(m.end_date) or None,
}
for m in members
]
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 __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 get_max_type_number(domain_model):
"""Get the current maximum numeric value for this domain_model's type_number.
If None (no existing instance as yet defines one) return 0.
!+RESETTABLE per parliamentary session
"""
session = Session()
return session.query(sa.func.max(domain_model.type_number)).scalar() or 0
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 = []
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 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 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 __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 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(
bungeni.core.workflows.states.StateWorkflowInfo,
(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 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 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 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 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 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 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 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 title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
if getattr(context, "delegation", None):
return u"%s %s" % (context.delegation.first_name, context.delegation.last_name)
else:
return u""
def description(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
text = "%s %s %s" % (translate_i18n(_(u"Submitted by")), context.owner.first_name, context.owner.last_name)
if context.notice_date:
text += " (%s %s)" % (translate_i18n(_(u"notice given on")), self.formatDate(context.notice_date))
return text + "."
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 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 _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 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 _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 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.
"""
field = self.request.form['field']
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 create(self, message, manual=False):
"""Store the existing state of the adapted context as a new version.
"""
context = self.__parent__
if manual:
if not self.has_write_permission(context):
raise Unauthorized
version = self.domain_model()
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 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 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 sitting
ON resourcebookings.sitting_id = sitting.sitting_id
WHERE sitting.start_date BETWEEN :start AND :end
OR sitting.end_date BETWEEN :start AND :end
OR :start BETWEEN sitting.start_date AND sitting.end_date
OR :end BETWEEN sitting.start_date AND sitting.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(sa.text(sql_resources), start=start, end=end)
resources= query.fetchall()
return resources
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 get_member_of_parliament(self, user_id):
"""Get the MemberOfParliament instance for user_id.
"""
return Session().query(domain.MemberOfParliament).filter(
domain.MemberOfParliament.user_id == user_id).one()
def handle_insert(self, action, data):
session = Session()
data["rec_end_date"] = data["end_date"]
self.template_data = []
trusted = removeSecurityProxy(ISchedulingContext(self.context))
initial_sitting = None
length = data["event_length"]
venue_id = unicode(data["venue"]) if data['venue'] else None
if data.get("rec_type") not in [None, "none"]:
data["end_date"] = data["start_date"] + timedelta(seconds=length)
self.request.form["end_date"] = data["end_date"].strftime(
DT_FORMAT)
data["headless"] = "true"
self.request.form["venue_id"] = data["venue_id"] = venue_id
self.request.form["headless"] = "true"
add_form = AddForm(trusted.get_group().sittings, self.request)
add_form.update()
if not add_form.errors:
initial_sitting = removeSecurityProxy(add_form.created_object)
else:
return self.insert_sitting_failure_handler(action, data,
add_form.errors)
if ("rec_type" in data.keys()) and (data["rec_type"]
not in [None, "none"]):
# create recurring sittings
#base_sitting_length = sitting_length + timedelta(hours=1)
sitting_length = timedelta(seconds=length)
base_sitting_length = timedelta(seconds=length) + timedelta(
hours=1)
dates = self.generate_dates(data)
initial_sitting.recurring_type = data.get("rec_type")
initial_sitting.recurring_id = 0
initial_sitting.sitting_length = length
for count, date in enumerate(dates):
if not count:
#we've already added the initial sitting
initial_sitting.recurring_end_date = (
dates[len(dates) - 1] + base_sitting_length)
session.merge(initial_sitting)
continue
sitting_data = copy(data)
sitting_data["start_date"] = date.strftime(DT_FORMAT)
sitting_data["end_date"] = (date +
sitting_length).strftime(DT_FORMAT)
request_copy = copy(self.request)
request_copy.form = sitting_data
add_form = AddForm(trusted.get_group().sittings, request_copy)
add_form.update()
if not add_form.errors:
# use finishConstruction API here
obj = add_form.created_object
obj.sitting_length = int(time.mktime(date.timetuple()))
obj.recurring_id = initial_sitting.sitting_id
session.merge(obj)
else:
initial_sitting.recurring_type = data.get("rec_type")
initial_sitting.recurring_id = data.get("event_pid", 0)
if data.get("event_length"):
initial_sitting.sitting_length = data.get("event_length")
session.merge(initial_sitting)
wfc = IWorkflowController(initial_sitting)
wfc.fireAutomatic()
sitting_action = "inserted"
if data["rec_type"] == "none":
sitting_action = "deleted"
session.merge(initial_sitting)
self.template_data.append({
"sitting_id": initial_sitting.sitting_id,
"action": sitting_action,
"ids": data["ids"],
})
self.request.response.setHeader("Content-type", "text/xml")
return self.xml_template()
def saveSchedule(self):
session = Session()
sitting_id = self.sitting.sitting_id
group_id = self.sitting.group_id
record_keys = []
for (index, data_item) in enumerate(self.data):
actual_index = index + 1
data_schedule_id = data_item.get("schedule_id")
data_item_id = data_item.get("item_id")
data_item_type = data_item.get("item_type")
data_item_text = data_item.get("item_text")
data_item_wf_status = data_item.get("wf_status")
if not data_item_id:
# create text record before inserting into schedule
kls = capi.get_type_info(data_item_type).domain_model
text_record = kls(text=data_item_text,
group_id=group_id,
language=get_default_language())
session.add(text_record)
session.flush()
notify(ObjectCreatedEvent(text_record))
data_item_id = domain.get_mapped_object_id(text_record)
schedule_record = domain.ItemSchedule(
item_id=data_item_id,
item_type=data_item_type,
planned_order=actual_index,
sitting_id=sitting_id)
session.add(schedule_record)
session.flush()
notify(ObjectCreatedEvent(schedule_record))
else:
if data_schedule_id:
current_record = removeSecurityProxy(
self.context.get(getItemKey(data_schedule_id)))
current_record.planned_order = actual_index
session.add(current_record)
session.flush()
notify(ObjectModifiedEvent(current_record))
#workflow operations
wfc = IWorkflowController(current_record.item, None)
if wfc:
if wfc and data_item_wf_status:
try:
wfc.workflow.get_transition(
data_item_wf_status)
wfc.fireTransition(data_item_wf_status)
except InvalidTransitionError:
log.error(
"Invalid transition [%s] for object: [%s] ",
data_item_wf_status, current_record)
wfc.fireAutomatic()
#update text for text records
text_record = removeSecurityProxy(current_record.item)
if model_interfaces.IScheduleText.providedBy(text_record):
if text_record.text != data_item_text:
text_record.text = data_item_text
session.add(text_record)
session.flush()
notify(ObjectModifiedEvent(text_record))
else:
schedule_record = domain.ItemSchedule(
item_id=data_item_id,
item_type=data_item_type,
planned_order=actual_index,
sitting_id=sitting_id)
session.add(schedule_record)
session.flush()
notify(ObjectCreatedEvent(schedule_record))
record_keys.append(self.RECORD_KEY %
(data_item_type, data_item_id))
records_to_delete = filter(
lambda item: (self.RECORD_KEY %
(item.item_type, item.item_id) not in record_keys),
[removeSecurityProxy(rec) for rec in self.context.values()])
map(session.delete, records_to_delete)
map(lambda deleted: notify(ObjectRemovedEvent(deleted)),
records_to_delete)
def get_principals(principal_ids):
session = Session()
return session.query(domain.User).filter(
domain.User.login.in_(principal_ids)).all()
def resolve(self, id):
class_path, oid = id.split('-', 1)
domain_class = resolve.resolve(class_path)
session = Session()
value_key = container.valueKey(oid)
return session.query(domain_class).get(value_key)
def handle_add_save(self, action, data):
"""After succesful creation of translation, redirect to the
view."""
for key in data.keys():
if isinstance(data[key], str):
data[key] = unescape(data[key])
#url = url.absoluteURL(self.context, self.request)
#language = get_language_by_name(data["language"])["name"]
session = Session()
trusted = removeSecurityProxy(self.context)
mapper = rdb.orm.object_mapper(trusted)
pk = getattr(trusted, mapper.primary_key[0].name)
current_translation = get_translation_for(self.context,
data["language"])
if current_translation:
for translation in current_translation:
session.delete(translation)
for form_field in data.keys():
if form_field == "language":
continue
translation = domain.ObjectTranslation()
translation.object_id = pk
translation.object_type = trusted.__class__.__name__
translation.field_name = form_field
translation.lang = data["language"]
translation.field_text = data[form_field]
session.add(translation)
session.flush()
session.commit()
session.close()
# !+EVENT_DRIVEN_CACHE_INVALIDATION(mr, mar-2011) no translate event
# invalidate caches for this domain object type
invalidate_caches_for(trusted.__class__.__name__, "translate")
#versions = IVersioned(self.context)
#version = versions.create("'%s' translation added" % language)
# reset workflow state
#version.status = None
#IWorkflowInfo(version).fireTransition("-draft_translation")
# redefine form context and proceed with edit action
#self.setUpAdapters(version)
#handle_edit_action(self, action, data)
# commit version such that it gets a version id
#transaction.commit()
#if not self._next_url:
# self._next_url = ( \
# "%s/versions/%s" % (url, stringKey(version)) + \
# "?portal_status_message=Translation added")
self._finished_add = True
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 = data["short_name"]
report.owner_id = get_db_user_id()
report.language = get_default_language()
report.created_date = datetime.datetime.now()
report.group_id = self.context.group_id
session.add(report)
session.flush()
notify(ObjectCreatedEvent(report))
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)
notify(ObjectCreatedEvent(report))
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 __setitem__(self, name, item):
session = Session()
session.add(item)
def version_tree(ob, root=False, reversion=False):
"""Create (if needed) a snapshot of the object graph starting at ob.
Recursively visit all ob children, and:
- check if they are cleanly versioned
- version them if not (procedure="a"), set dirty True
- version ob if necessary, and relate version of ob to children
- return (version, dirty) -- dirty flag is also propagated upwards, and
when True the version returned is just newly created else it is the
latest previously-existing version found.
root:bool -- a version of the root ob itself, even if cleanly vesrioned,
is always created. Plus, parameters for other sub-calls are affected
by whether we are daling with root instance or not.
reversion:bool -- whether this is a revert to a previous version or not, in
which case ob is the older version to revert to.
--
current root types: Doc (only Event...), Attachment
current child types: (only Event doc, that may not parent Events), Attachment
"""
assert get_feature_interface("version").providedBy(ob), \
"Not versionable! %s" % (ob) # !+reversion?
# ob must be newly versioned if dirty, we always explicitly version root ob
dirty = root or False
child_obs = []
child_versions = []
# process children (determine via child-implicating features)
if get_feature_interface("attachment").providedBy(ob):
child_obs.extend(ob.attachments)
#!+event-as-feature
if hasattr(ob, "sa_events") and ob.sa_events:
child_obs.extend(ob.sa_events)
#!+signatory-as-feature
#if hasattr(ob, "item_signatories") and ob.item_signatories:
# child_obs.extend(ob.item_signatories)
for child in child_obs:
child_dirty, child_version = version_tree(child)
child_versions.append(child_version)
dirty = dirty or child_dirty
def changed_since_last_version(ob):
"""Does ob need to be freshly versioned?
"""
try:
# ordered by audit_id, newest first
return ob.changes[0].action != "version"
# !+what if a sub-child has been reversioned since last child version?
except IndexError:
return True
dirty = dirty or changed_since_last_version(ob)
if dirty:
# create version if needed
if reversion:
auditor = audit.get_auditor(ob.audit_head)
else:
auditor = audit.get_auditor(ob)
last_version = auditor.object_version(ob, root=root)
session = Session()
for cv in child_versions:
# relate newly created ob last_version to child versions
ct = domain.ChangeTree()
ct.parent_id = last_version.audit_id
ct.child_id = cv.audit_id
session.add(ct)
else:
# retrieve newest version for ob
last_version = ob.changes[0]
return dirty, last_version
def __delitem__(self, name):
instance = self[name]
session = Session()
session.delete(instance)
def __init__(self, container, request):
self.session = Session()
super(SiteTraverser, self).__init__(container, request)
def _query(self):
session = Session()
query = session.query(self._class)
return query
def uri(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return (context.uri or "") if hasattr(context, "uri") else ""
def __setitem__(self, name, item):
session = Session()
current_parliament = get_current_parliament()
item.parliament_id = current_parliament.parliament_id
session.add(item)
def title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return self.translate(context, "committee_type_status_name")
class SiteTraverser(ContainerTraverser):
""" Custom traverser for special 'bungeni' section
"""
def __init__(self, container, request):
self.session = Session()
super(SiteTraverser, self).__init__(container, request)
def publishTraverse(self, request, name):
# last section, retrieve object
if name == "main":
try:
object = self.get_query(self.context.type, self.context.id,\
self.context.date, self.context.lang).one()
#object.__parent__ = self.context
if object.uri is not None:
return object
except:
traceback.print_exception(*sys.exc_info())
# creating temporary AkomaNtoso section to store url data
context = AkomaNtosoSection(
title=name,
description=name,
default_name=name,
)
# copying info
context.id = self.context.id
context.date = self.context.date
context.lang = self.context.lang
context.type = self.context.type
# for now should always be "ke"
if name == 'ke':
return context
# getting content type
if not context.type:
context.type = name
return context
# getting date
if not context.date:
context.date = name
return context
# getting registry number
if not context.id:
context.id = name
return context
# getting language
if not context.lang:
context.lang = name[:-1]
return context
return super(SiteTraverser, self).publishTraverse(request, name)
def get_query(self, content_type, id, date, lang):
d = date.split('-')
date = datetime.date(int(d[0]), int(d[1]), int(d[2]))
if content_type == "bill":
from bungeni.models.domain import Bill # !+CUSTOM
return self.session.query(Bill).filter(Bill.registry_number==id).\
filter(Bill.publication_date==date).\
filter(Bill.language==lang)
return self.session.query(Doc).filter(Doc.registry_number==id).\
filter(Doc.type==content_type).\
filter(Doc.language==lang).\
filter(extract('year',Doc.status_date)==date.year).\
filter(extract('month',Doc.status_date)==date.month).\
filter(extract('day',Doc.status_date)==date.day)
def description(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return u"%s (%s)" % (context.file_name, context.file_mimetype)
def title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return self.translate(context, "title_name")
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 self.translate(context, "attendance_type")
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 context.file_title
def description(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return self.translate(context, "full_name")
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 description(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return self.translate(context.attendance_type, "attendance_type")
def title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return '%s - %i' % (self.translate(context.constituency,
"name"), context.date.year)
def handle_insert(self, action, data):
session = Session()
self.template_data = []
trusted = removeSecurityProxy(ISchedulingContext(self.context))
if ("rec_type" in data.keys()) and (data["rec_type"] is not None):
# !+ DATETIME(miano, dec-2010) the datetime widget above returns
# aware datetime objects while the current database setup only
# supports naive objects. The lines below(and in subsequent actions)
# convert them to naive datetimes
recurrence_start_date = data["start_date"].replace(tzinfo=None)
recurrence_end_date = data["end_date"].replace(tzinfo=None)
length = data["event_length"]
sitting_length = timedelta(seconds=int(length))
#
# Check the end date of the recurrence
# The end date is set to be the end date of the current group
# or one year from the present date whichever is sooner.
group = trusted.get_group()
# If group is none then there is a big problem
assert group is not None
year = timedelta(days=365)
now = datetime.datetime.now()
if ((group.end_date is not None) and
((now + year) < group.end_date)) or (group.end_date is None):
end = now + year
else:
end = group.end_date
if recurrence_end_date > end:
recurrence_end_date = end
dates = utils.generate_recurrence_dates(recurrence_start_date,
recurrence_end_date,
data["rec_type"])
recurrent_sittings = []
for date in dates:
sitting = domain.GroupSitting()
sitting.group_id = trusted.group_id
sitting.start_date = date
sitting.end_date = date + sitting_length
sitting.language = data["language"]
sitting.venue_id = data["venue"]
session.add(sitting)
recurrent_sittings.append(sitting)
session.commit()
for s in recurrent_sittings:
notify(ObjectCreatedEvent(s))
self.template_data.append({
"group_sitting_id": s.group_sitting_id,
"action": "inserted",
"ids": data["ids"]
})
self.request.response.setHeader('Content-type', 'text/xml')
return self.xml_template()
else:
sitting = domain.GroupSitting()
sitting.start_date = data["start_date"].replace(tzinfo=None)
sitting.end_date = data["end_date"].replace(tzinfo=None)
sitting.group_id = trusted.group_id
sitting.language = data["language"]
sitting.venue_id = data["venue"]
session.add(sitting)
session.commit()
notify(ObjectCreatedEvent(sitting))
self.template_data.append({
"group_sitting_id": sitting.group_sitting_id,
"action": "inserted",
"ids": data["ids"]
})
self.request.response.setHeader('Content-type', 'text/xml')
return self.xml_template()
def status(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return translate_i18n(misc.get_wf_state(context))
def constructQuery(self, context):
session = Session()
users = session.query(domain.User).order_by(domain.User.last_name,
domain.User.first_name)
return users
def title(self):
session = Session()
context = session.merge(removeSecurityProxy(self.context))
return "%s %s %s" % (self.translate(
context, "titles"), context.first_name, context.last_name)
