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
 271                 EPUser user = EPUserUtils.getUserSession(request);
 272                 List<FunctionalMenuItem> menuItems = null;
 273                 try {
 274                         if (user == null) {
 275                                 EcompPortalUtils.setBadPermissions(user, response, "getMenuItemsForAuthUser");
 276                         } else if (adminRolesService.isSuperAdmin(user)) {
 277                                 menuItems = functionalMenuService.getFunctionalMenuItems();
 278                         } else {
 279                                 // calculate the menu items
 280                                 String orgUserId = user.getOrgUserId();
 281                                 menuItems = functionalMenuService.getFunctionalMenuItemsForUser(orgUserId);
 282                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuForUser/" + orgUserId,
 283                                                 "result =", menuItems);
 284                         }
 285                         functionalMenuService.assignHelpURLs(menuItems);
 286                 } catch (Exception e) {
 287                         logger.error(EELFLoggerDelegate.errorLogger,
 288                                         "Exception occurred while calling getMenuItemsForAuthUser. Details: "
 289                                                         + EcompPortalUtils.getStackTrace(e));
 290                 }
 291                 return menuItems;
 292         }
 293
 294         /**
 295          * RESTful service method to fetch the details for a functional menu item.
 296          * Requirement: you must be the Ecomp portal super admin user.
 297          *
 298          * @param request
 299          *            HttpServletRequest
 300          * @param response
 301          *            HttpServletResponse
 302          * @param menuId
 303          *            menu ID
 304          * @return FunctionalMenuItem object
 305          */
 306         @RequestMapping(value = {
 307                         "/portalApi/functionalMenuItemDetails/{menuId}" }, method = RequestMethod.GET, produces = "application/json")
 308         public FunctionalMenuItem getFunctionalMenuItemDetails(HttpServletRequest request,
 309                         @PathVariable("menuId") Integer menuId, HttpServletResponse response) {
 310                 // TODO: return FunctionalMenuItemJson
 311                 // TODO: modify FunctionalMenuItem to not include the transient fields
 312                 FunctionalMenuItem menuItem = null;
 313                 try {
 314                         EPUser user = EPUserUtils.getUserSession(request);
 315                         if (!adminRolesService.isSuperAdmin(user)) {
 316                                 EcompPortalUtils.setBadPermissions(user, response, "getFunctionalMenuItemDetails");
 317                         } else {
 318                                 menuItem = functionalMenuService.getFunctionalMenuItemDetails(menuId);
 319                                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuItemDetails/" + menuId,
 320                                                 "result =", menuItem);
 321                         }
 322                 } catch (Exception e) {
 323                         logger.error(EELFLoggerDelegate.errorLogger,
 324                                         "Exception occurred while calling functionalMenuItemDetails. Details: "
 325                                                         + EcompPortalUtils.getStackTrace(e));
 326                 }
 327
 328                 return menuItem;
 329         }
 330
 331         /**
 332          * RESTful service method to create a new menu item.
 333          *
 334          * Requirement: you must be the Ecomp portal super admin user.
 335          *
 336          * @param request
 337          *            HttpServletRequest
 338          * @param response
 339          *            HttpServletResponse
 340          * @param menuItemJson
 341          *            FunctionalMenuItemWithRoles
 342          * @return FieldsValidator
 343          */
 344         @RequestMapping(value = { "/portalApi/functionalMenuItem" }, method = RequestMethod.POST)
 345         public FieldsValidator createFunctionalMenuItem(HttpServletRequest request,
 346                         @RequestBody FunctionalMenuItemWithRoles menuItemJson, HttpServletResponse response) {
 347                 EPUser user = EPUserUtils.getUserSession(request);
 348                 FieldsValidator fieldsValidator = null;
 349                 if (!adminRolesService.isSuperAdmin(user)) {
 350                         logger.debug(EELFLoggerDelegate.debugLogger,
 351                                         "FunctionalMenuController.createFunctionalMenuItem bad permissions");
 352                         EcompPortalUtils.setBadPermissions(user, response, "createFunctionalMenuItem");
 353                 } else {
 354                         fieldsValidator = functionalMenuService.createFunctionalMenuItem(menuItemJson);
 355                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 356                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuItem", "POST result =",
 357                                         response.getStatus());
 358                 }
 359
 360                 return fieldsValidator;
 361         }
 362
 363         /**
 364          * RESTful service method to update an existing menu item
 365          *
 366          * Requirement: you must be the Ecomp portal super admin user.
 367          *
 368          * @param request
 369          *            HttpServletRequest
 370          * @param response
 371          *            HttpServletResponse
 372          * @param menuItemJson
 373          *            FunctionalMenuItemWithRoles
 374          * @return FieldsValidator
 375          */
 376         @RequestMapping(value = { "/portalApi/functionalMenuItem" }, method = RequestMethod.PUT)
 377         public FieldsValidator editFunctionalMenuItem(HttpServletRequest request,
 378                         @RequestBody FunctionalMenuItemWithRoles menuItemJson, HttpServletResponse response) {
 379                 EPUser user = EPUserUtils.getUserSession(request);
 380                 FieldsValidator fieldsValidator = null;
 381                 if (!adminRolesService.isSuperAdmin(user)) {
 382                         EcompPortalUtils.setBadPermissions(user, response, "editFunctionalMenuItem");
 383                 } else {
 384                         fieldsValidator = functionalMenuService.editFunctionalMenuItem(menuItemJson);
 385                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 386                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuItem", "PUT result =",
 387                                         response.getStatus());
 388                 }
 389
 390                 return fieldsValidator;
 391         }
 392
 393         /**
 394          * RESTful service method to delete a menu item
 395          *
 396          * @param request
 397          *            HttpServletRequest
 398          * @param response
 399          *            HttpServletResponse
 400          * @param menuId
 401          *            menu identifier
 402          * @return FieldsValidator
 403          */
 404         @RequestMapping(value = { "/portalApi/functionalMenuItem/{menuId}" }, method = RequestMethod.DELETE)
 405         public FieldsValidator deleteFunctionalMenuItem(HttpServletRequest request, @PathVariable("menuId") Long menuId,
 406                         HttpServletResponse response) {
 407                 EPUser user = EPUserUtils.getUserSession(request);
 408                 FieldsValidator fieldsValidator = null;
 409                 if (!adminRolesService.isSuperAdmin(user)) {
 410                         EcompPortalUtils.setBadPermissions(user, response, "deleteFunctionalMenuItem");
 411                 } else {
 412                         fieldsValidator = functionalMenuService.deleteFunctionalMenuItem(menuId);
 413                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 414                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuItem", "DELETE result =",
 415                                         response.getStatus());
 416                 }
 417
 418                 return fieldsValidator;
 419         }
 420
 421         /**
 422          * RESTful service to regenerate table
 423          *
 424          * @param request
 425          *            HttpServletRequest
 426          * @param response
 427          *            HttpServletResponse
 428          * @return FieldsValidator
 429          */
 430         @RequestMapping(value = { "/portalApi/regenerateFunctionalMenuAncestors" }, method = RequestMethod.GET)
 431         public FieldsValidator regenerateAncestorTable(HttpServletRequest request, HttpServletResponse response) {
 432                 // TODO: should only the superuser be allowed to use this API?
 433                 EPUser user = EPUserUtils.getUserSession(request);
 434                 FieldsValidator fieldsValidator = null;
 435
 436                 if (!adminRolesService.isSuperAdmin(user)) {
 437                         EcompPortalUtils.setBadPermissions(user, response, "deleteFunctionalMenuItem");
 438                 } else {
 439                         fieldsValidator = functionalMenuService.regenerateAncestorTable();
 440                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 441                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/regenerateAncestorTable", "GET result =",
 442                                         response.getStatus());
 443                 }
 444
 445                 return fieldsValidator;
 446         }
 447
 448         /**
 449          * RESful service to set a favorite item.
 450          *
 451          * @param request
 452          *            HttpServletRequest
 453          * @param response
 454          *            HttpServletResponse
 455          * @param menuItemJson
 456          *            FunctionalMenuItemWithRoles
 457          * @return FieldsValidator
 458          */
 459         @RequestMapping(value = { "/portalApi/setFavoriteItem" }, method = RequestMethod.POST)
 460         public FieldsValidator addFavoriteItem(HttpServletRequest request,
 461                         @RequestBody FavoritesFunctionalMenuItem menuItemJson, HttpServletResponse response) {
 462                 EPUser user = EPUserUtils.getUserSession(request);
 463                 FieldsValidator fieldsValidator = null;
 464                 menuItemJson.userId = user.getId();
 465                 fieldsValidator = functionalMenuService.setFavoriteItem(menuItemJson);
 466                 response.setStatus(fieldsValidator.httpStatusCode.intValue());
 467                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/setFavoriteItem", "Post result =",
 468                                 response.getStatus());
 469
 470                 return fieldsValidator;
 471         }
 472
 473         /**
 474          * RESTful service to get favorites for the current user as identified in
 475          * the session
 476          *
 477          * @param request
 478          *            HttpServletRequest
 479          * @param response
 480          *            HttpServletResponse
 481          * @return List of FavoritesFunctionalMenuItemJson
 482          */
 483         @RequestMapping(value = {
 484                         "/portalApi/getFavoriteItems" }, method = RequestMethod.GET, produces = "application/json")
 485         public List<FavoritesFunctionalMenuItemJson> getFavoritesForUser(HttpServletRequest request,
 486                         HttpServletResponse response) {
 487                 EPUser user = EPUserUtils.getUserSession(request);
 488                 List<FavoritesFunctionalMenuItemJson> favorites = functionalMenuService.getFavoriteItems(user.getId());
 489                 FieldsValidator fieldsValidator = new FieldsValidator();
 490                 response.setStatus(fieldsValidator.httpStatusCode.intValue());
 491                 EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/getFavoriteItems", "GET result =",
 492                                 response.getStatus());
 493                 return favorites;
 494         }
 495
 496         /**
 497          * RESTful service to delete a favorite menu item for the current user as
 498          * identified in the session.
 499          *
 500          * @param request
 501          *            HttpServletRequest
 502          * @param response
 503          *            HttpServletResponse
 504          * @param menuId
 505          *            menu identifier
 506          * @return FieldsValidator
 507          */
 508         @RequestMapping(value = { "/portalApi/removeFavoriteItem/{menuId}" }, method = RequestMethod.DELETE)
 509         public FieldsValidator deleteFavoriteItem(HttpServletRequest request, @PathVariable("menuId") Long menuId,
 510                         HttpServletResponse response) {
 511                 EPUser user = EPUserUtils.getUserSession(request);
 512                 FieldsValidator fieldsValidator = null;
 513                 Long userId = user.getId();
 514                 fieldsValidator = functionalMenuService.removeFavoriteItem(userId, menuId);
 515                 response.setStatus(fieldsValidator.httpStatusCode.intValue());
 516                 EcompPortalUtils.logAndSerializeObject(logger, "/deleteFavoriteItem", "DELETE result =", response.getStatus());
 517
 518                 return fieldsValidator;
 519         }
 520
 521         /**
 522          * RESTful service to get user information: user's first and last names, org
 523          * user ID, email and last-login. (Actually has nothing to do with the real
 524          * functional menu.) First attempts to get the information from the Tomcat
 525          * session (i.e., the CSP cookie); if that fails, calls the shared context
 526          * service to read the information from the database. Gives back what it
 527          * found, any of which may be null, as a JSON collection.
 528          *
 529          * @param request
 530          *            HttpServletRequest
 531          * @param response
 532          *            HttpServletResponse
 533          * @return JSON collection of key-value pairs shown below.
 534          */
 535         @RequestMapping(value = {
 536                         "/portalApi/functionalMenuStaticInfo" }, method = RequestMethod.GET, produces = "application/json")
 537         public String getFunctionalMenuStaticInfo(HttpServletRequest request, HttpServletResponse response) {
 538
 539                 // Get user details from session
 540                 logger.debug(EELFLoggerDelegate.debugLogger, "getFunctionalMenuStaticInfo: getting user info");
 541                 String fnMenuStaticResponse = null;
 542                 try {
 543                         String orgUserIdStr = null, firstNameStr = null, lastNameStr = null, emailStr = null, lastLogin = null;
 544                         EPUser user = EPUserUtils.getUserSession(request);
 545                         firstNameStr = user.getFirstName();
 546                         lastNameStr = user.getLastName();
 547                         orgUserIdStr = user.getOrgUserId();
 548                         emailStr = user.getEmail();
 549                         if (emailStr == null || emailStr.equals("")) {
 550                                 EPUser userResult = searchService.searchUserByUserId(orgUserIdStr);
 551                                 emailStr = userResult.getEmail();
 552                         }
 553                         SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy hh:mm:ssZ");
 554                         Date lastLoginDate = user.getLastLoginDate();
 555                         if (lastLoginDate == null) {
 556                                 // should never happen
 557                                 logger.error(EELFLoggerDelegate.errorLogger, "getFunctionalMenuStaticInfo: no last login in session");
 558                                 lastLogin = "no last login available";
 559                         } else {
 560                                 lastLogin = sdf.format(lastLoginDate);
 561                         }
 562
 563                         // If any item is missing from session, try the Shared Context
 564                         // service.
 565                         SharedContext orgUserIdSC = null, firstNameSC = null, lastNameSC = null, emailSC = null;
 566                         String sessionId = request.getSession().getId();
 567                         if (firstNameStr == null)
 568                                 firstNameSC = sharedContextService.getSharedContext(sessionId,
 569                                                 EPCommonSystemProperties.USER_FIRST_NAME);
 570                         if (lastNameStr == null)
 571                                 lastNameSC = sharedContextService.getSharedContext(sessionId, EPCommonSystemProperties.USER_LAST_NAME);
 572                         if (emailStr == null)
 573                                 emailSC = sharedContextService.getSharedContext(sessionId, EPCommonSystemProperties.USER_EMAIL);
 574                         if (orgUserIdStr == null)
 575                                 orgUserIdSC = sharedContextService.getSharedContext(sessionId,
 576                                                 EPCommonSystemProperties.USER_ORG_USERID);
 577
 578                         // Build the response
 579                         Map<String, String> map = new HashMap<String, String>();
 580                         map.put("firstName",
 581                                         firstNameStr != null ? firstNameStr : (firstNameSC != null ? firstNameSC.getCvalue() : null));
 582                         map.put("lastName",
 583                                         lastNameStr != null ? lastNameStr : (lastNameSC != null ? lastNameSC.getCvalue() : null));
 584                         map.put("email", emailStr != null ? emailStr : (emailSC != null ? emailSC.getCvalue() : null));
 585                         map.put("userId",
 586                                         orgUserIdStr != null ? orgUserIdStr : (orgUserIdSC != null ? orgUserIdSC.getCvalue() : null));
 587                         map.put("last_login", lastLogin);
 588                         JSONObject j = new JSONObject(map);
 589                         fnMenuStaticResponse = j.toString();
 590                         // Be chatty in the log
 591                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/functionalMenuStaticInfo", "GET result =",
 592                                         fnMenuStaticResponse);
 593                 } catch (Exception e) {
 594                         // Should never happen.
 595                         logger.error(EELFLoggerDelegate.errorLogger, "getFunctionalMenuStaticInfo failed", e);
 596                         // Return a real error?
 597                         // fnMenuStaticResponse = "{ \"status\": \"error\", \"message\": \""
 598                         // + e.toString() + "\" }";
 599                         // But the angular controller expects null on error.
 600                 }
 601                 return fnMenuStaticResponse;
 602         }
 603
 604         private Comparator<BusinessCardApplicationRole> getUserAppRolesComparator = new Comparator<BusinessCardApplicationRole>() {
 605                 public int compare(BusinessCardApplicationRole o1, BusinessCardApplicationRole o2) {
 606                         return o1.getAppName().compareTo(o2.getAppName());
 607                 }
 608         };
 609
 610         /**
 611          *
 612          * @param request
 613          *            HttpServletRequest
 614          * @param userId
 615          *            user ID
 616          * @return List<BusinessCardApplicationRolesList>
 617          * @throws IOException
 618          *             on error
 619          */
 620         @RequestMapping(value = {
 621                         "/portalApi/userApplicationRoles" }, method = RequestMethod.GET, produces = "application/json")
 622         public List<BusinessCardApplicationRolesList> getAppList(HttpServletRequest request,
 623                         @RequestParam("userId") String userId) throws IOException {
 624
 625                 List<BusinessCardApplicationRolesList> AppRoles = null;
 626                 try {
 627                         List<BusinessCardApplicationRole> userAppRoleList = functionalMenuService.getUserAppRolesList(userId);
 628
 629                         Collections.sort(userAppRoleList, getUserAppRolesComparator);
 630                         EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/userApplicationRoles", "result =",
 631                                         userAppRoleList);
 632
 633                         AppRoles = new ArrayList<BusinessCardApplicationRolesList>();
 634                         for (BusinessCardApplicationRole userAppRole : userAppRoleList) {
 635                                 boolean found = false;
 636                                 List<String> roles = null;
 637
 638                                 for (BusinessCardApplicationRolesList app : AppRoles) {
 639                                         if (app.getAppName().equals(userAppRole.getAppName())) {
 640                                                 roles = app.getRoleNames();
 641                                                 roles.add(userAppRole.getRoleName());
 642                                                 app.setRoleNames(roles);
 643                                                 found = true;
 644                                                 break;
 645                                         }
 646                                 }
 647
 648                                 if (!found) {
 649                                         roles = new ArrayList<String>();
 650                                         roles.add(userAppRole.getRoleName());
 651                                         AppRoles.add(new BusinessCardApplicationRolesList(userAppRole.getAppName(), roles));
 652                                 }
 653
 654                                 Collections.sort(roles);
 655                         }
 656                 } catch (Exception e) {
 657                         logger.error(EELFLoggerDelegate.errorLogger, "getAppList failed", e);
 658                 }
 659
 660                 return AppRoles;
 661
 662         }
 663 }