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