Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package pt.webdetails.cda;
  
  import java.io.File;
 
 import java.util.UUID;
 import  javax.servlet.http.HttpServletResponse;
 
 
 import  org.apache.commons.io.IOUtils;
 import  org.apache.commons.logging.Log;
 import  org.apache.commons.logging.LogFactory;
 import  org.pentaho.platform.api.engine.IMimeTypeListener;
 import  org.pentaho.platform.api.engine.IParameterProvider;
 import  org.pentaho.platform.api.repository.IContentItem;
 import  org.pentaho.platform.api.repository.ISolutionRepository;
 import  org.pentaho.platform.engine.core.solution.ActionInfo;
 import  org.pentaho.platform.engine.core.system.PentahoSystem;
 import  org.pentaho.platform.engine.services.solution.BaseContentGenerator;
 import  org.pentaho.platform.util.messages.LocaleHelper;
 import  org.apache.commons.lang.StringUtils;
 
 
 @SuppressWarnings("unchecked")
 public class CdaContentGenerator extends BaseContentGenerator
 {
 
   private static Log logger = LogFactory.getLog(CdaContentGenerator.class);
   public static final String PLUGIN_NAME = "cda";
   private static final long serialVersionUID = 1L;
   private static final String MIME_HTML = "text/xml";
   private static final String MIME_CSS = "text/css";
   private static final String MIME_JS = "text/javascript";
   private static final String MIME_JSON = "application/json";
   private static final String EDITOR_SOURCE = "/editor/editor.html";
   private static final String PREVIEWER_SOURCE = "/previewer/previewer.html";
   private static final String CACHEMAN_SOURCE = "/cachemanager/cache.html";
   private static final int DEFAULT_PAGE_SIZE = 20;
   private static final int DEFAULT_START_PAGE = 0;
   private static final String PREFIX_PARAMETER = "param";
   private static final String PREFIX_SETTING = "setting";
 
 
   public CdaContentGenerator()
   {
   }
 
 
   private String extractMethod(final String pathString)
   {
     if (StringUtils.isEmpty(pathString))
     {
       return null;
     }
     final String pathWithoutSlash = pathString.substring(1);
     if (pathWithoutSlash.indexOf('/') > -1)
     {
       return null;
     }
     final int queryStart = pathWithoutSlash.indexOf('?');
     if (queryStart < 0)
     {
       return pathWithoutSlash;
     }
     return pathWithoutSlash.substring(0, queryStart);
   }
 
 
   @Override
   public void createContent()
   {
     HttpServletResponse response = null;
     final IParameterProvider pathParams;
     final IParameterProvider requestParams;
     final IContentItem contentItem;
     final OutputStream out;
     final String method;
     final String pathString;
    try
    {
      // If callbacks is properly setup, we assume we're being called from another plugin
      if (this. != null && callbacks.size() > 0 && HashMap.class.isInstance(callbacks.get(0)))
      {
        HashMap<StringObjectiface = (HashMap<StringObject>) callbacks.get(0);
        pathParams = parameterProviders.get("path");
        requestParams = parameterProviders.get("request");
        contentItem = outputHandler.getOutputContentItem("response""content""", instanceId, );
        out = (OutputStreamiface.get("output");
        method = (Stringiface.get("method");
      }
      else
      { // if not, we handle the request normally
        pathParams = parameterProviders.get("path");
        requestParams = parameterProviders.get("request");
        contentItem = outputHandler.getOutputContentItem("response""content""", instanceId, );
        out = contentItem.getOutputStream(null);
        pathString = pathParams.getStringParameter("path"null);
        method = extractMethod(pathString);
        response = (HttpServletResponse) parameterProviders.get("path").getParameter("httpresponse"); //$NON-NLS-1$ //$NON-NLS-2$
      }
      if (method == null)
      {
        .error(("DashboardDesignerContentGenerator.ERROR_001_INVALID_METHOD_EXCEPTION") + " : " + method);
        if (response != null)
        {
          response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
        }
        return;
      }
      if ("doQuery".equals(method))
      {
        doQuery(requestParamsout);
      }
      else if ("previewQuery".equals(method))
      {
        previewQuery(requestParamsout);
      }
      else if ("listQueries".equals(method))
      {
        listQueries(requestParamsout);
      }
      else if ("getCdaList".equals(method))
      {
        getCdaList(requestParamsout);
      }
      else if ("listParameters".equals(method))
      {
        listParameters(requestParamsout);
      }
      else if ("clearCache".equals(method))
      {
        clearCache(requestParamsout);
      }
      else if ("synchronize".equals(method))
      {
        syncronize(requestParamsout);
      }
      else if ("getCdaFile".equals(method))
      {
        getCdaFile(requestParamsout);
      }
      else if ("writeCdaFile".equals(method))
      {
        writeCdaFile(requestParamsout);
      }
      else if ("editFile".equals(method))
      {
        editFile(requestParamsout);
      }
      else if ("getJsResource".equals(method))
      {
        getJsResource(requestParamsout);
      }
      else if ("getCssResource".equals(method))
      {
        getCssResource(requestParamsout);
      }
      else if ("listDataAccessTypes".equals(method))
      {
        listDataAccessTypes(requestParamsout);
      }
      else if ("manageCache".equals(method))
      {
        manageCache(requestParamsout);
      }
      else if ("cacheController".equals(method))
      {
        cacheController(requestParamsout);
      }
      else if(StringUtils.equals(method"cacheMonitor"))
      {
        CacheMonitorHandler.getInstance().handleCall(requestParamsout);
      }
      else
      {
        if (response != null)
        {
          response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
        }
        .error(("DashboardDesignerContentGenerator.ERROR_001_INVALID_METHOD_EXCEPTION") + " : " + method);
        return;
      }
    }
    catch (Exception e)
    {
      if (response != null)
      {
        response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
      }
      .error("Failed to execute: " + Util.getExceptionDescription(e), e);
    }
  }
  public void doQuery(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    
    final long start = System.currentTimeMillis();        
    UUID uuid = CpfAuditHelper.startAudit("doQuery"getObjectName(), this.thispathParams);       
    
        
    final CdaEngine engine = CdaEngine.getInstance();
    final QueryOptions queryOptions = new QueryOptions();
    final String path = getRelativePath(pathParams);
    final CdaSettings cdaSettings = SettingsManager.getInstance().parseSettingsFile(path);
    // Handle paging options
    // We assume that any paging options found mean that the user actively wants paging.
    final long pageSize = pathParams.getLongParameter("pageSize", 0);
    final long pageStart = pathParams.getLongParameter("pageStart", 0);
    final boolean paginate = "true".equals(pathParams.getStringParameter("paginateQuery""false"));
    if (pageSize > 0 || pageStart > 0 || paginate)
    {
      if (pageSize > . || pageStart > .)
      {
        throw new ArithmeticException("Paging values too large");
      }
      queryOptions.setPaginate(true);
      queryOptions.setPageSize(pageSize > 0 ? (intpageSize : paginate ?  : 0);
      queryOptions.setPageStart(pageStart > 0 ? (intpageStart : paginate ?  : 0);
    }
    
    // Handle the query itself and its output format...
    queryOptions.setOutputType(pathParams.getStringParameter("outputType""json"));
    queryOptions.setDataAccessId(pathParams.getStringParameter("dataAccessId""<blank>"));
    queryOptions.setOutputIndexId(Integer.parseInt(pathParams.getStringParameter("outputIndexId""1")));
    
    final ArrayList<StringsortBy = new ArrayList<String>();
    String[] def =
    {
    };
    for (Object obj : pathParams.getArrayParameter("sortBy"def))
    {
      if (!((Stringobj).equals(""))
      {
        sortBy.add((Stringobj);
      }
    }
    queryOptions.setSortBy(sortBy);
    // ... and the query parameters
    // We identify any pathParams starting with "param" as query parameters
    final Iterator<Stringparams = (Iterator<String>) pathParams.getParameterNames();
    while (params.hasNext())
    {
      final String param = params.next();
      if (param.startsWith())
      {
        queryOptions.addParameter(param.substring(.length()), pathParams.getParameter(param));
      }
      else if (param.startsWith())
      {
        queryOptions.addSetting(param.substring(.length()), pathParams.getStringParameter(param""));
      }
    }
    Exporter exporter = ExporterEngine.getInstance().getExporter(queryOptions.getOutputType(), queryOptions.getExtraSettings());
    String mimeType = exporter.getMimeType();
    String attachmentName = exporter.getAttachmentName();
    if (this. != null)
    {
      setResponseHeaders(mimeTypeattachmentName);
    }
    // Finally, pass the query to the engine
    engine.doQuery(outcdaSettingsqueryOptions);
    CpfAuditHelper.endAudit(,"doQuery"getObjectName(), this.thisstartuuid, System.currentTimeMillis());    
  }
  private void setResponseHeaders(final String mimeTypefinal String attachmentName)
  {
    // Make sure we have the correct mime type
    final HttpServletResponse response = (HttpServletResponse) parameterProviders.get("path").getParameter("httpresponse");
    if (response == null)
    {
      return;
    }
    response.setHeader("Content-Type"mimeType);
    if (attachmentName != null)
    {
      response.setHeader("content-disposition""attachment; filename=" + attachmentName);
    }
    // We can't cache this request
    response.setHeader("Cache-Control""max-age=0, no-store");
  }
  public void listQueries(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    final CdaEngine engine = CdaEngine.getInstance();
    final String path = getRelativePath(pathParams);
    .debug("Do Query: getRelativePath:" + path);
    .debug("Do Query: getSolPath:" + PentahoSystem.getApplicationContext().getSolutionPath(path));
    final CdaSettings cdaSettings = SettingsManager.getInstance().parseSettingsFile(path);
    // Handle the query itself and its output format...
    final DiscoveryOptions discoveryOptions = new DiscoveryOptions();
    discoveryOptions.setOutputType(pathParams.getStringParameter("outputType""json"));
    String mimeType = ExporterEngine.getInstance().getExporter(discoveryOptions.getOutputType()).getMimeType();
    setResponseHeaders(mimeTypenull);
    engine.listQueries(outcdaSettingsdiscoveryOptions);
  }
  public void listParameters(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    final CdaEngine engine = CdaEngine.getInstance();
    final String path = getRelativePath(pathParams);
    .debug("Do Query: getRelativePath:" + path);
    .debug("Do Query: getSolPath:" + PentahoSystem.getApplicationContext().getSolutionPath(path));
    final CdaSettings cdaSettings = SettingsManager.getInstance().parseSettingsFile(path);
    // Handle the query itself and its output format...
    final DiscoveryOptions discoveryOptions = new DiscoveryOptions();
    discoveryOptions.setOutputType(pathParams.getStringParameter("outputType""json"));
    discoveryOptions.setDataAccessId(pathParams.getStringParameter("dataAccessId""<blank>"));
    String mimeType = ExporterEngine.getInstance().getExporter(discoveryOptions.getOutputType()).getMimeType();
    setResponseHeaders(mimeTypenull);
    engine.listParameters(outcdaSettingsdiscoveryOptions);
  }
  public void getCdaFile(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    String document = getResourceAsString(getRelativePath(pathParams), ISolutionRepository.ACTION_UPDATE);
    setResponseHeaders("text/plain"null);
    out.write(document.getBytes("UTF-8"));
  }
  private void writeCdaFile(IParameterProvider pathParamsOutputStream outthrows Exception
  {
    //TODO: Validate the filename in some way, shape or form!
    String[] file = buildFileParameters(getRelativePath(pathParams));
    String rootDir = PentahoSystem.getApplicationContext().getSolutionPath("");
    ISolutionRepository solutionRepository = PentahoSystem.get(ISolutionRepository.class, userSession);
    // Check if the file exists and we have permissions to write to it
    String path = getRelativePath(pathParams);
    // 1 - is it a new file?
    final boolean resourceExists = solutionRepository.resourceExists(path);
    // 2 - it already exists - let's see if we have permissions
    if (!resourceExists || solutionRepository.getSolutionFile(path, ISolutionRepository.ACTION_UPDATE) != null)
    {
      int status = solutionRepository.publish(rootDirfile[0], file[1], ((StringpathParams.getParameter("data")).getBytes("UTF-8"), true);
      if (status == ISolutionRepository.FILE_ADD_SUCCESSFUL)
      {
        SettingsManager.getInstance().clearCache();
        setResponseHeaders("text/plain"null);
        out.write("File saved".getBytes());
      }
      else
      {
        setResponseHeaders("text/plain"null);
        out.write("Save unsuccessful!".getBytes());
        .error("writeCdaFile: saving " + file + " returned " + new Integer(status).toString());
      }
    }
    else
    {
      throw new AccessDeniedException(pathnull);
    }
  }
  public void getCdaList(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    final CdaEngine engine = CdaEngine.getInstance();
    final DiscoveryOptions discoveryOptions = new DiscoveryOptions();
    discoveryOptions.setOutputType(pathParams.getStringParameter("outputType""json"));
    String mimeType = ExporterEngine.getInstance().getExporter(discoveryOptions.getOutputType()).getMimeType();
    setResponseHeaders(mimeTypenull);
    engine.getCdaList(outdiscoveryOptions, userSession);
  }
  public void clearCache(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    SettingsManager.getInstance().clearCache();
    AbstractDataAccess.clearCache();
    setResponseHeaders("text/plain"null);
    out.write("Cache cleared".getBytes());
  }
  public void syncronize(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    throw new UnsupportedOperationException("Feature not implemented yet");
//    final SyncronizeCdfStructure syncCdfStructure = new SyncronizeCdfStructure();
//    syncCdfStructure.syncronize(userSession, out, pathParams);
  }
  public Log getLogger()
  {
    return ;
  }
  private String getRelativePath(final IParameterProvider pathParamsthrows UnsupportedEncodingException
  {
    String path = URLDecoder.decode(pathParams.getStringParameter("path"""), "UTF-8").replaceAll("//""/");
    final String solution = pathParams.getStringParameter("solution""");
    if (StringUtils.isEmpty(solution))
    {
      return path;
    }
    return ActionInfo.buildSolutionPath(
            solution,
            path,
            pathParams.getStringParameter("file"""));
  }
  public String getResourceAsString(final String pathfinal HashMap<StringStringtokensthrows IOException
  {
    // Read file
    ISolutionRepository solutionRepository = PentahoSystem.get(ISolutionRepository.class, userSession);
    
    String resourceContents = StringUtils.EMPTY;
    if (solutionRepository.resourceExists(path))
    {
      InputStream in = null;
      try
      {
        in = solutionRepository.getResourceInputStream(pathtrue, ISolutionRepository.ACTION_EXECUTE);
        resourceContents = IOUtils.toString(in);
      }
      finally 
      {
        IOUtils.closeQuietly(in);
      }
    }
    
    // Make replacement of tokens
    if (tokens != null)
    {
      for (final String key : tokens.keySet())
      { 
        resourceContents = StringUtils.replace(resourceContentskeytokens.get(key));
      }
    }
    return resourceContents;
  }
  public String getResourceAsString(final String pathint actionOperationthrows IOExceptionAccessDeniedException
  {
    ISolutionRepository solutionRepository = PentahoSystem.get(ISolutionRepository.class, userSession);
    // Check if the file exists and we have permissions to write to it
    if (solutionRepository.getSolutionFile(pathactionOperation) != null)
    {
      // Fill key map with locale definition
      HashMap<StringStringkeys = new HashMap();
      Locale locale = LocaleHelper.getLocale();
      if (.isDebugEnabled())
      {
        .debug("Current Pentaho user locale: " + locale.toString());
      }
      keys.put("#{LANGUAGE_CODE}"locale.toString());
      return getResourceAsString(pathkeys);
    }
    else
    {
      throw new AccessDeniedException(pathnull);
    }
  }
  public void editFile(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    ISolutionRepository solutionRepository = PentahoSystem.get(ISolutionRepository.class, userSession);
    // Check if the file exists and we have permissions to write to it
    String path = getRelativePath(pathParams);
    if (solutionRepository.getSolutionFile(path, ISolutionRepository.ACTION_UPDATE) != null)
    {
      final String editorPath = "system/" +  + ;
      //SettingsManager.getInstance().clearCache();
      //AbstractDataAccess.clearCache();
      setResponseHeaders("text/html"null);
      out.write(getResourceAsString(editorPath, ISolutionRepository.ACTION_UPDATE).getBytes("UTF-8"));
    }
    else
    {
      setResponseHeaders("text/plain"null);
      out.write("Access Denied".getBytes());
    }
  }
  public void previewQuery(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    final String previewerPath = "system/" +  + ;
    //SettingsManager.getInstance().clearCache();
    //AbstractDataAccess.clearCache();
    setResponseHeaders("text/html"null);
    out.write(getResourceAsString(previewerPath, ISolutionRepository.ACTION_EXECUTE).getBytes("UTF-8"));
  }
  public void getCssResource(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    final IMimeTypeListener mimeTypeListener = outputHandler.getMimeTypeListener();
    if (mimeTypeListener != null)
    {
      mimeTypeListener.setMimeType();
    }
    getresource(pathParamsout);
  }
  public void getJsResource(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    final IMimeTypeListener mimeTypeListener = outputHandler.getMimeTypeListener();
    if (mimeTypeListener != null)
    {
      mimeTypeListener.setMimeType();
    }
    getresource(pathParamsout);
  }
  public void getresource(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    String resource = pathParams.getStringParameter("resource"null);
    resource = resource.startsWith("/") ? resource : "/" + resource;
    getResource(outresource);
  }
  private void getResource(final OutputStream outfinal String resourcethrows IOException
  {
    final String path = PentahoSystem.getApplicationContext().getSolutionPath("system/" +  + resource); //$NON-NLS-1$ //$NON-NLS-2$
    final File file = new File(path);
    final InputStream in = new FileInputStream(file);
    
    try{
      IOUtils.copy(inout);
    }
    finally {
      IOUtils.closeQuietly(in);
    }
    
  }
  private String[] buildFileParameters(String filePath)
  {
    String[] result =
    {
      """"
    };
    String[] file = filePath.split("/");
    String fileName = file[file.length - 1];
    String path = filePath.substring(0, filePath.indexOf(fileName));
    result[0] = path;
    result[1] = fileName;
    return result;
  }
  public void listDataAccessTypes(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    DataAccessConnectionDescriptor[] data = SettingsManager.getInstance().
            getDataAccessDescriptors((pathParams.getStringParameter("refreshCache""false")).equalsIgnoreCase("true"));
    StringBuilder output = new StringBuilder("");
    if (data != null)
    {
      output.append("{\n");
      for (DataAccessConnectionDescriptor datum : data)
      {
        output.append(datum.toJSON() + ",\n");
      }
      out.write(output.toString().replaceAll(",\n\\z""\n}").getBytes("UTF-8"));
    }
  }
  private void cacheController(IParameterProvider requestParamsOutputStream out)
  {
    CacheScheduleManager.getInstance().handleCall(requestParamsout);
  }
  public void manageCache(final IParameterProvider pathParamsfinal OutputStream outthrows Exception
  {
    ISolutionRepository solutionRepository = PentahoSystem.get(ISolutionRepository.class, userSession);
    
    // Check if the file exists and we have permissions to write to it
    String path = getRelativePath(pathParams);
    if (solutionRepository.getSolutionFile(path, ISolutionRepository.ACTION_UPDATE) != null)
    {
      final String cachemanPath = "system/" +  + ;
      //SettingsManager.getInstance().clearCache();
      //AbstractDataAccess.clearCache();
      setResponseHeaders("text/html"null);
      out.write(getResourceAsString(cachemanPath, ISolutionRepository.ACTION_UPDATE).getBytes("UTF-8"));
    }
    else
    {
      setResponseHeaders("text/plain"null);
      out.write("Access Denied".getBytes());
    }
  }
New to GrepCode? Check out our FAQ X