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)