gerrit.onap Code Review - portal/sdk.git/blob

   1 /*-
   2  * ================================================================================
   3  * ECOMP Portal SDK
   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.portalsdk.core.onboarding.crossapi;
  21
  22 import java.io.BufferedReader;
  23 import java.io.IOException;
  24 import java.io.InputStream;
  25 import java.io.InputStreamReader;
  26 import java.io.PrintWriter;
  27 import java.io.StringWriter;
  28 import java.util.List;
  29 import java.util.Map;
  30
  31 import javax.servlet.ServletException;
  32 import javax.servlet.annotation.WebServlet;
  33 import javax.servlet.http.HttpServlet;
  34 import javax.servlet.http.HttpServletRequest;
  35 import javax.servlet.http.HttpServletResponse;
  36
  37 import org.apache.commons.logging.Log;
  38 import org.apache.commons.logging.LogFactory;
  39 import org.openecomp.portalsdk.core.onboarding.exception.PortalAPIException;
  40 import org.openecomp.portalsdk.core.onboarding.listener.PortalTimeoutHandler;
  41 import org.openecomp.portalsdk.core.onboarding.rest.RestWebServiceClient;
  42 import org.openecomp.portalsdk.core.onboarding.util.PortalApiConstants;
  43 import org.openecomp.portalsdk.core.onboarding.util.PortalApiProperties;
  44 import org.openecomp.portalsdk.core.restful.domain.EcompRole;
  45 import org.openecomp.portalsdk.core.restful.domain.EcompUser;
  46
  47 import com.fasterxml.jackson.core.JsonProcessingException;
  48 import com.fasterxml.jackson.core.type.TypeReference;
  49 import com.fasterxml.jackson.databind.DeserializationFeature;
  50 import com.fasterxml.jackson.databind.ObjectMapper;
  51
  52 /**
  53  * This servlet performs the functions described below. It listens on a path
  54  * like "/api" (see {@link PortalApiConstants#API_PREFIX}). The servlet checks
  55  * for authorized access and rejects unauthorized requests.
  56  * <OL>
  57  * <LI>Proxies user (i.e., browser) requests for web analytics. The GET method
  58  * fetches javascript from the Portal and returns it. The POST method forwards
  59  * data sent by the browser on to Portal. These requests are checked for a valid
  60  * User UID in a header; these requests do NOT use the application
  61  * username-password header.</LI>
  62  * <LI>Responds to ECOMP Portal API requests to query and update user, role and
  63  * user-role information. The servlet proxies all requests on to a local Java
  64  * class that implements {@link IPortalRestAPIService}. These requests must have
  65  * the application username-password header.</LI>
  66  * </OL>
  67  * This servlet will not start if the required portal.properties file is not
  68  * found on the classpath.
  69  */
  70
  71 @WebServlet(urlPatterns = { PortalApiConstants.API_PREFIX + "/*" })
  72 public class PortalRestAPIProxy extends HttpServlet implements IPortalRestAPIService {
  73         private static final long serialVersionUID = 1L;
  74
  75         private static final String contentTypeAppJson = "application/json";
  76
  77         private final Log logger = LogFactory.getLog(getClass());
  78
  79         /**
  80          * Mapper for JSON to object etc.
  81          */
  82         private final ObjectMapper mapper = new ObjectMapper();
  83
  84         /**
  85          * Client-supplied class that implements our interface.
  86          */
  87         private static IPortalRestAPIService portalRestApiServiceImpl;
  88
  89         public PortalRestAPIProxy() {
  90                 // Ensure that any additional fields sent by the Portal
  91                 // will be ignored when creating objects.
  92                 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  93         }
  94
  95         @Override
  96         public void init() throws ServletException {
  97                 String className = PortalApiProperties.getProperty(PortalApiConstants.PORTAL_API_IMPL_CLASS);
  98                 if (className == null)
  99                         throw new ServletException(
 100                                         "init: Failed to find class name property " + PortalApiConstants.PORTAL_API_IMPL_CLASS);
 101                 try {
 102                         logger.debug("init: creating instance of class " + className);
 103                         Class<?> implClass = Class.forName(className);
 104                         portalRestApiServiceImpl = (IPortalRestAPIService) (implClass.getConstructor().newInstance());
 105                 } catch (Exception ex) {
 106                         throw new ServletException("init: Failed to find or instantiate class " + className, ex);
 107                 }
 108         }
 109
 110         @Override
 111         protected void doPost(HttpServletRequest request, HttpServletResponse response)
 112                         throws IOException, ServletException {
 113
 114                 if (portalRestApiServiceImpl == null) {
 115                         // Should never happen due to checks in init()
 116                         logger.error("doPost: no service class instance");
 117                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 118                         response.getWriter().write(buildJsonResponse(false, "Misconfigured - no instance of service class"));
 119                         return;
 120                 }
 121                 String requestUri = request.getRequestURI();
 122                 String responseJson = "";
 123                 String storeAnalyticsContextPath = "/storeAnalytics";
 124                 if (requestUri.endsWith(PortalApiConstants.API_PREFIX + storeAnalyticsContextPath)) {
 125                         String userId;
 126                         try {
 127                                 userId = getUserId(request);
 128                         } catch (PortalAPIException e) {
 129                                 logger.error("Issue with invoking getUserId implemenation !!! ", e);
 130                                 throw new ServletException(e);
 131                         }
 132                         if (userId == null || userId.length() == 0) {
 133                                 logger.debug("doPost: userId is null or empty");
 134                                 response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
 135                                 responseJson = buildJsonResponse(false, "Not authorized for " + storeAnalyticsContextPath);
 136                         } else {
 137                                 // User ID obtained from request
 138                                 try {
 139                                         String credential = PortalApiProperties.getProperty(PortalApiConstants.UEB_APP_KEY);
 140                                         // for now lets also pass uebkey as user name and password
 141                                         String requestBody = readRequestBody(request);
 142                                         @SuppressWarnings("unchecked")
 143                                         Map<String, String> bodyMap = mapper.readValue(requestBody, Map.class);
 144                                         // add user ID
 145                                         bodyMap.put("userid", userId);
 146                                         requestBody = mapper.writeValueAsString(bodyMap);
 147                                         responseJson = RestWebServiceClient.getInstance().postPortalContent(storeAnalyticsContextPath,
 148                                                         userId, credential, null, credential, credential, "application/json", requestBody);
 149                                         if (logger.isDebugEnabled())
 150                                                 logger.debug("doPost: postPortalContent returns " + responseJson);
 151                                         response.setStatus(HttpServletResponse.SC_OK);
 152                                 } catch (Exception ex) {
 153                                         logger.error("doPost: " + storeAnalyticsContextPath + " caught exception", ex);
 154                                         responseJson = buildJsonResponse(ex);
 155                                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 156                                 }
 157                         }
 158                         writeAndFlush(response, contentTypeAppJson, responseJson);
 159                         return;
 160                 } // post analytics
 161
 162                 boolean secure = false;
 163                 try {
 164                         secure = isAppAuthenticated(request);
 165                 } catch (PortalAPIException ex) {
 166                         logger.error("doPost: isAppAuthenticated threw exception", ex);
 167                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 168                         response.getWriter().write(buildJsonResponse(false, "Failed to authenticate request"));
 169                         return;
 170                 }
 171                 if (!secure) {
 172                         if (logger.isDebugEnabled())
 173                                 logger.debug("doPost: isAppAuthenticated answered false");
 174                         response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
 175                         writeAndFlush(response, contentTypeAppJson, buildJsonResponse(false, "Not authorized"));
 176                         return;
 177                 }
 178
 179                 try {
 180                         String requestBody = readRequestBody(request);
 181                         if (logger.isDebugEnabled())
 182                                 logger.debug("doPost: URI =  " + requestUri + ", payload = " + requestBody);
 183
 184                         /*
 185                          * All APIs:
 186                          *
 187                          * 1. /user <-- save user
 188                          *
 189                          * 2. /user/{loginId} <-- edit user
 190                          *
 191                          * 3. /user/{loginId}/roles <-- save roles for user
 192                          */
 193
 194                         // On success return the empty string.
 195
 196                         if (requestUri.endsWith("/updateSessionTimeOuts")) {
 197                                 if (updateSessionTimeOuts(requestBody)) {
 198                                         if (logger.isDebugEnabled())
 199                                                 logger.debug("doPost: updated session timeouts");
 200                                         response.setStatus(HttpServletResponse.SC_OK);
 201                                 } else {
 202                                         String msg = "Failed to update session time outs";
 203                                         logger.error("doPost: " + msg);
 204                                         responseJson = buildJsonResponse(false, msg);
 205                                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 206                                 }
 207                         } else if (requestUri.endsWith("/timeoutSession")) {
 208                                 String portalJSessionId = request.getParameter("portalJSessionId");
 209                                 if (portalJSessionId == null) {
 210                                         portalJSessionId = "";
 211                                 }
 212                                 if (timeoutSession(portalJSessionId)) {
 213                                         if (logger.isDebugEnabled())
 214                                                 logger.debug("doPost: timed out session");
 215                                         response.setStatus(HttpServletResponse.SC_OK);
 216                                 } else {
 217                                         String msg = "Failed to timeout session";
 218                                         logger.error("doPost: " + msg);
 219                                         responseJson = buildJsonResponse(false, msg);
 220                                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 221                                 }
 222                         } else
 223                         // Example: /user <-- create user
 224                         if (requestUri.endsWith(PortalApiConstants.API_PREFIX + "/user")) {
 225                                 try {
 226                                         EcompUser user = mapper.readValue(requestBody, EcompUser.class);
 227                                         pushUser(user);
 228                                         if (logger.isDebugEnabled())
 229                                                 logger.debug("doPost: pushUser: success");
 230                                         responseJson = buildJsonResponse(true, null);
 231                                         response.setStatus(HttpServletResponse.SC_OK);
 232                                 } catch (Exception ex) {
 233                                         responseJson = buildJsonResponse(ex);
 234                                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 235                                         logger.error("doPost: pushUser: caught exception", ex);
 236                                 }
 237                         } else
 238                         // Example: /user/fi241c <-- edit user fi241c
 239                         if (requestUri.contains(PortalApiConstants.API_PREFIX + "/user/") && !(requestUri.endsWith("/roles"))) {
 240                                 String loginId = requestUri.substring(requestUri.lastIndexOf('/') + 1);
 241                                 try {
 242                                         EcompUser user = mapper.readValue(requestBody, EcompUser.class);
 243                                         editUser(loginId, user);
 244                                         if (logger.isDebugEnabled())
 245                                                 logger.debug("doPost: editUser: success");
 246                                         responseJson = buildJsonResponse(true, null);
 247                                         response.setStatus(HttpServletResponse.SC_OK);
 248                                 } catch (Exception ex) {
 249                                         responseJson = buildJsonResponse(ex);
 250                                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 251                                         logger.error("doPost: editUser: caught exception", ex);
 252                                 }
 253                         } else
 254                         // Example: /user/{loginId}/roles <-- save roles for user
 255                         if (requestUri.contains(PortalApiConstants.API_PREFIX + "/user/") && requestUri.endsWith("/roles")) {
 256                                 String loginId = requestUri.substring(requestUri.indexOf("/user/") + ("/user").length() + 1,
 257                                                 requestUri.lastIndexOf('/'));
 258                                 try {
 259                                         TypeReference<List<EcompRole>> typeRef = new TypeReference<List<EcompRole>>() {
 260                                         };
 261                                         List<EcompRole> roles = mapper.readValue(requestBody, typeRef);
 262                                         pushUserRole(loginId, roles);
 263                                         if (logger.isDebugEnabled())
 264                                                 logger.debug("doPost: pushUserRole: success");
 265                                         responseJson = buildJsonResponse(true, null);
 266                                         response.setStatus(HttpServletResponse.SC_OK);
 267                                 } catch (Exception ex) {
 268                                         responseJson = buildJsonResponse(ex);
 269                                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 270                                         logger.error("doPost: pushUserRole: caught exception", ex);
 271                                 }
 272                         } else {
 273                                 String msg = "doPost: no match for request " + requestUri;
 274                                 logger.warn(msg);
 275                                 responseJson = buildJsonResponse(false, msg);
 276                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 277                         }
 278                 } catch (Exception ex) {
 279                         logger.error("doPost: Failed to process request " + requestUri, ex);
 280                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 281                         responseJson = buildJsonResponse(ex);
 282                 }
 283
 284                 writeAndFlush(response, contentTypeAppJson, responseJson);
 285
 286         }
 287
 288         @Override
 289         protected void doGet(HttpServletRequest request, HttpServletResponse response)
 290                         throws IOException, ServletException {
 291
 292                 if (portalRestApiServiceImpl == null) {
 293                         // Should never happen due to checks in init()
 294                         logger.error("doGet: no service class instance");
 295                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 296                         writeAndFlush(response, contentTypeAppJson,
 297                                         buildJsonResponse(false, "Misconfigured - no instance of service class"));
 298                         return;
 299                 }
 300
 301                 String requestUri = request.getRequestURI();
 302                 String responseString = "";
 303                 String contentType = contentTypeAppJson;
 304
 305                 String webAnalyticsContextPath = "/analytics";
 306                 if (requestUri.endsWith(PortalApiConstants.API_PREFIX + webAnalyticsContextPath)) {
 307                         String userId;
 308                         try {
 309                                 userId = getUserId(request);
 310                         } catch (PortalAPIException e) {
 311                                 logger.error("Issue with invoking getUserId implemenation !!! ", e);
 312                                 throw new ServletException(e);
 313                         }
 314                         if (userId == null || userId.length() == 0) {
 315                                 logger.debug("doGet: userId is null or empty");
 316                                 response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
 317                                 responseString = buildJsonResponse(false, "Not authorized for " + webAnalyticsContextPath);
 318                         } else {
 319                                 // User ID obtained from request
 320                                 try {
 321                                         String credential = PortalApiProperties.getProperty(PortalApiConstants.UEB_APP_KEY);
 322                                         // for now lets also pass uebkey as user name and password
 323                                         contentType = "text/javascript";
 324                                         responseString = RestWebServiceClient.getInstance().getPortalContent(webAnalyticsContextPath,
 325                                                         userId, credential, null, credential, credential);
 326                                         if (logger.isDebugEnabled())
 327                                                 logger.debug("doGet: " + webAnalyticsContextPath + ": " + responseString);
 328                                         response.setStatus(HttpServletResponse.SC_OK);
 329                                 } catch (Exception ex) {
 330                                         responseString = buildJsonResponse(ex);
 331                                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 332                                         logger.error("doGet: " + webAnalyticsContextPath + " caught exception", ex);
 333                                 }
 334                         }
 335                         writeAndFlush(response, contentType, responseString);
 336                         return;
 337                 }
 338
 339                 boolean secure = false;
 340                 try {
 341                         secure = isAppAuthenticated(request);
 342                 } catch (PortalAPIException ex) {
 343                         logger.error("doGet: isAppAuthenticated threw exception", ex);
 344                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 345                         writeAndFlush(response, contentTypeAppJson, buildJsonResponse(false, "Failed to authenticate request"));
 346                         return;
 347                 }
 348
 349                 if (!secure) {
 350                         if (logger.isDebugEnabled())
 351                                 logger.debug("doGet: isAppAuthenticated answered false");
 352                         response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
 353                         writeAndFlush(response, contentTypeAppJson, buildJsonResponse(false, "Not authorized"));
 354                         return;
 355                 }
 356
 357                 String responseJson = null;
 358                 try {
 359                         // Ignore any request body in a GET.
 360                         // String requestBody = readRequestBody(request);
 361                         if (logger.isDebugEnabled())
 362                                 logger.debug("doGet: URI =  " + requestUri);
 363
 364                         /*
 365                          * 1. /roles <-- get roles
 366                          *
 367                          * 2. /user/{loginId} <-- get user
 368                          *
 369                          * 3. /users <-- get all users
 370                          *
 371                          * 4. /user/{loginId}/roles <-- get roles for user
 372                          */
 373
 374                         if (requestUri.endsWith("/sessionTimeOuts")) {
 375                                 responseJson = getSessionTimeOuts();
 376                                 if (responseJson != null && responseJson.length() > 0) {
 377                                         if (logger.isDebugEnabled())
 378                                                 logger.debug("doGet: got session timeouts");
 379                                         response.setStatus(HttpServletResponse.SC_OK);
 380                                 } else {
 381                                         String msg = "Failed to get session time outs";
 382                                         logger.error("doGet: " + msg);
 383                                         responseJson = buildJsonResponse(false, msg);
 384                                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 385                                 }
 386                         } else
 387                         // Example: /users <-- get all users
 388                         if (requestUri.endsWith(PortalApiConstants.API_PREFIX + "/users")) {
 389                                 try {
 390                                         List<EcompUser> users = getUsers();
 391                                         responseJson = mapper.writeValueAsString(users);
 392                                         if (logger.isDebugEnabled())
 393                                                 logger.debug("doGet: getUsers: " + responseJson);
 394                                 } catch (Exception ex) {
 395                                         responseJson = buildJsonResponse(ex);
 396                                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 397                                         logger.error("doGet: getUsers: caught exception", ex);
 398                                 }
 399                         } else
 400                         // Example: /roles <-- get all roles
 401                         if (requestUri.endsWith(PortalApiConstants.API_PREFIX + "/roles")) {
 402                                 try {
 403                                         List<EcompRole> roles = getAvailableRoles();
 404                                         responseJson = mapper.writeValueAsString(roles);
 405                                         if (logger.isDebugEnabled())
 406                                                 logger.debug("doGet: getAvailableRoles: " + responseJson);
 407                                 } catch (Exception ex) {
 408                                         responseJson = buildJsonResponse(ex);
 409                                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 410                                         logger.error("doGet: getAvailableRoles: caught exception", ex);
 411                                 }
 412                         } else
 413                         // Example: /user/fi241c <-- get user fi241c
 414                         if (requestUri.contains(PortalApiConstants.API_PREFIX + "/user/") && !requestUri.endsWith("/roles")) {
 415                                 String loginId = requestUri.substring(requestUri.lastIndexOf('/') + 1);
 416                                 try {
 417                                         EcompUser user = getUser(loginId);
 418                                         responseJson = mapper.writeValueAsString(user);
 419                                         if (logger.isDebugEnabled())
 420                                                 logger.debug("doGet: getUser: " + responseJson);
 421                                 } catch (Exception ex) {
 422                                         responseJson = buildJsonResponse(ex);
 423                                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 424                                         logger.error("doGet: getUser: caught exception", ex);
 425                                 }
 426                         }
 427                         // Example: /user/fi241c/roles <-- get roles for user fi241c
 428                         else if (requestUri.contains(PortalApiConstants.API_PREFIX + "/user/") && requestUri.endsWith("/roles")) {
 429                                 String loginId = requestUri.substring(requestUri.indexOf("/user/") + ("/user").length() + 1,
 430                                                 requestUri.lastIndexOf('/'));
 431                                 try {
 432                                         List<EcompRole> roles = getUserRoles(loginId);
 433                                         responseJson = mapper.writeValueAsString(roles);
 434                                         if (logger.isDebugEnabled())
 435                                                 logger.debug("doGet: getUserRoles: " + responseJson);
 436                                 } catch (Exception ex) {
 437                                         responseJson = buildJsonResponse(ex);
 438                                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 439                                         logger.error("doGet: getUserRoles: caught exception", ex);
 440                                 }
 441                         } else {
 442                                 logger.warn("doGet: no match found for request");
 443                                 responseJson = buildJsonResponse(false, "No match for request");
 444                                 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 445                         }
 446                 } catch (Exception ex) {
 447                         logger.error("doGet: Failed to process request", ex);
 448                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 449                         responseJson = buildJsonResponse(ex);
 450                 }
 451                 writeAndFlush(response, contentTypeAppJson, responseJson);
 452         }
 453
 454         public String getSessionTimeOuts() throws Exception {
 455                 return PortalTimeoutHandler.gatherSessionExtensions();
 456         }
 457
 458         public boolean timeoutSession(String portalJSessionId) throws Exception {
 459                 return PortalTimeoutHandler.invalidateSession(portalJSessionId);
 460         }
 461
 462         public boolean updateSessionTimeOuts(String sessionMap) throws Exception {
 463                 return PortalTimeoutHandler.updateSessionExtensions(sessionMap);
 464         }
 465
 466         @Override
 467         public void pushUser(EcompUser user) throws PortalAPIException {
 468                 portalRestApiServiceImpl.pushUser(user);
 469         }
 470
 471         @Override
 472         public void editUser(String loginId, EcompUser user) throws PortalAPIException {
 473                 portalRestApiServiceImpl.editUser(loginId, user);
 474         }
 475
 476         @Override
 477         public EcompUser getUser(String loginId) throws PortalAPIException {
 478                 return portalRestApiServiceImpl.getUser(loginId);
 479         }
 480
 481         @Override
 482         public List<EcompUser> getUsers() throws PortalAPIException {
 483                 return portalRestApiServiceImpl.getUsers();
 484         }
 485
 486         @Override
 487         public List<EcompRole> getAvailableRoles() throws PortalAPIException {
 488                 return portalRestApiServiceImpl.getAvailableRoles();
 489         }
 490
 491         @Override
 492         public void pushUserRole(String loginId, List<EcompRole> roles) throws PortalAPIException {
 493                 portalRestApiServiceImpl.pushUserRole(loginId, roles);
 494         }
 495
 496         @Override
 497         public List<EcompRole> getUserRoles(String loginId) throws PortalAPIException {
 498                 return portalRestApiServiceImpl.getUserRoles(loginId);
 499         }
 500
 501         @Override
 502         public boolean isAppAuthenticated(HttpServletRequest request) throws PortalAPIException {
 503                 return portalRestApiServiceImpl.isAppAuthenticated(request);
 504         }
 505
 506         /**
 507          * Sets the content type and writes the response.
 508          *
 509          * @param response
 510          * @param contentType
 511          * @param responseBody
 512          * @throws IOException
 513          */
 514         private void writeAndFlush(HttpServletResponse response, String contentType, String responseBody)
 515                         throws IOException {
 516                 response.setContentType(contentType);
 517                 PrintWriter out = response.getWriter();
 518                 out.print(responseBody);
 519                 out.flush();
 520         }
 521
 522         /**
 523          * Reads the request body and closes the input stream.
 524          *
 525          * @param request
 526          * @return String read from the request, the empty string if nothing is
 527          *         read.
 528          * @throws IOException
 529          */
 530         private static String readRequestBody(HttpServletRequest request) throws IOException {
 531
 532                 String body = null;
 533                 StringBuilder stringBuilder = new StringBuilder();
 534                 BufferedReader bufferedReader = null;
 535                 try {
 536                         InputStream inputStream = request.getInputStream();
 537                         if (inputStream != null) {
 538                                 bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
 539                                 char[] charBuffer = new char[1024];
 540                                 int bytesRead = -1;
 541                                 while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
 542                                         stringBuilder.append(charBuffer, 0, bytesRead);
 543                                 }
 544                         } else {
 545                                 stringBuilder.append("");
 546                         }
 547                 } finally {
 548                         if (bufferedReader != null) {
 549                                 try {
 550                                         bufferedReader.close();
 551                                 } catch (IOException ex) {
 552                                         throw ex;
 553                                 }
 554                         }
 555                 }
 556                 body = stringBuilder.toString();
 557                 return body;
 558         }
 559
 560         /**
 561          * Builds JSON object with status + message response body.
 562          *
 563          * @param success
 564          *            True to indicate success, false to signal failure.
 565          * @param msg
 566          *            Message to include in the response object; ignored if null.
 567          * @return
 568          *
 569          *         <pre>
 570          * { "status" : "ok" (or "error"), "message": "some explanation" }
 571          *         </pre>
 572          */
 573         private String buildJsonResponse(boolean success, String msg) {
 574                 PortalAPIResponse response = new PortalAPIResponse(success, msg);
 575                 String json = null;
 576                 try {
 577                         json = mapper.writeValueAsString(response);
 578                 } catch (JsonProcessingException ex) {
 579                         // Truly should never, ever happen
 580                         json = "{ \"status\": \"error\",\"message\":\"" + ex.toString() + "\" }";
 581                 }
 582                 return json;
 583         }
 584
 585         /**
 586          * Builds JSON object with status of error and message containing stack
 587          * trace for the specified throwable.
 588          *
 589          * @param t
 590          *            Throwable with stack trace to use as message
 591          *
 592          * @return
 593          *
 594          *         <pre>
 595          * { "status" : "error", "message": "some-big-stacktrace" }
 596          *         </pre>
 597          */
 598         private String buildJsonResponse(Throwable t) {
 599                 StringWriter sw = new StringWriter();
 600                 PrintWriter pw = new PrintWriter(sw);
 601                 t.printStackTrace(pw);
 602                 return buildJsonResponse(false, sw.toString());
 603         }
 604
 605         @Override
 606         public String getUserId(HttpServletRequest request) throws PortalAPIException {
 607                 return portalRestApiServiceImpl.getUserId(request);
 608         }
 609
 610         public static IPortalRestAPIService getPortalRestApiServiceImpl() {
 611                 return portalRestApiServiceImpl;
 612         }
 613
 614         public static void setPortalRestApiServiceImpl(IPortalRestAPIService portalRestApiServiceImpl) {
 615                 PortalRestAPIProxy.portalRestApiServiceImpl = portalRestApiServiceImpl;
 616         }
 617
 618 }