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