server/web/context-generator.js

   1 'use strict';
   2
   3 var assert = require('assert');
   4 var Promise = require('bluebird');
   5 var _ = require('lodash');
   6 const debug = require('debug')('gitter:app:context-generator');
   7 var restSerializer = require('../serializers/rest-serializer');
   8 var userService = require('gitter-web-users');
   9 var roomMetaService = require('gitter-web-rooms/lib/room-meta-service');
  10 var contextGeneratorRequest = require('./context-generator-request');
  11
  12 function serializeUser(user) {
  13   var strategy = new restSerializer.UserStrategy({
  14     exposeRawDisplayName: true,
  15     includeScopes: true,
  16     includePermissions: true,
  17     showPremiumStatus: true,
  18     includeProviders: true
  19   });
  20
  21   return restSerializer.serializeObject(user, strategy);
  22 }
  23
  24 function serializeTroupe(troupe, user) {
  25   var strategy = new restSerializer.TroupeStrategy({
  26     currentUserId: user ? user.id : null,
  27     currentUser: user,
  28     includePermissions: true,
  29     includeOwner: true,
  30     includeGroups: true,
  31     includeBackend: true,
  32     includeAssociatedRepo: true
  33   });
  34
  35   return restSerializer.serializeObject(troupe, strategy);
  36 }
  37
  38 function serializeGroup(group, user) {
  39   var strategy = new restSerializer.GroupStrategy({
  40     currentUser: user,
  41     currentUserId: user && user._id
  42   });
  43
  44   return restSerializer.serializeObject(group, strategy);
  45 }
  46
  47 function serializeTroupeId(troupeId, user) {
  48   var strategy = new restSerializer.TroupeIdStrategy({
  49     currentUserId: user ? user.id : null,
  50     currentUser: user,
  51     includePermissions: true,
  52     includeOwner: true,
  53     includeGroups: true,
  54     includeBackend: true,
  55     includeAssociatedRepo: true
  56   });
  57
  58   return restSerializer.serializeObject(troupeId, strategy);
  59 }
  60
  61 /**
  62  * Returns the promise of a mini-context
  63  */
  64 function generateMainMenuContext(req) {
  65   var user = req.user;
  66   var uriContext = req.uriContext;
  67
  68   var troupe = uriContext && uriContext.troupe;
  69   const group = uriContext && uriContext.group;
  70   var roomMember = uriContext && uriContext.roomMember;
  71
  72   return Promise.all([
  73     contextGeneratorRequest(req),
  74     user ? serializeUser(user) : null,
  75     serializeGroup(group, user),
  76     troupe ? serializeTroupe(troupe, user) : undefined
  77   ]).spread(function(reqContextHash, serializedUser, serializedGroup, serializedTroupe) {
  78     var serializedContext = _.extend({}, reqContextHash, {
  79       roomMember: roomMember,
  80       user: serializedUser,
  81       group: serializedGroup,
  82       troupe: serializedTroupe
  83     });
  84
  85     return serializedContext;
  86   });
  87 }
  88
  89 async function generateOrgContext(req) {
  90   const { user } = req;
  91   const { uriContext } = req;
  92   assert(uriContext);
  93   const { group } = uriContext;
  94   assert(group);
  95
  96   const [basicContext, serializedGroup] = await Promise.all([
  97     generateBasicContext(req),
  98     serializeGroup(group, user)
  99   ]);
 100
 101   return _.extend({}, basicContext, {
 102     group: serializedGroup
 103   });
 104 }
 105
 106 function generateBasicContext(req) {
 107   var user = req.user;
 108
 109   return Promise.all([contextGeneratorRequest(req), user ? serializeUser(user) : null]).spread(
 110     function(reqContextHash, serializedUser) {
 111       return _.extend({}, reqContextHash, {
 112         user: serializedUser
 113       });
 114     }
 115   );
 116 }
 117
 118 /**
 119  * Generates a context for sending over a bayeux connection
 120  */
 121 function generateSocketContext(userId, troupeId) {
 122   function getUser() {
 123     if (!userId) return Promise.resolve(null);
 124     return userService.findById(userId);
 125   }
 126
 127   return getUser()
 128     .then(function(user) {
 129       return [user && serializeUser(user), troupeId && serializeTroupeId(troupeId, user)];
 130     })
 131     .spread(function(serializedUser, serializedTroupe) {
 132       return {
 133         user: serializedUser || undefined,
 134         troupe: serializedTroupe || undefined
 135       };
 136     });
 137 }
 138
 139 /**
 140  * Generates the context to send for a main-frame
 141  */
 142 function generateTroupeContext(req, extras) {
 143   var user = req.user;
 144   var uriContext = req.uriContext;
 145   var troupe = uriContext && uriContext.troupe;
 146   var roomMember = uriContext && uriContext.roomMember;
 147
 148   debug(
 149     `generateTroupeContext -> roomMember=${roomMember} ${
 150       troupe ? `troupe=${troupe.lcUri}(${troupe._id})` : ''
 151     } ${user ? `user=${user.username}(${user._id})` : ''}`
 152   );
 153
 154   return Promise.all([
 155     contextGeneratorRequest(req),
 156     user ? serializeUser(user) : null,
 157     troupe ? serializeTroupe(troupe, user) : undefined,
 158     // TODO: if we keep serializing troupes with metadata, we can replace following with troupe.meta.welcomeMessage
 159     troupe && troupe._id
 160       ? roomMetaService.findMetaByTroupeId(troupe._id, ['welcomeMessage'])
 161       : false
 162   ]).spread(function(reqContextHash, serializedUser, serializedTroupe, { welcomeMessage }) {
 163     var roomHasWelcomeMessage = !!(
 164       welcomeMessage &&
 165       welcomeMessage.text &&
 166       welcomeMessage.text.length
 167     );
 168
 169     return _.extend(
 170       {},
 171       reqContextHash,
 172       {
 173         roomMember: roomMember,
 174         user: serializedUser,
 175         troupe: serializedTroupe,
 176         roomHasWelcomeMessage: roomHasWelcomeMessage
 177       },
 178       extras
 179     );
 180   });
 181 }
 182
 183 module.exports = {
 184   generateBasicContext,
 185   generateMainMenuContext,
 186   generateSocketContext,
 187   generateTroupeContext,
 188   generateOrgContext
 189 };