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)
