skyquake/framework/core/modules/api/projectManagementAPI.js

   1 /*
   2  *
   3  *   Copyright 2016 RIFT.IO Inc
   4  *
   5  *   Licensed under the Apache License, Version 2.0 (the "License");
   6  *   you may not use this file except in compliance with the License.
   7  *   You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *   Unless required by applicable law or agreed to in writing, software
  12  *   distributed under the License is distributed on an "AS IS" BASIS,
  13  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *   See the License for the specific language governing permissions and
  15  *   limitations under the License.
  16  *
  17  */
  18 // DescriptorModelMeta API (NSD + VNFD)
  19
  20
  21 var ProjectManagement = {};
  22 var Promise = require('bluebird');
  23 var rp = require('request-promise');
  24 var Promise = require('promise');
  25 var constants = require('../../api_utils/constants');
  26 var utils = require('../../api_utils/utils');
  27 var _ = require('lodash');
  28
  29 ProjectManagement.get = function(req) {
  30     var self = this;
  31     var api_server = req.query['api_server'];
  32
  33     return new Promise(function(resolve, reject) {
  34         Promise.all([
  35             rp({
  36                 uri: utils.confdPort(api_server) + '/api/operational/project',
  37                 method: 'GET',
  38                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
  39                     'Authorization': req.session && req.session.authorization
  40                 }),
  41                 forever: constants.FOREVER_ON,
  42                 rejectUnauthorized: false,
  43                 resolveWithFullResponse: true
  44             })
  45         ]).then(function(result) {
  46             var response = {};
  47             response['data'] = {};
  48             if (result[0].body) {
  49                 response['data']['project'] = JSON.parse(result[0].body)['rw-project:project'];
  50             }
  51             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
  52
  53             resolve(response);
  54         }).catch(function(error) {
  55             var response = {};
  56             console.log('Problem with ProjectManagement.get', error);
  57             response.statusCode = error.statusCode || 500;
  58             response.errorMessage = {
  59                 error: 'Failed to get ProjectManagement' + error
  60             };
  61             reject(response);
  62         });
  63     });
  64 };
  65
  66 ProjectManagement.create = function(req) {
  67     var self = this;
  68     var api_server = req.query['api_server'];
  69     var data = req.body;
  70     data = {
  71         "project":[data]
  72     }
  73     return new Promise(function(resolve, reject) {
  74         Promise.all([
  75             rp({
  76                 uri: utils.confdPort(api_server) + '/api/config/project',
  77                 method: 'POST',
  78                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
  79                     'Authorization': req.session && req.session.authorization
  80                 }),
  81                 forever: constants.FOREVER_ON,
  82                 json: data,
  83                 rejectUnauthorized: false,
  84                 resolveWithFullResponse: true
  85             })
  86         ]).then(function(result) {
  87             var response = {};
  88             response['data'] = {};
  89             if (result[0].body) {
  90                 response['data'] = result[0].body;
  91             }
  92             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
  93
  94             resolve(response);
  95         }).catch(function(error) {
  96             var response = {};
  97             console.log('Problem with ProjectManagement.create', error);
  98             response.statusCode = error.statusCode || 500;
  99             response.errorMessage = {
 100                 error: 'Failed to create user' + error
 101             };
 102             reject(response);
 103         });
 104     });
 105 };
 106 ProjectManagement.update = function(req) {
 107     //"rw-project:project"
 108     var self = this;
 109     var api_server = req.query['api_server'];
 110     var bodyData = req.body;
 111     var data = {
 112         "rw-project:project" : {
 113             "name": bodyData.name,
 114             "description": bodyData.description,
 115             "project-config": bodyData['project-config']
 116         }
 117     }
 118     var updateTasks = [];
 119
 120     var updateProject= rp({
 121                 uri: utils.confdPort(api_server) + '/api/config/project/',
 122                 method: 'PUT',
 123                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 124                     'Authorization': req.session && req.session.authorization
 125                 }),
 126                 forever: constants.FOREVER_ON,
 127                 json: data,
 128                 rejectUnauthorized: false,
 129                 resolveWithFullResponse: true
 130             });
 131     updateTasks.push(updateProject)
 132     return new Promise(function(resolve, reject) {
 133         Promise.all([
 134             updateTasks
 135         ]).then(function(result) {
 136             var response = {};
 137             response['data'] = {};
 138             if (result[0].body) {
 139                 response['data'] = result[0].body;
 140             }
 141             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 142
 143             resolve(response);
 144         }).catch(function(error) {
 145             var response = {};
 146             console.log('Problem with ProjectManagement.update', error);
 147             response.statusCode = error.statusCode || 500;
 148             response.errorMessage = {
 149                 error: 'Failed to passwordChange user' + error
 150             };
 151             reject(response);
 152         });
 153     });
 154 };
 155
 156 ProjectManagement.delete = function(req) {
 157     var self = this;
 158     var projectname = req.params.projectname;
 159     var api_server = req.query["api_server"];
 160     var requestHeaders = {};
 161     var url = `${utils.confdPort(api_server)}/api/config/project/${projectname}`
 162     return new Promise(function(resolve, reject) {
 163         _.extend(requestHeaders,
 164             constants.HTTP_HEADERS.accept.data,
 165             constants.HTTP_HEADERS.content_type.data, {
 166                 'Authorization': req.session && req.session.authorization
 167             });
 168         rp({
 169             url: url,
 170             method: 'DELETE',
 171             headers: requestHeaders,
 172             forever: constants.FOREVER_ON,
 173             rejectUnauthorized: false,
 174         }, function(error, response, body) {
 175             if (utils.validateResponse('ProjectManagement.DELETE', error, response, body, resolve, reject)) {
 176                 return resolve({
 177                     statusCode: response.statusCode,
 178                     data: JSON.stringify(response.body)
 179                 });
 180             };
 181         });
 182     })
 183 }
 184
 185
 186 ProjectManagement.getPlatform = function(req, userId) {
 187     var self = this;
 188     var api_server = req.query['api_server'];
 189     var user = req.params['userId'] || userId;
 190     return new Promise(function(resolve, reject) {
 191         var url = utils.confdPort(api_server) + '/api/operational/rbac-platform-config';
 192         if(user) {
 193             url = url + '/user/' + user;
 194         }
 195         Promise.all([
 196             rp({
 197                 uri: url,
 198                 method: 'GET',
 199                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 200                     'Authorization': req.session && req.session.authorization
 201                 }),
 202                 forever: constants.FOREVER_ON,
 203                 rejectUnauthorized: false,
 204                 resolveWithFullResponse: true
 205             })
 206         ]).then(function(result) {
 207             var response = {};
 208             response['data'] = {};
 209             if (result[0].body) {
 210                 if(user) {
 211                     response['data']['platform'] = JSON.parse(result[0].body)['rw-rbac-platform:user'];
 212                 } else {
 213                     response['data']['platform'] = JSON.parse(result[0].body)['rw-rbac-platform:rbac-platform-config'];
 214                 }
 215             }
 216             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 217
 218             resolve(response);
 219         }).catch(function(error) {
 220             var response = {};
 221             console.log('Problem with ProjectManagement.getPlatform', error);
 222             response.statusCode = error.statusCode || 500;
 223             response.errorMessage = {
 224                 error: 'Failed to get ProjectManagement.getPlatform' + error
 225             };
 226             reject(response);
 227         });
 228     });
 229 };
 230
 231 ProjectManagement.updatePlatform = function(req) {
 232     var self = this;
 233     var api_server = req.query['api_server'];
 234     var bodyData = req.body;
 235     data = bodyData;
 236     data.user = JSON.parse(data.user)
 237     var updateTasks = [];
 238
 239     var updatePlatform = rp({
 240                 uri: utils.confdPort(api_server) + '/api/config/rbac-platform-config',
 241                 method: 'PUT',
 242                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 243                     'Authorization': req.session && req.session.authorization
 244                 }),
 245                 forever: constants.FOREVER_ON,
 246                 json: data,
 247                 rejectUnauthorized: false,
 248                 resolveWithFullResponse: true
 249             });
 250     updateTasks.push(updatePlatform)
 251     return new Promise(function(resolve, reject) {
 252         Promise.all([
 253             updateTasks
 254         ]).then(function(result) {
 255             var response = {};
 256             response['data'] = {};
 257             if (result[0].body) {
 258                 response['data'] = result[0].body;
 259             }
 260             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 261
 262             resolve(response);
 263         }).catch(function(error) {
 264             var response = {};
 265             console.log('Problem with ProjectManagement.updatePlatform', error);
 266             response.statusCode = error.statusCode || 500;
 267             response.errorMessage = {
 268                 error: 'Failed to passwordChange user' + error
 269             };
 270             reject(response);
 271         });
 272     });
 273 };
 274
 275
 276 module.exports = ProjectManagement;