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

   1 /*-
   2  * ================================================================================
   3  * eCOMP Portal
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ================================================================================
  19  */
  20 package org.openecomp.portalapp.portal.controller;
  21
  22 import java.text.SimpleDateFormat;
  23 import java.util.Date;
  24 import java.util.HashMap;
  25 import java.util.HashSet;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import javax.servlet.http.HttpServletRequest;
  30 import javax.servlet.http.HttpServletResponse;
  31
  32 import org.apache.cxf.transport.http.HTTPException;
  33 import org.json.JSONObject;
  34 import org.openecomp.portalapp.controller.EPRestrictedBaseController;
  35 import org.openecomp.portalapp.portal.domain.EPUser;
  36 import org.openecomp.portalapp.portal.domain.SharedContext;
  37 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
  38 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  39 import org.openecomp.portalapp.portal.logging.aop.EPAuditLog;
  40 import org.openecomp.portalapp.portal.service.AdminRolesService;
  41 import org.openecomp.portalapp.portal.service.FunctionalMenuService;
  42 import org.openecomp.portalapp.portal.service.SearchService;
  43 import org.openecomp.portalapp.portal.service.SharedContextService;
  44 import org.openecomp.portalapp.portal.transport.FavoritesFunctionalMenuItem;
  45 import org.openecomp.portalapp.portal.transport.FavoritesFunctionalMenuItemJson;
  46 import org.openecomp.portalapp.portal.transport.FieldsValidator;
  47 import org.openecomp.portalapp.portal.transport.FunctionalMenuItem;
  48 import org.openecomp.portalapp.portal.transport.FunctionalMenuItemJson;
  49 import org.openecomp.portalapp.portal.utils.EPSystemProperties;
  50 import org.openecomp.portalapp.portal.utils.EcompPortalUtils;
  51 import org.openecomp.portalapp.util.EPUserUtils;
  52 import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate;
  53 import org.openecomp.portalsdk.core.service.UserProfileService;
  54 import org.openecomp.portalsdk.core.util.SystemProperties;
  55 import org.slf4j.MDC;
  56 import org.springframework.beans.factory.annotation.Autowired;
  57 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  58 import org.springframework.web.bind.annotation.PathVariable;
  59 import org.springframework.web.bind.annotation.RequestBody;
  60 import org.springframework.web.bind.annotation.RequestMapping;
  61 import org.springframework.web.bind.annotation.RequestMethod;
  62 import org.springframework.web.bind.annotation.RestController;
  63
  64
  65 @RestController
  66 @org.springframework.context.annotation.Configuration
  67 @EnableAspectJAutoProxy
  68 @EPAuditLog
  69 public class FunctionalMenuController extends EPRestrictedBaseController {
  70         EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(FunctionalMenuController.class);
  71
  72         @Autowired
  73         AdminRolesService adminRolesService;
  74         @Autowired
  75         FunctionalMenuService functionalMenuService;
  76         @Autowired
  77         SharedContextService sharedContextService;
  78
  79         @Autowired
  80         UserProfileService service;
  81
  82         @Autowired
  83         SearchService searchService;
  84
  85         /**
  86          * RESTful service method to fetch all the FunctionalMenuItems.
  87          *
  88          * @return
  89          */
  90         @RequestMapping(value = { "/portalApi/functionalMenu" }, method = RequestMethod.GET, produces = "application/json")
  91         public List<FunctionalMenuItem> getMenuItems(HttpServletRequest request, HttpServletResponse response) {
  92                 // TODO: should only the superuser be allowed to use this API?
  93                 List<FunctionalMenuItem> menuItems = null;
  94                 try{
  95                         menuItems = functionalMenuService.getFunctionalMenuItems();
  96                         functionalMenuService.assignHelpURLs(menuItems);
  97                         EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenu", "result =", menuItems);
  98                 }catch(Exception e){
  99                         logger.error(EELFLoggerDelegate.errorLogger, "Exception occurred while calling functionalMenu. Details: " +
 100                                         EcompPortalUtils.getStackTrace(e));
 101                 }
 102                 return menuItems;
 103         }
 104
 105
 106         /**
 107          * RESTful service method to fetch all the FunctionalMenuItems, both active and inactive,
 108          * for the EditFunctionalMenu feature.
 109          * Can only be accessed by the portal admin.
 110          *
 111          * @return
 112          */
 113         @RequestMapping(value = { "/portalApi/functionalMenuForEditing" }, method = RequestMethod.GET, produces = "application/json")
 114         public List<FunctionalMenuItem> getMenuItemsForEditing(HttpServletRequest request, HttpServletResponse response) {
 115                 // TODO: should only the superuser be allowed to use this API?
 116                 EPUser user = EPUserUtils.getUserSession(request);
 117                 List<FunctionalMenuItem> menuItems = null;
 118                 try{
 119                     if (!adminRolesService.isSuperAdmin(user)) {
 120                             EcompPortalUtils.setBadPermissions(user, response, "getFunctionalMenuItemDetails");
 121                     } else {
 122                             menuItems = functionalMenuService.getFunctionalMenuItems(true);
 123                     }
 124                     EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenuForEditing", "result =", menuItems);
 125                 }catch(Exception e){
 126                         logger.error(EELFLoggerDelegate.errorLogger, "Exception occurred while calling functionalMenuForEditing. Details: " +
 127                                         EcompPortalUtils.getStackTrace(e));
 128                 }
 129                 return menuItems;
 130         }
 131
 132         /**
 133          * RESTful service method to fetch all FunctionalMenuItems associated with an application.
 134          *
 135          * @return
 136          */
 137         @RequestMapping(value = { "/portalApi/functionalMenuForApp/{appId}" }, method = RequestMethod.GET, produces = "application/json")
 138         public List<FunctionalMenuItem> getMenuItemsForApp(HttpServletRequest request, @PathVariable("appId") Integer appId) throws HTTPException {
 139                 // TODO: should only the superuser be allowed to use this API?
 140                 List<FunctionalMenuItem> menuItems = null;
 141                 try{
 142                         menuItems = functionalMenuService.getFunctionalMenuItemsForApp(appId);
 143                         functionalMenuService.assignHelpURLs(menuItems);
 144                         EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenuForApp/"+appId, "result =", menuItems);
 145                 }catch(Exception e){
 146                         logger.error(EELFLoggerDelegate.errorLogger, "Exception occurred while calling functionalMenuForApp. Details: " +
 147                                         EcompPortalUtils.getStackTrace(e));
 148                 }
 149                 return menuItems;
 150         }
 151
 152         /**
 153          * RESTful service method to fetch all FunctionalMenuItems associated with the applications
 154          * and roles that a user has access to.
 155          *
 156          * @return
 157          */
 158
 159         @RequestMapping(value = { "/portalApi/functionalMenuForUser/{userId}" }, method = RequestMethod.GET, produces = "application/json")
 160         public List<FunctionalMenuItem> getMenuItemsForUser(HttpServletRequest request, @PathVariable("userId") String userId) throws HTTPException {
 161                 // TODO: should only the superuser be allowed to use this API?
 162                 List<FunctionalMenuItem> menuItems = null;
 163                 try{
 164                         menuItems = functionalMenuService.getFunctionalMenuItemsForUser(userId);
 165                         functionalMenuService.assignHelpURLs(menuItems);
 166                         EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenuForUser/"+userId, "result =", menuItems);
 167                 }catch(Exception e){
 168                         logger.error(EELFLoggerDelegate.errorLogger, "Exception occurred while calling functionalMenuForUser. Details: " +
 169                                         EcompPortalUtils.getStackTrace(e));
 170                 }
 171
 172                 return menuItems;
 173         }
 174
 175         /**
 176          * RESTful service method to fetch all FunctionalMenuItems associated with the applications
 177          * and roles that the authenticated user has access to.
 178          *
 179          * @return
 180          */
 181
 182         @RequestMapping(value = { "/portalApi/functionalMenuForAuthUser" }, method = RequestMethod.GET, produces = "application/json")
 183         public List<FunctionalMenuItem> getMenuItemsForAuthUser(HttpServletRequest request, HttpServletResponse response) {
 184                 EPUser user = EPUserUtils.getUserSession(request);
 185                 List<FunctionalMenuItem> menuItems = null;
 186                 try{
 187                         if (user == null) {
 188                                 EcompPortalUtils.setBadPermissions(user, response, "getMenuItemsForAuthUser");
 189                         } else if (adminRolesService.isSuperAdmin(user)) {
 190                                 menuItems = functionalMenuService.getFunctionalMenuItems();
 191                         } else {
 192                                 // calculate the menu items
 193                                 String orgUserId = user.getOrgUserId();
 194                                 menuItems = functionalMenuService.getFunctionalMenuItemsForUser(orgUserId);
 195                                 EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenuForUser/"+orgUserId, "result =", menuItems);
 196                         }
 197                         functionalMenuService.assignHelpURLs(menuItems);
 198                 }catch(Exception e){
 199                         logger.error(EELFLoggerDelegate.errorLogger, "Exception occurred while calling getMenuItemsForAuthUser. Details: " +
 200                                         EcompPortalUtils.getStackTrace(e));
 201                 }
 202                 return menuItems;
 203         }
 204
 205         /**
 206          * RESTful service method to fetch the details for a functional menu item.
 207          * Requirement: you must be the Ecomp portal super admin user.
 208          *
 209          * @return
 210          */
 211
 212         @RequestMapping(value = { "/portalApi/functionalMenuItemDetails/{menuId}" }, method = RequestMethod.GET, produces = "application/json")
 213         public FunctionalMenuItem getFunctionalMenuItemDetails(HttpServletRequest request, @PathVariable("menuId") Integer menuId, HttpServletResponse response) throws HTTPException {
 214                 // TODO: return FunctionalMenuItemJson
 215                 // TODO: modify FunctionalMenuItem to not include the transient fields
 216                 FunctionalMenuItem menuItem = null;
 217                 try{
 218                         EPUser user = EPUserUtils.getUserSession(request);
 219
 220                         if (!adminRolesService.isSuperAdmin(user)) {
 221                                 EcompPortalUtils.setBadPermissions(user, response, "getFunctionalMenuItemDetails");
 222                         } else {
 223                                 menuItem = functionalMenuService.getFunctionalMenuItemDetails(menuId);
 224                                 EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenuItemDetails/"+menuId, "result =", menuItem);
 225                         }
 226                 }catch(Exception e){
 227                         logger.error(EELFLoggerDelegate.errorLogger, "Exception occurred while calling functionalMenuItemDetails. Details: " +
 228                                         EcompPortalUtils.getStackTrace(e));
 229                 }
 230
 231                 return menuItem;
 232         }
 233
 234         /**
 235          * RESTful service method to create a new menu item.
 236          * Requirement: you must be the Ecomp portal super admin user.
 237          */
 238
 239         @RequestMapping(value={"/portalApi/functionalMenuItem"}, method = RequestMethod.POST)
 240         public FieldsValidator createFunctionalMenuItem(HttpServletRequest request, @RequestBody FunctionalMenuItemJson menuItemJson, HttpServletResponse response) {
 241                 EPUser user = EPUserUtils.getUserSession(request);
 242                 FieldsValidator fieldsValidator = null;
 243                 if (!adminRolesService.isSuperAdmin(user)) {
 244                         logger.debug(EELFLoggerDelegate.debugLogger, "FunctionalMenuController.createFunctionalMenuItem bad permissions");
 245                         EcompPortalUtils.setBadPermissions(user, response, "createFunctionalMenuItem");
 246                 } else {
 247                         fieldsValidator = functionalMenuService.createFunctionalMenuItem(menuItemJson);
 248                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 249                         EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenuItem", "POST result =", response.getStatus());
 250                 }
 251
 252                 return fieldsValidator;
 253         }
 254
 255         /**
 256          * RESTful service method to update an existing menu item
 257          * Requirement: you must be the Ecomp portal super admin user.
 258          */
 259
 260         @RequestMapping(value={"/portalApi/functionalMenuItem"}, method = RequestMethod.PUT)
 261         public FieldsValidator editFunctionalMenuItem(HttpServletRequest request, @RequestBody FunctionalMenuItemJson menuItemJson, HttpServletResponse response) {
 262                 EPUser user = EPUserUtils.getUserSession(request);
 263                 FieldsValidator fieldsValidator = null;
 264                 if (!adminRolesService.isSuperAdmin(user)) {
 265                         EcompPortalUtils.setBadPermissions(user, response, "editFunctionalMenuItem");
 266                 } else {
 267                         fieldsValidator = functionalMenuService.editFunctionalMenuItem(menuItemJson);
 268                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 269                         EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenuItem", "PUT result =", response.getStatus());
 270                 }
 271
 272                 return fieldsValidator;
 273         }
 274
 275         @RequestMapping(value={"/portalApi/functionalMenuItem/{menuId}"}, method = RequestMethod.DELETE)
 276         public FieldsValidator deleteFunctionalMenuItem(HttpServletRequest request, @PathVariable("menuId") Long menuId, HttpServletResponse response) {
 277                 EPUser user = EPUserUtils.getUserSession(request);
 278                 FieldsValidator fieldsValidator = null;
 279                 if (!adminRolesService.isSuperAdmin(user)) {
 280                         EcompPortalUtils.setBadPermissions(user, response, "deleteFunctionalMenuItem");
 281                 } else {
 282                         fieldsValidator = functionalMenuService.deleteFunctionalMenuItem(menuId);
 283                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 284                         EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenuItem", "DELETE result =", response.getStatus());
 285                 }
 286
 287                 return fieldsValidator;
 288         }
 289
 290         @RequestMapping(value = {"/portalApi/regenerateFunctionalMenuAncestors" }, method = RequestMethod.GET)
 291         public FieldsValidator regenerateAncestorTable(HttpServletRequest request, HttpServletResponse response) {
 292                 // TODO: should only the superuser be allowed to use this API?
 293                 EPUser user = EPUserUtils.getUserSession(request);
 294                 FieldsValidator fieldsValidator = null;
 295
 296                 if (!adminRolesService.isSuperAdmin(user)) {
 297                         EcompPortalUtils.setBadPermissions(user, response, "deleteFunctionalMenuItem");
 298                 } else {
 299                         fieldsValidator = functionalMenuService.regenerateAncestorTable();
 300                         response.setStatus(fieldsValidator.httpStatusCode.intValue());
 301                         EcompPortalUtils.logAndSerializeObject("/portalApi/regenerateAncestorTable", "GET result =", response.getStatus());
 302                 }
 303
 304                 return fieldsValidator;
 305         }
 306
 307
 308         @RequestMapping(value={"/portalApi/setFavoriteItem"}, method = RequestMethod.POST)
 309         public FieldsValidator addFavoriteItem(HttpServletRequest request, @RequestBody FavoritesFunctionalMenuItem menuItemJson, HttpServletResponse response) {
 310                 EPUser user = EPUserUtils.getUserSession(request);
 311                 FieldsValidator fieldsValidator = null;
 312                 menuItemJson.userId = user.getId();
 313                 fieldsValidator = functionalMenuService.setFavoriteItem(menuItemJson);
 314                 response.setStatus(fieldsValidator.httpStatusCode.intValue());
 315                 EcompPortalUtils.logAndSerializeObject("/portalApi/setFavoriteItem", "Post result =", response.getStatus());
 316
 317                 return fieldsValidator;
 318         }
 319
 320
 321         @RequestMapping(value={"/portalApi/getFavoriteItems"}, method = RequestMethod.GET,produces = "application/json")
 322         public List<FavoritesFunctionalMenuItemJson> getFavoritesForUser(HttpServletRequest request, HttpServletResponse response) {
 323                 EPUser user = EPUserUtils.getUserSession(request);
 324                 List<FavoritesFunctionalMenuItemJson> favorites = functionalMenuService.getFavoriteItems(user.getId());
 325                 FieldsValidator fieldsValidator = new FieldsValidator();
 326                 response.setStatus(fieldsValidator.httpStatusCode.intValue());
 327                 EcompPortalUtils.logAndSerializeObject("/portalApi/getFavoriteItems", "GET result =", response.getStatus());
 328
 329                 return favorites;
 330         }
 331
 332         @RequestMapping(value={"/portalApi/removeFavoriteItem/{menuId}"}, method = RequestMethod.DELETE)
 333         public FieldsValidator deleteFavoriteItem(HttpServletRequest request, @PathVariable("menuId") Long menuId, HttpServletResponse response) {
 334                 EPUser user = EPUserUtils.getUserSession(request);
 335                 FieldsValidator fieldsValidator = null;
 336                 Long userId = user.getId();
 337                 fieldsValidator = functionalMenuService.removeFavoriteItem(userId,menuId);
 338                 response.setStatus(fieldsValidator.httpStatusCode.intValue());
 339                 EcompPortalUtils.logAndSerializeObject("/deleteFavoriteItem", "DELETE result =", response.getStatus());
 340
 341                 return fieldsValidator;
 342         }
 343
 344         @RequestMapping(value = {"/portalApi/functionalMenuStaticInfo" }, method = RequestMethod.GET,produces = "application/json")
 345         public String functionalMenuStaticInfo(HttpServletRequest request, HttpServletResponse response) {
 346
 347                 /*Getting first name, last name, and email from session*/
 348                 logger.debug(EELFLoggerDelegate.debugLogger, "getting functionalMenuStaticInfo values from session");
 349                 Map<String,String> map = new HashMap<String,String>();
 350                 String sessionId = request.getSession().getId();
 351                 SharedContext userIdSC = null , firstNameSC = null, lastNameSC = null, emailSC = null;
 352                 String userIdStr= null, firstNameStr= null, lastNameStr = null, emailStr = null;
 353                 EPUser user = EPUserUtils.getUserSession(request);
 354                 String contact_us_link = null;
 355                 String last_login = null;
 356                 try{
 357                         contact_us_link = SystemProperties.getProperty(EPSystemProperties.CONTACT_US_URL);
 358                         SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy hh:mm:ss");
 359                         Date lastLoginDate = user.getLastLoginDate();
 360                         last_login =sdf.format(lastLoginDate);// sdf.parse(lastLoginDate.);
 361                 }catch(Exception e){
 362                         logger.error(EELFLoggerDelegate.errorLogger, "CONTACT_US_URL is missing in property file! Details: " + EcompPortalUtils.getStackTrace(e));
 363                 }
 364
 365                 try{
 366                         if (user!=null) {
 367                                 firstNameStr = user.getFirstName();
 368                                 lastNameStr = user.getLastName();
 369                                 userIdStr = user.getOrgUserId();
 370                                 emailStr = user.getEmail();
 371                                 /*if(emailStr==null || emailStr.equals("")){
 372                                         EPUser userResult = searchService.searchUsersByUserId(user); //.searchUserByUserId(userIdStr);
 373                                         emailStr = userResult.getEmail();
 374                                 }               */
 375                         } else {
 376                                 logger.warn(EELFLoggerDelegate.errorLogger, "Unable to locate the user information in the session. LoginId: " + MDC.get(EPSystemProperties.MDC_LOGIN_ID));
 377                         }
 378
 379                         /*If failed getting from session, then get the values from Shared Context*/
 380                         if(firstNameStr==null)
 381                                 firstNameSC = sharedContextService.getSharedContext(sessionId,EPSystemProperties.USER_FIRST_NAME);
 382                         if(lastNameStr==null)
 383                                 lastNameSC = sharedContextService.getSharedContext(sessionId,EPSystemProperties.USER_LAST_NAME);
 384                         if(emailStr==null)
 385                                 emailSC = sharedContextService.getSharedContext(sessionId,EPSystemProperties.USER_EMAIL);
 386                         if(userIdStr==null)
 387                                 userIdSC = sharedContextService.getSharedContext(sessionId,EPSystemProperties.USER_ORG_USERID);
 388
 389                         /*Getting Contact Us link from properties file*/
 390
 391                         map.put("firstName", firstNameStr!=null?firstNameStr:(firstNameSC!=null?firstNameSC.getCvalue():null));
 392                         map.put("lastName", lastNameStr!=null?lastNameStr:(lastNameSC!=null?lastNameSC.getCvalue():null));
 393                         map.put("email", emailStr!=null?emailStr:(emailSC!=null?emailSC.getCvalue():null));
 394                         map.put("userId", userIdStr!=null?userIdStr:(userIdSC!=null?userIdSC.getCvalue():null));
 395                         map.put("last_login",last_login);
 396                         map.put("contact_us_link",contact_us_link);
 397                 }catch(Exception e){
 398                         logger.error(EELFLoggerDelegate.errorLogger, "Exception occurred while getting values : " + EcompPortalUtils.getStackTrace(e));
 399                 }
 400
 401                 JSONObject j = new JSONObject(map);
 402                 String fnMenuStaticResponse = "";
 403                 try {
 404                         fnMenuStaticResponse = j.toString();
 405                 //      response.getWriter().write(fnMenuStaticResponse);
 406                         EcompPortalUtils.logAndSerializeObject("/portalApi/functionalMenuStaticInfo", "GET result =", fnMenuStaticResponse);
 407                 } catch(Exception e) {
 408                         logger.error(EELFLoggerDelegate.errorLogger, "Exception occurred while writing the result to the HttpServletResponse object. Details: " +
 409                                                         EcompPortalUtils.getStackTrace(e));
 410                 }
 411                 return fnMenuStaticResponse;
 412         }
 413
 414         @RequestMapping(value = {"/portalApi/resetFunctionalMenuStaticInfo" }, method = RequestMethod.GET,produces = "application/json")
 415         public PortalRestResponse<Map<String, String>> resetFunctionalMenuStaticInfo(HttpServletRequest request, HttpServletResponse response) {
 416                 PortalRestResponse<String> portalRestResponse = null;
 417                 try {
 418                 // get current user
 419                 EPUser user = EPUserUtils.getUserSession(request);
 420                 String userId = user.getOrgUserId();
 421         StringBuffer criteria = new StringBuffer();
 422         criteria.append(" where org_user_id = '").append(userId).append("'");
 423                 // retrieve latest user info from EPUser
 424         List list = getDataAccessService().getList(EPUser.class, criteria.toString(), null, null);
 425         EPUser updatedUser = (EPUser)list.get(0);
 426         EPUserUtils.setUserSession(request, updatedUser,  new HashSet(), new HashSet(), SystemProperties.getProperty(SystemProperties.AUTHENTICATION_MECHANISM));
 427                 return new PortalRestResponse<>(PortalRestStatusEnum.OK, "success", null);
 428                 }
 429                 catch (Exception e) {
 430                         logger.error(EELFLoggerDelegate.errorLogger, "getOnlineUserUpdateRate failed", e);
 431                         return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, e.toString(), null);
 432                 }
 433
 434         }
 435 }
 436