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