Esempio n. 1
0
    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()
Esempio n. 2
0
    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 delete(self, resource_id, params):
        resource = ConnectionOperationalAPI()
        resource.deleteConnection(resource_id)

        return self.search(params)
Esempio n. 4
0
    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()