X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=rest%2F__init__.py;h=fccfede72299bf4fb050e56a5354f6885016a07b;hb=89af8babd28a7da90ffe59be3ce7b7e812734cd0;hp=91f126ce829dc46d8050a95ecfd749b1422192cb;hpb=de9d705455770a4d532f3b36151217c857a899f9;p=myslice.git diff --git a/rest/__init__.py b/rest/__init__.py index 91f126ce..fccfede7 100644 --- a/rest/__init__.py +++ b/rest/__init__.py @@ -1,18 +1,13 @@ -from manifold.core.query import Query - -from django.views.generic.base import TemplateView -from django.shortcuts import render_to_response +import decimal +import datetime +import json -from unfold.loginrequired import LoginRequiredView from django.http import HttpResponse -from manifold.core.query import Query, AnalyzedQuery +from manifold.core.query import Query from manifoldapi.manifoldapi import execute_query -from string import join -import decimal -import datetime -import json +from myslice.settings import logger # handles serialization of datetime in json DateEncoder = lambda obj: obj.strftime("%B %d, %Y %H:%M:%S") if isinstance(obj, datetime.datetime) else None @@ -26,102 +21,175 @@ class DecimalEncoder(json.JSONEncoder): if isinstance(o, decimal.Decimal): return (str(o) for o in [o]) return super(DecimalEncoder, self)._iterencode(o, markers) + +class ObjectRequest(object): + + def __init__(self, request, object_type, object_name): + self.type = object_type + self.name = object_name + self.fields = [] + self.params = [] + self.filters = {} + self.options = None -def dispatch(request, object_type, object_name): + self.request = request + + if ((self.type == 'platform') or (self.type == 'testbed')) : + self.type = 'local:platform' + self.id = 'platform' + self.fields = ['platform', 'platform_longname', 'platform_url', 'platform_description','gateway_type']; + self.filters['disabled'] = '0' + self.filters['gateway_type'] = 'sfa' + self.filters['platform'] = '!myslice' + #elif(self.type.startswith('local:')): + elif ':' in self.type: + table = self.type.split(':') + prefix = table[0] + table = table[1] + if prefix == 'local': + # XXX TODO: find a generic Query to get the fields like + # select column.name from local:object where table == local:user + table = self.type.split(':') + table = table[1] + if table == "user": + self.id = table + '_id' + self.fields = ['user_id', 'email', 'password', 'config','status']; + elif table == "account": + # XXX TODO: Multiple key for account = (platform_id, user_id) + self.id = "platform_id, user_id" + self.fields = ['platform_id', 'user_id', 'auth_type', 'config']; + elif table == "platform": + self.id = 'platform' + self.fields = ['platform', 'platform_longname', 'platform_url', 'platform_description','gateway_type']; + else: + # If we use prefix, set the key without the prefix then add it again + self.type = table + self.setKey() + self.setLocalFields() + self.type = prefix + ':' + table + else : + self.setKey() + self.setLocalFields() - object_properties = None - object_filters = {} + def setKey(self): + # What about key formed of multiple fields??? + query = Query.get('local:object').filter_by('table', '==', self.type).select('key') + results = execute_query(self.request, query) + logger.debug("key of object = {}".format(results)) + if results : + for r in results[0]['key'] : + self.id = r + else : + raise Exception, 'Manifold db error' - switch = { - 'platform' : platform, - 'slice' : slice, - 'resource' : resource, - 'user' : user, - } + def setLocalFields(self): + query = Query.get('local:object').filter_by('table', '==', self.type).select('column.name') + results = execute_query(self.request, query) + if results : + for r in results[0]['column'] : + self.fields.append(r['name']) + else : + raise Exception, 'Manifold db error' - if request.method == 'POST': - req_items = request.POST.items() - elif request.method == 'GET': - req_items = request.GET.items() + def setFields(self, fields): +# selected_fields = [] +# for p in fields : +# if p in self.fields : +# selected_fields.append(p) + self.fields = fields - for el in req_items: - if el[0].startswith('filters'): - object_filters[el[0][8:-1]] = el[1] - elif el[0].startswith('columns'): - object_properties = request.POST.getlist('columns[]') - - # platform is local - if ((object_type == 'platform') or (object_type == 'testbed')) : - object_type = 'local:platform' - if object_properties == None : - object_properties = ['platform', 'platform_longname', 'platform_url', 'platform_description','gateway_type']; - return switch.get('platform', error)(request, object_name, object_properties, object_filters) - else : - if object_properties == None : - query = Query.get('local:object').filter_by('table', '==', object_type).select('column.name') - results = execute_query(request, query) - if results : - object_properties = [] - for r in results[0]['column'] : - object_properties.append(r['name']) - else : - return error(request, object_name, {}) - return switch.get(object_type, error)(request, object_name, object_properties, object_filters) - -def platform(request, object_name, object_properties, object_filters = None): - query = Query().get('local:platform').filter_by('disabled', '==', '0').filter_by('gateway_type', '==', 'sfa').filter_by('platform', '!=', 'myslice') - if object_filters : - for k, f in object_filters.iteritems() : - query.filter_by(k, '==', f) - query.select(object_properties) - return send(request, execute_query(request, query), object_properties) - -# Add different filters possibilities [['user.user_hrn','==','$user_hrn'],['parent_authority','==','ple.upmc']] -def slice(request, object_name, object_properties, object_filters = None): - query = Query().get('slice')#.filter_by('user.user_hrn', '==', '$user_hrn') - if object_filters : - for k, f in object_filters.iteritems() : - query.filter_by(k, '==', f) - query.select(object_properties) - return send(request, execute_query(request, query), object_properties) + + def applyFilters(self, query, force_filters = False): + if (force_filters and not self.filters) : + raise Exception, "Filters required" + if self.filters : + for k, f in self.filters.iteritems() : + if (f[:1] == "!") : + query.filter_by(k, '!=', f[1:]) + elif (f[:2] == ">=") : + query.filter_by(k, '>=', f[2:]) + elif (f[:1] == ">") : + query.filter_by(k, '>', f[1:]) + elif (f[:2] == "<=") : + query.filter_by(k, '<=', f[2:]) + elif (f[:1] == "<") : + query.filter_by(k, '<', f[1:]) + elif (f[:8] == "CONTAINS") : + query.filter_by(k, 'CONTAINS', f[8:]) + else : + query.filter_by(k, '==', f) + return query + + def get(self): + query = Query.get(self.type) + if (self.id is not None) and (self.id not in self.fields) : + query.select(self.fields + [self.id]) + else : + query.select(self.fields) + + query = self.applyFilters(query) + return execute_query(self.request, query) -def resource(request, object_name, object_properties, object_filters = None): - query = Query().get('resource') - if object_filters : - for k, f in object_filters.iteritems() : - query.filter_by(k, '==', f) - query.select(object_properties) - return send(request, execute_query(request, query), object_properties) + def create(self): + query = Query.create(self.type) + # No filters for create + if self.params : + for p in self.params : + for k,v in p.iteritems() : + logger.debug("param: {} : {}".format(k, v)) + query.set({k : v}) + logger.debug("query = {}".format(query)) + else: + raise Exception, "Params are required for create" + return execute_query(self.request, query) + + def update(self): + query = Query.update(self.type) + query = self.applyFilters(query, True) -def user(request, object_name, object_properties, object_filters = None): - query = Query().get('user')#.filter_by('user_hrn', '==', '$user_hrn') - if object_filters : - for k, f in object_filters.iteritems() : - query.filter_by(k, '==', f) - query.select(object_properties) - return send(request, execute_query(request, query), object_properties) + if self.params : + for p in self.params : + for k,v in p.iteritems() : + logger.debug("param: {} : {}".format(k, v)) + query.set({k : v}) + logger.debug("query = {}".format(query)) + else: + raise Exception, "Params are required for update" -def send(request, response, object_properties): - if request.path.split('/')[1] == 'rest' : - response_data = response - return HttpResponse(json.dumps(response_data, cls=DecimalEncoder, default=DateEncoder), content_type="application/json") - elif request.path.split('/')[1] == 'table' : - return render_to_response('table-default.html', {'data' : response, 'properties' : object_properties}) - elif request.path.split('/')[1] == 'datatable' : + if self.id is not None: + query.select(self.id) + + return execute_query(self.request, query) + + def delete(self): + query = Query.delete(self.type) + query = self.applyFilters(query, True) + if self.filters : + query.set(self.filters) + else: + raise Exception, "Filters are required for delete" + return execute_query(self.request, query) + + def json(self): + return HttpResponse(json.dumps(self.get(), cls=DecimalEncoder, default=DateEncoder), content_type="application/json") + + def datatable(self): + response = self.get() response_data = {} - response_data['columns'] = object_properties - response_data['labels'] = object_properties + response_data['fields'] = self.fields + response_data['labels'] = self.fields response_data['data'] = [] response_data['total'] = len(response) for r in response : d = [] - for p in object_properties : + for p in self.fields : d.append(r[p]) - print d - response_data['data'].append(d) - + return HttpResponse(json.dumps(response_data, cls=DecimalEncoder, default=DateEncoder), content_type="application/json") -def error(request, object_name, object_properties): - return HttpResponse(json.dumps({'error' : 'an error has occurred'}), content_type="application/json") +def error(msg): + return HttpResponse(json.dumps({'error' : msg}), content_type="application/json") + +def success(msg): + return HttpResponse(json.dumps({'success' : msg}), content_type="application/json")