gerrit.onap Code Review - portal.git/blob

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