def put(self):
set_id = self._request.matchdict['id']
try:
dset = DBSession.query(DigitalSet).filter(
DigitalSet.id_set == set_id).one()
dset.set_from_dict(self._request.validated)
old_groups = DBSession.query(GroupSet).filter(
GroupSet.id_set == set_id).all()
old_ids = [gs.id_group for gs in old_groups]
new_ids = [
g['id_group'] for g in self._request.validated['groups']
]
new_groups = [
GroupSet(set_id, gid) for gid in new_ids if not gid in old_ids
]
for new_group in new_groups:
DBSession.add(new_group)
for old_group in old_groups:
if old_group.id_group not in new_ids:
DBSession.delete(old_group)
# metadata = [x for x in DBSession.query(Metadata).filter(Metadata.id == dset.id_set).all()]
update_metadata(self._request.validated['metadata'], dset.id_set,
'set')
DBSession.flush()
return APIResponse(
add_metadata_record(dset.get_dict(), dset.id_set, 'set'))
except Exception as e:
print(e)
raise HTTPNotFound()
def group_item_service_func(request):
group_id = request.matchdict['group_id']
item_id = request.matchdict['item_id']
gi = GroupItem(group_id, item_id, 0, 0)
DBSession.add(gi)
req = Request.blank('/api/v1/di/' + item_id)
return request.invoke_subrequest(req)
def view_item_service_func(request):
view_id = request.matchdict['view_id']
container_id = request.matchdict['container_id']
item_id = request.matchdict['item_id']
ci = ContainerItem(container_id, item_id, '')
DBSession.add(ci)
req = Request.blank('/api/v1/view/' + view_id + '/container/' + container_id)
return request.invoke_subrequest(req)
def collection_post(self):
v = self._request.validated
v['id_container']=str(uuid4())
v['id_view'] = self._view_id
cnt = Container(v['id_container'], v['id_view'], v['type'], '', v['x'], v['y'], v['width'], v['height'], v['z'], v['data'])
DBSession.add(cnt)
for item in v['item_ids']:
ci = ContainerItem(v['id_container'], item, '{}')
DBSession.add(ci)
sr = Request.blank('/api/v1/view/' + self._view_id + '/container/' + cnt.id_container)
return self._request.invoke_subrequest(sr)
def post(self):
data = self._request.validated
user = DBSession.query(User).filter(
User.username == data['username']).filter(
User.passwd == hash_pw(data['password'])).one_or_none()
if not user:
raise HTTPUnauthorized()
token = Token(str(uuid.uuid4()), user.id_user)
DBSession.add(token)
d = user.get_dict()
d['token'] = token.id_token
return APIResponse(d)
def collection_post(self):
v = self._request.validated
v['id_user'] = self._request.user.id_user
type = 'annotation'
if v['time'] > 0 or v['duration'] > 0:
if v['duration'] > 0:
type = '%s;%d;%d' % (type, v['time'], v['duration'])
else:
type = '%s;%d' % (type, v['time'])
link = Link(str(uuid4()), v['id_item'], v['id_user'], type, '',
v['uri'])
DBSession.add(link)
DBSession.flush()
return APIResponse(link.get_dict())
def collection_post(self):
item_id = self._request.matchdict['item_id']
try:
v = self._request.validated
link = Link(str(uuid4()), item_id, v['id_user'], v['type'],
v['description'], v['uri'])
link = Link(str(uuid4()), item_id, v['id_user'], v['type'],
v['description'], v['uri'])
DBSession.add(link)
DBSession.flush()
return link.get_dict()
except Exception as e:
print(str(e))
return HTTPBadRequest
def view_item_service_func(request):
view_id = request.matchdict['view_id']
item_id = request.matchdict['item_id']
path = request.GET.get('path', None)
if path == 'null':
path = None
vi = DBSession.query(ViewItem).filter(
sqlalchemy.and_(ViewItem.id_item == item_id,
ViewItem.id_view == view_id)).one_or_none()
if vi:
vi.path = path
else:
vi = ViewItem(view_id, item_id, path)
DBSession.add(vi)
req = Request.blank('/api/v1/di/' + item_id)
return request.invoke_subrequest(req)
def collection_post(self):
key = self._request.validated['key']
item_id = self._request.matchdict['id']
try:
# Let's check if the id/key pair is already present. If it is, then bail out
res = DBSession.query(Metadata).filter(Metadata.id == item_id).filter(Metadata.key == key).count()
if res:
print('key already present...')
raise HTTPBadRequest()
# We're adding new metadata, so let's check whether the key is already present in metaKey table
meta_key = [x for x in DBSession.query(MetaKey).filter(MetaKey.key == key).all()]
if len(meta_key) < 1:
# nope, so let's create it
meta_key = MetaKey(key, 'string', '', '')
DBSession.add(meta_key)
metadata = Metadata(item_id, 'item', key, self._request.validated['value'])
DBSession.add(metadata)
DBSession.flush()
return metadata.get_dict()
except Exception as e:
print(str(e))
raise HTTPBadRequest()
# @view(permission=Everyone)
# def collection_get(self):
# return [x.get_dict() for x in DBSession.query(DigitalItem).all()]
#
# @view(permission=Everyone, schema = DigitalItemSchema, validators=(colander_body_validator,))
# def collection_post(self):
# self._request.validated['id_item'] = str(uuid4())
# self._request.validated['created'] = datetime.datetime.now()
# #di = DigitalItem(**self._request.validated)
# v = self._request.validated
# di = DigitalItem(v['id_item'], v['mime'], v['created'], '', v['author'], v['rights'])
# print(di)
#
# required_keys = DBSession.query(MetaKey).filter(MetaKey.mandatory.contains('i'))
# print('Required keys: %s' % (','.join((x.key for x in required_keys))))
#
# DBSession.add(di)
# DBSession.flush()
# print(di)
# return di.get_dict()
def collection_post(self):
self._request.validated['id_item'] = str(uuid4())
self._request.validated['created'] = datetime.datetime.now()
# di = DigitalItem(**self._request.validated)
v = self._request.validated
print(v)
metakeys = [m['key'] for m in v['metadata']]
print(metakeys)
missing_metakeys = check_missing_metakeys(metakeys, 'i')
if len(missing_metakeys) > 0:
raise HTTPBadRequest('missing metadata keys: %s' %
', '.join(missing_metakeys))
di = DigitalItem(v['id_item'], v['mime'], v['created'], '',
v['id_user'], v['rights'])
update_metadata(v['metadata'], di.id_item, 'item')
DBSession.add(di)
DBSession.flush()
for link in v['links']:
l = Link(str(uuid4()), di.id_item, link['id_user'], link['type'],
link['description'], link['uri'])
DBSession.add(l)
for group_id in v['group_ids']:
print('Adding to group %s' % group_id)
group_item = GroupItem(group_id, di.id_item, 0, 0)
DBSession.add(group_item)
print(di)
return APIResponse(self._add_metadata(di))
def collection_post(self):
self._request.validated['id_group'] = str(uuid4())
self._request.validated['created'] = datetime.datetime.now()
v = self._request.validated
print(v)
metakeys = [m['key'] for m in v['metadata']]
print(metakeys)
missing_metakeys = check_missing_metakeys(metakeys, 'g')
if len(missing_metakeys) > 0:
raise HTTPBadRequest('missing metadata keys: %s' %
', '.join(missing_metakeys))
dg = DIGroup(v['id_group'], v['created'], '', v['id_user'], v['type'])
update_metadata(v['metadata'], dg.id_group, 'group')
DBSession.add(dg)
DBSession.flush()
print(dg)
return APIResponse(
add_metadata_record(dg.get_dict(), dg.id_group, 'group'))
def collection_post(self):
self._request.validated['id_set'] = str(uuid4())
self._request.validated['created'] = datetime.datetime.now()
# di = DigitalItem(**self._request.validated)
v = self._request.validated
print(v)
metakeys = [m['key'] for m in v['metadata']]
print(metakeys)
missing_metakeys = check_missing_metakeys(metakeys, 's')
if len(missing_metakeys) > 0:
raise HTTPBadRequest('missing metadata keys: %s' %
', '.join(missing_metakeys))
dset = DigitalSet(v['id_set'], v['created'], '', v['id_user'])
update_metadata(v['metadata'], dset.id_set, 'set')
DBSession.add(dset)
DBSession.flush()
return APIResponse(
add_metadata_record(dset.get_dict(), dset.id_set, 'set'))
def update_links(new_links, item_id):
old_links = [
x for x in DBSession.query(Link).filter(Link.id_item == item_id).all()
]
for link in new_links:
print(link)
l = next((x for x in old_links if x.id_link == link['id_link']),
None) if 'id_link' in link else None
if not l:
# Our link is a new one
print('Creating new link')
ll = Link(str(uuid4()), item_id, link['id_user'], link['type'],
link['description'], link['uri'])
DBSession.add(ll)
else:
# Update old link
print('Updating link %s' % link['id_link'])
l.set_from_dict(link)
for link in old_links:
l = next((x for x in new_links if x['id_link'] == link.id_link), None)
if not l:
# link was deleted
print('Deleting link')
DBSession.delete(link)
def collection_post(self):
self._request.validated['id_view'] = str(uuid4())
self._request.validated['created'] = datetime.datetime.now()
copy_view_id = self._request.GET.get('view_id', '')
v = self._request.validated
print(v)
metakeys = [m['key'] for m in v['metadata']]
print(metakeys)
missing_metakeys = check_missing_metakeys(metakeys, 'i')
if len(missing_metakeys) > 0:
raise HTTPBadRequest('missing metadata keys: %s' %
', '.join(missing_metakeys))
view = View(v['id_view'], v['created'], v['description'], v['id_user'],
v['public'])
update_metadata(v['metadata'], view.id_view, 'view')
DBSession.add(view)
DBSession.flush()
#
# for meta in v['metadata']:
# m = Metadata(view.id_view, 'view', meta['key'], meta['value'])
# DBSession.add(m)
# DBSession.flush()
# If user specified a view_id parameter, let's make a copy
if copy_view_id:
old_view = DBSession.query(View).filter(
View.id_view == copy_view_id).one()
old_items = DBSession.query(ViewItem).filter(
ViewItem.id_view == copy_view_id).all()
for item in old_items:
print('Adding item' + item.id_item)
vi = ViewItem(view.id_view, item.id_item, item.path)
DBSession.add(vi)
old_containers = DBSession\
.query(Container, ContainerItem)\
.join(ContainerItem, ContainerItem.id_container == Container.id_container)\
.filter(Container.id_view == copy_view_id)\
.all()
process_conts = {}
for ci in old_containers:
cid = ci[0].id_container
if not cid in process_conts:
c = ci[0]
new_cid = str(uuid4())
print('Adding container %s as %s' % (cid, new_cid))
process_conts[cid] = new_cid
cont = Container(new_cid, view.id_view, c.type,
c.description, c.x, c.y, c.width,
c.height, c.z, c.data)
DBSession.add(cont)
else:
new_cid = process_conts[cid]
print('Adding item %s to container %s' %
(ci[1].id_item, new_cid))
citem = ContainerItem(new_cid, ci[1].id_item, ci[1].data)
DBSession.add(citem)
print(view)
return APIResponse(
add_metadata_record(view.get_dict(), view.id_view, 'view'))
def collection_post(self):
v = self._request.validated
user = User(str(uuid.uuid4()), v['username'], v['fullname'], hash_pw(v['passwd']), v['auth_level'])
DBSession.add(user)
DBSession.flush()
return APIResponse(user.get_dict())