catalog-be/src/main/java/org/openecomp/sdc/be/servlets/UserAdminServlet.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   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  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.servlets;
  22
  23 import com.jcabi.aspects.Loggable;
  24 import fj.data.Either;
  25 import io.swagger.annotations.Api;
  26 import io.swagger.annotations.ApiOperation;
  27 import io.swagger.annotations.ApiParam;
  28 import io.swagger.annotations.ApiResponse;
  29 import io.swagger.annotations.ApiResponses;
  30 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  31 import org.openecomp.sdc.be.dao.api.ActionStatus;
  32 import org.openecomp.sdc.be.model.User;
  33 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  34 import org.openecomp.sdc.be.user.UserBusinessLogic;
  35 import org.openecomp.sdc.common.api.Constants;
  36 import org.openecomp.sdc.exception.ResponseFormat;
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39
  40 import javax.inject.Singleton;
  41 import javax.servlet.ServletContext;
  42 import javax.servlet.http.HttpServletRequest;
  43 import javax.ws.rs.Consumes;
  44 import javax.ws.rs.DELETE;
  45 import javax.ws.rs.GET;
  46 import javax.ws.rs.HeaderParam;
  47 import javax.ws.rs.POST;
  48 import javax.ws.rs.Path;
  49 import javax.ws.rs.PathParam;
  50 import javax.ws.rs.Produces;
  51 import javax.ws.rs.QueryParam;
  52 import javax.ws.rs.core.Context;
  53 import javax.ws.rs.core.MediaType;
  54 import javax.ws.rs.core.Response;
  55 import java.io.UnsupportedEncodingException;
  56 import java.net.URLDecoder;
  57 import java.util.ArrayList;
  58 import java.util.List;
  59 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
  60 @Path("/v1/user")
  61 @Api(value = "User Administration", description = "User admininstarator operations")
  62 @Singleton
  63 public class UserAdminServlet extends BeGenericServlet {
  64
  65     private static final String ROLE_DELIMITER = ",";
  66     private static final Logger log = LoggerFactory.getLogger(UserAdminServlet.class);
  67
  68     /***************************************
  69      * API start
  70      *************************************************************/
  71
  72     /* User by userId CRUD start */
  73
  74     /////////////////////////////////////////////////////////////////////////////////////////////////////
  75     // retrieve all user details
  76     @GET
  77     @Path("/{userId}")
  78     @Consumes(MediaType.APPLICATION_JSON)
  79     @Produces(MediaType.APPLICATION_JSON)
  80     @ApiOperation(value = "retrieve user details", httpMethod = "GET", notes = "Returns user details according to userId", response = User.class)
  81     @ApiResponses(value = { @ApiResponse(code = 200, message = "Returns user Ok"), @ApiResponse(code = 404, message = "User not found"), @ApiResponse(code = 405, message = "Method Not Allowed"),
  82             @ApiResponse(code = 500, message = "Internal Server Error") })
  83     public Response get(@ApiParam(value = "userId of user to get", required = true) @PathParam("userId") final String userId, @Context final HttpServletRequest request) {
  84
  85         String url = request.getMethod() + " " + request.getRequestURI();
  86         log.debug("(get) Start handle request of {}", url);
  87
  88         UserBusinessLogic userAdminManager = getUserAdminManager(request.getSession().getServletContext());
  89
  90         try {
  91             Either<User, ActionStatus> either = userAdminManager.getUser(userId, false);
  92
  93             if (either.isRight()) {
  94                 return buildErrorResponse(getComponentsUtils().getResponseFormatByUserId(either.right().value(), userId));
  95             } else {
  96                 if (either.left().value() != null) {
  97                     return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), either.left().value());
  98                 } else {
  99                     return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 100                 }
 101             }
 102         } catch (Exception e) {
 103             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get User");
 104             log.debug("get user failed with unexpected error: {}", e.getMessage(), e);
 105             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 106         }
 107     }
 108
 109     @GET
 110     @Path("/{userId}/role")
 111     @Consumes(MediaType.APPLICATION_JSON)
 112     @Produces(MediaType.APPLICATION_JSON)
 113     @ApiOperation(value = "retrieve user role", notes = "Returns user role according to userId", response = String.class)
 114     @ApiResponses(value = { @ApiResponse(code = 200, message = "Returns user role Ok"), @ApiResponse(code = 404, message = "User not found"), @ApiResponse(code = 405, message = "Method Not Allowed"),
 115             @ApiResponse(code = 500, message = "Internal Server Error") })
 116     public Response getRole(@ApiParam(value = "userId of user to get", required = true) @PathParam("userId") final String userId, @Context final HttpServletRequest request) {
 117
 118         String url = request.getMethod() + " " + request.getRequestURI();
 119         log.debug("(getRole) Start handle request of {}", url);
 120
 121         UserBusinessLogic userAdminManager = getUserAdminManager(request.getSession().getServletContext());
 122
 123         try {
 124             Either<User, ActionStatus> either = userAdminManager.getUser(userId, false);
 125             if (either.isRight()) {
 126                 return buildErrorResponse(getComponentsUtils().getResponseFormatByUserId(either.right().value(), userId));
 127             } else {
 128                 if (either.left().value() != null) {
 129                     String roleJson = "{ \"role\" : \"" + either.left().value().getRole() + "\" }";
 130                     return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), roleJson);
 131                 } else {
 132                     return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 133                 }
 134             }
 135         } catch (Exception e) {
 136             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get User Role");
 137             log.debug("Get user role failed with unexpected error: {}", e);
 138             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 139         }
 140     }
 141
 142     /////////////////////////////////////////////////////////////////////////////////////////////////////
 143     // update user role
 144     @POST
 145     @Path("/{userId}/role")
 146     @Consumes(MediaType.APPLICATION_JSON)
 147     @Produces(MediaType.APPLICATION_JSON)
 148     @ApiOperation(value = "update user role", notes = "Update user role", response = User.class)
 149     @ApiResponses(value = { @ApiResponse(code = 200, message = "Update user OK"), @ApiResponse(code = 400, message = "Invalid Content."), @ApiResponse(code = 403, message = "Missing information/Restricted operation"),
 150             @ApiResponse(code = 404, message = "User not found"), @ApiResponse(code = 405, message = "Method Not Allowed"), @ApiResponse(code = 409, message = "User already exists"), @ApiResponse(code = 500, message = "Internal Server Error") })
 151     public Response updateUserRole(@ApiParam(value = "userId of user to get", required = true) @PathParam("userId") final String userIdUpdateUser, @Context final HttpServletRequest request,
 152             @ApiParam(value = "json describe the update role", required = true) String data, @HeaderParam(value = Constants.USER_ID_HEADER) String modifierUserId) {
 153
 154         ServletContext context = request.getSession().getServletContext();
 155
 156         String url = request.getMethod() + " " + request.getRequestURI();
 157         log.debug("Start handle request of {}", url);
 158
 159         // get modifier id
 160         User modifier = new User();
 161         modifier.setUserId(modifierUserId);
 162         log.debug("modifier id is {}", modifierUserId);
 163
 164         Response response = null;
 165
 166         try {
 167             UserBusinessLogic businessLogic = getUserAdminManager(context);
 168             User updateInfoUser = getComponentsUtils().convertJsonToObject(data, modifier, User.class, AuditingActionEnum.UPDATE_USER).left().value();
 169             Either<User, ResponseFormat> updateUserResponse = businessLogic.updateUserRole(modifier, userIdUpdateUser, updateInfoUser.getRole());
 170
 171             if (updateUserResponse.isRight()) {
 172                 log.debug("failed to update user role");
 173                 response = buildErrorResponse(updateUserResponse.right().value());
 174                 return response;
 175             }
 176             response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), updateUserResponse.left().value());
 177             return response;
 178
 179         } catch (Exception e) {
 180             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update User Metadata");
 181             log.debug("Update User Role failed with exception", e);
 182             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 183             return response;
 184
 185         }
 186     }
 187
 188     /* User role CRUD end */
 189
 190     /* New user CRUD start */
 191     @POST
 192     @Consumes(MediaType.APPLICATION_JSON)
 193     @Produces(MediaType.APPLICATION_JSON)
 194     @ApiOperation(value = "add user", httpMethod = "POST", notes = "Provision new user", response = User.class)
 195     @ApiResponses(value = { @ApiResponse(code = 201, message = "New user created"), @ApiResponse(code = 400, message = "Invalid Content."), @ApiResponse(code = 403, message = "Missing information"),
 196             @ApiResponse(code = 405, message = "Method Not Allowed"), @ApiResponse(code = 409, message = "User already exists"), @ApiResponse(code = 500, message = "Internal Server Error") })
 197     public Response createUser(@Context final HttpServletRequest request, @ApiParam(value = "json describe the user", required = true) String newUserData, @HeaderParam(value = Constants.USER_ID_HEADER) String modifierAttId) {
 198
 199         ServletContext context = request.getSession().getServletContext();
 200
 201         String url = request.getMethod() + " " + request.getRequestURI();
 202         log.debug("Start handle request of {}", url);
 203
 204         // get modifier id
 205         User modifier = new User();
 206         modifier.setUserId(modifierAttId);
 207         log.debug("modifier id is {}", modifierAttId);
 208
 209         Response response = null;
 210
 211         try {
 212             UserBusinessLogic businessLogic = getUserAdminManager(context);
 213             User newUserInfo = getComponentsUtils().convertJsonToObject(newUserData, modifier, User.class, AuditingActionEnum.ADD_USER).left().value();
 214             Either<User, ResponseFormat> createUserResponse = businessLogic.createUser(modifier, newUserInfo);
 215
 216             if (createUserResponse.isRight()) {
 217                 log.debug("failed to create user");
 218                 response = buildErrorResponse(createUserResponse.right().value());
 219                 return response;
 220             }
 221             response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.CREATED), createUserResponse.left().value());
 222             return response;
 223
 224         } catch (Exception e) {
 225             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update User Metadata");
 226             log.debug("Create User failed with exception", e);
 227             response = buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 228             return response;
 229
 230         }
 231     }
 232
 233     /* New user CRUD end */
 234
 235     /* User authorization start */
 236
 237     /////////////////////////////////////////////////////////////////////////////////////////////////////
 238     // User Authorization
 239     @GET
 240     @Path("/authorize")
 241     @Consumes(MediaType.APPLICATION_JSON)
 242     @Produces(MediaType.APPLICATION_JSON)
 243
 244     @ApiOperation(value = "authorize", notes = "authorize user", response = User.class)
 245     @ApiResponses(value = { @ApiResponse(code = 200, message = "Returns user Ok"), @ApiResponse(code = 403, message = "Restricted Access"), @ApiResponse(code = 500, message = "Internal Server Error") })
 246     public Response authorize(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @HeaderParam("HTTP_CSP_FIRSTNAME") String firstName, @HeaderParam("HTTP_CSP_LASTNAME") String lastName,
 247             @HeaderParam("HTTP_CSP_EMAIL") String email) {
 248
 249         try {
 250             userId = userId != null ? URLDecoder.decode(userId, "UTF-8") : null;
 251             firstName = firstName != null ? URLDecoder.decode(firstName, "UTF-8") : null;
 252             lastName = lastName != null ? URLDecoder.decode(lastName, "UTF-8") : null;
 253             email = email != null ? URLDecoder.decode(email, "UTF-8") : null;
 254         } catch (UnsupportedEncodingException e) {
 255             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Authorize User - decode headers");
 256             ResponseFormat errorResponseWrapper = getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR);
 257             log.error("#authorize - authorization decoding failed with error: ", e);
 258             return buildErrorResponse(errorResponseWrapper);
 259         }
 260
 261         ServletContext context = request.getSession().getServletContext();
 262         String url = request.getMethod() + " " + request.getRequestURI();
 263         log.debug("Start handle request of {}", url);
 264
 265         User authUser = new User();
 266         authUser.setUserId(userId);
 267         authUser.setFirstName(firstName);
 268         authUser.setLastName(lastName);
 269         authUser.setEmail(email);
 270         log.debug("auth user id is {}", userId);
 271
 272         Response response = null;
 273         try {
 274             UserBusinessLogic userAdminManager = getUserAdminManager(context);
 275             Either<User, ResponseFormat> authorize = userAdminManager.authorize(authUser);
 276
 277             if (authorize.isRight()) {
 278                 log.debug("authorize user failed");
 279                 response = buildErrorResponse(authorize.right().value());
 280                 return response;
 281             }
 282             response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), authorize.left().value());
 283             return response;
 284
 285         } catch (Exception e) {
 286             log.debug("authorize user failed with unexpected error: {}", e);
 287             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 288         }
 289     }
 290
 291     /* User authorization end */
 292
 293     @GET
 294     @Path("/admins")
 295     @Consumes(MediaType.APPLICATION_JSON)
 296     @Produces(MediaType.APPLICATION_JSON)
 297     @ApiOperation(value = "retrieve all administrators", httpMethod = "GET", notes = "Returns all administrators", response = User.class)
 298     @ApiResponses(value = { @ApiResponse(code = 200, message = "Returns user Ok"), @ApiResponse(code = 405, message = "Method Not Allowed"), @ApiResponse(code = 500, message = "Internal Server Error") })
 299     public Response getAdminsUser(@Context final HttpServletRequest request) {
 300
 301         String url = request.getMethod() + " " + request.getRequestURI();
 302         log.debug("(get) Start handle request of {}", url);
 303
 304         UserBusinessLogic userAdminManager = getUserAdminManager(request.getSession().getServletContext());
 305
 306         try {
 307             Either<List<User>, ResponseFormat> either = userAdminManager.getAllAdminUsers(request.getSession().getServletContext());
 308
 309             if (either.isRight()) {
 310                 log.debug("Failed to get all admin users");
 311                 return buildErrorResponse(either.right().value());
 312             } else {
 313                 if (either.left().value() != null) {
 314                     return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), either.left().value());
 315                 } else {
 316                     return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 317                 }
 318             }
 319         } catch (Exception e) {
 320             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get All Administrators");
 321             log.debug("get all admins failed with unexpected error: {}", e);
 322             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 323         }
 324     }
 325
 326     @GET
 327     @Path("/users")
 328     @Consumes(MediaType.APPLICATION_JSON)
 329     @Produces(MediaType.APPLICATION_JSON)
 330     @ApiOperation(value = "Retrieve the list of all active ASDC users or only group of users having specific roles.", httpMethod = "GET", notes = "Returns list of users with the specified roles, or all of users in the case of empty 'roles' header", response = User.class)
 331     @ApiResponses(value = { @ApiResponse(code = 200, message = "Returns users Ok"), @ApiResponse(code = 204, message = "No provisioned ASDC users of requested role"), @ApiResponse(code = 403, message = "Restricted Access"),
 332             @ApiResponse(code = 400, message = "Missing content"), @ApiResponse(code = 500, message = "Internal Server Error") })
 333     public Response getUsersList(@Context final HttpServletRequest request, @ApiParam(value = "Any active user's USER_ID ") @HeaderParam(Constants.USER_ID_HEADER) final String userId,
 334             @ApiParam(value = "TESTER,DESIGNER,PRODUCT_STRATEGIST,OPS,PRODUCT_MANAGER,GOVERNOR, ADMIN OR all users by not typing anything") @QueryParam("roles") final String roles) {
 335
 336         ServletContext context = request.getSession().getServletContext();
 337         String url = request.getMethod() + " " + request.getRequestURI();
 338         log.debug("Start handle request of {} modifier id is {}", url, userId);
 339
 340         List<String> rolesList = new ArrayList<>();
 341         if (roles != null && !roles.trim().isEmpty()) {
 342             String[] rolesArr = roles.split(ROLE_DELIMITER);
 343             for (String role : rolesArr) {
 344                 rolesList.add(role.trim());
 345             }
 346         }
 347
 348         try {
 349             UserBusinessLogic userAdminManager = getUserAdminManager(context);
 350             Either<List<User>, ResponseFormat> either = userAdminManager.getUsersList(userId, rolesList, roles);
 351
 352             if (either.isRight()) {
 353                 log.debug("Failed to get ASDC users");
 354                 return buildErrorResponse(either.right().value());
 355             } else {
 356                 return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), either.left().value());
 357             }
 358         } catch (Exception e) {
 359             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get ASDC users");
 360             log.debug("get users failed with unexpected error: {}", e);
 361             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 362         }
 363
 364     }
 365
 366     /////////////////////////////////////////////////////////////////////////////////////////////////////
 367     // delete user
 368     @DELETE
 369     @Path("/{userId}")
 370     @Consumes(MediaType.APPLICATION_JSON)
 371     @Produces(MediaType.APPLICATION_JSON)
 372     @ApiOperation(value = "delete user", notes = "Delete user", response = User.class)
 373     @ApiResponses(value = { @ApiResponse(code = 200, message = "Update deleted OK"), @ApiResponse(code = 400, message = "Invalid Content."), @ApiResponse(code = 403, message = "Missing information"),
 374             @ApiResponse(code = 404, message = "User not found"), @ApiResponse(code = 405, message = "Method Not Allowed"), @ApiResponse(code = 409, message = "Restricted operation"), @ApiResponse(code = 500, message = "Internal Server Error") })
 375     public Response deActivateUser(@ApiParam(value = "userId of user to get", required = true) @PathParam("userId") final String userId, @Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userIdHeader) {
 376
 377         ServletContext context = request.getSession().getServletContext();
 378         String url = request.getMethod() + " " + request.getRequestURI();
 379         log.debug("Start handle request of {} modifier id is {}", url, userIdHeader);
 380
 381         User modifier = new User();
 382         modifier.setUserId(userIdHeader);
 383
 384         Response response = null;
 385         try {
 386             UserBusinessLogic userAdminManager = getUserAdminManager(context);
 387             Either<User, ResponseFormat> deactiveUserResponse = userAdminManager.deActivateUser(modifier, userId);
 388
 389             if (deactiveUserResponse.isRight()) {
 390                 log.debug("Failed to deactivate user");
 391                 response = buildErrorResponse(deactiveUserResponse.right().value());
 392                 return response;
 393             }
 394             response = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), deactiveUserResponse.left().value());
 395             return response;
 396
 397         } catch (Exception e) {
 398             BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get ASDC users");
 399             log.debug("deactivate user failed with unexpected error: {}", e);
 400             return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
 401         }
 402     }
 403 }