コード例 #1
0
  protected void writeImage(Image image, HttpServletRequest request, HttpServletResponse response) {

    if (image == null) {
      return;
    }

    String contentType = null;

    String type = image.getType();

    if (!type.equals(ImageConstants.TYPE_NOT_AVAILABLE)) {
      contentType = MimeTypesUtil.getContentType("A." + type);

      response.setContentType(contentType);
    }

    String fileName = ParamUtil.getString(request, "fileName");

    try {
      byte[] bytes = getImageBytes(request, image);

      if (Validator.isNotNull(fileName)) {
        ServletResponseUtil.sendFile(request, response, fileName, bytes, contentType);
      } else {
        ServletResponseUtil.write(response, bytes);
      }
    } catch (Exception e) {
      if (_log.isWarnEnabled()) {
        _log.warn(e, e);
      }
    }
  }
コード例 #2
0
  @Override
  public void serveResource(ResourceRequest resourceRequest, ResourceResponse resourceResponse) {

    try {
      ThemeDisplay themeDisplay =
          (ThemeDisplay) resourceRequest.getAttribute(WebKeys.THEME_DISPLAY);

      if (!MentionsUtil.isMentionsEnabled(themeDisplay.getSiteGroupId())) {

        return;
      }

      HttpServletRequest request = PortalUtil.getHttpServletRequest(resourceRequest);

      JSONArray jsonArray = getJSONArray(request);

      HttpServletResponse response = PortalUtil.getHttpServletResponse(resourceResponse);

      response.setContentType(ContentTypes.APPLICATION_JSON);

      ServletResponseUtil.write(response, jsonArray.toString());
    } catch (Exception e) {
      _log.error(e, e);
    }

    return;
  }
コード例 #3
0
  protected void remoteProcessAction(ActionRequest actionRequest, ActionResponse actionResponse)
      throws Exception {

    ThemeDisplay themeDisplay = (ThemeDisplay) actionRequest.getAttribute(WebKeys.THEME_DISPLAY);

    OAuthRequest oAuthRequest = new OAuthRequest(Verb.POST, getServerPortletURL());

    setRequestParameters(actionRequest, actionResponse, oAuthRequest);

    addOAuthParameter(oAuthRequest, "p_p_lifecycle", "1");
    addOAuthParameter(oAuthRequest, "p_p_state", WindowState.NORMAL.toString());

    Response response = getResponse(themeDisplay.getUser(), oAuthRequest);

    if (response.getCode() == HttpServletResponse.SC_FOUND) {
      String redirectLocation = response.getHeader(HttpHeaders.LOCATION);

      actionResponse.sendRedirect(redirectLocation);
    } else {
      HttpServletResponse httpServletResponse = PortalUtil.getHttpServletResponse(actionResponse);

      httpServletResponse.setContentType(response.getHeader(HttpHeaders.CONTENT_TYPE));

      ServletResponseUtil.write(httpServletResponse, response.getStream());
    }
  }
コード例 #4
0
  @Override
  protected void processFilter(
      HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
      throws Exception {

    Object parsedContent = getDynamicContent(request, response, filterChain);

    if (parsedContent == null) {
      processFilter(DynamicCSSFilter.class, request, response, filterChain);
    } else {
      if (parsedContent instanceof File) {
        ServletResponseUtil.write(response, (File) parsedContent);
      } else if (parsedContent instanceof String) {
        ServletResponseUtil.write(response, (String) parsedContent);
      }
    }
  }
コード例 #5
0
  @Override
  public ActionForward execute(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
      throws Exception {

    // PLACEHOLDER 01
    // PLACEHOLDER 02
    // PLACEHOLDER 03
    // PLACEHOLDER 04
    // PLACEHOLDER 05

    if (_isValidRequest(request)) {
      String cmd = ParamUtil.getString(request, Constants.CMD);

      String clusterNodeId = ParamUtil.getString(request, "clusterNodeId");

      if (cmd.equals("licenseProperties")) {
        String licenseProperties = _getLicenseProperties(clusterNodeId);

        response.setContentType(ContentTypes.TEXT_JAVASCRIPT);

        ServletResponseUtil.write(response, licenseProperties);

        return null;
      } else if (cmd.equals("serverInfo")) {
        String serverInfo = _getServerInfo(clusterNodeId);

        response.setContentType(ContentTypes.TEXT_JAVASCRIPT);

        ServletResponseUtil.write(response, serverInfo);

        return null;
      }

      return mapping.findForward("portal.license");
    } else {
      response.sendRedirect(PortalUtil.getPathContext() + "/c/portal/layout");

      return null;
    }
  }
コード例 #6
0
  protected static void writeJSON(
      PortletRequest portletRequest, ActionResponse actionResponse, Object json)
      throws IOException {

    HttpServletResponse response = PortalUtil.getHttpServletResponse(actionResponse);

    response.setContentType(ContentTypes.APPLICATION_JSON);

    ServletResponseUtil.write(response, json.toString());

    response.flushBuffer();
  }
コード例 #7
0
  public static void writeJSON(
      PortletRequest portletRequest, PortletResponse portletResponse, Object json)
      throws IOException {

    HttpServletResponse response = PortalUtil.getHttpServletResponse(portletResponse);

    response.setContentType(_getContentType(portletRequest));

    ServletResponseUtil.write(response, json.toString());

    response.flushBuffer();
  }
コード例 #8
0
  @Override
  protected void processFilter(
      HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
      throws Exception {

    ByteBufferServletResponse byteBufferResponse = new ByteBufferServletResponse(response);

    processFilter(ETagFilter.class, request, byteBufferResponse, filterChain);

    if (!ETagUtil.processETag(request, response, byteBufferResponse)) {
      ServletResponseUtil.write(response, byteBufferResponse.getByteBuffer());
    }
  }
コード例 #9
0
  protected void sendFile(
      HttpServletResponse response, User user, long groupId, long folderId, String title)
      throws Exception {

    FileEntry fileEntry = DLAppServiceUtil.getFileEntry(groupId, folderId, title);

    String contentType = fileEntry.getMimeType();

    response.setContentType(contentType);

    InputStream inputStream = fileEntry.getContentStream();

    ServletResponseUtil.write(response, inputStream);
  }
コード例 #10
0
  protected void testDatabase(HttpServletRequest request, HttpServletResponse response)
      throws Exception {

    JSONObject jsonObject = JSONFactoryUtil.createJSONObject();

    try {
      SetupWizardUtil.testDatabase(request);

      jsonObject.put("success", true);

      putMessage(request, jsonObject, "database-connection-was-established-sucessfully");
    } catch (ClassNotFoundException cnfe) {
      putMessage(
          request, jsonObject, "database-driver-x-is-not-present", cnfe.getLocalizedMessage());
    } catch (SQLException sqle) {
      putMessage(request, jsonObject, "database-connection-could-not-be-established");
    }

    response.setContentType(ContentTypes.APPLICATION_JSON);
    response.setHeader(HttpHeaders.CACHE_CONTROL, HttpHeaders.CACHE_CONTROL_NO_CACHE_VALUE);

    ServletResponseUtil.write(response, jsonObject.toString());
  }
  @Override
  protected void doServeResource(ResourceRequest resourceRequest, ResourceResponse resourceResponse)
      throws Exception {

    HttpServletResponse httpServletResponse = PortalUtil.getHttpServletResponse(resourceResponse);

    HttpServletRequest httpServletRequest = PortalUtil.getHttpServletRequest(resourceRequest);

    DDMFormField ddmFormField = getDDMFormField(httpServletRequest);

    DDMFormFieldRenderer ddmFormFieldRenderer =
        _ddmFormFieldRendererRegistry.getDDMFormFieldRenderer(ddmFormField.getType());

    DDMFormFieldRenderingContext ddmFormFieldRenderingContext =
        createDDMFormFieldRenderingContext(httpServletRequest, httpServletResponse);

    String ddmFormFieldHTML =
        ddmFormFieldRenderer.render(ddmFormField, ddmFormFieldRenderingContext);

    httpServletResponse.setContentType(ContentTypes.TEXT_HTML);

    ServletResponseUtil.write(httpServletResponse, ddmFormFieldHTML);
  }
コード例 #12
0
  @Override
  protected void processFilter(
      HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
      throws Exception {

    request.setAttribute(SKIP_FILTER, Boolean.TRUE);

    if (_log.isDebugEnabled()) {
      String completeURL = HttpUtil.getCompleteURL(request);

      _log.debug("Fragmenting " + completeURL);
    }

    BufferCacheServletResponse bufferCacheServletResponse =
        new BufferCacheServletResponse(response);

    processFilter(FragmentFilter.class, request, bufferCacheServletResponse, filterChain);

    String content = bufferCacheServletResponse.getString();

    content = getContent(request, content);

    ServletResponseUtil.write(response, content);
  }
コード例 #13
0
  @Override
  public ActionForward execute(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
      throws Exception {

    if (!PropsValues.PORTLET_URL_GENERATE_BY_PATH_ENABLED) {
      response.sendError(HttpServletResponse.SC_FORBIDDEN);

      return null;
    }

    try {
      String portletURL = getPortletURL(request);

      ServletResponseUtil.write(response, portletURL);
    } catch (Exception e) {
      PortalUtil.sendError(e, request, response);
    }

    return null;
  }
コード例 #14
0
  protected void vtiBinWebsAsmx(HttpServletRequest request, HttpServletResponse response)
      throws Exception {

    StringBundler sb = new StringBundler(12);

    String url = "http://" + request.getLocalAddr() + ":" + request.getServerPort() + "/sharepoint";

    sb.append("<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"");
    sb.append("http://schemas.xmlsoap.org/soap/envelope/\">");
    sb.append("<SOAP-ENV:Header/>");
    sb.append("<SOAP-ENV:Body>");
    sb.append("<WebUrlFromPageUrlResponse xmlns=\"");
    sb.append("http://schemas.microsoft.com/sharepoint/soap/\">");
    sb.append("<WebUrlFromPageUrlResult>");
    sb.append(url);
    sb.append("</WebUrlFromPageUrlResult>");
    sb.append("</WebUrlFromPageUrlResponse>");
    sb.append("</SOAP-ENV:Body>");
    sb.append("</SOAP-ENV:Envelope>");

    response.setContentType(ContentTypes.TEXT_XML_UTF8);

    ServletResponseUtil.write(response, sb.toString());
  }
コード例 #15
0
  protected void sendFile(
      HttpServletRequest request, HttpServletResponse response, User user, String[] pathArray)
      throws Exception {

    // Retrieve file details

    FileEntry fileEntry = getFileEntry(pathArray);

    if (fileEntry == null) {
      throw new NoSuchFileEntryException();
    }

    String version = ParamUtil.getString(request, "version");

    if (Validator.isNull(version)) {
      if (Validator.isNotNull(fileEntry.getVersion())) {
        version = fileEntry.getVersion();
      }
    }

    String tempFileId = DLUtil.getTempFileId(fileEntry.getFileEntryId(), version);

    FileVersion fileVersion = fileEntry.getFileVersion(version);

    String fileName = fileVersion.getTitle();

    String extension = fileVersion.getExtension();

    if (Validator.isNotNull(extension) && !fileName.endsWith(StringPool.PERIOD + extension)) {

      fileName += StringPool.PERIOD + extension;
    }

    // Handle requested conversion

    boolean converted = false;

    String targetExtension = ParamUtil.getString(request, "targetExtension");
    int imageThumbnail = ParamUtil.getInteger(request, "imageThumbnail");
    int documentThumbnail = ParamUtil.getInteger(request, "documentThumbnail");
    int previewFileIndex = ParamUtil.getInteger(request, "previewFileIndex");
    boolean audioPreview = ParamUtil.getBoolean(request, "audioPreview");
    boolean imagePreview = ParamUtil.getBoolean(request, "imagePreview");
    boolean videoPreview = ParamUtil.getBoolean(request, "videoPreview");
    int videoThumbnail = ParamUtil.getInteger(request, "videoThumbnail");

    InputStream inputStream = null;
    long contentLength = 0;

    if ((imageThumbnail > 0) && (imageThumbnail <= 3)) {
      fileName =
          FileUtil.stripExtension(fileName)
              .concat(StringPool.PERIOD)
              .concat(ImageProcessorUtil.getThumbnailType(fileVersion));

      int thumbnailIndex = imageThumbnail - 1;

      inputStream = ImageProcessorUtil.getThumbnailAsStream(fileVersion, thumbnailIndex);
      contentLength = ImageProcessorUtil.getThumbnailFileSize(fileVersion, thumbnailIndex);

      converted = true;
    } else if ((documentThumbnail > 0) && (documentThumbnail <= 3)) {
      fileName =
          FileUtil.stripExtension(fileName)
              .concat(StringPool.PERIOD)
              .concat(PDFProcessor.THUMBNAIL_TYPE);

      int thumbnailIndex = documentThumbnail - 1;

      inputStream = PDFProcessorUtil.getThumbnailAsStream(fileVersion, thumbnailIndex);
      contentLength = PDFProcessorUtil.getThumbnailFileSize(fileVersion, thumbnailIndex);

      converted = true;
    } else if (previewFileIndex > 0) {
      fileName =
          FileUtil.stripExtension(fileName)
              .concat(StringPool.PERIOD)
              .concat(PDFProcessor.PREVIEW_TYPE);
      inputStream = PDFProcessorUtil.getPreviewAsStream(fileVersion, previewFileIndex);
      contentLength = PDFProcessorUtil.getPreviewFileSize(fileVersion, previewFileIndex);

      converted = true;
    } else if (audioPreview || videoPreview) {
      String type = ParamUtil.getString(request, "type");

      fileName = FileUtil.stripExtension(fileName).concat(StringPool.PERIOD).concat(type);

      if (audioPreview) {
        inputStream = AudioProcessorUtil.getPreviewAsStream(fileVersion, type);
        contentLength = AudioProcessorUtil.getPreviewFileSize(fileVersion, type);
      } else {
        inputStream = VideoProcessorUtil.getPreviewAsStream(fileVersion, type);
        contentLength = VideoProcessorUtil.getPreviewFileSize(fileVersion, type);
      }

      converted = true;
    } else if (imagePreview) {
      String type = ImageProcessorUtil.getPreviewType(fileVersion);

      fileName = FileUtil.stripExtension(fileName).concat(StringPool.PERIOD).concat(type);

      inputStream = ImageProcessorUtil.getPreviewAsStream(fileVersion);

      contentLength = ImageProcessorUtil.getPreviewFileSize(fileVersion);

      converted = true;
    } else if ((videoThumbnail > 0) && (videoThumbnail <= 3)) {
      fileName =
          FileUtil.stripExtension(fileName)
              .concat(StringPool.PERIOD)
              .concat(VideoProcessor.THUMBNAIL_TYPE);

      int thumbnailIndex = videoThumbnail - 1;

      inputStream = VideoProcessorUtil.getThumbnailAsStream(fileVersion, thumbnailIndex);
      contentLength = VideoProcessorUtil.getThumbnailFileSize(fileVersion, thumbnailIndex);

      converted = true;
    } else {
      inputStream = fileVersion.getContentStream(true);
      contentLength = fileVersion.getSize();

      if (Validator.isNotNull(targetExtension)) {
        File convertedFile =
            DocumentConversionUtil.convert(tempFileId, inputStream, extension, targetExtension);

        if (convertedFile != null) {
          fileName =
              FileUtil.stripExtension(fileName).concat(StringPool.PERIOD).concat(targetExtension);
          inputStream = new FileInputStream(convertedFile);
          contentLength = convertedFile.length();

          converted = true;
        }
      }
    }

    // Determine proper content type

    String contentType = null;

    if (converted) {
      contentType = MimeTypesUtil.getContentType(fileName);
    } else {
      contentType = fileVersion.getMimeType();
    }

    // Support range HTTP header

    response.setHeader(HttpHeaders.ACCEPT_RANGES, HttpHeaders.ACCEPT_RANGES_BYTES_VALUE);

    List<Range> ranges = null;

    try {
      ranges = ServletResponseUtil.getRanges(request, response, contentLength);
    } catch (IOException ioe) {
      if (_log.isErrorEnabled()) {
        _log.error(ioe);
      }

      response.setHeader(HttpHeaders.CONTENT_RANGE, "bytes */" + contentLength);

      response.sendError(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);

      return;
    }

    if ((ranges == null) || ranges.isEmpty()) {
      ServletResponseUtil.sendFile(
          request, response, fileName, inputStream, contentLength, contentType);
    } else {
      if (_log.isDebugEnabled()) {
        _log.debug("Request has range header " + request.getHeader(HttpHeaders.RANGE));
      }

      ServletResponseUtil.write(
          request, response, fileName, ranges, inputStream, contentLength, contentType);
    }
  }
コード例 #16
0
  protected int doProcess(WebDAVRequest webDAVRequest) throws Exception {
    WebDAVStorage storage = webDAVRequest.getWebDAVStorage();

    if (!storage.isSupportsClassTwo()) {
      return HttpServletResponse.SC_METHOD_NOT_ALLOWED;
    }

    HttpServletRequest request = webDAVRequest.getHttpServletRequest();
    HttpServletResponse response = webDAVRequest.getHttpServletResponse();

    Lock lock = null;
    Status status = null;

    String lockUuid = webDAVRequest.getLockUuid();
    long timeout = WebDAVUtil.getTimeout(request);

    if (Validator.isNull(lockUuid)) {

      // Create new lock

      String owner = null;
      String xml = new String(FileUtil.getBytes(request.getInputStream()));

      if (Validator.isNotNull(xml)) {
        if (_log.isDebugEnabled()) {
          _log.debug("Request XML\n" + XMLFormatter.toString(xml));
        }

        Document document = SAXReaderUtil.read(xml);

        Element rootElement = document.getRootElement();

        boolean exclusive = false;

        Element lockscopeElement = rootElement.element("lockscope");

        for (Element element : lockscopeElement.elements()) {
          String name = GetterUtil.getString(element.getName());

          if (name.equals("exclusive")) {
            exclusive = true;
          }
        }

        if (!exclusive) {
          return HttpServletResponse.SC_BAD_REQUEST;
        }

        Element ownerElement = rootElement.element("owner");

        owner = ownerElement.getTextTrim();

        if (Validator.isNull(owner)) {
          List<Element> hrefElements = ownerElement.elements("href");

          for (Element hrefElement : hrefElements) {
            owner = "<D:href>" + hrefElement.getTextTrim() + "</D:href>";
          }
        }
      } else {
        _log.error("Empty request XML");

        return HttpServletResponse.SC_PRECONDITION_FAILED;
      }

      status = storage.lockResource(webDAVRequest, owner, timeout);

      lock = (Lock) status.getObject();
    } else {
      try {

        // Refresh existing lock

        lock = storage.refreshResourceLock(webDAVRequest, lockUuid, timeout);

        status = new Status(HttpServletResponse.SC_OK);
      } catch (WebDAVException wde) {
        if (wde.getCause() instanceof NoSuchLockException) {
          return HttpServletResponse.SC_PRECONDITION_FAILED;
        } else {
          throw wde;
        }
      }
    }

    // Return lock details

    if (lock == null) {
      return status.getCode();
    }

    long depth = WebDAVUtil.getDepth(request);

    String xml = getResponseXML(lock, depth);

    if (_log.isDebugEnabled()) {
      _log.debug("Response XML\n" + xml);
    }

    String lockToken = "<" + WebDAVUtil.TOKEN_PREFIX + lock.getUuid() + ">";

    response.setContentType(ContentTypes.TEXT_XML_UTF8);
    response.setHeader("Lock-Token", lockToken);
    response.setStatus(status.getCode());

    if (_log.isDebugEnabled()) {
      _log.debug("Returning lock token " + lockToken);
    }

    try {
      ServletResponseUtil.write(response, xml);
    } catch (Exception e) {
      if (_log.isWarnEnabled()) {
        _log.warn(e);
      }
    }

    return status.getCode();
  }