diff --git a/projecthandler/views.py b/projecthandler/views.py
index de21e9a..6194b0a 100644
--- a/projecthandler/views.py
+++ b/projecthandler/views.py
@@ -15,7 +15,9 @@
 #
 
 import json
+import logging
 
+import yaml
 from django.contrib.auth.decorators import login_required
 from django.http import HttpResponse, JsonResponse
 from django.middleware.csrf import get_token
@@ -25,6 +27,8 @@
 from lib.osm.osmclient.clientv2 import Client
 
 
+logging.basicConfig(level=logging.DEBUG)
+log = logging.getLogger('projecthandler/view.py')
 
 
 @login_required
@@ -54,10 +58,11 @@
     try:
         user = request.user
         client = Client()
-        nsd = client.nsd_list()
-        vnfd = client.vnfd_list()
-        ns = client.ns_list()
-        vnf = client.vnf_list()
+        ##TODO change with adhoc api call
+        nsd = client.nsd_list(request.session['token'])
+        vnfd = client.vnfd_list(request.session['token'])
+        ns = client.ns_list(request.session['token'])
+        vnf = client.vnf_list(request.session['token'])
         project_overview = {
             'owner': user.username,
             'name': project_id,
@@ -65,10 +70,10 @@
             'created_date': '-',
             'info': '-',
             'type': 'osm',
-            'nsd': len(nsd) if nsd else 0,
-            'vnfd': len(vnfd) if vnfd else 0,
-            'ns': len(ns) if ns else 0,
-            'vnf': len(vnf) if vnf else 0,
+            'nsd': len(nsd['data']) if nsd and nsd['error'] is False else 0,
+            'vnfd': len(vnfd['data']) if vnfd and vnfd['error'] is False else 0,
+            'ns': len(ns['data']) if ns and ns['error'] is False else 0,
+            'vnf': len(vnf['data']) if vnf and vnf['error'] is False else 0,
         }
         return render(request, 'osm/osm_project_details.html',
                       {'project_overview': project_overview, 'project_id': project_id})
@@ -101,191 +106,210 @@
 
 @login_required
 def show_descriptors(request, project_id=None, descriptor_type=None):
-    csrf_token_value = get_token(request)
-
     client = Client()
+    print request.GET.dict()
     try:
         if descriptor_type == 'nsd':
-            descriptors = client.nsd_list()
-
+            descriptors = client.nsd_list(request.session['token'])
         elif descriptor_type == 'vnfd':
-            descriptors = client.vnfd_list()
+            descriptors = client.vnfd_list(request.session['token'])
     except Exception as e:
+        log.exception(e)
         descriptors = []
 
     url = 'osm/osm_project_descriptors.html'
     return __response_handler(request, {
-        'descriptors': descriptors,
+        'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
         'project_id': project_id,
         'project_type': 'osm',
-        "csrf_token_value": csrf_token_value,
         'descriptor_type': descriptor_type
     },url)
 
 
 @login_required
 def delete_descriptor(request, project_id=None, descriptor_type=None, descriptor_id=None):
-    csrf_token_value = get_token(request)
 
     try:
         client = Client()
         if descriptor_type == 'nsd':
-            result = client.nsd_delete(descriptor_id)
+            result = client.nsd_delete(request.session['token'], descriptor_id)
         elif descriptor_type == 'vnfd':
-            result = client.vnfd_delete(descriptor_id)
-
-        else:
-            return False
-
+            result = client.vnfd_delete(request.session['token'], descriptor_id)
     except Exception as e:
-        result = False
-    project_overview = OsmProject.get_overview_data()
-    prj_token = project_overview['type']
-    page = prj_token + '/' + prj_token + '_project_descriptors.html'
+        log.exception(e)
+        result = {'error': True, 'data': str(e)}
 
-    return render(request, page, {
-        'descriptors': OsmProject.get_descriptors(descriptor_type),
+    url = 'osm/osm_project_descriptors.html'
+    descriptors = {}
+    try:
+        if descriptor_type == 'nsd':
+            descriptors = client.nsd_list(request.session['token'])
+        elif descriptor_type == 'vnfd':
+            descriptors = client.vnfd_list(request.session['token'])
+    except Exception as e:
+        log.exception(e)
+
+    return __response_handler(request, {
+        'descriptors': descriptors['data'] if descriptors and descriptors['error'] is False else [],
         'project_id': project_id,
-        'project_overview_data': project_overview,
-        "csrf_token_value": csrf_token_value,
+        'project_type': 'osm',
         'descriptor_type': descriptor_type,
-        #'alert_message': {
-        #    'success': result,
-        #    'message': "Delete succeeded!" if result else 'Error in delete'}
-    })
+        'alert_message': {
+            'success': False if result['error'] is True else True,
+            'message': 'An error occurred while processing your request.' if result and result['error'] is True else "Record deleted successfully"}
+    }, url)
+
 
 
 @login_required
 def new_descriptor(request, project_id=None, descriptor_type=None):
 
-    project_overview = OsmProject.get_overview_data()
-    prj_token = project_overview['type']
-    page = prj_token + '/descriptor/descriptor_new.html'
+    page = 'osm/descriptor/descriptor_new.html'
     if request.method == 'GET':
         request_id = request.GET.get('id', '')
-        return render(request, page, {
+
+        return __response_handler(request,  {
             'project_id': project_id,
             'descriptor_type': descriptor_type,
             'descriptor_id': request_id,
-            'project_overview_data': project_overview
-        })
+        }, page)
     elif request.method == 'POST':
-        csrf_token_value = get_token(request)
         data_type = request.POST.get('type')
         print "TYPE", data_type
         if data_type == "file":
             file_uploaded = request.FILES['file']
-            text = file_uploaded.read()
-            data_type = file_uploaded.name.split(".")[-1]
-            desc_name = file_uploaded.name.split(".")[0]
-            result = OsmProject.create_descriptor(desc_name, descriptor_type, text, data_type, file_uploaded)
+
+            try:
+                client = Client()
+                if descriptor_type == 'nsd':
+                    result = client.nsd_onboard(request.session['token'], file_uploaded)
+                elif descriptor_type == 'vnfd':
+                    result = client.vnfd_onboard(request.session['token'], file_uploaded)
+                else:
+                    log.debug('Create descriptor: Unknown data type')
+                    result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
+
+            except Exception as e:
+                log.exception(e)
+                result = {'error': True, 'data': str(e)}
         else:
-            text = request.POST.get('text')
-            desc_name = request.POST.get('id')
-            result = OsmProject.create_descriptor(desc_name, descriptor_type, text, data_type)
+            result = {'error': True, 'data': 'Create descriptor: Unknown data type'}
 
+        if result['error']:
+            print result
+            return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
 
-        response_data = {
-            'project_id': project_id,
-            'descriptor_type': descriptor_type,
-            'project_overview_data':OsmProject.get_overview_data(),
-            'descriptor_id': result,
-            'alert_message': {
-                'success': True if result != False else False,
-                'message': "Descriptor created" if result else 'Error in creation'}
-        }
-        status_code = 200 if result != False else 500
-        response = HttpResponse(json.dumps(response_data), content_type="application/json", status=status_code)
-        response["Access-Control-Allow-Origin"] = "*"
-        return response
+        else:
+            return __response_handler(request, {}, url=None, status=200)
 
 
 @login_required
 def edit_descriptor(request, project_id=None, descriptor_id=None, descriptor_type=None):
     if request.method == 'POST':
         print "edit_descriptor"
-        result = OsmProject.edit_descriptor(descriptor_type, descriptor_id, request.POST.get('text'),
-                                             request.POST.get('type'))
-        response_data = {
-            'project_id': project_id,
-            'descriptor_type': descriptor_type,
-            #'project_overview_data': projects[0].get_overview_data(),
-            'alert_message': {
-                'success':  True if result else False,
-                'message': "Descriptor modified." if result else 'Error during descriptor editing.'}
-        }
-        status_code = 200 if result else 500
-        response = HttpResponse(json.dumps(response_data), content_type="application/json", status=status_code)
-        response["Access-Control-Allow-Origin"] = "*"
-        return response
+        new_data = request.POST.get('text'),
+        data_type = request.POST.get('type')
+        #print new_data
+        try:
+            client = Client()
+            if descriptor_type == 'nsd':
+                if data_type == 'yaml':
+                    new_data = yaml.load(request.POST.get('text'))
+                elif data_type == 'json':
+                    new_data = json.loads(request.POST.get('text'))
+                print new_data
+                result = client.nsd_update(request.session['token'], descriptor_id, new_data)
+            elif descriptor_type == 'vnfd':
+                if data_type == 'yaml':
+                    new_data = yaml.load(request.POST.get('text'))
+                elif data_type == 'json':
+                    new_data = json.loads(request.POST.get('text'))
+                print new_data
+                result = client.vnfd_update(request.session['token'], descriptor_id, new_data)
+
+            else:
+                log.debug('Update descriptor: Unknown data type')
+                result = {'error': True, 'data': 'Update descriptor: Unknown data type'}
+        except Exception as e:
+            log.exception(e)
+            result = {'error': True, 'data': str(e)}
+        print result
+        if result['error'] == True:
+            return __response_handler(request, result['data'], url=None, status=result['data']['status'] if 'status' in result['data'] else 500)
+
+        else:
+            return __response_handler(request, {}, url=None, status=200)
 
     elif request.method == 'GET':
-        csrf_token_value = get_token(request)
-        project_overview = OsmProject.get_overview_data()
-        print project_overview
-        prj_token = project_overview['type']
-        page = prj_token + '/descriptor/descriptor_view.html'
 
-        descriptor = OsmProject.get_descriptor(descriptor_id, descriptor_type)
+        page = 'osm/descriptor/descriptor_view.html'
+        try:
+            client = Client()
+            if descriptor_type == 'nsd':
+                result = client.nsd_get(request.session['token'], descriptor_id)
+                print result
+            elif descriptor_type == 'vnfd':
+                result = client.vnfd_get(request.session['token'], descriptor_id)
 
-        descriptor_string_json = json.dumps(descriptor)
-        descriptor_string_yaml = Util.json2yaml(descriptor)
+                print result
+        except Exception as e:
+            log.exception(e)
+            result = {'error': True, 'data': str(e)}
+
+        if isinstance(result, dict) and 'error' in result and result['error']:
+            return render(request, 'error.html')
+
+        descriptor_string_json = json.dumps(result, indent=2)
+        descriptor_string_yaml = Util.json2yaml(result)
         # print descriptor
         return render(request, page, {
             'project_id': project_id,
             'descriptor_id': descriptor_id,
-            'project_overview_data': OsmProject.get_overview_data(),
             'descriptor_type': descriptor_type,
             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
                                    'descriptor_string_json': descriptor_string_json}})
 
 
-# OSM specific method #
-def get_package_files_list(request, project_id, project, descriptor_id, descriptor_type):
+@login_required
+def get_package_files_list(request, project_id, descriptor_id, descriptor_type):
     files_list = []
     try:
-        files_list = project.get_package_files_list(descriptor_type, descriptor_id)
+        client = Client()
+        if descriptor_type == 'nsd':
+            artifacts_res = client.nsd_artifacts(request.session['token'], descriptor_id)
+        elif descriptor_type == 'vnfd':
+            artifacts_res = client.vnf_packages_artifacts(request.session['token'], descriptor_id)
+        else:
+            return False
+
+        files_list = yaml.load(artifacts_res['data'] if artifacts_res and artifacts_res['error'] is False else [])
         result = {'files': files_list}
     except Exception as e:
-        print e
+        log.exception(e)
         url = 'error.html'
         result = {'error_msg': 'Unknown error.'}
     return __response_handler(request, result)
 
-
+@login_required
 def download_pkg(request, project_id, descriptor_id, descriptor_type):
-    tar_pkg = OsmProject.download_pkg(descriptor_id, descriptor_type)
+    file_name = "osm_export.tar.gz"
+    tar_pkg = None
+    try:
+        client = Client()
+        if descriptor_type == 'nsd':
+            tar_pkg = client.get_nsd_pkg(request.session['token'], descriptor_id)
+        elif descriptor_type == 'vnfd':
+            tar_pkg = client.get_vnfd_pkg(request.session['token'], descriptor_id)
+
+    except Exception as e:
+        log.exception(e)
 
     response = HttpResponse(content_type="application/tgz")
-    response["Content-Disposition"] = "attachment; filename=osm_export.tar.gz"
+    response["Content-Disposition"] = "attachment; filename="+ file_name
     response.write(tar_pkg.getvalue())
     return response
 
 
-def create_ns(request, project_id, project, descriptor_id, descriptor_type):
-    files_list = []
-    try:
-        ns_data={
-          "nsName": request.POST.get('nsName', 'WithoutName'),
-          "nsDescription": request.POST.get('nsDescription', ''),
-          "nsdId": request.POST.get('nsdId', ''),
-          "vimAccountId": request.POST.get('vimAccountId', ''),
-          "ssh-authorized-key": [
-            {
-              request.POST.get('key-pair-ref', ''): request.POST.get('keyValue', '')
-            }
-          ]
-        }
-        #result = project.create_ns(descriptor_type, descriptor_id, ns_data)
-
-    except Exception as e:
-        print e
-        url = 'error.html'
-        result = {'error_msg': 'Unknown error.'}
-    return __response_handler(request, result)
-
-# end OSM specific method #
-
 @login_required
 def custom_action(request, project_id=None, descriptor_id=None, descriptor_type=None, action_name=None):
     if request.method == 'GET':
@@ -295,8 +319,8 @@
 
 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
-    if 'application/json' in raw_content_types:
-        return JsonResponse(data_res)
+    if 'application/json' in raw_content_types or url is None:
+        return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)
     elif to_redirect:
         return redirect(url, *args, **kwargs)
     else: