def get_queryset(self):
resource_list_request_validator = serializers.ResourceListRequestValidator(data=self.request.query_params)
if not resource_list_request_validator.is_valid():
raise ValidationError(detail=resource_list_request_validator.errors)
filter_parms = resource_list_request_validator.validated_data
filter_parms["user"] = self.request.user if self.request.user.is_authenticated() else None
if len(filter_parms["type"]) == 0:
filter_parms["type"] = None
filter_parms["public"] = not self.request.user.is_authenticated()
filtered_res_list = []
resource_table = hydroshare.get_resource_list(**filter_parms)
res = set()
for resources in resource_table.values():
res = res.union(resources)
for r in res:
resource_list_item = self.resourceToResourceListItem(r)
filtered_res_list.append(resource_list_item)
return filtered_res_list
def get_resource_list(self):
params = utils.create_form(GetResourceList.GetResourceListForm,
self.request)
if params.is_valid():
r = params.cleaned_data
if r['dc']:
r['dc'] = json.loads(r['dc'])
else:
r['dc'] = {}
ret = []
resource_table = hydroshare.get_resource_list(**r)
originator = get_user(self.request)
for resources in resource_table:
for r in filter(
lambda x: x.public or x.view_users.filter(
pk=originator.pk).exists() or x.view_groups.
filter(pk__in=[g.pk for g in originator.groups.all()]),
resources):
ret.append(r.short_id)
return json_or_jsonp(self.request, ret)
else:
raise exceptions.ValidationError('invalid request')
def get_queryset(self):
resource_list_request_validator = serializers.ResourceListRequestValidator(
data=self.request.query_params)
if not resource_list_request_validator.is_valid():
raise ValidationError(
detail=resource_list_request_validator.errors)
filter_parms = resource_list_request_validator.validated_data
filter_parms['user'] = (self.request.user if
self.request.user.is_authenticated() else None)
if len(filter_parms['type']) == 0:
filter_parms['type'] = None
else:
filter_parms['type'] = list(filter_parms['type'])
filter_parms['public'] = not self.request.user.is_authenticated()
return hydroshare.get_resource_list(**filter_parms)
def get_resource_list(self):
params = ResourceCRUD.GetResourceListForm(self.request.REQUEST)
if params.is_valid():
r = params.cleaned_data
if r['dc']:
r['dc'] = json.loads(r['dc'])
else:
r['dc'] = {}
ret = []
resource_table = hydroshare.get_resource_list(**r)
originator = get_user(self.request)
for resources in resource_table:
for r in filter(lambda x: authorize(self.request, x.short_id, view=True), resources):
ret.append(r.short_id)
return json_or_jsonp(self.request, ret)
else:
raise exceptions.ValidationError('invalid request')
def get_queryset(self):
resource_list_request_validator = serializers.ResourceListRequestValidator(
data=self.request.query_params)
if not resource_list_request_validator.is_valid():
raise ValidationError(detail=resource_list_request_validator.errors)
filter_parms = resource_list_request_validator.validated_data
filter_parms['user'] = (self.request.user if self.request.user.is_authenticated() else None)
if len(filter_parms['type']) == 0:
filter_parms['type'] = None
else:
filter_parms['type'] = list(filter_parms['type'])
filter_parms['public'] = not self.request.user.is_authenticated()
filtered_res_list = []
for r in hydroshare.get_resource_list(**filter_parms):
resource_list_item = self.resourceToResourceListItem(r)
filtered_res_list.append(resource_list_item)
return filtered_res_list
def get_resource_list(self):
params = GetResourceList.GetResourceListForm(self.request.REQUEST)
if params.is_valid():
r = params.cleaned_data
if r['dc']:
r['dc'] = json.loads(r['dc'])
else:
r['dc'] = {}
ret = []
resource_table = hydroshare.get_resource_list(**r)
originator = get_user(self.request)
for resources in resource_table:
for r in filter(lambda x:
x.public or
x.view_users.filter(pk=originator.pk).exists() or
x.view_groups.filter(pk__in=[g.pk for g in originator.groups.all()]), resources):
ret.append(r.short_id)
return json_or_jsonp(self.request, ret)
else:
raise exceptions.ValidationError('invalid request')
def get_resource_list(self):
params = utils.create_form(ResourceCRUD.GetResourceListForm,
self.request)
if params.is_valid():
r = params.cleaned_data
if r['dc']:
r['dc'] = json.loads(r['dc'])
else:
r['dc'] = {}
ret = []
resource_table = hydroshare.get_resource_list(**r)
originator = get_user(self.request)
for resources in resource_table:
for r in filter(
lambda x: authorize(
self.request, x.short_id, view=True), resources):
ret.append(r.short_id)
return json_or_jsonp(self.request, ret)
else:
raise exceptions.ValidationError(params.errors)
def my_resources(request, page):
# if not request.user.is_authenticated():
# return HttpResponseRedirect('/accounts/login/')
frm = FilterForm(data=request.REQUEST)
if frm.is_valid():
owner = frm.cleaned_data['creator'] or None
user = frm.cleaned_data['user'] or (
request.user if request.user.is_authenticated() else None)
edit_permission = frm.cleaned_data['edit_permission'] or False
published = frm.cleaned_data['published'] or False
start = frm.cleaned_data['start'] or 0
from_date = frm.cleaned_data['from_date'] or None
keywords = [k.strip() for k in request.REQUEST['keywords'].split(',')
] if request.REQUEST.get('keywords', None) else None
public = not request.user.is_authenticated()
dcterms = defaultdict(dict)
for k, v in filter(lambda (x, y): x.startswith('dc'),
request.REQUEST.items()):
num = int(k[-1])
vtype = k[2:-1]
dcterms[num][vtype] = v
res = set()
for lst in get_resource_list(
user=user,
owner=owner,
count=20,
published=published,
edit_permission=edit_permission,
start=start,
from_date=from_date,
dc=list(dcterms.values()) if dcterms else None,
keywords=keywords if keywords else None,
public=public).values():
res = res.union(lst)
res = sorted(list(res), key=lambda x: x.title)
return {
'resources':
res,
'first':
start,
'last':
start + len(res),
'ct':
len(res),
'dcterms': (
('AB', 'Abstract'),
('BX', 'Box'),
('CN', 'Contributor'),
('CVR', 'Coverage'),
('CR', 'Creator'),
('DT', 'Date'),
('DTS', 'DateSubmitted'),
('DC', 'DateCreated'),
('DM', 'DateModified'),
('DSC', 'Description'),
('FMT', 'Format'),
('ID', 'Identifier'),
('LG', 'Language'),
('PD', 'Period'),
('PT', 'Point'),
('PBL', 'Publisher'),
('REL', 'Relation'),
('RT', 'Rights'),
('SRC', 'Source'),
('SUB', 'Subject'),
('T', 'Title'),
('TYP', 'Type'),
)
}
def test_get_resources_by_type(self):
# This tests the ability to filter resources by type
# Note: print statements are for debugging assertion failures only
print '**********************\n' * 5
print '******* STDOUT *******'
print '**********************\n' * 5
group, _ = Group.objects.get_or_create(name='Hydroshare Author')
print 'Created Group : '+str(group)
# create a user
user = users.create_account(
'*****@*****.**',
username='******',
first_name='some_first_name',
last_name='some_last_name',
superuser=False,
groups=[group])
# get the user's id
userid = User.objects.get(username=user).pk
print 'UserID : '+ str(userid)
group = users.create_group('MyGroup',members=[user],owners=[user])
print 'Assigned User To Group'
# create a generic resource
new_res = resource.create_resource(
'GenericResource',user,'My Test GenericResource Resource')
pid = new_res.short_id
print 'Created GenericResource, PID : '+str(pid)
# create a raster resource
new_res = resource.create_resource(
'RefTimeSeries',user,'My Test RefTimeSeries Resource')
pid = new_res.short_id
print 'Created RefTimeSeries 1, PID : '+str(pid)
# create a raster resource
new_res = resource.create_resource(
'RefTimeSeries',user,'My Test RefTimeSeries Resource2')
pid = new_res.short_id
print 'Created RefTimeSeries 2, PID : '+str(pid)
# create a rhyssys resource
new_res = resource.create_resource(
'InstResource',user,'My Test InstResource Resource')
pid = new_res.short_id
print 'Created InstResource, PID : '+str(pid)
res_types_all = hydroshare.get_resource_list(user=user)
print '\nQuery All Resources: '
print 'Resource Type \t:\t Number of Resources Found'
print '------------- \t:\t -------------------------'
for k,v in res_types_all.iteritems():
print k.__name__+ '\t:\t '+ str(len(res_types_all[k]))
res_names = [r.__name__ for r in res_types_all]
self.assertTrue('GenericResource' in res_names)
self.assertTrue('RefTimeSeries' in res_names)
self.assertTrue('InstResource' in res_names)
res_types_one = hydroshare.get_resource_list(
user=user,types=['GenericResource'])
print '\nQuery One Resource: '
print 'Resource Type \t:\t Number of Resources Found'
print '------------- \t:\t -------------------------'
for k,v in res_types_one.iteritems():
print k.__name__+ '\t:\t '+ str(len(res_types_one[k]))
res_names = [r.__name__ for r in res_types_one]
self.assertTrue('GenericResource' in res_names)
self.assertTrue('RefTimeSeries' not in res_names)
self.assertTrue('InstResource' not in res_names)
res_types_multiple = hydroshare.get_resource_list(
user=user,types=['GenericResource','RefTimeSeries'])
print '\nQuery Multiple Resources: '
print 'Resource Type \t:\t Number of Resources Found'
print '------------- \t:\t -------------------------'
for k,v in res_types_multiple.iteritems():
print k.__name__+ '\t:\t '+ str(len(res_types_multiple[k]))
res_names = [r.__name__ for r in res_types_multiple]
self.assertTrue('GenericResource' in res_names)
self.assertTrue('RefTimeSeries' in res_names)
self.assertTrue('InstResource' not in res_names)
# delete the resource
resource.delete_resource(pid)
def my_resources(request, page):
# import sys
# sys.path.append("/home/docker/pycharm-debug")
# import pydevd
# pydevd.settrace('172.17.42.1', port=21000, suspend=False)
frm = FilterForm(data=request.REQUEST)
if frm.is_valid():
res_cnt = 20 # 20 is hardcoded for the number of resources to show on one page, which is also hardcoded in my-resources.html
owner = frm.cleaned_data['owner'] or None
user = frm.cleaned_data['user'] or (request.user if request.user.is_authenticated() else None)
edit_permission = frm.cleaned_data['edit_permission'] or False
published = frm.cleaned_data['published'] or False
startno = frm.cleaned_data['start']
if(startno < 0):
startno = 0
start = startno or 0
from_date = frm.cleaned_data['from_date'] or None
words = request.REQUEST.get('text', None)
public = not request.user.is_authenticated()
search_items = dict(
(item_type, [t.strip() for t in request.REQUEST.getlist(item_type)])
for item_type in ("type", "author", "contributor", "subject")
)
# TODO ten separate SQL queries for basically the same data
res = set()
for lst in get_resource_list(
user=user,
owner= owner,
published=published,
edit_permission=edit_permission,
from_date=from_date,
full_text_search=words,
public=public,
**search_items
).values():
res = res.union(lst)
total_res_cnt = len(res)
reslst = list(res)
# need to return total number of resources as 'ct' so have to get all resources
# and then filter by start and count
# TODO this is doing some pagination/limits before sorting, so it won't be consistent
if(start>=total_res_cnt):
start = total_res_cnt-res_cnt
if(start < 0):
start = 0
if(start+res_cnt > total_res_cnt):
res_cnt = total_res_cnt-start
reslst = reslst[start:start+res_cnt]
# TODO sorts should be in SQL not python
res = sorted(reslst, key=lambda x: x.title)
return {
'resources': res,
'first': start,
'last': start+len(res),
'ct': total_res_cnt,
}
