/**
   * Downloads a Bundle file for a given bundle id.
   *
   * @param request HttpRequest
   * @param response HttpResponse
   * @throws IOException If fails sending back to the user response information
   */
  public void downloadBundle(HttpServletRequest request, HttpServletResponse response)
      throws IOException {
    try {
      if (!APILocator.getLayoutAPI()
          .doesUserHaveAccessToPortlet("EXT_CONTENT_PUBLISHING_TOOL", getUser())) {
        response.sendError(401);
        return;
      }
    } catch (DotDataException e1) {
      Logger.error(RemotePublishAjaxAction.class, e1.getMessage(), e1);
      response.sendError(401);
      return;
    }
    Map<String, String> map = getURIParams();
    response.setContentType("application/x-tgz");

    String bid = map.get("bid");

    PublisherConfig config = new PublisherConfig();
    config.setId(bid);
    File bundleRoot = BundlerUtil.getBundleRoot(config);

    ArrayList<File> list = new ArrayList<File>(1);
    list.add(bundleRoot);
    File bundle =
        new File(bundleRoot + File.separator + ".." + File.separator + config.getId() + ".tar.gz");
    if (!bundle.exists()) {
      response.sendError(500, "No Bundle Found");
      return;
    }

    response.setHeader("Content-Disposition", "attachment; filename=" + config.getId() + ".tar.gz");
    BufferedInputStream in = null;
    try {
      in = new BufferedInputStream(new FileInputStream(bundle));
      byte[] buf = new byte[4096];
      int len;

      while ((len = in.read(buf, 0, buf.length)) != -1) {
        response.getOutputStream().write(buf, 0, len);
      }
    } catch (Exception e) {
      Logger.warn(this.getClass(), "Error Downloading Bundle.", e);
    } finally {
      try {
        in.close();
      } catch (Exception ex) {
        Logger.warn(this.getClass(), "Error Closing Stream.", ex);
      }
    }
    return;
  }
  /**
   * Adds to an specific given bundle a given asset. <br>
   * If the given bundle does not exist a new onw will be created with that name
   *
   * @param request HttpRequest
   * @param response HttpResponse
   */
  public void addToBundle(HttpServletRequest request, HttpServletResponse response)
      throws IOException {

    PublisherAPI publisherAPI = PublisherAPI.getInstance();
    String _assetId = request.getParameter("assetIdentifier");
    String _contentFilterDate = request.getParameter("remoteFilterDate");
    String bundleName = request.getParameter("bundleName");
    String bundleId = request.getParameter("bundleSelect");

    try {
      Bundle bundle;

      if (bundleId == null || bundleName.equals(bundleId)) {
        // if the user has a unsent bundle with that name just add to it
        bundle = null;
        for (Bundle b :
            APILocator.getBundleAPI()
                .getUnsendBundlesByName(getUser().getUserId(), bundleName, 1000, 0)) {
          if (b.getName().equalsIgnoreCase(bundleName)) {
            bundle = b;
          }
        }

        if (bundle == null) {
          bundle = new Bundle(bundleName, null, null, getUser().getUserId());
          APILocator.getBundleAPI().saveBundle(bundle);
        }
      } else {
        bundle = APILocator.getBundleAPI().getBundleById(bundleId);
      }

      // Put the selected bundle in session in order to have last one selected
      request.getSession().setAttribute(WebKeys.SELECTED_BUNDLE, bundle);

      List<String> ids;
      if (_assetId.startsWith("query_")) { // Support for lucene queries

        String luceneQuery = _assetId.replace("query_", "");
        List<String> queries = new ArrayList<String>();
        queries.add(luceneQuery);
        ids = PublisherUtil.getContentIds(queries);

      } else {

        String[] _assetsIds =
            _assetId.split(","); // Support for multiple ids in the assetIdentifier parameter
        List<String> assetsIds = Arrays.asList(_assetsIds);

        ids = getIdsToPush(assetsIds, _contentFilterDate, new SimpleDateFormat("yyyy-MM-dd-H-m"));
      }

      Map<String, Object> responseMap =
          publisherAPI.saveBundleAssets(ids, bundle.getId(), getUser());

      // If we have errors lets return them in order to feedback the user
      if (responseMap != null && !responseMap.isEmpty()) {

        // Error messages
        JSONArray jsonErrors = new JSONArray((ArrayList) responseMap.get("errorMessages"));

        // Prepare the Json response
        JSONObject jsonResponse = new JSONObject();
        jsonResponse.put("errorMessages", jsonErrors.toArray());
        jsonResponse.put("errors", responseMap.get("errors"));
        jsonResponse.put("total", responseMap.get("total"));

        // And send it back to the user
        response.getWriter().println(jsonResponse.toString());
      }
    } catch (Exception e) {
      Logger.error(RemotePublishAjaxAction.class, e.getMessage(), e);
      response.sendError(
          HttpStatus.SC_INTERNAL_SERVER_ERROR, "Error Adding content to Bundle: " + e.getMessage());
    }
  }
  @Override
  public void service(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    Map<String, String> map = getURIParams();
    String cmd = map.get("cmd");
    Method dispatchMethod = null;

    User user = getUser();

    try {
      // Check permissions if the user has access to the CMS Maintenance Portlet
      if (user == null) {
        String userName =
            map.get("u") != null ? map.get("u") : map.get("user") != null ? map.get("user") : null;

        String password =
            map.get("p") != null
                ? map.get("p")
                : map.get("passwd") != null ? map.get("passwd") : null;

        LoginFactory.doLogin(userName, password, false, request, response);
        user = (User) request.getSession().getAttribute(WebKeys.CMS_USER);
        // Set the logged user in order to make it available from this action using the getUser()
        // method
        if (user != null) {
          setUser(user);
        }

        if (user == null) {
          setUser(request);
          user = getUser();
        }
        if (user == null) {
          response.sendError(401);
          return;
        }
      }
    } catch (Exception e) {
      Logger.error(this.getClass(), e.getMessage());
      response.sendError(401);
      return;
    }

    if (null != cmd) {
      try {
        dispatchMethod =
            this.getClass()
                .getMethod(cmd, new Class[] {HttpServletRequest.class, HttpServletResponse.class});
      } catch (Exception e) {
        try {
          dispatchMethod =
              this.getClass()
                  .getMethod(
                      "action", new Class[] {HttpServletRequest.class, HttpServletResponse.class});
        } catch (Exception e1) {
          Logger.error(this.getClass(), "Trying to get method:" + cmd);
          Logger.error(this.getClass(), e1.getMessage(), e1.getCause());
          throw new DotRuntimeException(e1.getMessage());
        }
      }
      try {
        dispatchMethod.invoke(this, new Object[] {request, response});
      } catch (Exception e) {
        Logger.error(this.getClass(), "Trying to invoke method:" + cmd);
        Logger.error(this.getClass(), e.getMessage(), e.getCause());
        throw new DotRuntimeException(e.getMessage());
      }
    }
  }
  /**
   * Generates an Unpublish bundle for a given bundle id operation (publish/unpublish)
   *
   * @param bundleId The Bundle id of the Bundle we want to generate
   * @param operation Download for publish or un-publish
   * @return The generated requested Bundle file
   * @throws DotPublisherException If fails retrieving the Bundle contents
   * @throws DotDataException If fails finding the system user
   * @throws DotPublishingException If fails initializing the Publisher
   * @throws IllegalAccessException If fails creating new Bundlers instances
   * @throws InstantiationException If fails creating new Bundlers instances
   * @throws DotBundleException If fails generating the Bundle
   * @throws IOException If fails compressing the all the Bundle contents into the final Bundle file
   */
  @SuppressWarnings("unchecked")
  private Map<String, Object> generateBundle(
      String bundleId, PushPublisherConfig.Operation operation)
      throws DotPublisherException, DotDataException, DotPublishingException,
          IllegalAccessException, InstantiationException, DotBundleException, IOException {

    PushPublisherConfig pconf = new PushPublisherConfig();
    PublisherAPI pubAPI = PublisherAPI.getInstance();

    List<PublishQueueElement> tempBundleContents = pubAPI.getQueueElementsByBundleId(bundleId);
    List<PublishQueueElement> assetsToPublish =
        new ArrayList<PublishQueueElement>(); // all assets but contentlets

    for (PublishQueueElement c : tempBundleContents) {
      if (!c.getType().equals("contentlet")) {
        assetsToPublish.add(c);
      }
    }

    pconf.setDownloading(true);
    pconf.setOperation(operation);

    // all types of assets in the queue but contentlets are passed here, which are passed through
    // lucene queries
    pconf.setAssets(assetsToPublish);
    // Queries creation
    pconf.setLuceneQueries(PublisherUtil.prepareQueries(tempBundleContents));
    pconf.setId(bundleId);
    pconf.setUser(APILocator.getUserAPI().getSystemUser());

    // BUNDLERS

    List<Class<IBundler>> bundlers = new ArrayList<Class<IBundler>>();
    List<IBundler> confBundlers = new ArrayList<IBundler>();

    Publisher publisher = new PushPublisher();
    publisher.init(pconf);
    // Add the bundles for this publisher
    for (Class clazz : publisher.getBundlers()) {
      if (!bundlers.contains(clazz)) {
        bundlers.add(clazz);
      }
    }

    // Create a new bundle id for this generated bundle
    String newBundleId = UUID.randomUUID().toString();
    pconf.setId(newBundleId);
    File bundleRoot = BundlerUtil.getBundleRoot(pconf);

    // Run bundlers
    BundlerUtil.writeBundleXML(pconf);
    for (Class<IBundler> c : bundlers) {

      IBundler bundler = c.newInstance();
      confBundlers.add(bundler);
      bundler.setConfig(pconf);
      BundlerStatus bundlerStatus = new BundlerStatus(bundler.getClass().getName());
      // Generate the bundler
      bundler.generate(bundleRoot, bundlerStatus);
    }

    pconf.setBundlers(confBundlers);

    // Compressing bundle
    ArrayList<File> list = new ArrayList<File>();
    list.add(bundleRoot);
    File bundle =
        new File(bundleRoot + File.separator + ".." + File.separator + pconf.getId() + ".tar.gz");

    Map<String, Object> bundleData = new HashMap<String, Object>();
    bundleData.put("id", newBundleId);
    bundleData.put("file", PushUtils.compressFiles(list, bundle, bundleRoot.getAbsolutePath()));
    return bundleData;
  }
  /**
   * Generates and flush an Unpublish bundle for a given bundle id and operation (publish/unpublish)
   *
   * @param request HttpRequest
   * @param response HttpResponse
   * @throws IOException If fails sending back to the user response information
   */
  public void downloadUnpushedBundle(HttpServletRequest request, HttpServletResponse response)
      throws IOException {
    try {
      if (!APILocator.getLayoutAPI()
          .doesUserHaveAccessToPortlet("EXT_CONTENT_PUBLISHING_TOOL", getUser())) {
        response.sendError(401);
        return;
      }
    } catch (DotDataException e1) {
      Logger.error(RemotePublishAjaxAction.class, e1.getMessage(), e1);
      response.sendError(401);
      return;
    }
    // Read the parameters
    Map<String, String> map = getURIParams();
    String bundleId = map.get("bundleId");
    String paramOperation = map.get("operation");
    if (bundleId == null || bundleId.isEmpty()) {
      Logger.error(this.getClass(), "No Bundle Found with id: " + bundleId);
      response.sendError(500, "No Bundle Found with id: " + bundleId);
      return;
    }

    // What we want to do with this bundle
    PushPublisherConfig.Operation operation = PushPublisherConfig.Operation.PUBLISH;
    if (paramOperation != null && paramOperation.equalsIgnoreCase("unpublish")) {
      operation = PushPublisherConfig.Operation.UNPUBLISH;
    }

    File bundle;
    String generatedBundleId;
    try {
      // Generate the bundle file for this given operation
      Map<String, Object> bundleData = generateBundle(bundleId, operation);
      bundle = (File) bundleData.get("file");
      generatedBundleId = (String) bundleData.get("id");
    } catch (Exception e) {
      Logger.error(this.getClass(), "Error trying to generate bundle with id: " + bundleId, e);
      response.sendError(500, "Error trying to generate bundle with id: " + bundleId);
      return;
    }

    response.setContentType("application/x-tgz");
    response.setHeader("Content-Disposition", "attachment; filename=" + bundle.getName());
    BufferedInputStream in = null;
    try {
      in = new BufferedInputStream(new FileInputStream(bundle));
      byte[] buf = new byte[4096];
      int len;

      while ((len = in.read(buf, 0, buf.length)) != -1) {
        response.getOutputStream().write(buf, 0, len);
      }
    } catch (Exception e) {
      Logger.error(this.getClass(), "Error reading bundle stream for bundle id: " + bundleId, e);
      response.sendError(500, "Error reading bundle stream for bundle id: " + bundleId);
    } finally {
      try {
        in.close();
      } catch (Exception ex) {
        Logger.error(this.getClass(), "Error closing Stream for bundle: " + bundleId, ex);
      }

      // Clean the just created bundle because on each download we will generate a new bundle file
      // with a new id in order to avoid conflicts with ids
      File bundleRoot = BundlerUtil.getBundleRoot(generatedBundleId);
      File compressedBundle =
          new File(ConfigUtils.getBundlePath() + File.separator + generatedBundleId + ".tar.gz");
      if (compressedBundle.exists()) {
        compressedBundle.delete();
        if (bundleRoot.exists()) {
          com.liferay.util.FileUtil.deltree(bundleRoot);
        }
      }
    }
  }
  /**
   * Send to the publisher queue a list of assets for a given Operation (Publish/Unpublish) and
   * {@link Environment Environment}
   *
   * @param request HttpRequest
   * @param response HttpResponse
   * @throws WorkflowActionFailureException If fails adding the content for Publish
   * @see com.dotcms.publisher.business.PublisherQueueJob
   * @see Environment
   */
  public void publish(HttpServletRequest request, HttpServletResponse response)
      throws IOException, WorkflowActionFailureException {

    try {

      PublisherAPI publisherAPI = PublisherAPI.getInstance();

      // Read the form values
      String _assetId = request.getParameter("assetIdentifier");
      String _contentPushPublishDate = request.getParameter("remotePublishDate");
      String _contentPushPublishTime = request.getParameter("remotePublishTime");
      String _contentPushExpireDate = request.getParameter("remotePublishExpireDate");
      String _contentPushExpireTime = request.getParameter("remotePublishExpireTime");
      String _contentFilterDate = request.getParameter("remoteFilterDate");
      String _iWantTo = request.getParameter("iWantTo");
      String whoToSendTmp = request.getParameter("whoToSend");
      String forcePushStr = request.getParameter("forcePush");
      boolean forcePush = (forcePushStr != null && forcePushStr.equals("true"));
      List<String> whereToSend = Arrays.asList(whoToSendTmp.split(","));
      List<Environment> envsToSendTo = new ArrayList<Environment>();

      // Lists of Environments to push to
      for (String envId : whereToSend) {
        Environment e = APILocator.getEnvironmentAPI().findEnvironmentById(envId);

        if (e != null) {
          envsToSendTo.add(e);
        }
      }

      // Put the selected environments in session in order to have the list of the last selected
      // environments
      request.getSession().setAttribute(WebKeys.SELECTED_ENVIRONMENTS, envsToSendTo);

      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-H-m");
      Date publishDate = dateFormat.parse(_contentPushPublishDate + "-" + _contentPushPublishTime);

      List<String> ids;
      if (_assetId.startsWith("query_")) { // Support for lucene queries

        String luceneQuery = _assetId.replace("query_", "");
        List<String> queries = new ArrayList<String>();
        queries.add(luceneQuery);
        ids = PublisherUtil.getContentIds(queries);

      } else {

        String[] _assetsIds =
            _assetId.split(","); // Support for multiple ids in the assetIdentifier parameter
        List<String> assetsIds = Arrays.asList(_assetsIds);

        ids = getIdsToPush(assetsIds, _contentFilterDate, dateFormat);
      }

      // Response map with the status of the addContents operation (error messages and counts )
      Map<String, Object> responseMap = null;

      if (_iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_PUBLISH)
          || _iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_PUBLISH_AND_EXPIRE)) {
        Bundle bundle = new Bundle(null, publishDate, null, getUser().getUserId(), forcePush);
        APILocator.getBundleAPI().saveBundle(bundle, envsToSendTo);

        responseMap =
            publisherAPI.addContentsToPublish(ids, bundle.getId(), publishDate, getUser());
      }
      if (_iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_EXPIRE)
          || _iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_PUBLISH_AND_EXPIRE)) {
        if ((!"".equals(_contentPushExpireDate.trim())
            && !"".equals(_contentPushExpireTime.trim()))) {
          Date expireDate = dateFormat.parse(_contentPushExpireDate + "-" + _contentPushExpireTime);

          Bundle bundle =
              new Bundle(null, publishDate, expireDate, getUser().getUserId(), forcePush);
          APILocator.getBundleAPI().saveBundle(bundle, envsToSendTo);

          responseMap =
              publisherAPI.addContentsToUnpublish(ids, bundle.getId(), expireDate, getUser());
        }
      }

      // If we have errors lets return them in order to feedback the user
      if (responseMap != null && !responseMap.isEmpty()) {

        // Error messages
        JSONArray jsonErrors = new JSONArray((ArrayList) responseMap.get("errorMessages"));

        // Prepare the Json response
        JSONObject jsonResponse = new JSONObject();
        jsonResponse.put("errorMessages", jsonErrors.toArray());
        jsonResponse.put("errors", responseMap.get("errors"));
        jsonResponse.put("total", responseMap.get("total"));
        jsonResponse.put("bundleId", responseMap.get("bundleId"));

        // And send it back to the user
        response.getWriter().println(jsonResponse.toString());
      }
    } catch (Exception e) {
      Logger.error(RemotePublishAjaxAction.class, e.getMessage(), e);
      response.sendError(
          HttpStatus.SC_INTERNAL_SERVER_ERROR, "Error Publishing Bundle: " + e.getMessage());
    }
  }