projecthandler/views.py

   1 #
   2 #   Copyright 2017 CNIT - Consorzio Nazionale Interuniversitario per le Telecomunicazioni
   3 #
   4 #   Licensed under the Apache License, Version 2.0 (the "License");
   5 #   you may not use this file except in compliance with the License.
   6 #   You may obtain a copy of the License at
   7 #
   8 #       http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 #   Unless required by applicable law or agreed to in writing, software
  11 #   distributed under the License is distributed on an  BASIS,
  12 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 #   See the License for the specific language governing permissions and
  14 #   limitations under the License.
  15 #
  16
  17 import json
  18
  19 from django.contrib.auth.decorators import login_required
  20 from django.http import HttpResponse, JsonResponse
  21 from django.middleware.csrf import get_token
  22 from django.shortcuts import render, redirect
  23 from django.template.loader import render_to_string
  24 from lib.util import Util
  25 from sf_user.models import CustomUser
  26 import tarfile
  27
  28
  29 from projecthandler.osm_model import OsmProject
  30 from projecthandler.models import Project
  31
  32
  33 Project.add_project_type('osm', OsmProject)
  34
  35
  36
  37 from projecthandler.models import Repository
  38
  39 @login_required
  40 def home(request):
  41     return render(request, 'home.html', {})
  42
  43
  44 @login_required
  45 def create_new_project(request):
  46     if request.method == 'POST':
  47         error_msgs = []
  48         user = CustomUser.objects.get(id=request.user.id)
  49         name = request.POST.get('name', 'WithoutName')
  50         info = request.POST.get('info', ' ')
  51         type = request.POST.get('type', '')
  52         start_from = request.POST.get('startfrom', 'scratch')
  53
  54         project_types = Project.get_project_types()
  55         if type in project_types:
  56             project_class = project_types[type]
  57
  58         else:
  59             # FIXME this error is not handled
  60             error_msgs.append('Project type undefined.')
  61             return render(request, 'error.html',
  62                           {'error_msg': 'Error creating new project, project type undefined. Please retry.'})
  63
  64         try:
  65
  66             if start_from == 'scratch':
  67                 print 'from scratch'
  68                 data_project = {}
  69
  70             elif start_from == 'files':
  71                 print 'from files'
  72                 data_project = project_class.data_project_from_files(request)
  73
  74             elif start_from == 'example':
  75                 print 'from example'
  76                 data_project = project_class.data_project_from_example(request)
  77
  78             project = project_class.create_project(name, user, False, info, data_project)
  79             # print project.get_dataproject()
  80
  81
  82         except Exception as e:
  83             print 'Error creating ' + type + ' project! Please retry.'
  84             print e
  85             return render(request, 'error.html', {'error_msg': 'Error creating ' + type + ' project! Please retry.'})
  86         return redirect('projects:open_project', project_id=project.id)
  87
  88     elif request.method == 'GET':
  89         csrf_token_value = get_token(request)
  90         result = {}
  91         data_type_selector = [{
  92             'id': '-1',
  93             'text': 'Select an option'
  94         }]
  95         type_example_files = {}
  96         type_container_template = ''
  97         project_types = Project.get_project_types()
  98         print "project_types", project_types.keys()
  99         for type in project_types:
 100             project_class = project_types[type]
 101             type_example_files.update(project_class.get_example_list())
 102             data_type_selector.append({
 103                 'id': type,
 104                 'text': type,
 105                 'value': type
 106             })
 107             type_container_template += render_to_string(type + '/' + type + '_new_project.html')
 108
 109         result.update({'type_example_files': json.dumps(type_example_files)})
 110         result.update({'data_type_selector': json.dumps(data_type_selector)})
 111         result.update({'type_container_template': type_container_template})
 112         result.update({'csrf_token': csrf_token_value})
 113         return render(request, 'new_project.html', result)
 114
 115
 116 @login_required
 117 def user_projects(request):
 118     csrf_token_value = get_token(request)
 119     user = CustomUser.objects.get(id=request.user.id)
 120     projects = Project.objects.filter(owner=user).select_subclasses()
 121
 122     return render(request, 'projectlist.html', {
 123         'projects': list(projects),
 124         'csrf_token': csrf_token_value
 125     })
 126
 127
 128 @login_required
 129 def open_project(request, project_id=None):
 130     try:
 131         projects = Project.objects.filter(id=project_id).select_subclasses()
 132         project_overview = projects[0].get_overview_data()
 133         prj_token = project_overview['type']
 134         print request.COOKIES.keys()
 135         return render(request, prj_token + '/' + prj_token + '_project_details.html',
 136                       {'project_overview': project_overview, 'project_id': project_id})
 137
 138     except Exception as e:
 139         print e
 140         return render(request, 'error.html', {'error_msg': 'Error open project! Please retry.'})
 141
 142
 143 @login_required
 144 def delete_project(request, project_id=None):
 145     if request.method == 'POST':
 146
 147         try:
 148             Project.objects.filter(id=project_id).delete()
 149             return redirect('projects:projects_list')
 150         except Exception as e:
 151             print e
 152             return render(request, 'error.html', {'error_msg': 'Error deleting Project.'})
 153
 154     elif request.method == 'GET':
 155         try:
 156             projects = Project.objects.filter(id=project_id).select_subclasses()
 157             project_overview = projects[0].get_overview_data()
 158             prj_token = project_overview['type']
 159             #                 example: 'etsi/etsi_project_delete.html'
 160             print  prj_token + '/' + prj_token + '_project_delete.html', project_overview['name']
 161             return render(request, prj_token + '/' + prj_token + '_project_delete.html',
 162                           {'project_id': project_id, 'project_name': project_overview['name']})
 163
 164         except Exception as e:
 165             print e
 166             return render(request, 'error.html', {'error_msg': 'Project not found.'})
 167
 168
 169
 170 @login_required
 171 def show_descriptors(request, project_id=None, descriptor_type=None):
 172     csrf_token_value = get_token(request)
 173     projects = Project.objects.filter(id=project_id).select_subclasses()
 174     project_overview = projects[0].get_overview_data()
 175     prj_token = project_overview['type']
 176
 177     page = prj_token + '/' + prj_token + '_project_descriptors.html'
 178
 179     return render(request, page, {
 180         'descriptors': projects[0].get_descriptors(descriptor_type),
 181         'project_id': project_id,
 182         'project_type': prj_token,
 183         'project_overview_data': project_overview,
 184         "csrf_token_value": csrf_token_value,
 185         'descriptor_type': descriptor_type
 186     })
 187
 188
 189 @login_required
 190 def graph(request, project_id=None):
 191     if request.method == 'GET':
 192         csrf_token_value = get_token(request)
 193         projects = Project.objects.filter(id=project_id).select_subclasses()
 194         project_overview = projects[0].get_overview_data()
 195         prj_token = project_overview['type']
 196         # example : 'etsi/project_graph.html'
 197         return render(request, prj_token + '/project_graph.html', {
 198             'project_id': project_id,
 199             'project_overview_data': projects[0].get_overview_data(),
 200             'collapsed_sidebar': False
 201         })
 202
 203
 204 @login_required
 205 def graph_data(request, project_id=None, descriptor_id=None):
 206     print 'graph_data', project_id, descriptor_id
 207     projects = Project.objects.filter(id=project_id).select_subclasses()
 208     project_overview = projects[0].get_overview_data()
 209     # data = projects[0].get_overview_data()
 210     prj_token = project_overview['type']
 211
 212     topology = projects[0].get_graph_data_json_topology(descriptor_id)
 213     response = HttpResponse(topology, content_type="application/json")
 214     response["Access-Control-Allow-Origin"] = "*"
 215
 216     return response
 217
 218
 219 @login_required
 220 def delete_descriptor(request, project_id=None, descriptor_type=None, descriptor_id=None):
 221     csrf_token_value = get_token(request)
 222     projects = Project.objects.filter(id=project_id).select_subclasses()
 223     result = projects[0].delete_descriptor(descriptor_type, descriptor_id)
 224     project_overview = projects[0].get_overview_data()
 225     prj_token = project_overview['type']
 226     page = prj_token + '/' + prj_token + '_project_descriptors.html'
 227
 228     return render(request, page, {
 229         'descriptors': projects[0].get_descriptors(descriptor_type),
 230         'project_id': project_id,
 231         'project_overview_data': project_overview,
 232         "csrf_token_value": csrf_token_value,
 233         'descriptor_type': descriptor_type,
 234         #'alert_message': {
 235         #    'success': result,
 236         #    'message': "Delete succeeded!" if result else 'Error in delete'}
 237     })
 238
 239
 240 @login_required
 241 def clone_descriptor(request, project_id=None, descriptor_type=None, descriptor_id=None):
 242     csrf_token_value = get_token(request)
 243     projects = Project.objects.filter(id=project_id).select_subclasses()
 244     new_id = request.GET.get('newid', '')
 245     result = projects[0].clone_descriptor(descriptor_type, descriptor_id, new_id)
 246     project_overview = projects[0].get_overview_data()
 247     prj_token = project_overview['type']
 248     page = prj_token + '/' + prj_token + '_project_descriptors.html'
 249
 250     return render(request, page, {
 251         'descriptors': projects[0].get_descriptors(descriptor_type),
 252         'project_id': project_id,
 253         'project_overview_data': project_overview,
 254         "csrf_token_value": csrf_token_value,
 255         'descriptor_type': descriptor_type,
 256         'alert_message': {
 257             'success': result,
 258             'message': "Cloned!" if result else 'Error in cloning'}
 259     })
 260
 261
 262 @login_required
 263 def new_descriptor(request, project_id=None, descriptor_type=None):
 264     projects = Project.objects.filter(id=project_id).select_subclasses()
 265     project_overview = projects[0].get_overview_data()
 266     prj_token = project_overview['type']
 267     page = prj_token + '/descriptor/descriptor_new.html'
 268     if request.method == 'GET':
 269         request_id = request.GET.get('id', '')
 270
 271         json_template = projects[0].get_new_descriptor(descriptor_type, request_id)
 272         print 'new descriptor GET', json_template
 273
 274         descriptor_string_yaml = Util.json2yaml(json_template)
 275         descriptor_string_json = json.dumps(json_template)
 276
 277         return render(request, page, {
 278             'project_id': project_id,
 279             'descriptor_type': descriptor_type,
 280             'descriptor_id': request_id,
 281             'project_overview_data': project_overview,
 282             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 283                                    'descriptor_string_json': descriptor_string_json}
 284         })
 285     elif request.method == 'POST':
 286         csrf_token_value = get_token(request)
 287         data_type = request.POST.get('type')
 288         print "TYPE", data_type
 289         if data_type == "file":
 290             file_uploaded = request.FILES['file']
 291             text = file_uploaded.read()
 292             data_type = file_uploaded.name.split(".")[-1]
 293             desc_name = file_uploaded.name.split(".")[0]
 294             result = projects[0].create_descriptor(desc_name, descriptor_type, text, data_type, file_uploaded)
 295         else:
 296             text = request.POST.get('text')
 297             desc_name = request.POST.get('id')
 298             result = projects[0].create_descriptor(desc_name, descriptor_type, text, data_type)
 299
 300
 301         response_data = {
 302             'project_id': project_id,
 303             'descriptor_type': descriptor_type,
 304             'project_overview_data': projects[0].get_overview_data(),
 305             'descriptor_id': result,
 306             'alert_message': {
 307                 'success': True if result != False else False,
 308                 'message': "Descriptor created" if result else 'Error in creation'}
 309         }
 310         status_code = 200 if result != False else 500
 311         response = HttpResponse(json.dumps(response_data), content_type="application/json", status=status_code)
 312         response["Access-Control-Allow-Origin"] = "*"
 313         return response
 314
 315
 316 @login_required
 317 def edit_descriptor(request, project_id=None, descriptor_id=None, descriptor_type=None):
 318     if request.method == 'POST':
 319         print "edit_descriptor"
 320         projects = Project.objects.filter(id=project_id).select_subclasses()
 321         result = projects[0].edit_descriptor(descriptor_type, descriptor_id, request.POST.get('text'),
 322                                              request.POST.get('type'))
 323         response_data = {
 324             'project_id': project_id,
 325             'descriptor_type': descriptor_type,
 326             #'project_overview_data': projects[0].get_overview_data(),
 327             'alert_message': {
 328                 'success':  True if result else False,
 329                 'message': "Descriptor modified." if result else 'Error during descriptor editing.'}
 330         }
 331         status_code = 200 if result else 500
 332         response = HttpResponse(json.dumps(response_data), content_type="application/json", status=status_code)
 333         response["Access-Control-Allow-Origin"] = "*"
 334         return response
 335
 336     elif request.method == 'GET':
 337         csrf_token_value = get_token(request)
 338         projects = Project.objects.filter(id=project_id).select_subclasses()
 339         project_overview = projects[0].get_overview_data()
 340         print project_overview
 341         prj_token = project_overview['type']
 342         page = prj_token + '/descriptor/descriptor_view.html'
 343
 344         descriptor = projects[0].get_descriptor(descriptor_id, descriptor_type)
 345
 346         descriptor_string_json = json.dumps(descriptor)
 347         descriptor_string_yaml = Util.json2yaml(descriptor)
 348         # print descriptor
 349         return render(request, page, {
 350             'project_id': project_id,
 351             'descriptor_id': descriptor_id,
 352             'project_overview_data': projects[0].get_overview_data(),
 353             'descriptor_type': descriptor_type,
 354             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 355                                    'descriptor_string_json': descriptor_string_json}})
 356
 357
 358 @login_required
 359 def graph_positions(request, project_id=None):
 360     if request.method == 'POST':
 361         projects = Project.objects.filter(id=project_id).select_subclasses()
 362         result = projects[0].edit_graph_positions(json.loads(request.POST.get('positions')))
 363         status_code = 200 if result else 500
 364         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 365         response["Access-Control-Allow-Origin"] = "*"
 366         return response
 367
 368
 369 @login_required
 370 def add_element(request, project_id=None):
 371     if request.method == 'POST':
 372         projects = Project.objects.filter(id=project_id).select_subclasses()
 373         result = projects[0].get_add_element(request)
 374
 375         status_code = 200 if result else 500
 376         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 377         response["Access-Control-Allow-Origin"] = "*"
 378         return response
 379
 380
 381 @login_required
 382 def remove_element(request, project_id=None):
 383     if request.method == 'POST':
 384         projects = Project.objects.filter(id=project_id).select_subclasses()
 385         result = projects[0].get_remove_element(request)
 386
 387         status_code = 200 if result else 500
 388         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 389         response["Access-Control-Allow-Origin"] = "*"
 390         return response
 391
 392
 393 @login_required
 394 def add_link(request, project_id=None):
 395     if request.method == 'POST':
 396         projects = Project.objects.filter(id=project_id).select_subclasses()
 397         result = projects[0].get_add_link(request)
 398
 399         status_code = 200 if result else 500
 400         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 401         response["Access-Control-Allow-Origin"] = "*"
 402         return response
 403
 404
 405 @login_required
 406 def remove_link(request, project_id=None):
 407     if request.method == 'POST':
 408         projects = Project.objects.filter(id=project_id).select_subclasses()
 409         result = projects[0].get_remove_link(request)
 410
 411         status_code = 200 if result else 500
 412         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 413         response["Access-Control-Allow-Origin"] = "*"
 414         return response
 415
 416 @login_required
 417 def get_available_nodes(request, project_id=None):
 418     if request.method == 'GET':
 419         csrf_token_value = get_token(request)
 420         projects = Project.objects.filter(id=project_id).select_subclasses()
 421         print "get_available_nodes", request.GET.dict()
 422         result = projects[0].get_available_nodes(request.GET.dict())
 423         status_code = 500 if result == None else 200
 424         print json.dumps(result)
 425         response = HttpResponse(json.dumps(result), content_type="application/json", status=status_code)
 426         response["Access-Control-Allow-Origin"] = "*"
 427         return response
 428
 429 @login_required
 430 def overviewelement(request, project_id=None):
 431     if request.method == 'GET':
 432         result = {}
 433         error_msg = None
 434         try:
 435             projects = Project.objects.filter(id=project_id).select_subclasses()
 436             project = projects[0]
 437             parameters = request.GET.dict()
 438             print "parameters", parameters
 439             result = project.get_node_overview(**parameters)
 440         except Exception as e:
 441             error_msg = str(e)
 442
 443         if error_msg is not None:
 444             return JsonResponse({'error': {'error_msg': str(error_msg)}})
 445
 446         return JsonResponse({'node_overview': result})
 447
 448 # ETSI specific method #
 449 @login_required
 450 def add_node_to_vnffg(request, project_id=None):
 451     print "add_node_to_vnffg"  # TODO log
 452     if request.method == 'POST':
 453         projects = Project.objects.filter(id=project_id).select_subclasses()
 454         result = projects[0].add_node_to_vnffg(request)
 455
 456         status_code = 200 if result else 500
 457         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 458         response["Access-Control-Allow-Origin"] = "*"
 459         return response
 460
 461
 462 @login_required
 463 def unused_vnf(request, project_id=None, nsd_id=None):
 464     if request.method == 'GET':
 465         print 'in method unused_vnf : ', project_id, nsd_id  # TODO log
 466         projects = Project.objects.filter(id=project_id).select_subclasses()
 467         result = projects[0].get_unused_vnf(nsd_id)
 468         status_code = 500 if result == None else 200
 469         response = HttpResponse(json.dumps(result), content_type="application/json", status=status_code)
 470         response["Access-Control-Allow-Origin"] = "*"
 471         return response
 472
 473 # end ETSI specific method #
 474
 475
 476 # OSM specific method #
 477 def get_package_files_list(request, project_id, project, descriptor_id, descriptor_type):
 478     files_list = []
 479     try:
 480         files_list = project.get_package_files_list(descriptor_type, descriptor_id)
 481         result = {'files': files_list}
 482     except Exception as e:
 483         print e
 484         url = 'error.html'
 485         result = {'error_msg': 'Unknown error.'}
 486     return __response_handler(request, result)
 487
 488
 489 def download_pkg(request, project_id, project, descriptor_id, descriptor_type):
 490     tar_pkg = project.download_pkg(project, descriptor_id, descriptor_type)
 491
 492     response = HttpResponse(content_type="application/tgz")
 493     response["Content-Disposition"] = "attachment; filename=osm_export.tar.gz"
 494     response.write(tar_pkg.getvalue())
 495     return response
 496
 497
 498 def create_ns(request, project_id, project, descriptor_id, descriptor_type):
 499     files_list = []
 500     try:
 501         ns_data={
 502           "nsName": request.POST.get('nsName', 'WithoutName'),
 503           "nsDescription": request.POST.get('nsDescription', ''),
 504           "nsdId": request.POST.get('nsdId', ''),
 505           "vimAccountId": request.POST.get('vimAccountId', ''),
 506           "ssh-authorized-key": [
 507             {
 508               request.POST.get('key-pair-ref', ''): request.POST.get('keyValue', '')
 509             }
 510           ]
 511         }
 512         #result = project.create_ns(descriptor_type, descriptor_id, ns_data)
 513
 514     except Exception as e:
 515         print e
 516         url = 'error.html'
 517         result = {'error_msg': 'Unknown error.'}
 518     return __response_handler(request, result)
 519
 520 # end OSM specific method #
 521
 522 @login_required
 523 def custom_action(request, project_id=None, descriptor_id=None, descriptor_type=None, action_name=None):
 524     if request.method == 'GET':
 525         projects = Project.objects.filter(id=project_id).select_subclasses()
 526         print "Custom action: " + action_name
 527         return globals()[action_name](request, project_id, projects[0], descriptor_id, descriptor_type)
 528
 529
 530 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 531     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 532     if 'application/json' in raw_content_types:
 533         return JsonResponse(data_res)
 534     elif to_redirect:
 535         return redirect(url, *args, **kwargs)
 536     else:
 537         return render(request, url, data_res)