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
  30 UserManagement.get = function(req) {
  31     var self = this;
  32     var api_server = req.query['api_server'];
  33
  34     return new Promise(function(resolve, reject) {
  35         var userConfig = rp({
  36                 uri: utils.confdPort(api_server) + '/api/operational/user-config/user',
  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         var userOp = rp({
  46                 uri: utils.confdPort(api_server) + '/api/operational/user-state/user',
  47                 method: 'GET',
  48                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
  49                     'Authorization': req.session && req.session.authorization
  50                 }),
  51                 forever: constants.FOREVER_ON,
  52                 rejectUnauthorized: false,
  53                 resolveWithFullResponse: true
  54             })
  55         Promise.all([
  56             userConfig,
  57             userOp
  58         ]).then(function(result) {
  59             var response = {};
  60             response['data'] = {};
  61             var resultData = [];
  62             if (result[0].body) {
  63                 resultData.push(JSON.parse(result[0].body)['rw-user:user'].sort());
  64             }
  65             if (result[1].body) {
  66                 resultData.push(JSON.parse(result[1].body)['rw-user:user'].sort());
  67             }
  68             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
  69             response['data']['user'] = resultData[0].map(function(d,i) {
  70                 var mergedData = _.merge(d, resultData[1][i]);
  71                 mergedData.projects = {
  72                     ids: [],
  73                     data: {}
  74                 };
  75                 var projects = mergedData.projects;
  76                 mergedData.role && mergedData.role.map(function(r) {
  77                     if ((r.role != "rw-project:user-self" )&& (r.role != "rw-rbac-platform:user-self")) {
  78                         var projectId = r.keys.split(';')[0];
  79                         if (projectId == "") {
  80                             projectId = "platform"
  81                         }
  82                         if (!projects.data[projectId]) {
  83                             projects.ids.push(projectId);
  84                             projects.data[projectId] = [];
  85                         }
  86                         projects.data[projectId].push(r.role);
  87                     }
  88                 })
  89                 return mergedData;
  90             })
  91             resolve(response);
  92         }).catch(function(error) {
  93             var response = {};
  94             console.log('Problem with UserManagement.get', error);
  95             response.statusCode = error.statusCode || 500;
  96             response.errorMessage = {
  97                 error: 'Failed to get UserManagement' + error
  98             };
  99             reject(response);
 100         });
 101     });
 102 };
 103
 104
 105 UserManagement.getProfile = function(req) {
 106     var self = this;
 107     var api_server = req.query['api_server'];
 108     return new Promise(function(resolve, reject) {
 109         var response = {};
 110         try {
 111             var userId = req.session.userdata.username
 112             response['data'] = {
 113                 userId: userId,
 114                 projectId: req.session.projectId
 115             };
 116             UserManagement.getUserInfo(req, userId).then(function(result) {
 117                 response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK;
 118                 response.data.data = result.data
 119                 resolve(response);
 120             }, function(error) {
 121                 console.log('Error retrieving getUserInfo');
 122                 response.statusCode = constants.HTTP_RESPONSE_CODES.ERROR.INTERNAL_SERVER_ERROR;
 123                 reject(response);
 124             })
 125         } catch (e) {
 126             response.data.data = e;
 127             response.statusCode = constants.HTTP_RESPONSE_CODES.ERROR.INTERNAL_SERVER_ERROR;
 128             reject(response);
 129             reject()
 130         }
 131     });
 132 };
 133 UserManagement.getUserInfo = function(req, userId, domain) {
 134     var self = this;
 135     var api_server = req.query['api_server'];
 136     var id = req.params['userId'] || userId;
 137     var domain = req.params['domainId'] || domain;
 138     var response = {};
 139     return new Promise(function(resolve, reject) {
 140         if (id) {
 141             var getProjects = ProjectManagementAPI.get(req)
 142             var getPlatformUser = ProjectManagementAPI.getPlatform(req, id)
 143             Promise.all([
 144                 getProjects,
 145                 getPlatformUser
 146             ]).then(function(result) {
 147                 var userData = {
 148                     platform: {
 149                         role: {
 150
 151                         }
 152                     },
 153                     //id/key values for each project
 154                     projectId:[],
 155                     project: {
 156                         /**
 157                          *  [projectId] : {
 158                          *      data: [project object],
 159                          *      role: {
 160                          *          [roleId]: true
 161                          *      }
 162                          *  }
 163                          */
 164                     }
 165                 }
 166                 //Build project roles
 167                 var projects = result[0].data.project;
 168                 var userProjects = [];
 169                 projects && projects.map(function(p, i) {
 170                     var users = p['project-config'] && p['project-config'].user;
 171                     userData.projectId.push(p.name);
 172                     users && users.map(function(u) {
 173                         if(u['user-name'] == id) {
 174                             userData.project[p.name] = {
 175                                 data: p,
 176                                 role: {}
 177                             }
 178                             u.role && u.role.map(function(r) {
 179                                 userData.project[p.name].role[r.role] = true
 180                             });
 181                             u["rw-project-mano:mano-role"] && u["rw-project-mano:mano-role"] .map(function(r) {
 182                                 userData.project[p.name].role[r.role] = true
 183                             });
 184                         }
 185                     })
 186                 });
 187                 //Build platform roles
 188                 var platformRoles = result[1].data.platform && result[1].data.platform.role;
 189                 platformRoles && platformRoles.map(function(r) {
 190                     userData.platform.role[r.role] = true
 191                 });
 192                 response.data = userData;
 193                 response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 194                 resolve(response);
 195             })
 196         } else {
 197             var errorMsg = 'userId not specified in UserManagement.getUserInfo';
 198             console.error(errorMsg);
 199             response.statusCode = constants.HTTP_RESPONSE_CODES.ERROR.BAD_REQUEST;
 200             response.error = errorMsg;
 201             reject(response)
 202         }
 203
 204     })
 205 }
 206 UserManagement.create = function(req) {
 207     var self = this;
 208     var api_server = req.query['api_server'];
 209     var data = req.body;
 210     data = {
 211         "user":[data]
 212     }
 213     return new Promise(function(resolve, reject) {
 214         Promise.all([
 215             rp({
 216                 uri: utils.confdPort(api_server) + '/api/config/user-config',
 217                 method: 'POST',
 218                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 219                     'Authorization': req.session && req.session.authorization
 220                 }),
 221                 forever: constants.FOREVER_ON,
 222                 json: data,
 223                 rejectUnauthorized: false,
 224                 resolveWithFullResponse: true
 225             })
 226         ]).then(function(result) {
 227             var response = {};
 228             response['data'] = {};
 229             if (result[0].body) {
 230                 response['data'] = result[0].body;
 231             }
 232             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 233
 234             resolve(response);
 235         }).catch(function(error) {
 236             var response = {};
 237             console.log('Problem with UserManagement.create', error);
 238             response.statusCode = error.statusCode || 500;
 239             response.errorMessage = {
 240                 error: 'Failed to create user' + error
 241             };
 242             reject(response);
 243         });
 244     });
 245 };
 246 UserManagement.update = function(req) {
 247     var self = this;
 248     var api_server = req.query['api_server'];
 249     var bodyData = req.body;
 250     data = {
 251         "rw-user:user": bodyData
 252     }
 253     var updateTasks = [];
 254     if(bodyData.hasOwnProperty('old-password')) {
 255         var changePW = rp({
 256             uri: utils.confdPort(api_server) + '/api/operations/change-password',
 257             method: 'POST',
 258             headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 259                 'Authorization': req.session && req.session.authorization
 260             }),
 261             forever: constants.FOREVER_ON,
 262             json: {
 263                 "input": {
 264                     'user-name' : bodyData['user-name'],
 265                     'user-domain' : bodyData['user-domain'],
 266                     'old-password' : bodyData['old-password'],
 267                     'new-password' : bodyData['new-password'],
 268                     'confirm-password' : bodyData['confirm-password'],
 269                 }
 270             },
 271             rejectUnauthorized: false,
 272             resolveWithFullResponse: true
 273         });
 274         updateTasks.push(changePW);
 275     };
 276     var updateUser = rp({
 277                 uri: utils.confdPort(api_server) + '/api/config/user-config/user/' + bodyData['user-name'] + ',' +  bodyData['user-domain'],
 278                 method: 'PUT',
 279                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 280                     'Authorization': req.session && req.session.authorization
 281                 }),
 282                 forever: constants.FOREVER_ON,
 283                 json: data,
 284                 rejectUnauthorized: false,
 285                 resolveWithFullResponse: true
 286             });
 287     updateTasks.push(updateUser)
 288     return new Promise(function(resolve, reject) {
 289         Promise.all([
 290             updateTasks
 291         ]).then(function(result) {
 292             var response = {};
 293             response['data'] = {};
 294             if (result[0].body) {
 295                 response['data'] = result[0].body;
 296             }
 297             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 298
 299             resolve(response);
 300         }).catch(function(error) {
 301             var response = {};
 302             console.log('Problem with UserManagement.passwordChange', error);
 303             response.statusCode = error.statusCode || 500;
 304             response.errorMessage = {
 305                 error: 'Failed to passwordChange user' + error
 306             };
 307             reject(response);
 308         });
 309     });
 310 };
 311
 312 UserManagement.delete = function(req) {
 313     var self = this;
 314     var username = req.params.username;
 315     var domain = req.params.domain;
 316     var api_server = req.query["api_server"];
 317     var requestHeaders = {};
 318     var url = `${utils.confdPort(api_server)}/api/config/user-config/user/${username},${domain}`
 319     return new Promise(function(resolve, reject) {
 320         _.extend(requestHeaders,
 321             constants.HTTP_HEADERS.accept.data,
 322             constants.HTTP_HEADERS.content_type.data, {
 323                 'Authorization': req.session && req.session.authorization
 324             });
 325         rp({
 326             url: url,
 327             method: 'DELETE',
 328             headers: requestHeaders,
 329             forever: constants.FOREVER_ON,
 330             rejectUnauthorized: false,
 331         }, function(error, response, body) {
 332             if (utils.validateResponse('UserManagement.DELETE', error, response, body, resolve, reject)) {
 333                 return resolve({
 334                     statusCode: response.statusCode,
 335                     data: JSON.stringify(response.body)
 336                 });
 337             };
 338         });
 339     })
 340 }
 341 module.exports = UserManagement;