protected Engine getEngineByDocumentType(String type) {
    Engine engine;
    List<Engine> engines;

    engine = null;
    try {
      Assert.assertNotNull(DAOFactory.getEngineDAO(), "EngineDao cannot be null");
      engines = DAOFactory.getEngineDAO().loadAllEnginesForBIObjectType(type);
      if (engines == null || engines.size() == 0) {
        throw new SpagoBIServiceException(
            SERVICE_NAME, "There are no engines for documents of type [" + type + "] available");
      } else {
        engine = engines.get(0);
        if (engines.size() > 1) {
          LogMF.warn(
              logger,
              "There are more than one engine for document of type [WORKSHEET]. We will use the one whose label is equal to [{0}]",
              engine.getLabel());
        } else {
          LogMF.debug(logger, "Using worksheet engine with label [{0}]", engine.getLabel());
        }
      }
    } catch (Throwable t) {
      throw new SpagoBIServiceException(
          SERVICE_NAME, "Impossible to load a valid engine for document of type [WORKSHEET]", t);
    } finally {
      logger.debug("OUT");
    }

    return engine;
  }
  private JSONObject getBusinessMetadataFromRequest() {
    JSONObject businessMetadata;

    businessMetadata = null;
    try {
      if (requestContainsAttribute(INPUT_PARAMETER_BUSINESS_METADATA)) {
        logger.trace(
            "Reading input parametr [" + INPUT_PARAMETER_BUSINESS_METADATA + "] from request...");
        businessMetadata = this.getAttributeAsJSONObject(INPUT_PARAMETER_BUSINESS_METADATA);
        logger.debug(
            "Input parameter ["
                + INPUT_PARAMETER_BUSINESS_METADATA
                + "] is equal to ["
                + businessMetadata
                + "]");
      } else {
        LogMF.trace(
            logger, "Input parameter [{0}] not valorized", INPUT_PARAMETER_BUSINESS_METADATA);
      }
    } catch (Throwable t) {
      logger.error(
          "Impossible to parse input parameter [" + INPUT_PARAMETER_BUSINESS_METADATA + "]", t);
    }

    return businessMetadata;
  }
Example #3
0
  public static Engine getEngineByDocumentType(String type) {
    Engine engine;
    List<Engine> engines;

    engine = null;
    try {
      Assert.assertNotNull(DAOFactory.getEngineDAO(), "EngineDao cannot be null");
      engines = DAOFactory.getEngineDAO().loadAllEnginesForBIObjectType(type);
      if (engines == null || engines.size() == 0) {
        throw new SpagoBIRuntimeException(
            "There are no engines for documents of type [" + type + "] available");
      } else {
        engine = (Engine) engines.get(0);
        LogMF.warn(
            logger,
            "There are more than one engine for document of type ["
                + type
                + "]. We will use the one whose label is equal to [{0}]",
            engine.getLabel());
      }
    } catch (Throwable t) {
      throw new SpagoBIRuntimeException(
          "Impossible to load a valid engine for document of type [" + type + "]", t);
    } finally {
      logger.debug("OUT");
    }

    return engine;
  }
 protected void setTenant() {
   logger.debug("IN");
   try {
     IEngUserProfile profile = getUserProfile();
     Assert.assertNotNull(profile, "Input parameter [profile] cannot be null");
     UserProfile userProfile = (UserProfile) profile;
     String tenant = userProfile.getOrganization();
     LogMF.debug(logger, "Tenant: [{0}]", tenant);
     TenantManager.setTenant(new Tenant(tenant));
     LogMF.debug(logger, "Tenant [{0}] set properly", tenant);
   } catch (Throwable t) {
     logger.error("Cannot set tenant", t);
     throw new SpagoBIRuntimeException("Cannot set tenant", t);
   } finally {
     logger.debug("OUT");
   }
 }
  /**
   * Creates a table with columns got from metadata. PAY ATTENTION TO THE FACT THAT THE INPUT
   * CONNECTION WON'T BE CLOSED!!!!!
   *
   * @param conn The JDBC connection to be used
   * @param meta The metadata of the dataset to be persisted on the database
   * @param tableName The name of the table to be created
   * @param list The list of the fields of the dataset to be included on table
   * @return A DataSetTableDescriptor that contains the association between table's columns and
   *     dataset's fields.
   */
  public static DataSetTableDescriptor createTemporaryTable(
      Connection conn, IMetaData meta, String tableName, List<String> selectedFields) {
    logger.debug("IN");

    DataSetTableDescriptor dstd = null;
    Statement st = null;
    String sqlQuery = null;

    if (selectedFields == null) {
      selectedFields = new ArrayList<String>();
    }

    try {
      CreateTableCommand createTableCommand =
          new CreateTableCommand(tableName, conn.getMetaData().getDriverName());

      // run through all columns in order to build the SQL columndefinition
      int count = meta.getFieldCount();
      logger.debug("The table tableName has " + count + " columns ");
      for (int i = 0; i < count; i++) {
        IFieldMetaData fieldMeta = meta.getFieldMeta(i);
        String fieldName = fieldMeta.getName();
        if (selectedFields.isEmpty() || selectedFields.contains(fieldName)) {
          createTableCommand.addColumn(fieldMeta);
        }
      }

      // after built columns create SQL Query
      sqlQuery = createTableCommand.createSQLQuery();

      // execute
      logger.debug("Executing the query " + sqlQuery + "...");
      st = conn.createStatement();
      st.execute(sqlQuery);
      logger.debug("Query executed");
      dstd = createTableCommand.getDsTableDescriptor();
      LogMF.debug(logger, "The query descriptor is {0}", dstd);

    } catch (SQLException e) {
      logger.error("Error in excuting statement " + sqlQuery, e);
      throw new SpagoBIRuntimeException("Error creating temporary table", e);
    } finally {
      try {
        if (st != null) {
          st.close();
        }
      } catch (SQLException e) {
        logger.error("could not free resources ", e);
      }
    }
    logger.debug("OUT");
    return dstd;
  }
  private Map<String, String> getDatasetParameterValuesMapFromRequest() {
    Map<String, String> parametersMap;

    parametersMap = new HashMap<String, String>();

    try {
      if (requestContainsAttribute(INPUT_PARAMETER_DS_PARAMETERS_VALUES)) {
        logger.trace(
            "Reading input parametr ["
                + INPUT_PARAMETER_DS_PARAMETERS_VALUES
                + "] from request...");
        JSONObject parameterValues =
            this.getAttributeAsJSONObject(INPUT_PARAMETER_DS_PARAMETERS_VALUES);
        logger.debug(
            "Input parameter ["
                + INPUT_PARAMETER_DS_PARAMETERS_VALUES
                + "] is equal to ["
                + parameterValues
                + "]");

        for (Iterator<String> iterator = parameterValues.keys(); iterator.hasNext(); ) {
          String key = iterator.next();
          String value =
              parameterValues.get(key) != null ? parameterValues.get(key).toString() : null;
          parametersMap.put(key, value);
        }
      } else {
        LogMF.trace(
            logger, "Input parameter [{0}] not valorized", INPUT_PARAMETER_DS_PARAMETERS_VALUES);
      }
    } catch (Throwable t) {
      logger.error(
          "Impossible to parse input parameter [" + INPUT_PARAMETER_DS_PARAMETERS_VALUES + "]", t);
    }

    return parametersMap;
  }
  @Override
  public void doService() {

    DatasetManagementAPI creationUtilities;
    IDataSet datasetBean;

    logger.debug("IN");

    try {

      // create the input parameters to pass to the WorkSheet Edit Service
      Map worksheetEditActionParameters = buildWorksheetEditServiceBaseParametersMap();

      String executionId = ExecuteAdHocUtility.createNewExecutionId();
      worksheetEditActionParameters.put("SBI_EXECUTION_ID", executionId);

      Engine worksheetEngine = getWorksheetEngine();
      LogMF.debug(logger, "Engine label is equal to [{0}]", worksheetEngine.getLabel());

      IDataSource datasource;
      try {
        datasource = DAOFactory.getDataSourceDAO().loadDataSourceWriteDefault();
      } catch (EMFUserError e) {
        throw new SpagoBIRuntimeException("Error while loading default datasource for writing", e);
      }
      if (datasource != null) {
        LogMF.debug(logger, "Datasource label is equal to [{0}]", datasource.getLabel());
        worksheetEditActionParameters.put(
            EngineConstants.DEFAULT_DATASOURCE_FOR_WRITING_LABEL, datasource.getLabel());
      } else {
        logger.debug("There is no default datasource for writing");
      }

      datasetBean = getDatasetAttributesFromRequest();
      worksheetEditActionParameters.put("dataset_label", datasetBean.getLabel());

      Map<String, String> datasetParameterValuesMap = getDatasetParameterValuesMapFromRequest();
      worksheetEditActionParameters.putAll(datasetParameterValuesMap);

      // create the WorkSheet Edit Service's URL
      String worksheetEditActionUrl =
          GeneralUtilities.getUrl(worksheetEngine.getUrl(), worksheetEditActionParameters);
      LogMF.debug(
          logger, "Worksheet edit service invocation url is equal to [{}]", worksheetEditActionUrl);

      // create the dataset
      logger.trace("Creating the dataset...");
      Integer datasetId = null;
      try {
        creationUtilities = new DatasetManagementAPI();
        datasetId = creationUtilities.creatDataSet(datasetBean);
        Assert.assertNotNull(datasetId, "Dataset Id cannot be null");
      } catch (Throwable t) {
        throw new SpagoBIServiceException(
            SERVICE_NAME,
            "An error occurred while creating dataset from bean [" + datasetBean + "]",
            t);
      }
      LogMF.debug(logger, "Datset [{0}]succesfully created with id [{1}]", datasetBean, datasetId);

      logger.trace("Copying output parameters to response...");
      try {
        getServiceResponse().setAttribute(OUTPUT_PARAMETER_EXECUTION_ID, executionId);
        getServiceResponse()
            .setAttribute(OUTPUT_PARAMETER_WORKSHEET_EDIT_SERVICE_URL, worksheetEditActionUrl);
        getServiceResponse().setAttribute(OUTPUT_PARAMETER_DATASET_LABEL, datasetBean.getLabel());
        getServiceResponse()
            .setAttribute(OUTPUT_PARAMETER_DATASET_PARAMETERS, datasetParameterValuesMap);

        // business metadata
        JSONObject businessMetadata = getBusinessMetadataFromRequest();
        if (businessMetadata != null) {
          getServiceResponse()
              .setAttribute(OUTPUT_PARAMETER_BUSINESS_METADATA, businessMetadata.toString());
        }
      } catch (Throwable t) {
        throw new SpagoBIServiceException(
            SERVICE_NAME,
            "An error occurred while creating dataset from bean [" + datasetBean + "]",
            t);
      }
      logger.trace("Output parameter succesfully copied to response");

    } finally {
      logger.debug("OUT");
    }
  }
  /**
   * Read dataset's attributes from request and save them in a bean object.
   *
   * @return GuiGenericDataSet the bean object that collect all the dataset attributes read from
   *     request.
   */
  private IDataSet getDatasetAttributesFromRequest() {

    IDataSet datasetBean;

    String label;
    String name;
    String description;
    String customData;
    String jClassName;
    String metadata;
    String parametersDefinitionJson;
    String parametersDefinitionXML;

    logger.debug("IN");

    datasetBean = null;

    try {
      logger.trace("Reading from request attributes used to build the new dataset...");

      LogMF.trace(logger, "Reading input parametr [{0}] from request...", INPUT_PARAMETER_DS_LABEL);
      label = getAttributeAsString(INPUT_PARAMETER_DS_LABEL);
      LogMF.debug(
          logger, "Input parameter [{0}] is equal to [{1}]", INPUT_PARAMETER_DS_LABEL, label);
      Assert.assertNotNull(
          label, "Input parameter [" + INPUT_PARAMETER_DS_LABEL + "] cannot be null");

      LogMF.trace(logger, "Reading input parametr [{0}] from request...", INPUT_PARAMETER_DS_NAME);
      name = getAttributeAsString(INPUT_PARAMETER_DS_NAME);
      LogMF.debug(
          logger, "Input parameter [{0}] is equal to [{1}]", INPUT_PARAMETER_DS_LABEL, name);

      LogMF.trace(
          logger, "Reading input parametr [{0}] from request...", INPUT_PARAMETER_DS_DESCRIPTION);
      description = getAttributeAsString(INPUT_PARAMETER_DS_DESCRIPTION);
      LogMF.debug(
          logger,
          "Input parameter [{0}] is equal to [{1}]",
          INPUT_PARAMETER_DS_DESCRIPTION,
          description);

      LogMF.trace(
          logger, "Reading input parametr [{0}] from request...", INPUT_PARAMETER_DS_CUSTOM_DATA);
      customData = getAttributeAsString(INPUT_PARAMETER_DS_CUSTOM_DATA);
      LogMF.debug(
          logger,
          "Input parameter [{0}] is equal to [{1}]",
          INPUT_PARAMETER_DS_CUSTOM_DATA,
          customData);

      LogMF.trace(
          logger, "Reading input parametr [{0}] from request...", INPUT_PARAMETER_DS_JCLASS_NAME);
      jClassName = getAttributeAsString(INPUT_PARAMETER_DS_JCLASS_NAME);
      LogMF.debug(
          logger,
          "Input parameter [{0}] is equal to [{1}]",
          INPUT_PARAMETER_DS_JCLASS_NAME,
          jClassName);

      LogMF.trace(
          logger, "Reading input parametr [{0}] from request...", INPUT_PARAMETER_DS_METADATA);
      metadata = getAttributeAsString(INPUT_PARAMETER_DS_METADATA);
      LogMF.debug(
          logger, "Input parameter [{0}] is equal to [{1}]", INPUT_PARAMETER_DS_METADATA, metadata);

      LogMF.trace(
          logger,
          "Reading input parametr [{0}] from request...",
          INPUT_PARAMETER_DS_PARAMETER_DEFINITION);
      parametersDefinitionJson = getAttributeAsString(INPUT_PARAMETER_DS_PARAMETER_DEFINITION);
      LogMF.debug(
          logger,
          "Input parameter [{0}] is equal to [{1}]",
          INPUT_PARAMETER_DS_METADATA,
          parametersDefinitionJson);

      parametersDefinitionXML = null;
      if (!StringUtilities.isEmpty(parametersDefinitionJson)) {
        LogMF.trace(
            logger,
            "Coverting input parameter [{0}] from JSON format to XML format ...",
            INPUT_PARAMETER_DS_PARAMETER_DEFINITION);
        parametersDefinitionXML = parametersJsonToXML(parametersDefinitionJson);
        LogMF.trace(
            logger,
            "Input parameter [{0}] succesfully converted to xml formt [{1}]",
            INPUT_PARAMETER_DS_PARAMETER_DEFINITION,
            parametersDefinitionXML);
      }

      logger.trace("Attributes used to build the new dataset succesfully read from request");

      logger.trace("Building the dataset bean...");

      datasetBean = new CustomDataSet();
      datasetBean.setLabel(label);
      datasetBean.setName(name);
      datasetBean.setDescription(description);

      ((CustomDataSet) datasetBean).setCustomData(customData);
      ((CustomDataSet) datasetBean).setJavaClassName(jClassName);
      datasetBean.setParameters(parametersDefinitionXML);
      datasetBean.setDsType(DataSetConstants.DS_CUSTOM);
      if (!StringUtilities.isEmpty(metadata)) {
        datasetBean.setDsMetadata(metadata);
      }

      try {
        JSONObject jsonConf = new JSONObject();
        jsonConf.put(CUSTOM_DATA, customData);
        jsonConf.put(JCLASS_NAME, jClassName);
        jsonConf.put(DataSetConstants.PARS, parametersDefinitionXML);
        jsonConf.put(DataSetConstants.DS_CUSTOM, DataSetConstants.DS_CUSTOM);
        jsonConf.put(DataSetConstants.DS_TYPE_CD, DataSetConstants.DS_CUSTOM);
        datasetBean.setConfiguration(jsonConf.toString());
      } catch (Exception e) {
        logger.error("Error while defining dataset configuration.  Error: " + e.getMessage());
      }

      logger.trace("Dataset bean succesfully built");

    } catch (Throwable t) {
      throw new SpagoBIServiceException(
          SERVICE_NAME,
          "Impossible to read from request all parameters required to create the new dataset",
          t);
    } finally {
      logger.debug("OUT");
    }

    return datasetBean;
  }