skyquake/framework/core/modules/api/userManagementAPI.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 UserManagement = {};
  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 var ProjectManagementAPI = require('./projectManagementAPI.js');
  29 var API_VERSION = 'v2';
  30
  31 UserManagement.get = function(req) {
  32     var self = this;
  33     var api_server = req.query['api_server'];
  34
  35     return new Promise(function(resolve, reject) {
  36         var userConfig = rp({
  37                 uri: utils.confdPort(api_server) +  '/' + API_VERSION  + '/api/operational/user-config/user',
  38                 method: 'GET',
  39                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
  40                     'Authorization': req.session && req.session.authorization
  41                 }),
  42                 forever: constants.FOREVER_ON,
  43                 rejectUnauthorized: false,
  44                 resolveWithFullResponse: true
  45             });
  46         var userOp = rp({
  47                 uri: utils.confdPort(api_server) +  '/' + API_VERSION  + '/api/operational/user-state/user',
  48                 method: 'GET',
  49                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
  50                     'Authorization': req.session && req.session.authorization
  51                 }),
  52                 forever: constants.FOREVER_ON,
  53                 rejectUnauthorized: false,
  54                 resolveWithFullResponse: true
  55             })
  56         Promise.all([
  57             userConfig,
  58             userOp
  59         ]).then(function(result) {
  60             var response = {};
  61             var userConfig = [];
  62             var userOpData = {};
  63             response['data'] = {};
  64             if (result[0].body) {
  65                 userConfig = JSON.parse(result[0].body)['rw-user:user'];
  66             }
  67             if (result[1].body) {
  68                 JSON.parse(result[1].body)['rw-user:user'].map(function(u) {
  69                     userOpData[u['user-domain'] + ',' + u['user-name']] = u;
  70                 })
  71             }
  72             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
  73             response['data']['user'] = userConfig.map(function(u,i) {
  74                 var mergedData = _.merge(u, userOpData[u['user-domain'] + ',' + u['user-name']]);
  75                 mergedData.projects = {
  76                     ids: [],
  77                     data: {}
  78                 };
  79                 var projects = mergedData.projects;
  80                 mergedData.role && mergedData.role.map(function(r) {
  81                     if ((r.role != "rw-project:user-self" )&& (r.role != "rw-rbac-platform:user-self")) {
  82                         var projectId = r.keys.split(';')[0];
  83                         if (projectId == "") {
  84                             projectId = "platform"
  85                         }
  86                         if (!projects.data[projectId]) {
  87                             projects.ids.push(projectId);
  88                             projects.data[projectId] = [];
  89                         }
  90                         projects.data[projectId].push(r.role);
  91                     }
  92                 })
  93                 return mergedData;
  94             })
  95             resolve(response);
  96         }).catch(function(error) {
  97             var response = {};
  98             console.log('Problem with UserManagement.get', error);
  99             response.statusCode = error.statusCode || constants.HTTP_RESPONSE_CODES.ERROR.INTERNAL_SERVER_ERROR;
 100             response.errorMessage = {
 101                 error: 'Failed to get UserManagement' + error
 102             };
 103             reject(response);
 104         });
 105     });
 106 };
 107
 108
 109 UserManagement.getProfile = function(req) {
 110     var self = this;
 111     var api_server = req.query['api_server'];
 112     return new Promise(function(resolve, reject) {
 113         var response = {};
 114         try {
 115             var userId = req.session.userdata.username
 116             response['data'] = {
 117                 userId: userId,
 118                 projectId: req.session.projectId,
 119                 domain: req.session.passport.user.domain
 120             };
 121             UserManagement.getUserInfo(req, userId).then(function(result) {
 122                 response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK;
 123                 response.data.data = result.data
 124                 resolve(response);
 125             }, function(error) {
 126                 console.log('Error retrieving getUserInfo');
 127                 response.statusCode = constants.HTTP_RESPONSE_CODES.ERROR.INTERNAL_SERVER_ERROR;
 128                 reject(response);
 129             })
 130         } catch (e) {
 131             var response = {};
 132             console.log('Problem with UserManagement.get', error);
 133             response.statusCode = error.statusCode || 500;
 134             response.errorMessage = {
 135                 error: 'Failed to get UserManagement' + error
 136             };
 137             reject(response);
 138         }
 139     });
 140 };
 141 UserManagement.getUserInfo = function(req, userId, domain) {
 142     var self = this;
 143     var api_server = req.query['api_server'];
 144     var id = req.params['userId'] || userId;
 145     var domain = req.params['domainId'] || domain;
 146     var response = {};
 147     return new Promise(function(resolve, reject) {
 148         if (id) {
 149             var getProjects = ProjectManagementAPI.get(req, ['name', 'project-config']);
 150             var getPlatformUser = ProjectManagementAPI.getPlatform(req, id);
 151             var getUserUiState = UserManagement.getUserUiState(req);
 152             Promise.all([
 153                 getProjects,
 154                 getPlatformUser,
 155                 getUserUiState
 156             ]).then(function(result) {
 157                 var userData = {
 158                     platform: {
 159                         role: {
 160
 161                         }
 162                     },
 163                     //id/key values for each project
 164                     projectId:[],
 165                     project: {
 166                         /**
 167                          *  [projectId] : {
 168                          *      data: [project object],
 169                          *      role: {
 170                          *          [roleId]: true
 171                          *      }
 172                          *  }
 173                          */
 174                     }
 175                 }
 176                 //Build UI state
 177                 var uiState = result[2].data && result[2].data['rw-user:user'];
 178                 userData['ui-state'] = uiState['ui-state'];
 179                 //Build platform roles
 180                 var platformRoles = result[1].data.platform && result[1].data.platform.role;
 181                 platformRoles && platformRoles.map(function(r) {
 182                     userData.platform.role[r.role] = true
 183                 });
 184                 //Build project roles
 185                 var projects = result[0].data.project;
 186                 var userProjects = [];
 187                 projects && projects.map(function(p, i) {
 188                     userData.project[p.name] = {
 189                         data: p,
 190                         role: {}
 191                     }
 192                     userData.projectId.push(p.name);
 193                     if (userData.platform.role['rw-rbac-platform:super-admin']) {
 194                         userData.project[p.name] = {
 195                             data: p,
 196                             role: {
 197                                 "rw-project:project-admin": true,
 198                                 "rw-project:project-oper": true,
 199                                 "rw-project-mano:account-admin": true,
 200                                 "rw-project-mano:account-oper": true,
 201                                 "rw-project-mano:catalog-admin": true,
 202                                 "rw-project-mano:catalog-oper": true,
 203                                 "rw-project-mano:lcm-admin": true,
 204                                 "rw-project-mano:lcm-oper": true
 205                             }
 206                         }
 207                     } else {
 208                         var users = p['project-config'] && p['project-config'].user;
 209                         users && users.map(function(u) {
 210                             if(u['user-name'] == id) {
 211                                 u.role && u.role.map(function(r) {
 212                                     userData.project[p.name].role[r.role] = true;
 213                                     if (r.role === 'rw-project:project-admin') {
 214                                         userData.project[p.name].role["rw-project-mano:account-admin"] = true;
 215                                         userData.project[p.name].role["rw-project-mano:catalog-admin"] = true;
 216                                         userData.project[p.name].role["rw-project-mano:lcm-admin"] = true;
 217                                         userData.isLCM = true;
 218                                     } else if (r.role === 'rw-project:project-oper') {
 219                                         userData.project[p.name].role["rw-project-mano:account-oper"] = true;
 220                                         userData.project[p.name].role["rw-project-mano:catalog-oper"] = true;
 221                                         userData.project[p.name].role["rw-project-mano:lcm-oper"] = true;
 222                                         userData.isLCM = true;
 223                                     }
 224                                 });
 225                                 u["rw-project-mano:mano-role"] && u["rw-project-mano:mano-role"] .map(function(r) {
 226                                     userData.project[p.name].role[r.role] = true;
 227                                     if (r.role.indexOf('rw-project-mano:lcm') > -1) {
 228                                         userData.isLCM = true;
 229                                     }
 230                                 });
 231                             }
 232                         })
 233                     }
 234                 });
 235                 response.data = userData;
 236                 response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK;
 237
 238                 req.session.projectMap = userData.project;
 239                 req.session.platformMap = userData.platform;
 240                 resolve(response);
 241             })
 242         } else {
 243             var errorMsg = 'userId not specified in UserManagement.getUserInfo';
 244             console.error(errorMsg);
 245             response.statusCode = constants.HTTP_RESPONSE_CODES.ERROR.BAD_REQUEST;
 246             response.error = errorMsg;
 247             reject(response)
 248         }
 249
 250     })
 251 }
 252 UserManagement.create = function(req) {
 253     var self = this;
 254     var api_server = req.query['api_server'];
 255     var data = req.body;
 256     data = {
 257         "user":[data]
 258     }
 259     return new Promise(function(resolve, reject) {
 260         Promise.all([
 261             rp({
 262                 uri: utils.confdPort(api_server) +  '/' + API_VERSION  + '/api/config/user-config',
 263                 method: 'POST',
 264                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 265                     'Authorization': req.session && req.session.authorization
 266                 }),
 267                 forever: constants.FOREVER_ON,
 268                 json: data,
 269                 rejectUnauthorized: false,
 270                 resolveWithFullResponse: true
 271             })
 272         ]).then(function(result) {
 273             var response = {};
 274             response['data'] = {};
 275             if (result[0].body) {
 276                 response['data'] = result[0].body;
 277             }
 278             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 279
 280             resolve(response);
 281         }).catch(function(error) {
 282             var response = {};
 283             console.log('Problem with UserManagement.create', error);
 284             response.statusCode = error.statusCode || 500;
 285             response.errorMessage = {
 286                 error: 'Failed to create user' + error
 287             };
 288             reject(response);
 289         });
 290     });
 291 };
 292 UserManagement.update = function(req) {
 293     var self = this;
 294     var api_server = req.query['api_server'];
 295     var bodyData = req.body;
 296     data = {
 297         "rw-user:user": bodyData
 298     }
 299     var updateTasks = [];
 300     if(bodyData.hasOwnProperty('old-password')) {
 301         var changePW = rp({
 302             uri: utils.confdPort(api_server) +  '/' + API_VERSION  + '/api/operations/change-password',
 303             method: 'POST',
 304             headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 305                 'Authorization': req.session && req.session.authorization
 306             }),
 307             forever: constants.FOREVER_ON,
 308             json: {
 309                 "input": {
 310                     'user-name' : bodyData['user-name'],
 311                     'user-domain' : bodyData['user-domain'],
 312                     'old-password' : bodyData['old-password'],
 313                     'new-password' : bodyData['new-password'],
 314                     'confirm-password' : bodyData['confirm-password'],
 315                 }
 316             },
 317             rejectUnauthorized: false,
 318             resolveWithFullResponse: true
 319         });
 320         updateTasks.push(changePW);
 321     };
 322     var updateUser = rp({
 323                 uri: utils.confdPort(api_server) +  '/' + API_VERSION  + '/api/config/user-config/user/' + encodeURIComponent(bodyData['user-name']) + ',' +  encodeURIComponent(bodyData['user-domain']),
 324                 method: 'PUT',
 325                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 326                     'Authorization': req.session && req.session.authorization
 327                 }),
 328                 forever: constants.FOREVER_ON,
 329                 json: data,
 330                 rejectUnauthorized: false,
 331                 resolveWithFullResponse: true
 332             });
 333     updateTasks.push(updateUser)
 334     return new Promise(function(resolve, reject) {
 335         Promise.all([
 336             updateTasks
 337         ]).then(function(result) {
 338             var response = {};
 339             response['data'] = {};
 340             if (result[0].body) {
 341                 response['data'] = result[0].body;
 342             }
 343             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 344
 345             resolve(response);
 346         }).catch(function(error) {
 347             var response = {};
 348             console.log('Problem with UserManagement.passwordChange', error);
 349             response.statusCode = error.statusCode || 500;
 350             response.errorMessage = {
 351                 error: 'Failed to passwordChange user' + error
 352             };
 353             reject(response);
 354         });
 355     });
 356 };
 357
 358 UserManagement.delete = function(req) {
 359     var self = this;
 360     var username = req.params.username;
 361     var domain = req.params.domain;
 362     var api_server = req.query["api_server"];
 363     var requestHeaders = {};
 364     var url = `${utils.confdPort(api_server)}/${API_VERSION}/api/config/user-config/user/${encodeURIComponent(username)},${encodeURIComponent(domain)}`
 365     return new Promise(function(resolve, reject) {
 366         _.extend(requestHeaders,
 367             constants.HTTP_HEADERS.accept.data,
 368             constants.HTTP_HEADERS.content_type.data, {
 369                 'Authorization': req.session && req.session.authorization
 370             });
 371         rp({
 372             url: url,
 373             method: 'DELETE',
 374             headers: requestHeaders,
 375             forever: constants.FOREVER_ON,
 376             rejectUnauthorized: false,
 377         }, function(error, response, body) {
 378             if (utils.validateResponse('UserManagement.DELETE', error, response, body, resolve, reject)) {
 379                 return resolve({
 380                     statusCode: response.statusCode,
 381                     data: JSON.stringify(response.body)
 382                 });
 383             };
 384         });
 385     })
 386 };
 387 UserManagement.getUserUiState = function(req) {
 388     var self = this;
 389     var api_server = req.query['api_server'];
 390     var user = req.session.passport.user;
 391     return new Promise(function(resolve, reject) {
 392         Promise.all([
 393             rp({
 394                 uri: utils.confdPort(api_server) +  '/' + API_VERSION  + '/api/config/user-config/user/'+encodeURIComponent(user.username) + ',' + encodeURIComponent(user.domain),
 395                 method: 'GET',
 396                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 397                     'Authorization': req.session && req.session.authorization
 398                 }),
 399                 forever: constants.FOREVER_ON,
 400                 rejectUnauthorized: false,
 401                 resolveWithFullResponse: true
 402             })
 403         ]).then(function(result) {
 404             var response = {};
 405             response['data'] = {};
 406             if (result[0].body) {
 407                 response['data'] = JSON.parse(result[0].body);
 408             }
 409             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 410
 411             resolve(response);
 412         }).catch(function(error) {
 413             var response = {};
 414             console.log('Problem with UserManagement.getUserUiState', error);
 415             response.statusCode = error.statusCode || 500;
 416             response.errorMessage = {
 417                 error: 'Failed to create user' + error
 418             };
 419             reject(response);
 420         });
 421     });
 422 };
 423 UserManagement.updateActiveProject = function(req) {
 424     var self = this;
 425     var api_server = req.query['api_server'];
 426     var user = req.session.passport.user;
 427     var data = {
 428         "rw-user:user-config": {
 429             "user":{
 430                 "user-name" : user.username,
 431                 "user-domain": user.domain,
 432                 "ui-state": {
 433                      "last-active-project" : req.params.projectId
 434                 }
 435             }
 436         }
 437     }
 438     return new Promise(function(resolve, reject) {
 439         Promise.all([
 440             rp({
 441                 uri: utils.confdPort(api_server) +  '/' + API_VERSION  + '/api/config/user-config',
 442                 method: 'PATCH',
 443                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 444                     'Authorization': req.session && req.session.authorization
 445                 }),
 446                 forever: constants.FOREVER_ON,
 447                 json: data,
 448                 rejectUnauthorized: false,
 449                 resolveWithFullResponse: true
 450             })
 451         ]).then(function(result) {
 452             var response = {};
 453             response['data'] = {};
 454             if (result[0].body) {
 455                 response['data'] = result[0].body;
 456             }
 457             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 458
 459             resolve(response);
 460         }).catch(function(error) {
 461             var response = {};
 462             console.log('Problem with UserManagement.updateActiveProject', error);
 463             response.statusCode = error.statusCode || 500;
 464             response.errorMessage = {
 465                 error: 'Failed to create user' + error
 466             };
 467             reject(response);
 468         });
 469     });
 470 };
 471 UserManagement.updateActiveUri = function(req) {
 472     if (!req.session.passport) {
 473         console.debug("passport gone before we got the save the active uri");
 474         var response = {
 475             statusCode: 500,
 476             errorMessage: {
 477                 error: 'Failed to save active uri'
 478             }};
 479         return Promise.resolve(response);
 480     }
 481     var self = this;
 482     var api_server = req.query['api_server'];
 483     var user = req.session.passport.user;
 484     var ref = req.headers.referer;
 485     var hash = req.query.hash;
 486     var data = {
 487         "rw-user:user-config": {
 488             "user":{
 489                 "user-name" : user.username,
 490                 "user-domain": user.domain,
 491                 "ui-state": {
 492                      "last-active-uri" : ref + decodeURIComponent(hash)
 493                 }
 494             }
 495         }
 496     }
 497     return new Promise(function(resolve, reject) {
 498         Promise.all([
 499             rp({
 500                 uri: utils.confdPort(api_server) +  '/' + API_VERSION  + '/api/config/user-config',
 501                 method: 'PATCH',
 502                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 503                     'Authorization': req.session && req.session.authorization
 504                 }),
 505                 forever: constants.FOREVER_ON,
 506                 json: data,
 507                 rejectUnauthorized: false,
 508                 resolveWithFullResponse: true
 509             })
 510         ]).then(function(result) {
 511             var response = {};
 512             response['data'] = {};
 513             if (result[0].body) {
 514                 response['data'] = result[0].body;
 515             }
 516             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 517
 518             resolve(response);
 519         }).catch(function(error) {
 520             var response = {};
 521             console.log('Problem with UserManagement.updateActiveProject', error);
 522             response.statusCode = error.statusCode || 500;
 523             response.errorMessage = {
 524                 error: 'Failed to create user' + error
 525             };
 526             reject(response);
 527         });
 528     });
 529 };
 530 module.exports = UserManagement;