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 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 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 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 execute_sql(sql_statement, **kwargs): """Evaluates sql_statement for parameter values specified in kwargs and executes it """ session = Session() connection = session.connection(domain.Parliament) query = connection.execute(sql.text(sql_statement), **kwargs) return query
def execute_sql(sql_statement, **kwargs): """Evaluates sql_statement for parameter values specified in kwargs and executes it """ session = Session() connection = session.connection(domain.Parliament) query = connection.execute(sql.text(sql_statement), **kwargs) return query
def get_groups(user_id): user_group_membserhip_select = select([schema.user_group_memberships, schema.groups], and_(schema.user_group_memberships.c.user_id == user_id, schema.user_group_memberships.c.active_p == True, schema.user_group_memberships.c.group_id == schema.groups.c.group_id )) session = Session() results = session.connection().execute(user_group_membership_select) return [result[schema.groups.c.group_principal_id] for result in results]
def setMotionSerialNumber(motion): """ Number that indicate the order in which motions have been approved by the Speaker. The Number is reset at the start of each new session with the first motion assigned the number 1 """ session = Session() connection = session.connection(domain.Motion) sequence = rdb.Sequence('motion_number_sequence') motion.motion_number = connection.execute(sequence)
def setQuestionSerialNumber(question): """ Approved questions are given a serial number enabling the clerks office to record the order in which questions are received and hence enforce a first come first served policy in placing the questions on the order paper. The serial number is re-initialized at the start of each session """ session = Session() connection = session.connection(domain.Question) sequence = rdb.Sequence('question_number_sequence') question.question_number = connection.execute(sequence)
def GET(self): if "auth" in self.request.keys(): cols = [users.c.user_id] if self.request["auth"] != "None": cols.extend([users.c.password, users.c.salt]) session = Session() connection = session.connection(domain.Group) res = connection.execute( rdb.select( cols, rdb.and_(users.c.login == self.request["login"], users.c.active_p == 'A'))) uid_tuple = res.fetchone() if not uid_tuple: return None if self.request["auth"] != "None": return self.json_response(str(uid_tuple)) return self.json_response(uid_tuple[0]) elif "login" in self.request.keys(): session = Session() user = session.query(domain.User).filter( rdb.and_(domain.User.login == self.request["login"], domain.User.active_p == 'A')).one() return self.json_response(user) elif "user_name" in self.request.keys(): session = Session() user_values = session.query(domain.User).filter( domain.User.login == self.request["user_name"]).all() data = {} if len(user_values) == 1: b_user = user_values[0] data = { '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.receive_notification or False, } return self.json_response(data) else: user_values = users.select([users.c.login], users.c.active_p == 'A').execute() if "user_manager_id" in self.request.keys(): plugin_id = self.request["user_manager_id"] data = [ dict(id=safeencode(r['login']), login=safeencode(r['login']), pluginid=plugin_id) for r in user_values ] else: data = tuple([safeencode(r['login']) for r in user_values]) return self.json_response(data)
def get_user_delegations(user_id): """ get all delegations for a given user_id user_id = schema.users.c.user_id both delegator and delegee must be active """ user_delegations_select = ([schema.user_delegations, schema.users], and_(schema.user_delegations.c.delegation_id == user_id, schema.user.c.active_p == 'A', schema.user_delegations.c.active_p == 'A')) session = Session() results = session.connection().execute(user_delegations_select) return [result[schema.users.c.login] for result in results]
def PUT(self): session = Session() principal_id = simplejson.loads(self.request["principal_id"]) connection = session.connection(domain.Group) # 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))
def get_user_id(login_id): db_user_select = select([schema.users], schema.users.c.login == login_id) session = Session() result = session.connection().execute(db_user_select) if len(result) == 0: log.warn("No user with login id, %s exists" % login_id) return None elif len(result) > 1: # !+non_unique_login(mr, oct-2011) impossible, login column is UNIQUE! log.error("Multiple users found with same login id, %s" % login_id) return None else: return result.fetchone()[schema.users.c.login]
def deactivateGroupMemberTitles(group): session = Session() group_id = group.group_id end_date = group.end_date assert (end_date != None) connection = session.connection(domain.Group) group_members = rdb.select( [schema.user_group_memberships.c.user_id], schema.user_group_memberships.c.group_id == group_id) connection.execute(schema.role_titles.update().where( rdb.and_( schema.role_titles.c.membership_id.in_(group_members), schema.role_titles.c.end_date == None)).values(end_date=end_date))
def get_groups(user_id): user_group_membserhip_select = select( [schema.user_group_memberships, schema.groups], and_( schema.user_group_memberships.c.user_id == user_id, schema.user_group_memberships.c.active_p == True, schema.user_group_memberships.c.group_id == schema.groups.c.group_id)) session = Session() results = session.connection().execute(user_group_membership_select) return [ result[schema.groups.c.group_principal_id] for result in results ]
def get_user_id(login_id): db_user_select = select([schema.users], schema.users.c.login == login_id) session = Session() result = session.connection().execute(db_user_select) if len(result) == 0: log.warn("No user with login id, %s exists" % login_id) return None elif len(result) > 1: # !+non_unique_login(mr, oct-2011) impossible, login column is UNIQUE! log.error("Multiple users found with same login id, %s" % login_id) return None else: return result.fetchone()[schema.users.c.login]
def get_user_delegations(user_id): """ get all delegations for a given user_id user_id = schema.users.c.user_id both delegator and delegee must be active """ user_delegations_select = ( [schema.user_delegations, schema.users], and_(schema.user_delegations.c.delegation_id == user_id, schema.user.c.active_p == 'A', schema.user_delegations.c.active_p == 'A')) session = Session() results = session.connection().execute(user_delegations_select) return [result[schema.users.c.login] for result in results]
def deactivateGroupMemberTitles(group): session = Session() group_id = group.group_id end_date = group.end_date assert(end_date != None) connection = session.connection(domain.Group) group_members = rdb.select([schema.user_group_memberships.c.user_id], schema.user_group_memberships.c.group_id == group_id) connection.execute(schema.role_titles.update( ).where(rdb.and_( schema.role_titles.c.membership_id.in_(group_members), schema.role_titles.c.end_date == None) ).values(end_date=end_date) )
def GET(self): if "auth" in self.request.keys(): cols = [users.c.user_id] if self.request["auth"] != "None": cols.extend([users.c.password, users.c.salt]) session = Session() connection = session.connection(domain.Group) res = connection.execute( rdb.select(cols, rdb.and_(users.c.login == self.request["login"], users.c.active_p == "A")) ) uid_tuple = res.fetchone() if not uid_tuple: return None if self.request["auth"] != "None": return self.json_response(str(uid_tuple)) return self.json_response(uid_tuple[0]) elif "login" in self.request.keys(): session = Session() user = ( session.query(domain.User) .filter(rdb.and_(domain.User.login == self.request["login"], domain.User.active_p == "A")) .one() ) return self.json_response(user) elif "user_name" in self.request.keys(): session = Session() user_values = session.query(domain.User).filter(domain.User.login == self.request["user_name"]).all() data = {} if len(user_values) == 1: b_user = user_values[0] data = { "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.receive_notification or False, } return self.json_response(data) else: user_values = users.select([users.c.login], users.c.active_p == "A").execute() if "user_manager_id" in self.request.keys(): plugin_id = self.request["user_manager_id"] data = [ dict(id=safeencode(r["login"]), login=safeencode(r["login"]), pluginid=plugin_id) for r in user_values ] else: data = tuple([safeencode(r["login"]) for r in user_values]) return self.json_response(data)
def get_group_ids_for_user_in_parliament(user_id, parliament_id): """ get the groups a user is member of for a specific parliament """ session = Session() connection = session.connection(domain.Group) group_ids = get_all_group_ids_in_parliament(parliament_id) my_groups = rdb.select([schema.user_group_memberships.c.group_id], rdb.and_(schema.user_group_memberships.c.active_p == True, schema.user_group_memberships.c.user_id == user_id, schema.user_group_memberships.c.group_id.in_(group_ids)), distinct=True) my_group_ids = [] for group_id in connection.execute(my_groups): my_group_ids.append(group_id[0]) return my_group_ids
def get_group_ids_for_user_in_parliament(user_id, parliament_id): """ get the groups a user is member of for a specific parliament """ session = Session() connection = session.connection(domain.Group) group_ids = get_all_group_ids_in_parliament(parliament_id) my_groups = rdb.select([schema.user_group_memberships.c.group_id], rdb.and_(schema.user_group_memberships.c.active_p == True, schema.user_group_memberships.c.user_id == user_id, schema.user_group_memberships.c.group_id.in_(group_ids)), distinct=True) my_group_ids = [] for group_id in connection.execute(my_groups): my_group_ids.append(group_id[0]) return my_group_ids
def PUT(self): session = Session() principal_id = simplejson.loads(self.request["principal_id"]) connection = session.connection(domain.Group) # 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) )
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 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)
def deactivateGroupMembers(group): """ upon dissolution of a group all group members are deactivated and get the end date of the group""" session = Session() group_id = group.group_id end_date = group.end_date assert (end_date != None) connection = session.connection(domain.Group) connection.execute(schema.user_group_memberships.update().where( rdb.and_(schema.user_group_memberships.c.group_id == group_id, schema.user_group_memberships.c.active_p == True)).values( active_p=False)) connection.execute(schema.user_group_memberships.update().where( rdb.and_(schema.user_group_memberships.c.group_id == group_id, schema.user_group_memberships.c.end_date == None)).values( end_date=end_date)) deactivateGroupMemberTitles(group)
def GET(self): session = Session() connection = session.connection(domain.Group) principal_id = self.request["principal_id"] mappings = connection.execute( rdb.select( [security_schema.principal_role_map.c.role_id], rdb.and_( security_schema.principal_role_map.c.principal_id == principal_id, security_schema.principal_role_map.c.setting == True, security_schema.principal_role_map.c.object_type == None, security_schema.principal_role_map.c.object_id == None))) role_names = [] for (role_name, ) in mappings: role_names.append(role_name) return self.json_response(role_names)
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 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(self): session = Session() connection = session.connection(domain.Group) principal_id = self.request["principal_id"] mappings = connection.execute( rdb.select( [security_schema.principal_role_map.c.role_id], rdb.and_( security_schema.principal_role_map.c.principal_id == principal_id, security_schema.principal_role_map.c.setting == True, security_schema.principal_role_map.c.object_type == None, security_schema.principal_role_map.c.object_id == None, ), ) ) role_names = [] for (role_name,) in mappings: role_names.append(role_name) return self.json_response(role_names)
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 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 _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(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)
def deactivateGroupMembers(group): """ upon dissolution of a group all group members are deactivated and get the end date of the group""" session = Session() group_id = group.group_id end_date = group.end_date assert(end_date != None) connection = session.connection(domain.Group) connection.execute(schema.user_group_memberships.update().where( rdb.and_( schema.user_group_memberships.c.group_id == group_id, schema.user_group_memberships.c.active_p == True) ).values(active_p = False) ) connection.execute(schema.user_group_memberships.update().where( rdb.and_( schema.user_group_memberships.c.group_id == group_id, schema.user_group_memberships.c.end_date == None) ).values(end_date = end_date) ) deactivateGroupMemberTitles(group)
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 getRolesForPrincipal(self, principal, request=None ): """ principal -> ( role_1, ... role_N ) o Return a sequence of role names which the principal has. o May assign roles based on values in the REQUEST object, if present. """ principal_id = principal.getId() session = Session() connection = session.connection(domain.Group) mappings = connection.execute(rdb.select( [security_schema.principal_role_map.c.role_id], rdb.and_( security_schema.principal_role_map.c.principal_id==principal_id, security_schema.principal_role_map.c.setting==True, security_schema.principal_role_map.c.object_type==None, security_schema.principal_role_map.c.object_id==None))) role_names = [] for (role_name,) in mappings: role_names.append(role_name) return role_names
def getRolesForPrincipal(self, principal, request=None): """ principal -> ( role_1, ... role_N ) o Return a sequence of role names which the principal has. o May assign roles based on values in the REQUEST object, if present. """ principal_id = principal.getId() session = Session() connection = session.connection(domain.Group) mappings = connection.execute( rdb.select( [security_schema.principal_role_map.c.role_id], rdb.and_( security_schema.principal_role_map.c.principal_id == principal_id, security_schema.principal_role_map.c.setting == True, security_schema.principal_role_map.c.object_type == None, security_schema.principal_role_map.c.object_id == None))) role_names = [] for (role_name, ) in mappings: role_names.append(role_name) return role_names
def setTabledDocumentSerialNumber(tabled_document): session = Session() connection = session.connection(domain.TabledDocument) sequence = rdb.Sequence('tabled_document_number_sequence') tabled_document.tabled_document_number = connection.execute(sequence)
def enumerateRoles(self, id=None, exact_match=False, sort_by=None, max_results=None, **kw): """ -> ( role_info_1, ... role_info_N ) o Return mappings for roles matching the given criteria. o 'id' in combination with 'exact_match' true, will return at most one mapping per supplied ID ('id' and 'login' may be sequences). o If 'exact_match' is False, then 'id' may be treated by the plugin as "contains" searches (more complicated searches may be supported by some plugins using other keyword arguments). o If 'sort_by' is passed, the results will be sorted accordingly. known valid values are 'id' (some plugins may support others). o If 'max_results' is specified, it must be a positive integer, limiting the number of returned mappings. If unspecified, the plugin should return mappings for all roles satisfying the criteria. o Minimal keys in the returned mappings: 'id' -- (required) the role ID 'pluginid' -- (required) the plugin ID (as returned by getId()) 'properties_url' -- (optional) the URL to a page for updating the role's properties. 'members_url' -- (optional) the URL to a page for updating the principals to whom the role is assigned. o Plugin *must* ignore unknown criteria. o Plugin may raise ValueError for invalid critera. o Insufficiently-specified criteria may have catastrophic scaling issues for some implementations. """ pluginid = self.getId() session = Session() connection = session.connection(domain.Group) 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) return [{ 'id': role_id, 'pluginid': pluginid, } for role_id in role_ids]
def enumerateRoles( self, id=None , exact_match=False , sort_by=None , max_results=None , **kw ): """ -> ( role_info_1, ... role_info_N ) o Return mappings for roles matching the given criteria. o 'id' in combination with 'exact_match' true, will return at most one mapping per supplied ID ('id' and 'login' may be sequences). o If 'exact_match' is False, then 'id' may be treated by the plugin as "contains" searches (more complicated searches may be supported by some plugins using other keyword arguments). o If 'sort_by' is passed, the results will be sorted accordingly. known valid values are 'id' (some plugins may support others). o If 'max_results' is specified, it must be a positive integer, limiting the number of returned mappings. If unspecified, the plugin should return mappings for all roles satisfying the criteria. o Minimal keys in the returned mappings: 'id' -- (required) the role ID 'pluginid' -- (required) the plugin ID (as returned by getId()) 'properties_url' -- (optional) the URL to a page for updating the role's properties. 'members_url' -- (optional) the URL to a page for updating the principals to whom the role is assigned. o Plugin *must* ignore unknown criteria. o Plugin may raise ValueError for invalid critera. o Insufficiently-specified criteria may have catastrophic scaling issues for some implementations. """ pluginid = self.getId() session = Session() connection = session.connection(domain.Group) 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) return [{ 'id': role_id, 'pluginid': pluginid, } for role_id in role_ids]
def setRegistryNumber(item): session = Session() connection = session.connection(domain.ParliamentaryItem) sequence = rdb.Sequence('registry_number_sequence') item.registry_number = connection.execute(sequence)