skyquake/framework/core/modules/api/sessions.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
  19 /**
  20  * sessions api module. Provides API functions for sessions
  21  * @module framework/core/modules/api/sessions
  22  * @author Kiran Kashalkar <kiran.kashalkar@riftio.com>
  23  */
  24 "use strict"
  25 var Promise = require('promise');
  26 var constants = require('../../api_utils/constants');
  27 var utils = require('../../api_utils/utils');
  28 var request = utils.request;
  29 var rp = require('request-promise');
  30 var sessionsAPI = {};
  31 var _ = require('lodash');
  32 var base64 = require('base-64');
  33 var APIVersion = '/v2';
  34 var configurationAPI = require('./configuration');
  35 var UserManagement = require('./userManagementAPI.js');
  36 var URL = require('url');
  37
  38 // Used for determining what page a user should first go to.
  39 var Application = {
  40     order: [
  41         "rw-rbac-platform:super-admin",
  42         "rw-rbac-platform:platform-admin",
  43         "rw-rbac-platform:platform-oper",
  44         "rw-project:project-admin",
  45         "rw-project:project-oper",
  46         "rw-project-mano:lcm-admin",
  47         "rw-project-mano:lcm-oper",
  48         "rw-project-mano:catalog-admin",
  49         "rw-project-mano:catalog-oper",
  50         "rw-project-mano:account-admin",
  51         "rw-project-mano:account-oper"
  52     ],
  53     key: {
  54         "rw-rbac-platform:super-admin": "user_management",
  55         "rw-rbac-platform:platform-admin": "user_management",
  56         "rw-rbac-platform:platform-oper": "user_management",
  57         "rw-project:project-admin": "project_management",
  58         "rw-project:project-oper": "project_management",
  59         "rw-project-mano:catalog-admin": "composer",
  60         "rw-project-mano:catalog-oper": "composer",
  61         "rw-project-mano:lcm-admin": "launchpad",
  62         "rw-project-mano:lcm-oper": "launchpad",
  63         "rw-project-mano:account-admin": "accounts",
  64         "rw-project-mano:account-oper": "accounts"
  65     }
  66 };
  67
  68 function logAndReject(mesg, reject, errCode) {
  69     var res = {};
  70     res.errorMessage = {
  71         error: mesg
  72     }
  73     res.statusCode = errCode || constants.HTTP_RESPONSE_CODES.ERROR.BAD_REQUEST;
  74     console.log(mesg);
  75     reject(res);
  76 }
  77
  78 function logAndRedirectToLogin(mesg, res, req, invalid) {
  79     console.log(mesg);
  80     if (!invalid) {
  81         res.redirect(utils.buildRedirectURL(req, configurationAPI.globalConfiguration, 'login', '&referer=' + encodeURIComponent(req.headers.referer)));
  82     }
  83     res.end();
  84 }
  85
  86 function logAndRedirectToEndSession(mesg, res, authorization, url) {
  87     console.log(mesg);
  88     res.set({
  89         'Authorization': authorization
  90     });
  91     res.redirect(url);
  92     res.end();
  93 }
  94 var sessionPromiseResolve = null;
  95 sessionsAPI.sessionPromise = new Promise(function(resolve, reject) {
  96     sessionPromiseResolve = resolve;
  97 });
  98
  99 sessionsAPI.create = function (req, res) {
 100     if (!req.session.passport){
 101         logAndRedirectToLogin("lost session", res, req);
 102         return new Promise(function (resolve, reject){reject("lost session")});
 103     }
 104     var api_server = req.query['api_server'] || (req.protocol + '://' + configurationAPI.globalConfiguration.get().api_server);
 105     var uri = utils.confdPort(api_server);
 106     var username = req.session.passport.user['username'];
 107     var authorization_header_string = 'Bearer ' + req.session.passport.user.user.access_token;
 108     return new Promise(function (resolve, reject) {
 109         req.session.authorization = authorization_header_string;
 110         req.session.api_server = api_server;
 111         req.session.api_protocal = req.protocol;
 112         req.session.loggedIn = true;
 113         req.session.userdata = {
 114             username: username,
 115         };
 116         UserManagement.getUserInfo(req, req.session.passport.user.username).then(function (results) {
 117             var project_list_for_user = null;
 118             if (!req.session.projectId && results.data.project) {
 119                 project_list_for_user = Object.keys(results.data.project);
 120                 if (project_list_for_user.length > 0) {
 121                     req.session.projectId = project_list_for_user.sort() && project_list_for_user[0];
 122                 }
 123             }
 124             sessionsAPI.setTopApplication(req);
 125             req.session.isLCM = results.data.isLCM;
 126
 127             req.session['ui-state'] = results.data['ui-state'];
 128             var lastActiveProject = req.session['ui-state'] && req.session['ui-state']['last-active-project'];
 129             if (lastActiveProject) {
 130                 if (results.data.project.hasOwnProperty(lastActiveProject)) {
 131                     req.session.projectId = lastActiveProject;
 132                 }
 133
 134             }
 135
 136             var successMsg = 'User => ' + username + ' successfully logged in.';
 137             successMsg += req.session.projectId ? 'Project => ' + req.session.projectId + ' set as default.' : '';
 138
 139             console.log(successMsg);
 140
 141             req.session.save(function (err) {
 142                 if (err) {
 143                     console.log('Error saving session to store', err);
 144                 }
 145                 // no response data, just redirect now that session data is set
 146                 if (req.session['ui-state'] && req.session['ui-state']['last-active-uri']) {
 147                     var url = URL.parse(req.session['ui-state']['last-active-uri']);
 148                     var host = req.headers.host;
 149                     var path = url.path;
 150                     var hash = url.hash;
 151                     var protocol = url.protocol;
 152                     var newUrl = protocol + '//' + host + path + (hash?hash:'');
 153                     console.log('Redirecting to: ' + newUrl)
 154                     res.redirect(newUrl)
 155                 } else {
 156                     if(req.session.topApplication) {
 157                         res.redirect(utils.buildRedirectURL(req, configurationAPI.globalConfiguration, req.session.topApplication));
 158                     } else {
 159                         res.redirect(utils.buildRedirectURL(req, configurationAPI.globalConfiguration, 'user_management', '#/user-profile'));
 160                     }
 161                 }
 162             })
 163
 164             sessionPromiseResolve(req.session);
 165
 166         }).catch(function (error) {
 167             // Something went wrong - Redirect to /login
 168             var errorMsg = 'Error logging in or getting list of projects. Error: ' + error;
 169             console.log(errorMsg);
 170             logAndRedirectToLogin(errorMsg, res, req);
 171         });
 172     })
 173 };
 174
 175 sessionsAPI.addProjectToSession = function (req, res) {
 176     return new Promise(function (resolve, reject) {
 177         if (req.session && req.session.loggedIn == true) {
 178             Promise.all([UserManagement.getProfile(req), UserManagement.updateActiveProject(req)]).then(function () {
 179                 req.session.projectId = req.params.projectId;
 180                 req.session.topApplication = null;
 181                 sessionsAPI.setTopApplication(req, req.query.app);
 182                 req.session.save(function (err) {
 183                     if (err) {
 184                         console.log('Error saving session to store', err);
 185                         var errorMsg = 'Session does not exist or not logged in';
 186                         logAndReject(errorMsg, reject, constants.HTTP_RESPONSE_CODES.ERROR.NOT_FOUND);
 187                     } else {
 188                         var successMsg = 'Added project ' + req.session.projectId + ' to session ' + req.sessionID;
 189                         console.log(successMsg);
 190                         var response = {
 191                             statusCode: constants.HTTP_RESPONSE_CODES.SUCCESS.OK,
 192                             data: JSON.stringify({
 193                                 status: successMsg
 194                             })
 195                         }
 196                         return resolve(response);
 197                     }
 198                     // res.redirect('/');
 199                 });
 200
 201             })
 202
 203         }
 204     });
 205 }
 206
 207 sessionsAPI.delete = function (req, res) {
 208     var idpServerAddress = configurationAPI.globalConfiguration.get().idp_server_address;
 209     var idpServerProtocol = configurationAPI.globalConfiguration.get().idp_server_protocol;
 210     var idpServerPortNumber = configurationAPI.globalConfiguration.get().idp_server_port_number;
 211     var idpEndSessionPath = constants.END_SESSION_PATH;
 212     var url = idpServerProtocol + '://' +
 213         idpServerAddress + ':' +
 214         idpServerPortNumber + '/' +
 215         idpEndSessionPath;
 216     var authorization = req.session.authorization;
 217     return new Promise(function (resolve, reject) {
 218         Promise.all([
 219             UserManagement.updateActiveUri(req),
 220             new Promise(function (success, failure) {
 221                 req.session.destroy(function (err) {
 222                     if (err) {
 223                         var errorMsg = 'Error deleting session. Error: ' + err;
 224                         console.log(errorMsg);
 225                         success({
 226                             status: 'error',
 227                             message: errorMsg
 228                         });
 229                     }
 230
 231                     var successMsg = 'Success deleting session';
 232                     console.log(successMsg);
 233
 234                     success({
 235                         status: 'success',
 236                         message: successMsg
 237                     });
 238                 });
 239             })
 240         ]).then(function (result) {
 241             // assume the session was deleted!
 242             var message = 'Session was deleted. Redirecting to end_session';
 243             resolve({
 244                 statusCode: constants.HTTP_RESPONSE_CODES.SUCCESS.OK,
 245                 data: {
 246                     url: url,
 247                     message: message
 248                 }
 249             });
 250
 251         }).catch(function (error) {
 252             var message = "An error occured while deleting session";
 253             resolve({
 254                 statusCode: constants.HTTP_RESPONSE_CODES.SUCCESS.OK,
 255                 data: {
 256                     url: url,
 257                     message: message
 258                 }
 259             });
 260         });
 261     });
 262 }
 263
 264 sessionsAPI.setTopApplication = function (req, suggestedPlugin) {
 265     var selectedProject = req.session.projectId;
 266     var userProject = selectedProject ? req.session.projectMap[selectedProject] : null;
 267     if (userProject) {
 268         if (suggestedPlugin) {
 269             if (req.session.platformMap['rw-rbac-platform:super-admin']) {
 270                 topApplication = suggestedPlugin;
 271             } else {
 272                 var roles = _.reduce(Object.keys(Application.key), function (accumulator, role) {
 273                     if (Application.key[role] === suggestedPlugin) {
 274                         accumulator.push(role);
 275                     }
 276                     return accumulator;
 277                 }, []);
 278                 if (_.some(roles, function (role){return userProject.role[role]})) {
 279                     req.session.topApplication = suggestedPlugin;
 280                     return;
 281                 }
 282             }
 283         }
 284         _.some(Application.order, function (role) {
 285             if (userProject.role[role] || req.session.platformMap.role[role]) {
 286                 req.session.topApplication = Application.key[role];
 287                 return true;
 288             }
 289             return false;
 290         })
 291     }
 292 }
 293
 294 module.exports = sessionsAPI;