def add_link(request, session, ro):
"""Add a new 'use' link between this RO and another
Args:
request (Request):
session (DBSession):
ro (ResearchObject):
Returns:
(None|uid): None if something failed, created link
"""
uid = request.params.get('ro_id', "")
if len(uid) == 0:
request.session.flash("Enter a RO id first", 'warning')
return None
# check whether the RO is already associated to this RO
if uid == ro.id:
request.session.flash("Can not create link with oneself", 'warning')
return None
linked = [link.target for link in ro.out_links if link.type == 'use']
if uid in linked:
request.session.flash("%s is already linked" % uid, 'warning')
return None
# check whether uid correspond to a valid RO
tgt = ResearchObject.get(session, uid)
if tgt is None:
request.session.flash("%s is not a valid RO" % uid, 'warning')
return None
# create link
link = ROLink.connect(session, ro.id, uid, "use")
return link
def view(request):
session = DBSession()
uid = request.params["uid"]
delete_recursive = json.loads(request.params["recursive"])
ro = ResearchObject.get(session, uid)
if ro.owner == request.unauthenticated_userid:
ResearchObject.remove(session, ro, delete_recursive)
return {}
def view(request):
session = DBSession()
ro, view_params = view_init_min(request, session)
view_params['description'] = Markup(ro.html_description())
ancestors = []
for link in ro.in_links:
if link.type == 'is_ancestor_of':
ancestors.append(ResearchObject.get(session, link.source))
view_params['ancestors'] = ancestors
return view_params
def fetch_ro(request, session):
"""Retrieve RO whose id is in URL.
Args:
request: (Request)
session: (DBSession)
Returns:
(str, ResearchObject): uid, ro
"""
uid = request.matchdict['uid']
ro = ResearchObject.get(session, uid)
if ro is None:
request.session.flash("RO %s does not exists" % uid, 'warning')
raise HTTPFound(location=request.route_url('home'))
return uid, ro
def append_ro(request, session, container):
"""Add a new RO in this container.
Args:
request (Request):
session (DBSession):
container (ROContainer):
Returns:
(None|uid): None if something failed, created link
"""
uid = request.params.get('ro_id', "")
if len(uid) == 0:
request.session.flash("Enter a RO id first", 'warning')
return None
# check whether the RO is already a member of the container
if uid == container.id:
request.session.flash("Can not contain oneself", 'warning')
return None
content = [link.target for link in container.out_links if link.type == 'contains']
if uid in content:
request.session.flash("%s is already in this container" % uid, 'warning')
return None
# check whether uid correspond to a valid RO
ro = ResearchObject.get(session, uid)
if ro is None:
request.session.flash("%s is not a valid RO" % uid, 'warning')
return None
# check whether user has 'install' rights on this RO
role = ro.access_role(session, request.unauthenticated_userid)
if role < Role.install:
request.session.flash("You're not allowed to add %s to this container" % uid, 'warning')
return None
# create link
link = ROLink.connect(session, container.id, uid, "contains")
return link
def view(request):
session = DBSession()
ro, view_params = view_init_min(request, session)
if view_params["allow_edit"] and ('new_content' in request.params or request.params.get("ro_id", "") != ""):
if append_ro(request, session, ro) is not None:
loc = request.current_route_url()
return HTTPFound(location=loc)
view_params['description'] = Markup(ro.html_description())
content = []
for link in ro.out_links:
if link.type == "contains":
ro = ResearchObject.get(session, link.target)
content.append((ro.name.lower(), ro))
content.sort()
view_params['content'] = [ro for name, ro in content]
return view_params
def view(request):
session = DBSession()
user = request.unauthenticated_userid
if 'uid' in request.params:
# search a RO with a specific id
uid = request.params['uid']
ro = ResearchObject.get(session, uid)
if ro is None:
return None
else:
# check credentials
role = ro.access_role(session, user)
if role == Role.denied:
return None
else:
return ro.repr_json(full=True)
else:
ros = search(session, request.params)
return [ro.id for ro in ros
if ro.access_role(session, user) != Role.denied]
def view_init_min(request, session):
"""Common init for all 'view' parts.
Args:
request: (Request)
session: (DBSession)
Returns:
(ResearchObject, dict of (str: any)): ro, view_params
"""
if 'main_search' in request.params:
loc = request.route_url('ro_list', _query=dict(request.params))
raise HTTPFound(location=loc)
uid, ro = fetch_ro(request, session)
current_uid = request.unauthenticated_userid
role = ro.access_role(session, current_uid)
if role == Role.denied:
request.session.flash("Access to %s not granted for you" % uid,
'warning')
raise HTTPFound(location=request.route_url('home'))
# allow edition
allow_edit = (current_uid is not None and role == Role.edit)
# find containers
uids = fetch_containers(session, ro)
containers = [(uid, ResearchObject.get(session, uid).name) for uid in uids]
view_params = {"ro": ro,
"containers": containers,
"allow_edit": allow_edit,
"minimized": True}
return ro, view_params
def search(session, params):
"""Perform a query for RO objects
Args:
session (DBSession):
params (dict): extra parameters for search
Returns:
(list of str): list of ids of RO matching query
"""
# query on RO direct common attributes
query = session.query(ResearchObject.id)
if "type" in params and params['type'] != 'ro':
query = query.filter(ResearchObject.type == params["type"])
if "owner" in params:
query = query.filter(ResearchObject.owner == params["owner"])
if "name" in params:
name = params['name']
if name[-1] == "*":
name = name[:-1]
query = query.filter(ResearchObject.name.like("%s%%" % name))
else:
query = query.filter(ResearchObject.name == name)
# query = query.order_by(ResearchObject.name)
uids = {uid for uid, in query.all()}
# query on type of link
if 'in' in params:
# search all RO in a specific container
uid = params['in']
query = session.query(ROLink.target)
query = query.filter(ROLink.source == uid, ROLink.type == 'contains')
uids &= {uid for uid, in query.all()}
if 'use' in params:
# search all RO that use a specific id
uid = params['use']
query = session.query(ROLink.source)
query = query.filter(ROLink.target == uid, ROLink.type == 'use')
uids &= {uid for uid, in query.all()}
# specific query by type
if "type" in params:
typ = params['type']
if typ in search_factory:
loc_uids = search_factory[typ](session, params)
if loc_uids is not None:
uids &= loc_uids
# fetch ROs
res = [ResearchObject.get(session, uid) for uid in uids]
# high level python expressed query
if "toplevel" in params:
res = [ro for ro in res if ro.is_lonely()]
# sort by name
res = sorted([(ro.name, ro) for ro in res])
return [ro for name, ro in res]
