ecomp-portal-BE-common/src/main/java/org/openecomp/portalapp/portal/controller/FunctionalMenuController.java

   1 /*-\r
   2  * ================================================================================\r
   3  * ECOMP Portal\r
   4  * ================================================================================\r
   5  * Copyright (C) 2017 AT&T Intellectual Property\r
   6  * ================================================================================\r
   7  * Licensed under the Apache License, Version 2.0 (the "License");\r
   8  * you may not use this file except in compliance with the License.\r
   9  * You may obtain a copy of the License at\r
  10  * \r
  11  *      http://www.apache.org/licenses/LICENSE-2.0\r
  12  * \r
  13  * Unless required by applicable law or agreed to in writing, software\r
  14  * distributed under the License is distributed on an "AS IS" BASIS,\r
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  * See the License for the specific language governing permissions and\r
  17  * limitations under the License.\r
  18  * ================================================================================\r
  19  */\r
  20 package org.openecomp.portalapp.portal.controller;\r
  21 \r
  22 import java.io.IOException;\r
  23 import java.text.SimpleDateFormat;\r
  24 import java.util.ArrayList;\r
  25 import java.util.Collections;\r
  26 import java.util.Comparator;\r
  27 import java.util.Date;\r
  28 import java.util.HashMap;\r
  29 import java.util.List;\r
  30 import java.util.Map;\r
  31 \r
  32 import javax.servlet.http.HttpServletRequest;\r
  33 import javax.servlet.http.HttpServletResponse;\r
  34 \r
  35 import org.apache.cxf.transport.http.HTTPException;\r
  36 import org.json.JSONObject;\r
  37 import org.springframework.beans.factory.annotation.Autowired;\r
  38 import org.springframework.context.annotation.EnableAspectJAutoProxy;\r
  39 import org.springframework.web.bind.annotation.PathVariable;\r
  40 import org.springframework.web.bind.annotation.RequestBody;\r
  41 import org.springframework.web.bind.annotation.RequestMapping;\r
  42 import org.springframework.web.bind.annotation.RequestMethod;\r
  43 import org.springframework.web.bind.annotation.RequestParam;\r
  44 import org.springframework.web.bind.annotation.RestController;\r
  45 \r
  46 import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate;\r
  47 import org.openecomp.portalsdk.core.service.UserProfileService;\r
  48 import org.openecomp.portalapp.controller.EPRestrictedBaseController;\r
  49 import org.openecomp.portalapp.portal.domain.EPUser;\r
  50 import org.openecomp.portalapp.portal.domain.SharedContext;\r
  51 import org.openecomp.portalapp.portal.logging.aop.EPAuditLog;\r
  52 import org.openecomp.portalapp.portal.service.AdminRolesService;\r
  53 import org.openecomp.portalapp.portal.service.EPAuditService;\r
  54 import org.openecomp.portalapp.portal.service.FunctionalMenuService;\r
  55 import org.openecomp.portalapp.portal.service.SearchService;\r
  56 import org.openecomp.portalapp.portal.service.SharedContextService;\r
  57 import org.openecomp.portalapp.portal.transport.BusinessCardApplicationRole;\r
  58 import org.openecomp.portalapp.portal.transport.BusinessCardApplicationRolesList;\r
  59 import org.openecomp.portalapp.portal.transport.FavoritesFunctionalMenuItem;\r
  60 import org.openecomp.portalapp.portal.transport.FavoritesFunctionalMenuItemJson;\r
  61 import org.openecomp.portalapp.portal.transport.FieldsValidator;\r
  62 import org.openecomp.portalapp.portal.transport.FunctionalMenuItem;\r
  63 import org.openecomp.portalapp.portal.transport.FunctionalMenuItemWithRoles;\r
  64 import org.openecomp.portalapp.portal.utils.EPCommonSystemProperties;\r
  65 import org.openecomp.portalapp.portal.utils.EcompPortalUtils;\r
  66 import org.openecomp.portalapp.util.EPUserUtils;\r
  67 \r
  68 /**\r
  69  * Supports menus at the top of the Portal app landing page.\r
  70  */\r
  71 @RestController\r
  72 @org.springframework.context.annotation.Configuration\r
  73 @EnableAspectJAutoProxy\r
  74 @EPAuditLog\r
  75 public class FunctionalMenuController extends EPRestrictedBaseController {\r
  76         EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(FunctionalMenuController.class);\r
  77 \r
  78         @Autowired\r
  79         AdminRolesService adminRolesService;\r
  80         @Autowired\r
  81         FunctionalMenuService functionalMenuService;\r
  82         @Autowired\r
  83         SharedContextService sharedContextService;\r
  84         @Autowired\r
  85         UserProfileService service;\r
  86         @Autowired\r
  87         SearchService searchService;\r
  88         @Autowired\r
  89         EPAuditService epAuditService;\r
  90 \r
  91         /**\r
  92          * RESTful service method to fetch all the FunctionalMenuItems.\r
  93          * \r
  94          * @return List of FunctionalMenuItem objects\r
  95          */\r
  96         @RequestMapping(value = { "/portalApi/functionalMenu" }, method = RequestMethod.GET, produces = "application/json")\r
  97         public List<FunctionalMenuItem> getMenuItems(HttpServletRequest request, HttpServletResponse response) {\r
  98                 // TODO: should only the superuser be allowed to use this API?\r
  99                 List<FunctionalMenuItem> menuItems = null;\r
 100                 try {\r
 101                         menuItems = functionalMenuService.getFunctionalMenuItems();\r
 102                         functionalMenuService.assignHelpURLs(menuItems);\r
 103                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenu", "result =", menuItems);\r
 104                 } catch (Exception e) {\r
 105                         logger.error(EELFLoggerDelegate.errorLogger,\r
 106                                         "Exception occurred while calling functionalMenu. Details: " + EcompPortalUtils.getStackTrace(e));\r
 107                 }\r
 108                 return menuItems;\r
 109         }\r
 110 \r
 111         /**\r
 112          * RESTful service method to fetch all the FunctionalMenuItems, both active\r
 113          * and inactive, for the EditFunctionalMenu feature. Can only be accessed by\r
 114          * the portal admin.\r
 115          * \r
 116          * @return List of FunctionalMenuItem objects\r
 117          */\r
 118         @RequestMapping(value = {\r
 119                         "/portalApi/functionalMenuForEditing" }, method = RequestMethod.GET, produces = "application/json")\r
 120         public List<FunctionalMenuItem> getMenuItemsForEditing(HttpServletRequest request, HttpServletResponse response) {\r
 121                 // TODO: should only the superuser be allowed to use this API?\r
 122                 EPUser user = EPUserUtils.getUserSession(request);\r
 123                 List<FunctionalMenuItem> menuItems = null;\r
 124                 try {\r
 125                         if (!adminRolesService.isSuperAdmin(user)) {\r
 126                                 EcompPortalUtils.setBadPermissions(user, response, "getFunctionalMenuItemDetails");\r
 127                         } else {\r
 128                                 menuItems = functionalMenuService.getFunctionalMenuItems(true);\r
 129                         }\r
 130                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuForEditing", "result =", menuItems);\r
 131                 } catch (Exception e) {\r
 132                         logger.error(EELFLoggerDelegate.errorLogger,\r
 133                                         "Exception occurred while calling functionalMenuForEditing. Details: "\r
 134                                                         + EcompPortalUtils.getStackTrace(e));\r
 135                 }\r
 136                 return menuItems;\r
 137         }\r
 138         \r
 139         /**\r
 140          * RESTful service method to fetch all the FunctionalMenuItems,  active\r
 141          *, for the Functional menu in notification Tree feature.\r
 142          * \r
 143          * @return List of FunctionalMenuItem objects\r
 144          */\r
 145         @RequestMapping(value = {\r
 146                         "/portalApi/functionalMenuForNotificationTree" }, method = RequestMethod.GET, produces = "application/json")\r
 147         public List<FunctionalMenuItem> getMenuItemsForNotifications(HttpServletRequest request, HttpServletResponse response) {\r
 148                 // TODO: should only the superuser be allowed to use this API?\r
 149                 EPUser user = EPUserUtils.getUserSession(request);\r
 150                 List<FunctionalMenuItem> menuItems = null;\r
 151                 try {\r
 152                         menuItems = functionalMenuService.getFunctionalMenuItemsForNotificationTree(true);\r
 153                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuForNotificationTree", "result =", menuItems);\r
 154                 } catch (Exception e) {\r
 155                         logger.error(EELFLoggerDelegate.errorLogger,\r
 156                                         "Exception occurred while calling functionalMenuForNotifications. Details: "\r
 157                                                         + EcompPortalUtils.getStackTrace(e));\r
 158                 }\r
 159                 return menuItems;\r
 160         }\r
 161 \r
 162         /**\r
 163          * RESTful service method to fetch all FunctionalMenuItems associated with\r
 164          * an application.\r
 165          * \r
 166          * @return List of FunctionalMenuItem objects\r
 167          */\r
 168         @RequestMapping(value = {\r
 169                         "/portalApi/functionalMenuForApp/{appId}" }, method = RequestMethod.GET, produces = "application/json")\r
 170         public List<FunctionalMenuItem> getMenuItemsForApp(HttpServletRequest request, @PathVariable("appId") Integer appId)\r
 171                         throws HTTPException {\r
 172                 // TODO: should only the superuser be allowed to use this API?\r
 173                 List<FunctionalMenuItem> menuItems = null;\r
 174                 try {\r
 175                         menuItems = functionalMenuService.getFunctionalMenuItemsForApp(appId);\r
 176                         functionalMenuService.assignHelpURLs(menuItems);\r
 177                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuForApp/" + appId, "result =", menuItems);\r
 178                 } catch (Exception e) {\r
 179                         logger.error(EELFLoggerDelegate.errorLogger,\r
 180                                         "Exception occurred while calling functionalMenuForApp. Details: "\r
 181                                                         + EcompPortalUtils.getStackTrace(e));\r
 182                 }\r
 183                 return menuItems;\r
 184         }\r
 185 \r
 186         /**\r
 187          * RESTful service method to fetch all FunctionalMenuItems associated with\r
 188          * the applications and roles that a user has access to.\r
 189          * \r
 190          * @return List of FunctionalMenuItem objects\r
 191          */\r
 192         @RequestMapping(value = {\r
 193                         "/portalApi/functionalMenuForUser/{orgUserId}" }, method = RequestMethod.GET, produces = "application/json")\r
 194         public List<FunctionalMenuItem> getMenuItemsForUser(HttpServletRequest request,\r
 195                         @PathVariable("orgUserId") String orgUserId) throws HTTPException {\r
 196                 // TODO: should only the superuser be allowed to use this API?\r
 197                 List<FunctionalMenuItem> menuItems = null;\r
 198                 try {\r
 199                         menuItems = functionalMenuService.getFunctionalMenuItemsForUser(orgUserId);\r
 200                         functionalMenuService.assignHelpURLs(menuItems);\r
 201                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuForUser/" + orgUserId, "result =", menuItems);\r
 202                 } catch (Exception e) {\r
 203                         logger.error(EELFLoggerDelegate.errorLogger,\r
 204                                         "Exception occurred while calling functionalMenuForUser. Details: "\r
 205                                                         + EcompPortalUtils.getStackTrace(e));\r
 206                 }\r
 207 \r
 208                 return menuItems;\r
 209         }\r
 210 \r
 211         /**\r
 212          * RESTful service method to fetch all FunctionalMenuItems associated with\r
 213          * the applications and roles that the authenticated user has access to.\r
 214          * \r
 215          * @return List of FunctionalMenuItem objects\r
 216          */\r
 217         @RequestMapping(value = {\r
 218                         "/portalApi/functionalMenuForAuthUser" }, method = RequestMethod.GET, produces = "application/json")\r
 219         public List<FunctionalMenuItem> getMenuItemsForAuthUser(HttpServletRequest request, HttpServletResponse response) {\r
 220                 EPUser user = EPUserUtils.getUserSession(request);\r
 221                 List<FunctionalMenuItem> menuItems = null;\r
 222                 try {\r
 223                         if (user == null) {\r
 224                                 EcompPortalUtils.setBadPermissions(user, response, "getMenuItemsForAuthUser");\r
 225                         } else if (adminRolesService.isSuperAdmin(user)) {\r
 226                                 menuItems = functionalMenuService.getFunctionalMenuItems();\r
 227                         } else {\r
 228                                 // calculate the menu items\r
 229                                 String orgUserId = user.getOrgUserId();\r
 230                                 menuItems = functionalMenuService.getFunctionalMenuItemsForUser(orgUserId);\r
 231                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuForUser/" + orgUserId, "result =",\r
 232                                                 menuItems);\r
 233                         }\r
 234                         functionalMenuService.assignHelpURLs(menuItems);\r
 235                 } catch (Exception e) {\r
 236                         logger.error(EELFLoggerDelegate.errorLogger,\r
 237                                         "Exception occurred while calling getMenuItemsForAuthUser. Details: "\r
 238                                                         + EcompPortalUtils.getStackTrace(e));\r
 239                 }\r
 240                 return menuItems;\r
 241         }\r
 242 \r
 243         /**\r
 244          * RESTful service method to fetch the details for a functional menu item.\r
 245          * Requirement: you must be the Ecomp portal super admin user.\r
 246          * \r
 247          * @return FunctionalMenuItem object\r
 248          */\r
 249         @RequestMapping(value = {\r
 250                         "/portalApi/functionalMenuItemDetails/{menuId}" }, method = RequestMethod.GET, produces = "application/json")\r
 251         public FunctionalMenuItem getFunctionalMenuItemDetails(HttpServletRequest request,\r
 252                         @PathVariable("menuId") Integer menuId, HttpServletResponse response) throws HTTPException {\r
 253                 // TODO: return FunctionalMenuItemJson\r
 254                 // TODO: modify FunctionalMenuItem to not include the transient fields\r
 255                 FunctionalMenuItem menuItem = null;\r
 256                 try {\r
 257                         EPUser user = EPUserUtils.getUserSession(request);\r
 258                         if (!adminRolesService.isSuperAdmin(user)) {\r
 259                                 EcompPortalUtils.setBadPermissions(user, response, "getFunctionalMenuItemDetails");\r
 260                         } else {\r
 261                                 menuItem = functionalMenuService.getFunctionalMenuItemDetails(menuId);\r
 262                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuItemDetails/" + menuId, "result =",\r
 263                                                 menuItem);\r
 264                         }\r
 265                 } catch (Exception e) {\r
 266                         logger.error(EELFLoggerDelegate.errorLogger,\r
 267                                         "Exception occurred while calling functionalMenuItemDetails. Details: "\r
 268                                                         + EcompPortalUtils.getStackTrace(e));\r
 269                 }\r
 270 \r
 271                 return menuItem;\r
 272         }\r
 273 \r
 274         /**\r
 275          * RESTful service method to create a new menu item.\r
 276          * \r
 277          * Requirement: you must be the Ecomp portal super admin user.\r
 278          */\r
 279         @RequestMapping(value = { "/portalApi/functionalMenuItem" }, method = RequestMethod.POST)\r
 280         public FieldsValidator createFunctionalMenuItem(HttpServletRequest request,\r
 281                         @RequestBody FunctionalMenuItemWithRoles menuItemJson, HttpServletResponse response) {\r
 282                 EPUser user = EPUserUtils.getUserSession(request);\r
 283                 FieldsValidator fieldsValidator = null;\r
 284                 if (!adminRolesService.isSuperAdmin(user)) {\r
 285                         logger.debug(EELFLoggerDelegate.debugLogger,\r
 286                                         "FunctionalMenuController.createFunctionalMenuItem bad permissions");\r
 287                         EcompPortalUtils.setBadPermissions(user, response, "createFunctionalMenuItem");\r
 288                 } else {\r
 289                         fieldsValidator = functionalMenuService.createFunctionalMenuItem(menuItemJson);\r
 290                         response.setStatus(fieldsValidator.httpStatusCode.intValue());\r
 291                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuItem", "POST result =",\r
 292                                         response.getStatus());\r
 293                 }\r
 294 \r
 295                 return fieldsValidator;\r
 296         }\r
 297 \r
 298         /**\r
 299          * RESTful service method to update an existing menu item\r
 300          * \r
 301          * Requirement: you must be the Ecomp portal super admin user.\r
 302          * \r
 303          * @return FieldsValidator\r
 304          */\r
 305         @RequestMapping(value = { "/portalApi/functionalMenuItem" }, method = RequestMethod.PUT)\r
 306         public FieldsValidator editFunctionalMenuItem(HttpServletRequest request,\r
 307                         @RequestBody FunctionalMenuItemWithRoles menuItemJson, HttpServletResponse response) {\r
 308                 EPUser user = EPUserUtils.getUserSession(request);\r
 309                 FieldsValidator fieldsValidator = null;\r
 310                 if (!adminRolesService.isSuperAdmin(user)) {\r
 311                         EcompPortalUtils.setBadPermissions(user, response, "editFunctionalMenuItem");\r
 312                 } else {\r
 313                         fieldsValidator = functionalMenuService.editFunctionalMenuItem(menuItemJson);\r
 314                         response.setStatus(fieldsValidator.httpStatusCode.intValue());\r
 315                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuItem", "PUT result =",\r
 316                                         response.getStatus());\r
 317                 }\r
 318 \r
 319                 return fieldsValidator;\r
 320         }\r
 321 \r
 322         /**\r
 323          * RESTful service method to delete a menu item\r
 324          * \r
 325          * @return FieldsValidator\r
 326          */\r
 327         @RequestMapping(value = { "/portalApi/functionalMenuItem/{menuId}" }, method = RequestMethod.DELETE)\r
 328         public FieldsValidator deleteFunctionalMenuItem(HttpServletRequest request, @PathVariable("menuId") Long menuId,\r
 329                         HttpServletResponse response) {\r
 330                 EPUser user = EPUserUtils.getUserSession(request);\r
 331                 FieldsValidator fieldsValidator = null;\r
 332                 if (!adminRolesService.isSuperAdmin(user)) {\r
 333                         EcompPortalUtils.setBadPermissions(user, response, "deleteFunctionalMenuItem");\r
 334                 } else {\r
 335                         fieldsValidator = functionalMenuService.deleteFunctionalMenuItem(menuId);\r
 336                         response.setStatus(fieldsValidator.httpStatusCode.intValue());\r
 337                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuItem", "DELETE result =",\r
 338                                         response.getStatus());\r
 339                 }\r
 340 \r
 341                 return fieldsValidator;\r
 342         }\r
 343 \r
 344         /**\r
 345          * RESTful service to regenerate table\r
 346          * \r
 347          * @param request\r
 348          * @param response\r
 349          * \r
 350          * @return FieldsValidator\r
 351          */\r
 352         @RequestMapping(value = { "/portalApi/regenerateFunctionalMenuAncestors" }, method = RequestMethod.GET)\r
 353         public FieldsValidator regenerateAncestorTable(HttpServletRequest request, HttpServletResponse response) {\r
 354                 // TODO: should only the superuser be allowed to use this API?\r
 355                 EPUser user = EPUserUtils.getUserSession(request);\r
 356                 FieldsValidator fieldsValidator = null;\r
 357 \r
 358                 if (!adminRolesService.isSuperAdmin(user)) {\r
 359                         EcompPortalUtils.setBadPermissions(user, response, "deleteFunctionalMenuItem");\r
 360                 } else {\r
 361                         fieldsValidator = functionalMenuService.regenerateAncestorTable();\r
 362                         response.setStatus(fieldsValidator.httpStatusCode.intValue());\r
 363                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/regenerateAncestorTable", "GET result =",\r
 364                                         response.getStatus());\r
 365                 }\r
 366 \r
 367                 return fieldsValidator;\r
 368         }\r
 369 \r
 370         /**\r
 371          * RESful service to set a favorite item.\r
 372          * \r
 373          * @return FieldsValidator\r
 374          */\r
 375         @RequestMapping(value = { "/portalApi/setFavoriteItem" }, method = RequestMethod.POST)\r
 376         public FieldsValidator addFavoriteItem(HttpServletRequest request,\r
 377                         @RequestBody FavoritesFunctionalMenuItem menuItemJson, HttpServletResponse response) {\r
 378                 EPUser user = EPUserUtils.getUserSession(request);\r
 379                 FieldsValidator fieldsValidator = null;\r
 380                 menuItemJson.userId = user.getId();\r
 381                 fieldsValidator = functionalMenuService.setFavoriteItem(menuItemJson);\r
 382                 response.setStatus(fieldsValidator.httpStatusCode.intValue());\r
 383                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/setFavoriteItem", "Post result =", response.getStatus());\r
 384 \r
 385                 return fieldsValidator;\r
 386         }\r
 387 \r
 388         /**\r
 389          * RESTful service to get favorites for the current user as identified in\r
 390          * the session\r
 391          * \r
 392          * @return List of FavoritesFunctionalMenuItemJson\r
 393          */\r
 394         @RequestMapping(value = {\r
 395                         "/portalApi/getFavoriteItems" }, method = RequestMethod.GET, produces = "application/json")\r
 396         public List<FavoritesFunctionalMenuItemJson> getFavoritesForUser(HttpServletRequest request,\r
 397                         HttpServletResponse response) {\r
 398                 EPUser user = EPUserUtils.getUserSession(request);\r
 399                 List<FavoritesFunctionalMenuItemJson> favorites = functionalMenuService.getFavoriteItems(user.getId());\r
 400                 FieldsValidator fieldsValidator = new FieldsValidator();\r
 401                 response.setStatus(fieldsValidator.httpStatusCode.intValue());\r
 402                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/getFavoriteItems", "GET result =", response.getStatus());\r
 403                 return favorites;\r
 404         }\r
 405 \r
 406         /**\r
 407          * RESTful service to delete a favorite menu item for the current user as\r
 408          * identified in the session.\r
 409          * \r
 410          * @return FieldsValidator\r
 411          */\r
 412         @RequestMapping(value = { "/portalApi/removeFavoriteItem/{menuId}" }, method = RequestMethod.DELETE)\r
 413         public FieldsValidator deleteFavoriteItem(HttpServletRequest request, @PathVariable("menuId") Long menuId,\r
 414                         HttpServletResponse response) {\r
 415                 EPUser user = EPUserUtils.getUserSession(request);\r
 416                 FieldsValidator fieldsValidator = null;\r
 417                 Long userId = user.getId();\r
 418                 fieldsValidator = functionalMenuService.removeFavoriteItem(userId, menuId);\r
 419                 response.setStatus(fieldsValidator.httpStatusCode.intValue());\r
 420                 EcompPortalUtils.logAndSerializeObject(logger, "/deleteFavoriteItem", "DELETE result =", response.getStatus());\r
 421 \r
 422                 return fieldsValidator;\r
 423         }\r
 424 \r
 425         /**\r
 426          * RESTful service to get user information: user's first and last names, ATT\r
 427          * UID, email and last-login. (Actually has nothing to do with the real\r
 428          * functional menu.) First attempts to get the information from the Tomcat\r
 429          * session (i.e., the CSP cookie); if that fails, calls the shared context\r
 430          * service to read the information from the database. Gives back what it\r
 431          * found, any of which may be null, as a JSON collection.\r
 432          * \r
 433          * @return JSON collection of key-value pairs shown below.\r
 434          */\r
 435         @RequestMapping(value = {\r
 436                         "/portalApi/functionalMenuStaticInfo" }, method = RequestMethod.GET, produces = "application/json")\r
 437         public String getFunctionalMenuStaticInfo(HttpServletRequest request, HttpServletResponse response) {\r
 438 \r
 439                 // Get user details from session\r
 440                 logger.debug(EELFLoggerDelegate.debugLogger, "getFunctionalMenuStaticInfo: getting user info");\r
 441                 String fnMenuStaticResponse = null;\r
 442                 try {                   \r
 443                         String orgUserIdStr = null, firstNameStr = null, lastNameStr = null, emailStr = null, lastLogin = null;\r
 444                         EPUser user = EPUserUtils.getUserSession(request);\r
 445                         firstNameStr = user.getFirstName();\r
 446                         lastNameStr = user.getLastName();\r
 447                         orgUserIdStr = user.getOrgUserId();\r
 448                         emailStr = user.getEmail();\r
 449                         if (emailStr == null || emailStr.equals("")) {\r
 450                                 EPUser userResult = searchService.searchUserByUserId(orgUserIdStr);\r
 451                                 emailStr = userResult.getEmail();\r
 452                         }\r
 453                         SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy hh:mm:ssZ");\r
 454                         Date lastLoginDate = user.getLastLoginDate();\r
 455                         if (lastLoginDate == null) {\r
 456                                 // should never happen\r
 457                                 logger.error(EELFLoggerDelegate.errorLogger, "getFunctionalMenuStaticInfo: no last login in session");\r
 458                                 lastLogin = "no last login available";\r
 459                         }\r
 460                         else {\r
 461                                 lastLogin = sdf.format(lastLoginDate);\r
 462                         }\r
 463                         \r
 464                         // If any item is missing from session, try the Shared Context\r
 465                         // service.\r
 466                         SharedContext orgUserIdSC = null, firstNameSC = null, lastNameSC = null, emailSC = null;\r
 467                         String sessionId = request.getSession().getId();\r
 468                         if (firstNameStr == null)\r
 469                                 firstNameSC = sharedContextService.getSharedContext(sessionId, EPCommonSystemProperties.USER_FIRST_NAME);\r
 470                         if (lastNameStr == null)\r
 471                                 lastNameSC = sharedContextService.getSharedContext(sessionId, EPCommonSystemProperties.USER_LAST_NAME);\r
 472                         if (emailStr == null)\r
 473                                 emailSC = sharedContextService.getSharedContext(sessionId, EPCommonSystemProperties.USER_EMAIL);\r
 474                         if (orgUserIdStr == null)\r
 475                                 orgUserIdSC = sharedContextService.getSharedContext(sessionId, EPCommonSystemProperties.USER_ORG_USERID);\r
 476 \r
 477                         // Build the response\r
 478                         Map<String, String> map = new HashMap<String, String>();\r
 479                         map.put("firstName",\r
 480                                         firstNameStr != null ? firstNameStr : (firstNameSC != null ? firstNameSC.getCvalue() : null));\r
 481                         map.put("lastName",\r
 482                                         lastNameStr != null ? lastNameStr : (lastNameSC != null ? lastNameSC.getCvalue() : null));\r
 483                         map.put("email", emailStr != null ? emailStr : (emailSC != null ? emailSC.getCvalue() : null));\r
 484                         map.put("userId", orgUserIdStr != null ? orgUserIdStr : (orgUserIdSC != null ? orgUserIdSC.getCvalue() : null));\r
 485                         map.put("last_login", lastLogin);\r
 486                         JSONObject j = new JSONObject(map);\r
 487                         fnMenuStaticResponse = j.toString();\r
 488                         // Be chatty in the log\r
 489                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuStaticInfo", "GET result =",\r
 490                                         fnMenuStaticResponse);\r
 491                 } catch (Exception e) {\r
 492                         // Should never happen.\r
 493                         logger.error(EELFLoggerDelegate.errorLogger, "getFunctionalMenuStaticInfo failed", e);\r
 494                         // Return a real error?\r
 495                         // fnMenuStaticResponse = "{ \"status\": \"error\", \"message\": \""\r
 496                         // + e.toString() + "\" }";\r
 497                         // But the angular controller expects null on error.\r
 498                 }\r
 499                 return fnMenuStaticResponse;\r
 500         }\r
 501         \r
 502         private Comparator<BusinessCardApplicationRole> getUserAppRolesComparator = new Comparator<BusinessCardApplicationRole>() {\r
 503                 public int compare(BusinessCardApplicationRole o1, BusinessCardApplicationRole o2) {\r
 504                         return o1.getAppName().compareTo(o2.getAppName());\r
 505                 }\r
 506         };\r
 507 \r
 508         @RequestMapping(value = {\r
 509                         "/portalApi/userApplicationRoles" }, method = RequestMethod.GET, produces = "application/json")\r
 510         public List<BusinessCardApplicationRolesList> getAppList(HttpServletRequest request,@RequestParam("userId") String userId) throws IOException {\r
 511 \r
 512                 \r
 513                 List<BusinessCardApplicationRolesList> AppRoles = null;\r
 514                 try {\r
 515                         List<BusinessCardApplicationRole> userAppRoleList = functionalMenuService.getUserAppRolesList(userId);\r
 516                         \r
 517                         Collections.sort(userAppRoleList, getUserAppRolesComparator);\r
 518                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userApplicationRoles", "result =", userAppRoleList);\r
 519                         \r
 520                          AppRoles = new ArrayList<BusinessCardApplicationRolesList>();     \r
 521                         for(BusinessCardApplicationRole userAppRole: userAppRoleList)\r
 522                         {    \r
 523                                   boolean found = false;\r
 524                               List<String> roles = null;\r
 525                              \r
 526                                 for(BusinessCardApplicationRolesList app :AppRoles)\r
 527                                 {       \r
 528                                         if(app.getAppName().equals(userAppRole.getAppName()))\r
 529                                         {\r
 530                                                 roles= app.getRoleNames();\r
 531                                                 roles.add(userAppRole.getRoleName());\r
 532                                                 app.setRoleNames(roles);\r
 533                                                 found = true;   \r
 534                                                 break;  \r
 535                                         }\r
 536                                 }\r
 537                                 \r
 538                                 if(!found)\r
 539                                 {\r
 540                                 roles = new ArrayList<String>();        \r
 541                                 roles.add(userAppRole.getRoleName());\r
 542                                 AppRoles.add(new BusinessCardApplicationRolesList(userAppRole.getAppName(), roles));\r
 543                                 }       \r
 544                                 \r
 545                                 Collections.sort(roles);\r
 546                         }\r
 547                 } catch (Exception e) {\r
 548                         // TODO Auto-generated catch block\r
 549                         logger.error(EELFLoggerDelegate.errorLogger, "getAppList failed", e);\r
 550                 }\r
 551 \r
 552         return  AppRoles;\r
 553 \r
 554         }\r
 555 }\r