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 @login_required
 170 def show_descriptors(request, project_id=None, descriptor_type=None):
 171     csrf_token_value = get_token(request)
 172     projects = Project.objects.filter(id=project_id).select_subclasses()
 173     project_overview = projects[0].get_overview_data()
 174     prj_token = project_overview['type']
 175
 176     url = prj_token + '/' + prj_token + '_project_descriptors.html'
 177     return __response_handler(request, {
 178         'descriptors': projects[0].get_descriptors(descriptor_type),
 179         'project_id': project_id,
 180         'project_type': prj_token,
 181         'project_overview_data': project_overview,
 182         "csrf_token_value": csrf_token_value,
 183         'descriptor_type': descriptor_type
 184     },url)
 185
 186
 187 @login_required
 188 def graph(request, project_id=None):
 189     if request.method == 'GET':
 190         csrf_token_value = get_token(request)
 191         projects = Project.objects.filter(id=project_id).select_subclasses()
 192         project_overview = projects[0].get_overview_data()
 193         prj_token = project_overview['type']
 194         # example : 'etsi/project_graph.html'
 195         return render(request, prj_token + '/project_graph.html', {
 196             'project_id': project_id,
 197             'project_overview_data': projects[0].get_overview_data(),
 198             'collapsed_sidebar': False
 199         })
 200
 201
 202 @login_required
 203 def graph_data(request, project_id=None, descriptor_id=None):
 204     print 'graph_data', project_id, descriptor_id
 205     projects = Project.objects.filter(id=project_id).select_subclasses()
 206     project_overview = projects[0].get_overview_data()
 207     # data = projects[0].get_overview_data()
 208     prj_token = project_overview['type']
 209
 210     topology = projects[0].get_graph_data_json_topology(descriptor_id)
 211     response = HttpResponse(topology, content_type="application/json")
 212     response["Access-Control-Allow-Origin"] = "*"
 213
 214     return response
 215
 216
 217 @login_required
 218 def delete_descriptor(request, project_id=None, descriptor_type=None, descriptor_id=None):
 219     csrf_token_value = get_token(request)
 220     projects = Project.objects.filter(id=project_id).select_subclasses()
 221     result = projects[0].delete_descriptor(descriptor_type, descriptor_id)
 222     project_overview = projects[0].get_overview_data()
 223     prj_token = project_overview['type']
 224     page = prj_token + '/' + prj_token + '_project_descriptors.html'
 225
 226     return render(request, page, {
 227         'descriptors': projects[0].get_descriptors(descriptor_type),
 228         'project_id': project_id,
 229         'project_overview_data': project_overview,
 230         "csrf_token_value": csrf_token_value,
 231         'descriptor_type': descriptor_type,
 232         #'alert_message': {
 233         #    'success': result,
 234         #    'message': "Delete succeeded!" if result else 'Error in delete'}
 235     })
 236
 237
 238 @login_required
 239 def clone_descriptor(request, project_id=None, descriptor_type=None, descriptor_id=None):
 240     csrf_token_value = get_token(request)
 241     projects = Project.objects.filter(id=project_id).select_subclasses()
 242     new_id = request.GET.get('newid', '')
 243     result = projects[0].clone_descriptor(descriptor_type, descriptor_id, new_id)
 244     project_overview = projects[0].get_overview_data()
 245     prj_token = project_overview['type']
 246     page = prj_token + '/' + prj_token + '_project_descriptors.html'
 247
 248     return render(request, page, {
 249         'descriptors': projects[0].get_descriptors(descriptor_type),
 250         'project_id': project_id,
 251         'project_overview_data': project_overview,
 252         "csrf_token_value": csrf_token_value,
 253         'descriptor_type': descriptor_type,
 254         'alert_message': {
 255             'success': result,
 256             'message': "Cloned!" if result else 'Error in cloning'}
 257     })
 258
 259
 260 @login_required
 261 def new_descriptor(request, project_id=None, descriptor_type=None):
 262     projects = Project.objects.filter(id=project_id).select_subclasses()
 263     project_overview = projects[0].get_overview_data()
 264     prj_token = project_overview['type']
 265     page = prj_token + '/descriptor/descriptor_new.html'
 266     if request.method == 'GET':
 267         request_id = request.GET.get('id', '')
 268         return render(request, page, {
 269             'project_id': project_id,
 270             'descriptor_type': descriptor_type,
 271             'descriptor_id': request_id,
 272             'project_overview_data': project_overview
 273         })
 274     elif request.method == 'POST':
 275         csrf_token_value = get_token(request)
 276         data_type = request.POST.get('type')
 277         print "TYPE", data_type
 278         if data_type == "file":
 279             file_uploaded = request.FILES['file']
 280             text = file_uploaded.read()
 281             data_type = file_uploaded.name.split(".")[-1]
 282             desc_name = file_uploaded.name.split(".")[0]
 283             result = projects[0].create_descriptor(desc_name, descriptor_type, text, data_type, file_uploaded)
 284         else:
 285             text = request.POST.get('text')
 286             desc_name = request.POST.get('id')
 287             result = projects[0].create_descriptor(desc_name, descriptor_type, text, data_type)
 288
 289
 290         response_data = {
 291             'project_id': project_id,
 292             'descriptor_type': descriptor_type,
 293             'project_overview_data': projects[0].get_overview_data(),
 294             'descriptor_id': result,
 295             'alert_message': {
 296                 'success': True if result != False else False,
 297                 'message': "Descriptor created" if result else 'Error in creation'}
 298         }
 299         status_code = 200 if result != False else 500
 300         response = HttpResponse(json.dumps(response_data), content_type="application/json", status=status_code)
 301         response["Access-Control-Allow-Origin"] = "*"
 302         return response
 303
 304
 305 @login_required
 306 def edit_descriptor(request, project_id=None, descriptor_id=None, descriptor_type=None):
 307     if request.method == 'POST':
 308         print "edit_descriptor"
 309         projects = Project.objects.filter(id=project_id).select_subclasses()
 310         result = projects[0].edit_descriptor(descriptor_type, descriptor_id, request.POST.get('text'),
 311                                              request.POST.get('type'))
 312         response_data = {
 313             'project_id': project_id,
 314             'descriptor_type': descriptor_type,
 315             #'project_overview_data': projects[0].get_overview_data(),
 316             'alert_message': {
 317                 'success':  True if result else False,
 318                 'message': "Descriptor modified." if result else 'Error during descriptor editing.'}
 319         }
 320         status_code = 200 if result else 500
 321         response = HttpResponse(json.dumps(response_data), content_type="application/json", status=status_code)
 322         response["Access-Control-Allow-Origin"] = "*"
 323         return response
 324
 325     elif request.method == 'GET':
 326         csrf_token_value = get_token(request)
 327         projects = Project.objects.filter(id=project_id).select_subclasses()
 328         project_overview = projects[0].get_overview_data()
 329         print project_overview
 330         prj_token = project_overview['type']
 331         page = prj_token + '/descriptor/descriptor_view.html'
 332
 333         descriptor = projects[0].get_descriptor(descriptor_id, descriptor_type)
 334
 335         descriptor_string_json = json.dumps(descriptor)
 336         descriptor_string_yaml = Util.json2yaml(descriptor)
 337         # print descriptor
 338         return render(request, page, {
 339             'project_id': project_id,
 340             'descriptor_id': descriptor_id,
 341             'project_overview_data': projects[0].get_overview_data(),
 342             'descriptor_type': descriptor_type,
 343             'descriptor_strings': {'descriptor_string_yaml': descriptor_string_yaml,
 344                                    'descriptor_string_json': descriptor_string_json}})
 345
 346
 347 @login_required
 348 def graph_positions(request, project_id=None):
 349     if request.method == 'POST':
 350         projects = Project.objects.filter(id=project_id).select_subclasses()
 351         result = projects[0].edit_graph_positions(json.loads(request.POST.get('positions')))
 352         status_code = 200 if result else 500
 353         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 354         response["Access-Control-Allow-Origin"] = "*"
 355         return response
 356
 357
 358 @login_required
 359 def add_element(request, project_id=None):
 360     if request.method == 'POST':
 361         projects = Project.objects.filter(id=project_id).select_subclasses()
 362         result = projects[0].get_add_element(request)
 363
 364         status_code = 200 if result else 500
 365         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 366         response["Access-Control-Allow-Origin"] = "*"
 367         return response
 368
 369
 370 @login_required
 371 def remove_element(request, project_id=None):
 372     if request.method == 'POST':
 373         projects = Project.objects.filter(id=project_id).select_subclasses()
 374         result = projects[0].get_remove_element(request)
 375
 376         status_code = 200 if result else 500
 377         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 378         response["Access-Control-Allow-Origin"] = "*"
 379         return response
 380
 381
 382 @login_required
 383 def add_link(request, project_id=None):
 384     if request.method == 'POST':
 385         projects = Project.objects.filter(id=project_id).select_subclasses()
 386         result = projects[0].get_add_link(request)
 387
 388         status_code = 200 if result else 500
 389         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 390         response["Access-Control-Allow-Origin"] = "*"
 391         return response
 392
 393
 394 @login_required
 395 def remove_link(request, project_id=None):
 396     if request.method == 'POST':
 397         projects = Project.objects.filter(id=project_id).select_subclasses()
 398         result = projects[0].get_remove_link(request)
 399
 400         status_code = 200 if result else 500
 401         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 402         response["Access-Control-Allow-Origin"] = "*"
 403         return response
 404
 405 @login_required
 406 def get_available_nodes(request, project_id=None):
 407     if request.method == 'GET':
 408         csrf_token_value = get_token(request)
 409         projects = Project.objects.filter(id=project_id).select_subclasses()
 410         print "get_available_nodes", request.GET.dict()
 411         result = projects[0].get_available_nodes(request.GET.dict())
 412         status_code = 500 if result == None else 200
 413         print json.dumps(result)
 414         response = HttpResponse(json.dumps(result), content_type="application/json", status=status_code)
 415         response["Access-Control-Allow-Origin"] = "*"
 416         return response
 417
 418 @login_required
 419 def overviewelement(request, project_id=None):
 420     if request.method == 'GET':
 421         result = {}
 422         error_msg = None
 423         try:
 424             projects = Project.objects.filter(id=project_id).select_subclasses()
 425             project = projects[0]
 426             parameters = request.GET.dict()
 427             print "parameters", parameters
 428             result = project.get_node_overview(**parameters)
 429         except Exception as e:
 430             error_msg = str(e)
 431
 432         if error_msg is not None:
 433             return JsonResponse({'error': {'error_msg': str(error_msg)}})
 434
 435         return JsonResponse({'node_overview': result})
 436
 437 # ETSI specific method #
 438 @login_required
 439 def add_node_to_vnffg(request, project_id=None):
 440     print "add_node_to_vnffg"  # TODO log
 441     if request.method == 'POST':
 442         projects = Project.objects.filter(id=project_id).select_subclasses()
 443         result = projects[0].add_node_to_vnffg(request)
 444
 445         status_code = 200 if result else 500
 446         response = HttpResponse(json.dumps({}), content_type="application/json", status=status_code)
 447         response["Access-Control-Allow-Origin"] = "*"
 448         return response
 449
 450
 451 @login_required
 452 def unused_vnf(request, project_id=None, nsd_id=None):
 453     if request.method == 'GET':
 454         print 'in method unused_vnf : ', project_id, nsd_id  # TODO log
 455         projects = Project.objects.filter(id=project_id).select_subclasses()
 456         result = projects[0].get_unused_vnf(nsd_id)
 457         status_code = 500 if result == None else 200
 458         response = HttpResponse(json.dumps(result), content_type="application/json", status=status_code)
 459         response["Access-Control-Allow-Origin"] = "*"
 460         return response
 461
 462 # end ETSI specific method #
 463
 464
 465 # OSM specific method #
 466 def get_package_files_list(request, project_id, project, descriptor_id, descriptor_type):
 467     files_list = []
 468     try:
 469         files_list = project.get_package_files_list(descriptor_type, descriptor_id)
 470         result = {'files': files_list}
 471     except Exception as e:
 472         print e
 473         url = 'error.html'
 474         result = {'error_msg': 'Unknown error.'}
 475     return __response_handler(request, result)
 476
 477
 478 def download_pkg(request, project_id, project, descriptor_id, descriptor_type):
 479     tar_pkg = project.download_pkg(project, descriptor_id, descriptor_type)
 480
 481     response = HttpResponse(content_type="application/tgz")
 482     response["Content-Disposition"] = "attachment; filename=osm_export.tar.gz"
 483     response.write(tar_pkg.getvalue())
 484     return response
 485
 486
 487 def create_ns(request, project_id, project, descriptor_id, descriptor_type):
 488     files_list = []
 489     try:
 490         ns_data={
 491           "nsName": request.POST.get('nsName', 'WithoutName'),
 492           "nsDescription": request.POST.get('nsDescription', ''),
 493           "nsdId": request.POST.get('nsdId', ''),
 494           "vimAccountId": request.POST.get('vimAccountId', ''),
 495           "ssh-authorized-key": [
 496             {
 497               request.POST.get('key-pair-ref', ''): request.POST.get('keyValue', '')
 498             }
 499           ]
 500         }
 501         #result = project.create_ns(descriptor_type, descriptor_id, ns_data)
 502
 503     except Exception as e:
 504         print e
 505         url = 'error.html'
 506         result = {'error_msg': 'Unknown error.'}
 507     return __response_handler(request, result)
 508
 509 # end OSM specific method #
 510
 511 @login_required
 512 def custom_action(request, project_id=None, descriptor_id=None, descriptor_type=None, action_name=None):
 513     if request.method == 'GET':
 514         projects = Project.objects.filter(id=project_id).select_subclasses()
 515         print "Custom action: " + action_name
 516         return globals()[action_name](request, project_id, projects[0], descriptor_id, descriptor_type)
 517
 518
 519 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
 520     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 521     if 'application/json' in raw_content_types:
 522         return JsonResponse(data_res)
 523     elif to_redirect:
 524         return redirect(url, *args, **kwargs)
 525     else:
 526         return render(request, url, data_res)