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

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