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

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