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
  29 UserManagement.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/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         ]).then(function(result) {
  46             var response = {};
  47             response['data'] = {};
  48             if (result[0].body) {
  49                 response['data']['user'] = JSON.parse(result[0].body)['rw-user:user'];
  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 UserManagement.get', error);
  57             response.statusCode = error.statusCode || 500;
  58             response.errorMessage = {
  59                 error: 'Failed to get UserManagement' + error
  60             };
  61             reject(response);
  62         });
  63     });
  64 };
  65
  66 UserManagement.getProfile = function(req) {
  67     var self = this;
  68     var api_server = req.query['api_server'];
  69     return new Promise(function(resolve, reject) {
  70         var response = {};
  71             response['data'] = {
  72             userId: req.session.userdata.username,
  73             projectId: req.session.projectId
  74         };
  75         response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
  76
  77         resolve(response);
  78     });
  79 };
  80 UserManagement.create = function(req) {
  81     var self = this;
  82     var api_server = req.query['api_server'];
  83     var data = req.body;
  84     data = {
  85         "user":[data]
  86     }
  87     return new Promise(function(resolve, reject) {
  88         Promise.all([
  89             rp({
  90                 uri: utils.confdPort(api_server) + '/api/config/user-config',
  91                 method: 'POST',
  92                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
  93                     'Authorization': req.session && req.session.authorization
  94                 }),
  95                 forever: constants.FOREVER_ON,
  96                 json: data,
  97                 rejectUnauthorized: false,
  98                 resolveWithFullResponse: true
  99             })
 100         ]).then(function(result) {
 101             var response = {};
 102             response['data'] = {};
 103             if (result[0].body) {
 104                 response['data'] = result[0].body;
 105             }
 106             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 107
 108             resolve(response);
 109         }).catch(function(error) {
 110             var response = {};
 111             console.log('Problem with UserManagement.create', error);
 112             response.statusCode = error.statusCode || 500;
 113             response.errorMessage = {
 114                 error: 'Failed to create user' + error
 115             };
 116             reject(response);
 117         });
 118     });
 119 };
 120 UserManagement.update = function(req) {
 121     var self = this;
 122     var api_server = req.query['api_server'];
 123     var bodyData = req.body;
 124     data = {
 125         "user":[bodyData]
 126     }
 127     var updateTasks = [];
 128     if(bodyData.hasOwnProperty('old-password')) {
 129         var changePW = rp({
 130             uri: utils.confdPort(api_server) + '/api/operations/change-password',
 131             method: 'POST',
 132             headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 133                 'Authorization': req.session && req.session.authorization
 134             }),
 135             forever: constants.FOREVER_ON,
 136             json: {
 137                 "input": {
 138                     'user-name' : bodyData['user-name'],
 139                     'user-domain' : bodyData['user-domain'],
 140                     'old-password' : bodyData['old-password'],
 141                     'new-password' : bodyData['new-password'],
 142                     'confirm-password' : bodyData['confirm-password'],
 143                 }
 144             },
 145             rejectUnauthorized: false,
 146             resolveWithFullResponse: true
 147         });
 148         updateTasks.push(changePW);
 149     };
 150     var updateUser = rp({
 151                 uri: utils.confdPort(api_server) + '/api/config/user-config',
 152                 method: 'PUT',
 153                 headers: _.extend({}, constants.HTTP_HEADERS.accept.data, {
 154                     'Authorization': req.session && req.session.authorization
 155                 }),
 156                 forever: constants.FOREVER_ON,
 157                 json: data,
 158                 rejectUnauthorized: false,
 159                 resolveWithFullResponse: true
 160             });
 161     updateTasks.push(updateUser)
 162     return new Promise(function(resolve, reject) {
 163         Promise.all([
 164             updateTasks
 165         ]).then(function(result) {
 166             var response = {};
 167             response['data'] = {};
 168             if (result[0].body) {
 169                 response['data'] = result[0].body;
 170             }
 171             response.statusCode = constants.HTTP_RESPONSE_CODES.SUCCESS.OK
 172
 173             resolve(response);
 174         }).catch(function(error) {
 175             var response = {};
 176             console.log('Problem with UserManagement.passwordChange', error);
 177             response.statusCode = error.statusCode || 500;
 178             response.errorMessage = {
 179                 error: 'Failed to passwordChange user' + error
 180             };
 181             reject(response);
 182         });
 183     });
 184 };
 185
 186 UserManagement.delete = function(req) {
 187     var self = this;
 188     var username = req.params.username;
 189     var domain = req.params.domain;
 190     var api_server = req.query["api_server"];
 191     var requestHeaders = {};
 192     var url = `${utils.confdPort(api_server)}/api/config/user-config/user/${username},${domain}`
 193     return new Promise(function(resolve, reject) {
 194         _.extend(requestHeaders,
 195             constants.HTTP_HEADERS.accept.data,
 196             constants.HTTP_HEADERS.content_type.data, {
 197                 'Authorization': req.session && req.session.authorization
 198             });
 199         rp({
 200             url: url,
 201             method: 'DELETE',
 202             headers: requestHeaders,
 203             forever: constants.FOREVER_ON,
 204             rejectUnauthorized: false,
 205         }, function(error, response, body) {
 206             if (utils.validateResponse('UserManagement.DELETE', error, response, body, resolve, reject)) {
 207                 return resolve({
 208                     statusCode: response.statusCode,
 209                     data: JSON.stringify(response.body)
 210                 });
 211             };
 212         });
 213     })
 214 }
 215 module.exports = UserManagement;