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)