def search(self, params_dict):
collection = CollectionOperationalAPI()
resource_filter = {}
for param, val in params_dict.iteritems():
if param == 'specification_name' and val:
resource_filter[param] = val
specification = ManagementAPI()
res_list = self._search_elem(resource_filter, collection)
coll_list = []
if res_list:
for param in res_list:
spec = specification.findSpecification('collection', {'type_name': param['specification_name']})
for item in spec:
d = item.to_dict()
param['allowed_types'] = d['allowed_types']
coll_list.append(param)
return coll_list
def _search_elem(self, resource_filter, element):
obj_list = []
if isinstance(element, ConnectionOperationalAPI):
obj_list = element.findConnection(resource_filter)
resource = ResourceOperationalAPI()
specification = ManagementAPI()
elems_list = []
for item in obj_list:
s = item.to_dict()
#print s
spec = specification.findSpecification('connection', {'type_name': s['specification_name']})[0].to_dict()
s['id'] = s.pop('_id')
s['connected_res_name'] = resource.getResourceInfo(s['connected_resource']).to_dict()['resource_name']
s['connecting_res_name'] = resource.getResourceInfo(s['connecting_resource']).to_dict()['resource_name']
s['connecting_type'] = spec['connecting_type']
s['connected_type'] = spec['connected_type']
elems_list.append(s)
#print elems_list
return elems_list
def connectResources(self, conn_type, connecting_res_id, connected_res_id, conn_desc=None, **add_params):
""" Connecting resource by connect type """
filter_conn = {'specification_name': conn_type,
'connecting_resource': connecting_res_id,
'connected_resource': connected_res_id}
if connecting_res_id == connected_res_id:
raise BIException('Connection between similar resources is not allowed!')
elif self.findConnection(filter_conn):
raise BIException('Connection between resources already exist!')
connection = Connection(specification_name=conn_type, connecting_resource=connecting_res_id,
connected_resource=connected_res_id, description=conn_desc,
additional_parameters=add_params)
res = ResourceOperationalAPI()
connecting_res = res.getResourceInfo(connecting_res_id)
connected_res = res.getResourceInfo(connected_res_id)
if connecting_res.to_dict() and connected_res.to_dict():
spec = ManagementAPI()
connecting_res_d = connecting_res.to_dict()
connected_res_d = connected_res.to_dict()
connecting_res_spec = spec.findSpecification(self.RESOURCE,
{'type_name': connecting_res_d['specification_name'],
'spec_type': self.RESOURCE})[0]
connected_res_spec = spec.findSpecification(self.RESOURCE, {'type_name': connected_res_d['specification_name'],
'spec_type': self.RESOURCE})[0]
Resource.setup_specification([ResourceSpecification(connecting_res_spec.to_dict())])
Resource.setup_specification([ResourceSpecification(connected_res_spec.to_dict())])
connection.connect(connecting_res, connected_res)
self.db_conn.connect()
self.db_conn.save_entity(self.CONNECTION, connection.to_dict())
self.db_conn.close()
def delete(self, resource_id, params):
resource = ManagementAPI()
resource.removeResource(resource_id)
return self.search_resource(params)
def __init__(self):
self.specification = ManagementAPI()
class SetViews():
""" Base class API """
def __init__(self):
self.specification = ManagementAPI()
#self.resource = ResourceOperationalAPI()
#self.collection = CollectionOperationalAPI()
def conn_search_del(self, request):
""" Search and delete connections """
conn = ConnectionAPI()
conn_list = []
if request.GET and not request.POST:
conn_list = conn.search(request.GET)
elif request.POST:
conn_list = conn.delete(request.POST.get('del_id', None), request.GET)
#spec = self._search_spec('connection', spec_name=request.GET['specification_name'])
return render_to_response('connection_search.html',
{'res_list': conn_list, 'elem_type': ELEM_TYPES['IS_CONN']},
context_instance=RequestContext(request))
def connection(self, request):
""" Get connection for create/modify """
conn_id = request.GET.get('elem_id',)
# MODIFY connection
if conn_id:
return render_to_response('connection.html',
{'conn_id': conn_id},
context_instance=RequestContext(request))
# create connection
conn_spec_list = self._search_spec(ELEM_TYPES['IS_CONN'])
return render_to_response('connection_create.html',
{'items_list': conn_spec_list},
context_instance=RequestContext(request))
def get_connection_params(self, request):
""" Implement GET method """
if request.GET.get('spec_id', None):
connection = ConnectionOperationalAPI()
conn_info = connection.getConnectionInfo(request.GET['spec_id']).to_dict()
conn_spec = self._search_spec(ELEM_TYPES['IS_CONN'], conn_info['specification_name'])[0]
connected_type = conn_spec['connected_type']
connecting_type = conn_spec['connecting_type']
resource = ResourceOperationalAPI()
res_filter = {'specification_name': str(connecting_type)}
raw_connecting_res_list = self._search_elem(res_filter, resource)
connecting_res_list = []
if raw_connecting_res_list:
for res in raw_connecting_res_list:
connecting_res_dict = dict()
connecting_res_dict['connecting_res_id'] = res['id']
connecting_res_dict['res_name'] = res['resource_name']
connecting_res_list.append(connecting_res_dict)
res_filter = {'specification_name': str(connected_type)}
raw_connected_res_list = self._search_elem(res_filter, resource)
connected_res_list = []
if raw_connected_res_list:
for res in raw_connected_res_list:
connected_res_dict = dict()
connected_res_dict['connected_res_id'] = res['id']
connected_res_dict['res_name'] = res['resource_name']
connected_res_list.append(connected_res_dict)
# for TreeMenu
spec_params_json = json.dumps(conn_spec['params_spec'])
to_text = spec_params_json.replace('param_name','text')
items = to_text.replace('children_spec','items')
json_data = {'conn_spec': conn_spec['params_spec'],
'conn_info': conn_info,
'items': json.loads(items),
'connected_type': conn_spec.get('connected_type', None),
'connecting_type': conn_spec.get('connecting_type', None),
'connected_res_list': connected_res_list,
'connecting_res_list': connecting_res_list}
return HttpResponse(json.dumps(json_data), mimetype="application/json")
return HttpResponse()
def coll_search_del(self, request):
""" Search and delete collections """
coll = CollectionAPI()
coll_list = []
if request.GET and not request.POST:
coll_list = coll.search(request.GET)
elif request.POST:
coll_list = coll.delete(request.POST.get('del_id', None), request.GET)
return render_to_response('collection_search.html',
{'res_list': coll_list,'elem_type': ELEM_TYPES['IS_COLL']},
context_instance=RequestContext(request))
def collection(self, request):
""" Get collection for modify """
if request.GET.get('elem_id', None):
return render_to_response('collection.html',
{'coll_id': request.GET['elem_id']},
context_instance=RequestContext(request))
coll_spec_list = self._search_spec(ELEM_TYPES['IS_COLL'])
return render_to_response('collection_create.html',
{'items_list': coll_spec_list},
context_instance=RequestContext(request))
def get_collection_params(self, request):
""" Implement GET method """
if request.GET.get('coll_id', None):
collection = CollectionOperationalAPI()
coll_info = collection.getCollectionInfo(request.GET['coll_id']).to_dict()
coll_spec = self._search_spec(ELEM_TYPES['IS_COLL'], coll_info['specification_name'])[0]
# for TreeMenu
spec_params_json = json.dumps(coll_spec['params_spec'])
to_text = spec_params_json.replace('param_name','text')
items = to_text.replace('children_spec','items')
json_data = {'coll_spec': coll_spec['params_spec'],
'coll_info': coll_info,
'allowed_types': coll_spec['allowed_types'],
'items': json.loads(items)}
return HttpResponse(json.dumps(json_data), mimetype="application/json")
return HttpResponse()
def resource(self,request):
""" Render resource page for creating and modifying """
# render UPDATE page for resource
if request.GET.get('elem_id', None):
# get connections list
connection = ConnectionAPI()
conn_list_raw = connection.search()
conn_list = []
if conn_list_raw:
for conn in conn_list_raw:
conn_list.append(conn['specification_name'])
return render_to_response('resource.html',
{'res_id': request.GET['elem_id'], 'conn_list': list(set(conn_list))},
context_instance=RequestContext(request))
# render CREATE page resource
# get specs for creating resource
res_spec_list = self._search_spec(ELEM_TYPES['IS_RES'])
return render_to_response('resource_create.html',
{'items_list': res_spec_list},
context_instance=RequestContext(request))
def get_resource_params(self, request):
""" Implement GET method for get resource info """
if request.GET.get('elem_id', None):
res_id = request.GET['elem_id']
resource = ResourceOperationalAPI()
res_info = resource.getResourceInfo(res_id).to_dict()
res_spec = self._search_spec(ELEM_TYPES['IS_RES'], res_info['specification_name'])[0]
# find allowed collections for resource
spec_filter = {'allowed_types': str(res_info['specification_name'])}
raw_spec_list = self.specification.findSpecification(ELEM_TYPES['IS_COLL'], spec_filter)
allowed_spec_coll_list = []
if raw_spec_list:
for spec in raw_spec_list:
spec_dict = spec.to_dict()
allowed_spec_coll_list.append(spec_dict['type_name'])
# find created collections and fill 'Allowed collection' on web page
collection = CollectionOperationalAPI()
raw_allow_coll_list = collection.findCollections({'specification_name__in': allowed_spec_coll_list})
allow_coll_list = []
for coll in raw_allow_coll_list:
coll_dict = coll.to_dict()
# change key for display in collection on web page
time_dict = dict()
time_dict['value'] = coll_dict.pop('_id')
time_dict['content'] = coll_dict.pop('specification_name')
allow_coll_list.append(time_dict)
# find assigned resource in collections and fill 'Assigned collection' on web page
raw_coll_list = collection.findCollections({'resources': res_id})
assigned_coll_list = []
for coll in raw_coll_list:
coll_dict = coll.to_dict()
assigned_coll_list.append(coll_dict['_id'])
# for treeMenu. replace keys :( TODO for refactoring
spec_params_json = json.dumps(res_spec['params_spec'])
to_text = spec_params_json.replace('param_name','text')
items = to_text.replace('children_spec','items')
json_data = {'res_spec': res_spec['params_spec'],
'res_info': res_info,
'items': json.loads(items),
'allowed_coll': allow_coll_list,
'assigned_coll': assigned_coll_list}
time.sleep(0.1)
return HttpResponse(json.dumps(json_data), mimetype="application/json")
return HttpResponse()
def res_search_del(self, request):
""" Searching and deleting resource """
res = ResourceAPI()
# SEARCH resource
if request.GET and not request.POST:
res_list = res.search_resource(request.GET)
return render_to_response('resource_search.html',
{'res_list': res_list, 'elem_type': ELEM_TYPES['IS_RES']},
context_instance=RequestContext(request))
# DELETE resource
elif request.POST:
if request.POST.get('del_id', None):
res_list = res.del_resource(request.POST['del_id'], request.GET)
return render_to_response('resource_search.html',
{'res_list': res_list, 'elem_type': ELEM_TYPES['IS_RES']},
context_instance=RequestContext(request))
return HttpResponse()
# render empty page
return render_to_response('resource_search.html',
{'res_list': [], 'elem_type': ELEM_TYPES['IS_RES']},
context_instance=RequestContext(request))
def _search_elem(self, resource_filter, element):
obj_list = []
if isinstance(element, ResourceOperationalAPI):
obj_list = element.findResources(resource_filter)
elif isinstance(element, CollectionOperationalAPI):
obj_list = element.findCollections(resource_filter)
elif isinstance(element, ConnectionOperationalAPI):
obj_list = element.findConnection(resource_filter)
elems_list = []
for item in obj_list:
s = item.to_dict()
s['id'] = s.pop('_id')
elems_list.append(s)
return elems_list
def save_element(self, request):
""" Saving and updating elements """
elem_type = request.POST.get('res_name',)
elem_desc = request.POST.get('elem_desc',) # must be elem_desc
elem_id = request.POST.get('elem_id',)
res_status = request.POST.get('res_status',)
res_name = request.POST.get('res_name1',)
res_sys = request.POST.get('res_sys',)
res_loc = request.POST.get('res_loc',)
res_dep = request.POST.get('res_dep',)
res_own = request.POST.get('res_own',)
res_type = request.POST.get('res_type',)
raw_param_res = request.POST.get('res_param',)
old_assigned_to_coll = request.POST.get('old_assigned_to_coll',)
new_assigned_to_coll = request.POST.get('new_assigned_to_coll',)
if old_assigned_to_coll:
old_assigned_to_coll = json.loads(old_assigned_to_coll)
if new_assigned_to_coll:
new_assigned_to_coll = json.loads(new_assigned_to_coll)
# resource
if res_type == ELEM_TYPES['IS_RES']:
resource = ResourceOperationalAPI()
spec = self._search_spec(ELEM_TYPES['IS_RES'], elem_type)[0]
Resource.setup_specification([ResourceSpecification(spec)])
if elem_id: # UPDATE
self._update_collections(old_assigned_to_coll, new_assigned_to_coll, elem_id)
resource.updateResource(elem_id, res_name, res_status, elem_desc, res_sys, res_loc, res_dep, res_own,
**json.loads(raw_param_res))
else: # CREATE
resource.createResource(elem_type, res_name, res_status, elem_desc, res_sys, res_loc, res_dep, res_own,
**json.loads(raw_param_res))
return HttpResponse()
# collections
if res_type == ELEM_TYPES['IS_COLL']:
collection = CollectionOperationalAPI()
coll_spec = self._search_spec(ELEM_TYPES['IS_COLL'], elem_type)[0]
Collection.setup_specification([CollectionSpecification(coll_spec)])
if elem_id:
collection.updateCollectionInfo(elem_id, elem_desc, additional_parameters=json.loads(raw_param_res))
else:
collection.createCollection(elem_type, elem_desc, additional_parameters=json.loads(raw_param_res))
return HttpResponse()
# connections
if res_type == ELEM_TYPES['IS_CONN']:
connection = ConnectionOperationalAPI()
connecting_res_id = request.POST.get('connecting_res_id',)
connected_res_id = request.POST.get('connected_res_id',)
conn_spec = self._search_spec(ELEM_TYPES['IS_CONN'], elem_type)[0]
Connection.setup_specification([ConnectionSpecification(conn_spec)])
if elem_id:
connection.updateConnection(elem_id, elem_desc, connecting_res_id, connected_res_id,
additional_parameters=json.loads(raw_param_res))
else:
connection.connectResources(elem_type, connecting_res_id, connected_res_id, elem_desc,
**json.loads(raw_param_res))
return HttpResponse()
def _update_collections(self, old_assigned_to_coll, new_assigned_to_coll, res_id):
""" Append or remove resource from collections """
diff_list = set(old_assigned_to_coll)
new_list = diff_list.symmetric_difference(new_assigned_to_coll)
collection = CollectionOperationalAPI()
for coll_id in new_list:
if coll_id in new_assigned_to_coll:
coll = collection.getCollectionInfo(coll_id).to_dict()
coll_spec = self._search_spec(ELEM_TYPES['IS_COLL'], coll['specification_name'])[0]
Collection.setup_specification([CollectionSpecification(coll_spec)])
collection.appendResourceToCollection(coll_id, res_id)
elif coll_id in old_assigned_to_coll:
collection.removeResourceFromCollection(coll_id, res_id)
def save_spec(self,request):
if request.is_ajax():
spec_id = request.POST.get('spec_id',)
spec_name = request.POST.get('spec_name',)
spec_type = request.POST.get('spec_type',)
description = request.POST.get('spec_desc',)
spec_parent = request.POST.get('parent_spec',)
connion_type = request.POST.get('connion_type',)
conned_type = request.POST.get('conned_type',)
allowed_types = request.POST.get('allowed_types',)
raw_param_spec = request.POST.get('param_spec',)
params_spec = json.loads(raw_param_spec)
if spec_type == ELEM_TYPES['IS_RES']:
if spec_id:
self.specification.updateSpecification(spec_id, spec_name, spec_parent, spec_type, description,
params_spec=params_spec)
else:
self.specification.createSpecification(spec_name, spec_parent, spec_type, description,
params_spec=params_spec)
elif spec_type == ELEM_TYPES['IS_CONN']:
if spec_id:
self.specification.updateSpecification(spec_id, spec_name, spec_parent, spec_type, description,
connecting_type=connion_type, connected_type=conned_type,
params_spec=params_spec)
else:
self.specification.createSpecification(spec_name, spec_parent, spec_type, description,
connecting_type=connion_type, connected_type=conned_type,
params_spec=params_spec)
elif spec_type == ELEM_TYPES['IS_COLL']:
all_type = allowed_types.split(',')
if spec_id:
self.specification.updateSpecification(spec_id, spec_name, spec_parent, spec_type, description,
allowed_types=all_type, params_spec=params_spec)
else:
self.specification.createSpecification(spec_name, spec_parent, spec_type, description,
allowed_types=all_type, params_spec=params_spec)
return HttpResponse()
def get_connection_by_type(self, request):
""" Get connection type for resource """
if request.is_ajax():
res_id = request.GET.get('elem_id', None)
conn_type = request.GET.get('conn_id', None)
connection = ConnectionOperationalAPI()
resource = ResourceOperationalAPI()
connected_res = connection.getLinkedResources(res_id, conn_type=conn_type, conn_direction=CONNECTED)
connecting_res = connection.getLinkedResources(res_id, conn_type=conn_type, conn_direction=CONNECTING)
connected_list = []
for tt in connecting_res:
conn_res_id = tt.to_dict()['connected_resource']
res_info = resource.getResourceInfo(conn_res_id).to_dict()
connected_list.append(res_info['resource_name'])
connecting_list = []
for tt in connected_res:
conn_res_id = tt.to_dict()['connecting_resource']
res_info = resource.getResourceInfo(conn_res_id).to_dict()
connecting_list.append(res_info['resource_name'])
return HttpResponse(json.dumps({'connecting_list': connecting_list,
'connected_list': connected_list}), mimetype="application/json")
def get_param_spec(self,request):
if request.is_ajax():
spec_id = request.GET.get('spec_id',)
raw_spec = self.specification.getSpecification(spec_id).to_dict()
spec_param_json = json.dumps(raw_spec)
json_params = {}
# for connections get connected_type and connecting_type. for create conn spec
if raw_spec['spec_type'] == ELEM_TYPES['IS_CONN']:
connected_type = raw_spec['connected_type']
connecting_type = raw_spec['connecting_type']
resource = ResourceOperationalAPI()
res_filter = {'specification_name': str(connecting_type)}
raw_connecting_res_list = self._search_elem(res_filter, resource)
if raw_connecting_res_list:
connecting_res_list = []
for res in raw_connecting_res_list:
connecting_res_dict = dict()
connecting_res_dict['connecting_res_id'] = res['id']
connecting_res_dict['res_name'] = res['resource_name']
connecting_res_list.append(connecting_res_dict)
json_params['connecting_res_list'] = connecting_res_list
res_filter = {'specification_name': str(connected_type)}
raw_connected_res_list = self._search_elem(res_filter, resource)
if raw_connected_res_list:
connected_res_list = []
for res in raw_connected_res_list:
connected_res_dict = dict()
connected_res_dict['connected_res_id'] = res['id']
connected_res_dict['res_name'] = res['resource_name']
connected_res_list.append(connected_res_dict)
json_params['connected_res_list'] = connected_res_list
#for treeMenu
to_text = spec_param_json.replace('param_name','text')
items = to_text.replace('children_spec','items')
json_params['params_list'] = json.loads(items)
json_params['connected_type'] = raw_spec.get('connected_type', None)
json_params['connecting_type'] = raw_spec.get('connecting_type', None)
json_params['spec_param_list'] = json.loads(spec_param_json)
return HttpResponse(json.dumps(json_params), mimetype="application/json")
# for create specifications
#load_page = request.META.get('HTTP_REFERER').split('/')
#if load_page[3] in SPEC_TYPE.keys():
else:
to_text = spec_param_json.replace('param_name','text')
items = to_text.replace('children_spec','items')
json_params = {'spec_param_list': json.loads(spec_param_json), 'params_list': json.loads(items)}
return HttpResponse(json.dumps(json_params), mimetype="application/json")
def get_spec(self, request):
""" Get specification for edit """
spec_id = request.GET.get('spec_id',)
load_page = request.META.get('PATH_INFO')
render_page = load_page.split('/')
#render specification page
if spec_id:
raw_spec = self.specification.getSpecification(spec_id).to_dict()
return render_to_response(render_page[1] + '.html',
{'spec_id': raw_spec['_id']},
context_instance=RequestContext(request))
#render page for create
items_list = self._search_spec(SPEC_TYPE[render_page[1]])
res_type_list = []
if SPEC_TYPE[render_page[1]] == 'connection':
# find all resource type
res_type_list_raw = self._search_spec('resource')
for res in res_type_list_raw:
res_type_list.append({'id': res['id'], 'name': res['type_name']})
return render_to_response(render_page[1] + '_create.html',
{'items_list': items_list,
'res_type_list': res_type_list},
context_instance=RequestContext(request))
def get_specification_params(self, request):
""" Implement GET method """
if request.GET.get('spec_id', None):
raw_spec = self.specification.getSpecification(request.GET['spec_id']).to_dict()
spec_param_json = json.dumps(raw_spec['params_spec'])
# find all resource type
res_type_list = []
res_type_list_raw = self._search_spec('resource')
for res in res_type_list_raw:
res_type_list.append({'id': res['id'], 'name': res['type_name']})
#for treeMenu
to_text = spec_param_json.replace('param_name','text')
items = to_text.replace('children_spec','items')
json_data = {'spec_info': raw_spec,
'res_type_list': res_type_list,
'items': json.loads(items)}
return HttpResponse(json.dumps(json_data), mimetype="application/json")
return HttpResponse()
def search_del(self,request):
"""searching and delete for all specifications
"""
#if request.GET and not request.POST:
search_spec_name = request.GET.get('s',)
search_spec_type = request.GET.get('spec_type',)
search_page = request.META.get('PATH_INFO').split('/')
del_item_id = request.POST.get('del_id',)
spec_type = [key for key, value in SEARCH_PAGE.iteritems() if value == search_page[1]][0]
spec_page = [key for key, value in SPEC_TYPE.iteritems() if value == spec_type][0]
allowed_types = ''
#render search spec page with data
if search_spec_type:
if del_item_id:
self.specification.deleteSpecification(del_item_id)
spec_list = self._search_spec(search_spec_type, search_spec_name)
if search_spec_type == ELEM_TYPES['IS_COLL'] and spec_list:
allowed_types = json.dumps(spec_list[0]['allowed_types'])
return render_to_response(SEARCH_PAGE[search_spec_type] + '.html',
{'spec_list': spec_list,
'allowed_types': allowed_types,
'spec_type': spec_type,
'spec_page': spec_page},
context_instance=RequestContext(request))
# render empty page
return render_to_response(search_page[1] + '.html',
{'spec_type': spec_type, 'spec_page': spec_page},
context_instance=RequestContext(request))
def _search_spec(self, spec_type, spec_name=None):
if not spec_name:
self.spec_filter = {'spec_type': spec_type}
else:
self.spec_filter = {'type_name': spec_name,
'spec_type': spec_type}
res_list = self.specification.findSpecification(spec_type, self.spec_filter)
spec_list = []
#convert spec id for @name.id in .html
if res_list:
for item in res_list:
s = item.to_dict()
s['id'] = s.pop('_id')
spec_list.append(s)
return spec_list
def update_elem(self, type_spec):
"""update elements by specification
{$rename: { <old name1>: <new name1>, <old name2>: <new name2>, ... } }
"""
pass
