org.pentaho.di.core.Const#toLong

Source File: ServerStatus.java From pentaho-kettle with Apache License 2.0

6 votes

public ServerStatus( Node statusNode ) throws KettleException {
  this();
  statusDescription = XMLHandler.getTagValue( statusNode, "statusdesc" );

  memoryFree = Const.toLong( XMLHandler.getTagValue( statusNode, "memory_free" ), -1L );
  memoryTotal = Const.toLong( XMLHandler.getTagValue( statusNode, "memory_total" ), -1L );

  String cpuCoresStr = XMLHandler.getTagValue( statusNode, "cpu_cores" );
  cpuCores = Const.toInt( cpuCoresStr, -1 );
  String cpuProcessTimeStr = XMLHandler.getTagValue( statusNode, "cpu_process_time" );
  cpuProcessTime = Utils.isEmpty( cpuProcessTimeStr ) ? 0L : Long.valueOf( cpuProcessTimeStr );

  uptime = Const.toLong( XMLHandler.getTagValue( statusNode, "uptime" ), -1 );
  threadCount = Const.toInt( XMLHandler.getTagValue( statusNode, "thread_count" ), -1 );
  loadAvg = Const.toDouble( XMLHandler.getTagValue( statusNode, "load_avg" ), -1.0 );

  osName = XMLHandler.getTagValue( statusNode, "os_name" );
  osVersion = XMLHandler.getTagValue( statusNode, "os_version" );
  osArchitecture = XMLHandler.getTagValue( statusNode, "os_arch" );
}

Source File: GetSubFoldersMeta.java From pentaho-kettle with Apache License 2.0

6 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {
    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "rownum" ) );
    isFoldernameDynamic = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "foldername_dynamic" ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, "rownum_field" );
    dynamicFoldernameField = XMLHandler.getTagValue( stepnode, "foldername_field" );

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, "limit" ), 0L );

    Node filenode = XMLHandler.getSubNode( stepnode, "file" );
    int nrfiles = XMLHandler.countNodes( filenode, "name" );

    allocate( nrfiles );

    for ( int i = 0; i < nrfiles; i++ ) {
      Node folderNamenode = XMLHandler.getSubNodeByNr( filenode, "name", i );
      Node folderRequirednode = XMLHandler.getSubNodeByNr( filenode, "file_required", i );
      folderName[i] = XMLHandler.getNodeValue( folderNamenode );
      folderRequired[i] = XMLHandler.getNodeValue( folderRequirednode );
    }
  } catch ( Exception e ) {
    throw new KettleXMLException( "Unable to load step info from XML", e );
  }
}

Source File: Neo4JOutput.java From knowbi-pentaho-pdi-neo4j-output with Apache License 2.0

5 votes

public boolean init( StepMetaInterface smi, StepDataInterface sdi ) {
  meta = (Neo4JOutputMeta) smi;
  data = (Neo4JOutputData) sdi;

  if ( !meta.isReturningGraph() ) {

    // Connect to Neo4j using info metastore Neo4j Connection metadata
    //
    if ( StringUtils.isEmpty( meta.getConnection() ) ) {
      log.logError( "You need to specify a Neo4j connection to use in this step" );
      return false;
    }

    try {
      // To correct lazy programmers who built certain PDI steps...
      //
      data.metaStore = MetaStoreUtil.findMetaStore( this );
      data.neoConnection = NeoConnectionUtils.getConnectionFactory( data.metaStore ).loadElement( meta.getConnection() );
      if (data.neoConnection==null) {
        log.logError("Connection '"+meta.getConnection()+"' could not be found in the metastore "+MetaStoreUtil.getMetaStoreDescription(metaStore));
        return false;
      }
      data.neoConnection.initializeVariablesFrom( this );
      data.version4 = data.neoConnection.isVersion4();
    } catch ( MetaStoreException e ) {
      log.logError( "Could not gencsv Neo4j connection '" + meta.getConnection() + "' from the metastore", e );
      return false;
    }

    data.batchSize = Const.toLong( environmentSubstitute( meta.getBatchSize() ), 1 );
  }

  return super.init( smi, sdi );
}

Source File: SlaveServerStatus.java From pentaho-kettle with Apache License 2.0

5 votes

public SlaveServerStatus( Node statusNode ) throws KettleException {
  this();
  statusDescription = XMLHandler.getTagValue( statusNode, "statusdesc" );

  memoryFree = Const.toLong( XMLHandler.getTagValue( statusNode, "memory_free" ), -1L );
  memoryTotal = Const.toLong( XMLHandler.getTagValue( statusNode, "memory_total" ), -1L );

  String cpuCoresStr = XMLHandler.getTagValue( statusNode, "cpu_cores" );
  cpuCores = Const.toInt( cpuCoresStr, -1 );
  String cpuProcessTimeStr = XMLHandler.getTagValue( statusNode, "cpu_process_time" );
  cpuProcessTime = Utils.isEmpty( cpuProcessTimeStr ) ? 0L : Long.valueOf( cpuProcessTimeStr );

  uptime = Const.toLong( XMLHandler.getTagValue( statusNode, "uptime" ), -1 );
  threadCount = Const.toInt( XMLHandler.getTagValue( statusNode, "thread_count" ), -1 );
  loadAvg = Const.toDouble( XMLHandler.getTagValue( statusNode, "load_avg" ), -1.0 );

  osName = XMLHandler.getTagValue( statusNode, "os_name" );
  osVersion = XMLHandler.getTagValue( statusNode, "os_version" );
  osArchitecture = XMLHandler.getTagValue( statusNode, "os_arch" );

  Node listTransNode = XMLHandler.getSubNode( statusNode, "transstatuslist" );
  Node listJobsNode = XMLHandler.getSubNode( statusNode, "jobstatuslist" );

  int nrTrans = XMLHandler.countNodes( listTransNode, SlaveServerTransStatus.XML_TAG );
  int nrJobs = XMLHandler.countNodes( listJobsNode, SlaveServerJobStatus.XML_TAG );

  for ( int i = 0; i < nrTrans; i++ ) {
    Node transStatusNode = XMLHandler.getSubNodeByNr( listTransNode, SlaveServerTransStatus.XML_TAG, i );
    transStatusList.add( new SlaveServerTransStatus( transStatusNode ) );
  }

  for ( int i = 0; i < nrJobs; i++ ) {
    Node jobStatusNode = XMLHandler.getSubNodeByNr( listJobsNode, SlaveServerJobStatus.XML_TAG, i );
    jobStatusList.add( new SlaveServerJobStatus( jobStatusNode ) );
  }
}

Source File: GetSlaveSequence.java From pentaho-kettle with Apache License 2.0

5 votes

public boolean init( StepMetaInterface smi, StepDataInterface sdi ) {
  meta = (GetSlaveSequenceMeta) smi;
  data = (GetSlaveSequenceData) sdi;

  if ( super.init( smi, sdi ) ) {
    data.increment = Const.toLong( environmentSubstitute( meta.getIncrement() ), 1000 );
    data.slaveServer = getTransMeta().findSlaveServer( environmentSubstitute( meta.getSlaveServerName() ) );
    data.sequenceName = environmentSubstitute( meta.getSequenceName() );
    data.value = -1;

    return true;
  }
  return false;
}

Source File: SlaveServer.java From pentaho-kettle with Apache License 2.0

5 votes

public long getNextSlaveSequenceValue( String slaveSequenceName, long incrementValue ) throws KettleException {
  try {
    String xml =
      execService( NextSequenceValueServlet.CONTEXT_PATH + "/" + "?" + NextSequenceValueServlet.PARAM_NAME + "="
        + URLEncoder.encode( slaveSequenceName, "UTF-8" ) + "&" + NextSequenceValueServlet.PARAM_INCREMENT + "="
        + Long.toString( incrementValue ) );

    Document doc = XMLHandler.loadXMLString( xml );
    Node seqNode = XMLHandler.getSubNode( doc, NextSequenceValueServlet.XML_TAG );
    String nextValueString = XMLHandler.getTagValue( seqNode, NextSequenceValueServlet.XML_TAG_VALUE );
    String errorString = XMLHandler.getTagValue( seqNode, NextSequenceValueServlet.XML_TAG_ERROR );

    if ( !Utils.isEmpty( errorString ) ) {
      throw new KettleException( errorString );
    }
    if ( Utils.isEmpty( nextValueString ) ) {
      throw new KettleException( "No value retrieved from slave sequence '" + slaveSequenceName + "' on slave "
        + toString() );
    }
    long nextValue = Const.toLong( nextValueString, Long.MIN_VALUE );
    if ( nextValue == Long.MIN_VALUE ) {
      throw new KettleException( "Incorrect value '" + nextValueString + "' retrieved from slave sequence '"
        + slaveSequenceName + "' on slave " + toString() );
    }

    return nextValue;
  } catch ( Exception e ) {
    throw new KettleException( "There was a problem retrieving a next sequence value from slave sequence '"
      + slaveSequenceName + "' on slave " + toString(), e );
  }
}

Source File: RssInputMeta.java From pentaho-kettle with Apache License 2.0

5 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {

    urlInField = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "url_in_field" ) );
    urlFieldname = XMLHandler.getTagValue( stepnode, "url_field_name" );
    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "rownum" ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, "rownum_field" );
    includeUrl = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "include_url" ) );
    urlField = XMLHandler.getTagValue( stepnode, "url_Field" );
    readfrom = XMLHandler.getTagValue( stepnode, "read_from" );
    Node fields = XMLHandler.getSubNode( stepnode, "fields" );
    int nrFields = XMLHandler.countNodes( fields, "field" );
    Node urlnode = XMLHandler.getSubNode( stepnode, "urls" );
    int nrUrls = XMLHandler.countNodes( urlnode, "url" );
    allocate( nrUrls, nrFields );
    for ( int i = 0; i < nrUrls; i++ ) {
      Node urlnamenode = XMLHandler.getSubNodeByNr( urlnode, "url", i );
      url[i] = XMLHandler.getNodeValue( urlnamenode );
    }

    for ( int i = 0; i < nrFields; i++ ) {
      Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
      RssInputField field = new RssInputField( fnode );
      inputFields[i] = field;
    }

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, "limit" ), 0L );
  } catch ( Exception e ) {
    throw new KettleXMLException( "Unable to load step info from XML", e );
  }
}

Source File: RowGenerator.java From pentaho-kettle with Apache License 2.0

5 votes

@Override
public boolean init( StepMetaInterface smi, StepDataInterface sdi ) {
  try {
    meta = (RowGeneratorMeta) smi;
    data = (RowGeneratorData) sdi;

    if ( super.init( smi, sdi ) ) {
      // Determine the number of rows to generate...
      data.rowLimit = Const.toLong( environmentSubstitute( meta.getRowLimit() ), -1L );
      data.rowsWritten = 0L;
      data.delay = Const.toLong( environmentSubstitute( meta.getIntervalInMs() ), -1L );

      if ( data.rowLimit < 0L ) { // Unable to parse
        logError( BaseMessages.getString( PKG, "RowGenerator.Wrong.RowLimit.Number" ) );
        return false; // fail
      }

      // Create a row (constants) with all the values in it...
      List<CheckResultInterface> remarks = new ArrayList<CheckResultInterface>(); // stores the errors...
      RowMetaAndData outputRow = buildRow( meta, remarks, getStepname() );
      if ( !remarks.isEmpty() ) {
        for ( int i = 0; i < remarks.size(); i++ ) {
          CheckResult cr = (CheckResult) remarks.get( i );
          logError( cr.getText() );
        }
        return false;
      }

      data.outputRowData = outputRow.getData();
      data.outputRowMeta = outputRow.getRowMeta();
      return true;
    }
    return false;
  } catch ( Exception e ) {
    setErrors( 1L );
    logError( "Error initializing step", e );
    return false;
  }
}

Source File: PropertyInputMeta.java From pentaho-kettle with Apache License 2.0

4 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {
    fileType = XMLHandler.getTagValue( stepnode, "file_type" );
    encoding = XMLHandler.getTagValue( stepnode, "encoding" );
    includeFilename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "include" ) );
    filenameField = XMLHandler.getTagValue( stepnode, "include_field" );
    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "rownum" ) );

    String addresult = XMLHandler.getTagValue( stepnode, "isaddresult" );
    if ( Utils.isEmpty( addresult ) ) {
      isaddresult = true;
    } else {
      isaddresult = "Y".equalsIgnoreCase( addresult );
    }
    section = XMLHandler.getTagValue( stepnode, "section" );
    iniSectionField = XMLHandler.getTagValue( stepnode, "ini_section_field" );
    includeIniSection = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "ini_section" ) );
    filefield = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "filefield" ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, "rownum_field" );
    dynamicFilenameField = XMLHandler.getTagValue( stepnode, "filename_Field" );
    resetRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "resetrownumber" ) );
    resolvevaluevariable = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "resolvevaluevariable" ) );
    Node filenode = XMLHandler.getSubNode( stepnode, "file" );
    Node fields = XMLHandler.getSubNode( stepnode, "fields" );
    int nrFiles = XMLHandler.countNodes( filenode, "name" );
    int nrFields = XMLHandler.countNodes( fields, "field" );

    allocate( nrFiles, nrFields );

    for ( int i = 0; i < nrFiles; i++ ) {
      Node filenamenode = XMLHandler.getSubNodeByNr( filenode, "name", i );
      Node filemasknode = XMLHandler.getSubNodeByNr( filenode, "filemask", i );
      Node excludefilemasknode = XMLHandler.getSubNodeByNr( filenode, "exclude_filemask", i );
      Node fileRequirednode = XMLHandler.getSubNodeByNr( filenode, "file_required", i );
      Node includeSubFoldersnode = XMLHandler.getSubNodeByNr( filenode, "include_subfolders", i );
      fileName[i] = XMLHandler.getNodeValue( filenamenode );
      fileMask[i] = XMLHandler.getNodeValue( filemasknode );
      excludeFileMask[i] = XMLHandler.getNodeValue( excludefilemasknode );
      fileRequired[i] = XMLHandler.getNodeValue( fileRequirednode );
      includeSubFolders[i] = XMLHandler.getNodeValue( includeSubFoldersnode );
    }

    for ( int i = 0; i < nrFields; i++ ) {
      Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
      inputFields[i] = new PropertyInputField();

      inputFields[i].setName( XMLHandler.getTagValue( fnode, "name" ) );
      inputFields[i].setColumn( getColumnByCode( XMLHandler.getTagValue( fnode, "column" ) ) );
      inputFields[i].setType( ValueMetaFactory.getIdForValueMeta( XMLHandler.getTagValue( fnode, "type" ) ) );
      inputFields[i].setLength( Const.toInt( XMLHandler.getTagValue( fnode, "length" ), -1 ) );
      inputFields[i].setPrecision( Const.toInt( XMLHandler.getTagValue( fnode, "precision" ), -1 ) );
      String srepeat = XMLHandler.getTagValue( fnode, "repeat" );
      inputFields[i].setTrimType( getTrimTypeByCode( XMLHandler.getTagValue( fnode, "trim_type" ) ) );

      if ( srepeat != null ) {
        inputFields[i].setRepeated( YES.equalsIgnoreCase( srepeat ) );
      } else {
        inputFields[i].setRepeated( false );
      }

      inputFields[i].setFormat( XMLHandler.getTagValue( fnode, "format" ) );
      inputFields[i].setCurrencySymbol( XMLHandler.getTagValue( fnode, "currency" ) );
      inputFields[i].setDecimalSymbol( XMLHandler.getTagValue( fnode, "decimal" ) );
      inputFields[i].setGroupSymbol( XMLHandler.getTagValue( fnode, "group" ) );

    }

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, "limit" ), 0L );
    shortFileFieldName = XMLHandler.getTagValue( stepnode, "shortFileFieldName" );
    pathFieldName = XMLHandler.getTagValue( stepnode, "pathFieldName" );
    hiddenFieldName = XMLHandler.getTagValue( stepnode, "hiddenFieldName" );
    lastModificationTimeFieldName = XMLHandler.getTagValue( stepnode, "lastModificationTimeFieldName" );
    uriNameFieldName = XMLHandler.getTagValue( stepnode, "uriNameFieldName" );
    rootUriNameFieldName = XMLHandler.getTagValue( stepnode, "rootUriNameFieldName" );
    extensionFieldName = XMLHandler.getTagValue( stepnode, "extensionFieldName" );
    sizeFieldName = XMLHandler.getTagValue( stepnode, "sizeFieldName" );

  } catch ( Exception e ) {
    throw new KettleXMLException( "Unable to load step info from XML", e );
  }
}

Source File: JsonInputMeta.java From pentaho-kettle with Apache License 2.0

4 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {
    includeFilename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "include" ) );
    filenameField = XMLHandler.getTagValue( stepnode, "include_field" );
    addResultFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "addresultfile" ) );
    readurl = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "readurl" ) );
    removeSourceField = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "removeSourceField" ) );
    isIgnoreEmptyFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "IsIgnoreEmptyFile" ) );
    ignoreMissingPath = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "ignoreMissingPath" ) );
    defaultPathLeafToNull = getDefaultPathLeafToNull( stepnode );
    doNotFailIfNoFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "doNotFailIfNoFile" ) );
    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "rownum" ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, "rownum_field" );

    Node filenode = XMLHandler.getSubNode( stepnode, "file" );
    Node fields = XMLHandler.getSubNode( stepnode, "fields" );
    int nrFiles = XMLHandler.countNodes( filenode, "name" );
    int nrFields = XMLHandler.countNodes( fields, "field" );

    initArrayFields( nrFiles, nrFields );

    for ( int i = 0; i < nrFiles; i++ ) {
      Node filenamenode = XMLHandler.getSubNodeByNr( filenode, "name", i );
      Node filemasknode = XMLHandler.getSubNodeByNr( filenode, "filemask", i );
      Node excludefilemasknode = XMLHandler.getSubNodeByNr( filenode, "exclude_filemask", i );
      Node fileRequirednode = XMLHandler.getSubNodeByNr( filenode, "file_required", i );
      Node includeSubFoldersnode = XMLHandler.getSubNodeByNr( filenode, "include_subfolders", i );
      getFileName()[i] = XMLHandler.getNodeValue( filenamenode );
      getFileMask()[i] = XMLHandler.getNodeValue( filemasknode );
      getExcludeFileMask()[i] = XMLHandler.getNodeValue( excludefilemasknode );
      getFileRequired()[i] = XMLHandler.getNodeValue( fileRequirednode );
      getIncludeSubFolders()[i] = XMLHandler.getNodeValue( includeSubFoldersnode );
    }

    for ( int i = 0; i < nrFields; i++ ) {
      Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
      JsonInputField field = new JsonInputField( fnode );
      getInputFields()[i] = field;
    }

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, "limit" ), 0L );

    setInFields( "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "IsInFields" ) ) );
    isAFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "IsAFile" ) );
    setFieldValue( XMLHandler.getTagValue( stepnode, "valueField" ) );
    setShortFileNameField( XMLHandler.getTagValue( stepnode, "shortFileFieldName" ) );
    setPathField( XMLHandler.getTagValue( stepnode, "pathFieldName" ) );
    setIsHiddenField( XMLHandler.getTagValue( stepnode, "hiddenFieldName" ) );
    setLastModificationDateField( XMLHandler.getTagValue( stepnode, "lastModificationTimeFieldName" ) );
    setUriField( XMLHandler.getTagValue( stepnode, "uriNameFieldName" ) );
    setRootUriField( XMLHandler.getTagValue( stepnode, "rootUriNameFieldName" ) );
    setExtensionField( XMLHandler.getTagValue( stepnode, "extensionFieldName" ) );
    setSizeField( XMLHandler.getTagValue( stepnode, "sizeFieldName" ) );
  } catch ( Exception e ) {
    throw new KettleXMLException( BaseMessages.getString( PKG, "JsonInputMeta.Exception.ErrorLoadingXML", e
        .toString() ) );
  }
}

Source File: AccessInputMeta.java From pentaho-kettle with Apache License 2.0

4 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {
    includeFilename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "include" ) );
    filenameField = XMLHandler.getTagValue( stepnode, "include_field" );
    includeTablename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "tablename" ) );
    tablenameField = XMLHandler.getTagValue( stepnode, "tablename_field" );
    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "rownum" ) );

    String addresult = XMLHandler.getTagValue( stepnode, "isaddresult" );
    if ( Utils.isEmpty( addresult ) ) {
      isaddresult = true;
    } else {
      isaddresult = "Y".equalsIgnoreCase( addresult );
    }

    filefield = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "filefield" ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, "rownum_field" );
    TableName = XMLHandler.getTagValue( stepnode, "table_name" );
    dynamicFilenameField = XMLHandler.getTagValue( stepnode, "filename_Field" );
    resetRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "resetrownumber" ) );

    Node filenode = XMLHandler.getSubNode( stepnode, "file" );
    Node fields = XMLHandler.getSubNode( stepnode, "fields" );
    int nrFiles = XMLHandler.countNodes( filenode, "name" );
    int nrFields = XMLHandler.countNodes( fields, "field" );

    allocate( nrFiles, nrFields );

    for ( int i = 0; i < nrFiles; i++ ) {
      Node filenamenode = XMLHandler.getSubNodeByNr( filenode, "name", i );
      Node filemasknode = XMLHandler.getSubNodeByNr( filenode, "filemask", i );
      Node excludefilemasknode = XMLHandler.getSubNodeByNr( filenode, "exclude_filemask", i );
      Node fileRequirednode = XMLHandler.getSubNodeByNr( filenode, "file_required", i );
      Node includeSubFoldersnode = XMLHandler.getSubNodeByNr( filenode, "include_subfolders", i );
      fileName[i] = XMLHandler.getNodeValue( filenamenode );
      fileMask[i] = XMLHandler.getNodeValue( filemasknode );
      excludeFileMask[i] = XMLHandler.getNodeValue( excludefilemasknode );
      fileRequired[i] = XMLHandler.getNodeValue( fileRequirednode );
      includeSubFolders[i] = XMLHandler.getNodeValue( includeSubFoldersnode );
    }

    for ( int i = 0; i < nrFields; i++ ) {
      Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
      inputFields[i] = new AccessInputField();

      inputFields[i].setName( XMLHandler.getTagValue( fnode, "name" ) );
      inputFields[i].setColumn( XMLHandler.getTagValue( fnode, "attribut" ) );
      inputFields[i].setType( ValueMetaFactory.getIdForValueMeta( XMLHandler.getTagValue( fnode, "type" ) ) );
      inputFields[i].setLength( Const.toInt( XMLHandler.getTagValue( fnode, "length" ), -1 ) );
      inputFields[i].setPrecision( Const.toInt( XMLHandler.getTagValue( fnode, "precision" ), -1 ) );
      String srepeat = XMLHandler.getTagValue( fnode, "repeat" );
      inputFields[i].setTrimType( getTrimTypeByCode( XMLHandler.getTagValue( fnode, "trim_type" ) ) );

      if ( srepeat != null ) {
        inputFields[i].setRepeated( YES.equalsIgnoreCase( srepeat ) );
      } else {
        inputFields[i].setRepeated( false );
      }

      inputFields[i].setFormat( XMLHandler.getTagValue( fnode, "format" ) );
      inputFields[i].setCurrencySymbol( XMLHandler.getTagValue( fnode, "currency" ) );
      inputFields[i].setDecimalSymbol( XMLHandler.getTagValue( fnode, "decimal" ) );
      inputFields[i].setGroupSymbol( XMLHandler.getTagValue( fnode, "group" ) );

    }

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, "limit" ), 0L );
    shortFileFieldName = XMLHandler.getTagValue( stepnode, "shortFileFieldName" );
    pathFieldName = XMLHandler.getTagValue( stepnode, "pathFieldName" );
    hiddenFieldName = XMLHandler.getTagValue( stepnode, "hiddenFieldName" );
    lastModificationTimeFieldName = XMLHandler.getTagValue( stepnode, "lastModificationTimeFieldName" );
    uriNameFieldName = XMLHandler.getTagValue( stepnode, "uriNameFieldName" );
    rootUriNameFieldName = XMLHandler.getTagValue( stepnode, "rootUriNameFieldName" );
    extensionFieldName = XMLHandler.getTagValue( stepnode, "extensionFieldName" );
    sizeFieldName = XMLHandler.getTagValue( stepnode, "sizeFieldName" );
  } catch ( Exception e ) {
    throw new KettleXMLException( "Unable to load step info from XML", e );
  }
}

Source File: ValueString.java From pentaho-kettle with Apache License 2.0

4 votes

@Override
public long getInteger() {
  return Const.toLong( Const.ltrim( string ), 0L ); // Remove the leading space to make "int to string to int"
                                                    // conversion possible.
}

Source File: GetXMLDataMeta.java From pentaho-kettle with Apache License 2.0

4 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {
    includeFilename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "include" ) );
    filenameField = XMLHandler.getTagValue( stepnode, "include_field" );

    addResultFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "addresultfile" ) );
    nameSpaceAware = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "namespaceaware" ) );
    ignorecomments = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "ignorecomments" ) );

    readurl = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "readurl" ) );
    validating = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "validating" ) );
    usetoken = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "usetoken" ) );
    IsIgnoreEmptyFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "IsIgnoreEmptyFile" ) );
    doNotFailIfNoFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "doNotFailIfNoFile" ) );

    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "rownum" ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, "rownum_field" );
    encoding = XMLHandler.getTagValue( stepnode, "encoding" );

    Node filenode = XMLHandler.getSubNode( stepnode, "file" );
    Node fields = XMLHandler.getSubNode( stepnode, "fields" );
    int nrFiles = XMLHandler.countNodes( filenode, "name" );
    int nrFields = XMLHandler.countNodes( fields, "field" );

    allocate( nrFiles, nrFields );

    for ( int i = 0; i < nrFiles; i++ ) {
      Node filenamenode = XMLHandler.getSubNodeByNr( filenode, "name", i );
      Node filemasknode = XMLHandler.getSubNodeByNr( filenode, "filemask", i );
      Node excludefilemasknode = XMLHandler.getSubNodeByNr( filenode, "exclude_filemask", i );
      Node fileRequirednode = XMLHandler.getSubNodeByNr( filenode, "file_required", i );
      Node includeSubFoldersnode = XMLHandler.getSubNodeByNr( filenode, "include_subfolders", i );
      fileName[i] = XMLHandler.getNodeValue( filenamenode );
      fileMask[i] = XMLHandler.getNodeValue( filemasknode );
      excludeFileMask[i] = XMLHandler.getNodeValue( excludefilemasknode );
      fileRequired[i] = XMLHandler.getNodeValue( fileRequirednode );
      includeSubFolders[i] = XMLHandler.getNodeValue( includeSubFoldersnode );
    }

    for ( int i = 0; i < nrFields; i++ ) {
      Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
      GetXMLDataField field = new GetXMLDataField( fnode );
      inputFields[i] = field;
    }

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, "limit" ), 0L );
    // Do we skip rows before starting to read
    loopxpath = XMLHandler.getTagValue( stepnode, "loopxpath" );

    inFields = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "IsInFields" ) );
    IsAFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "IsAFile" ) );

    xmlField = XMLHandler.getTagValue( stepnode, "XmlField" );
    prunePath = XMLHandler.getTagValue( stepnode, "prunePath" );

    shortFileFieldName = XMLHandler.getTagValue( stepnode, "shortFileFieldName" );
    pathFieldName = XMLHandler.getTagValue( stepnode, "pathFieldName" );
    hiddenFieldName = XMLHandler.getTagValue( stepnode, "hiddenFieldName" );
    lastModificationTimeFieldName = XMLHandler.getTagValue( stepnode, "lastModificationTimeFieldName" );
    uriNameFieldName = XMLHandler.getTagValue( stepnode, "uriNameFieldName" );
    rootUriNameFieldName = XMLHandler.getTagValue( stepnode, "rootUriNameFieldName" );
    extensionFieldName = XMLHandler.getTagValue( stepnode, "extensionFieldName" );
    sizeFieldName = XMLHandler.getTagValue( stepnode, "sizeFieldName" );
  } catch ( Exception e ) {
    throw new KettleXMLException( BaseMessages.getString( PKG, "GetXMLDataMeta.Exception.ErrorLoadingXML", e
        .toString() ) );
  }
}

Source File: MySQLBulkLoader.java From pentaho-kettle with Apache License 2.0

4 votes

@Override
public boolean init( StepMetaInterface smi, StepDataInterface sdi ) {
  meta = (MySQLBulkLoaderMeta) smi;
  data = (MySQLBulkLoaderData) sdi;

  if ( super.init( smi, sdi ) ) {

    // Confirming Database Connection is defined.
    try {
      verifyDatabaseConnection();
    } catch ( KettleException ex ) {
      logError( ex.getMessage() );
      return false;
    }

    if ( Utils.isEmpty( meta.getEnclosure() ) ) {
      data.quote = new byte[] {};
    } else {
      data.quote = environmentSubstitute( meta.getEnclosure() ).getBytes();
    }
    if ( Utils.isEmpty( meta.getDelimiter() ) ) {
      data.separator = "\t".getBytes();
    } else {
      data.separator = environmentSubstitute( meta.getDelimiter() ).getBytes();
    }
    data.newline = Const.CR.getBytes();

    String realEncoding = environmentSubstitute( meta.getEncoding() );
    data.bulkTimestampMeta = new ValueMetaDate( "timestampMeta" );
    data.bulkTimestampMeta.setConversionMask( "yyyy-MM-dd HH:mm:ss" );
    data.bulkTimestampMeta.setStringEncoding( realEncoding );

    data.bulkDateMeta = new ValueMetaDate( "dateMeta" );
    data.bulkDateMeta.setConversionMask( "yyyy-MM-dd" );
    data.bulkDateMeta.setStringEncoding( realEncoding );

    data.bulkNumberMeta = new ValueMetaNumber( "numberMeta" );
    data.bulkNumberMeta.setConversionMask( "#.#" );
    data.bulkNumberMeta.setGroupingSymbol( "," );
    data.bulkNumberMeta.setDecimalSymbol( "." );
    data.bulkNumberMeta.setStringEncoding( realEncoding );

    data.bulkSize = Const.toLong( environmentSubstitute( meta.getBulkSize() ), -1L );

    // Schema-table combination...
    data.schemaTable =
        meta.getDatabaseMeta().getQuotedSchemaTableCombination( environmentSubstitute( meta.getSchemaName() ),
            environmentSubstitute( meta.getTableName() ) );

    return true;
  }
  return false;
}

Source File: LDIFInputMeta.java From pentaho-kettle with Apache License 2.0

4 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {
    filefield = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "filefield" ) );
    dynamicFilenameField = XMLHandler.getTagValue( stepnode, "dynamicFilenameField" );
    includeFilename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "include" ) );
    filenameField = XMLHandler.getTagValue( stepnode, "include_field" );
    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "rownum" ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, "rownum_field" );
    includeContentType = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "contenttype" ) );
    contentTypeField = XMLHandler.getTagValue( stepnode, "contenttype_field" );
    DNField = XMLHandler.getTagValue( stepnode, "dn_field" );
    includeDN = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "dn" ) );
    addtoresultfilename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "addtoresultfilename" ) );
    multiValuedSeparator = XMLHandler.getTagValue( stepnode, "multiValuedSeparator" );

    Node filenode = XMLHandler.getSubNode( stepnode, "file" );
    Node fields = XMLHandler.getSubNode( stepnode, "fields" );
    int nrFiles = XMLHandler.countNodes( filenode, "name" );
    int nrFields = XMLHandler.countNodes( fields, "field" );

    allocate( nrFiles, nrFields );

    for ( int i = 0; i < nrFiles; i++ ) {
      Node filenamenode = XMLHandler.getSubNodeByNr( filenode, "name", i );
      Node filemasknode = XMLHandler.getSubNodeByNr( filenode, "filemask", i );
      Node excludefilemasknode = XMLHandler.getSubNodeByNr( filenode, "exclude_filemask", i );
      Node fileRequirednode = XMLHandler.getSubNodeByNr( filenode, "file_required", i );
      Node includeSubFoldersnode = XMLHandler.getSubNodeByNr( filenode, "include_subfolders", i );
      fileName[i] = XMLHandler.getNodeValue( filenamenode );
      fileMask[i] = XMLHandler.getNodeValue( filemasknode );
      excludeFileMask[i] = XMLHandler.getNodeValue( excludefilemasknode );
      fileRequired[i] = XMLHandler.getNodeValue( fileRequirednode );
      includeSubFolders[i] = XMLHandler.getNodeValue( includeSubFoldersnode );
    }

    for ( int i = 0; i < nrFields; i++ ) {
      Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
      LDIFInputField field = new LDIFInputField( fnode );
      inputFields[i] = field;
    }

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, "limit" ), 0L );
    shortFileFieldName = XMLHandler.getTagValue( stepnode, "shortFileFieldName" );
    pathFieldName = XMLHandler.getTagValue( stepnode, "pathFieldName" );
    hiddenFieldName = XMLHandler.getTagValue( stepnode, "hiddenFieldName" );
    lastModificationTimeFieldName = XMLHandler.getTagValue( stepnode, "lastModificationTimeFieldName" );
    uriNameFieldName = XMLHandler.getTagValue( stepnode, "uriNameFieldName" );
    rootUriNameFieldName = XMLHandler.getTagValue( stepnode, "rootUriNameFieldName" );
    extensionFieldName = XMLHandler.getTagValue( stepnode, "extensionFieldName" );
    sizeFieldName = XMLHandler.getTagValue( stepnode, "sizeFieldName" );
  } catch ( Exception e ) {
    throw new KettleXMLException( "Unable to load step info from XML", e );
  }
}

Source File: BeamWindowStepHandler.java From kettle-beam with Apache License 2.0

4 votes

@Override public void handleStep( LogChannelInterface log, StepMeta stepMeta, Map<String, PCollection<KettleRow>> stepCollectionMap,
                                  Pipeline pipeline, RowMetaInterface inputRowMeta, List<StepMeta> previousSteps,
                                  PCollection<KettleRow> input ) throws KettleException {

  BeamWindowMeta beamWindowMeta = (BeamWindowMeta) stepMeta.getStepMetaInterface();

  if ( StringUtils.isEmpty( beamWindowMeta.getWindowType() ) ) {
    throw new KettleException( "Please specify a window type in Beam Window step '" + stepMeta.getName() + "'" );
  }

  String duration = transMeta.environmentSubstitute( beamWindowMeta.getDuration() );
  long durationSeconds = Const.toLong( duration, -1L );

  PCollection<KettleRow> stepPCollection;

  if ( BeamDefaults.WINDOW_TYPE_FIXED.equals( beamWindowMeta.getWindowType() ) ) {

    if ( durationSeconds <= 0 ) {
      throw new KettleException( "Please specify a valid positive window size (duration) for Beam window step '" + stepMeta.getName() + "'" );
    }

    FixedWindows fixedWindows = FixedWindows
      .of( Duration.standardSeconds( durationSeconds ) );
    stepPCollection = input.apply( Window.into( fixedWindows ) );

  } else if ( BeamDefaults.WINDOW_TYPE_SLIDING.equals( beamWindowMeta.getWindowType() ) ) {

    if ( durationSeconds <= 0 ) {
      throw new KettleException( "Please specify a valid positive window size (duration) for Beam window step '" + stepMeta.getName() + "'" );
    }

    String every = transMeta.environmentSubstitute( beamWindowMeta.getEvery() );
    long everySeconds = Const.toLong( every, -1L );

    SlidingWindows slidingWindows = SlidingWindows
      .of( Duration.standardSeconds( durationSeconds ) )
      .every( Duration.standardSeconds( everySeconds ) );
    stepPCollection = input.apply( Window.into( slidingWindows ) );

  } else if ( BeamDefaults.WINDOW_TYPE_SESSION.equals( beamWindowMeta.getWindowType() ) ) {

    if ( durationSeconds < 600 ) {
      throw new KettleException(
        "Please specify a window size (duration) of at least 600 (10 minutes) for Beam window step '" + stepMeta.getName() + "'.  This is the minimum gap between session windows." );
    }

    Sessions sessionWindows = Sessions
      .withGapDuration( Duration.standardSeconds( durationSeconds ) );
    stepPCollection = input.apply( Window.into( sessionWindows ) );

  } else if ( BeamDefaults.WINDOW_TYPE_GLOBAL.equals( beamWindowMeta.getWindowType() ) ) {

    stepPCollection = input.apply( Window.into( new GlobalWindows() ) );

  } else {
    throw new KettleException( "Beam Window type '" + beamWindowMeta.getWindowType() + " is not supported in step '" + stepMeta.getName() + "'" );
  }

  // Now get window information about the window if we asked about it...
  //
  if ( StringUtils.isNotEmpty( beamWindowMeta.getStartWindowField() ) ||
    StringUtils.isNotEmpty( beamWindowMeta.getEndWindowField() ) ||
    StringUtils.isNotEmpty( beamWindowMeta.getMaxWindowField() ) ) {

    WindowInfoFn windowInfoFn = new WindowInfoFn(
      stepMeta.getName(),
      transMeta.environmentSubstitute( beamWindowMeta.getMaxWindowField() ),
      transMeta.environmentSubstitute( beamWindowMeta.getStartWindowField() ),
      transMeta.environmentSubstitute( beamWindowMeta.getMaxWindowField() ),
      JsonRowMeta.toJson( inputRowMeta ),
      stepPluginClasses,
      xpPluginClasses
    );

    stepPCollection = stepPCollection.apply( ParDo.of( windowInfoFn ) );
  }

  // Save this in the map
  //
  stepCollectionMap.put( stepMeta.getName(), stepPCollection );
  log.logBasic( "Handled step (WINDOW) : " + stepMeta.getName() + ", gets data from " + previousSteps.size() + " previous step(s)" );
}

Source File: YamlInputMeta.java From pentaho-kettle with Apache License 2.0

4 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {
    includeFilename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "include" ) );
    filenameField = XMLHandler.getTagValue( stepnode, "include_field" );

    addResultFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "addresultfile" ) );
    validating = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "validating" ) );
    IsIgnoreEmptyFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "IsIgnoreEmptyFile" ) );
    doNotFailIfNoFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "doNotFailIfNoFile" ) );

    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "rownum" ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, "rownum_field" );
    encoding = XMLHandler.getTagValue( stepnode, "encoding" );

    Node filenode = XMLHandler.getSubNode( stepnode, "file" );
    Node fields = XMLHandler.getSubNode( stepnode, "fields" );
    int nrFiles = XMLHandler.countNodes( filenode, "name" );
    int nrFields = XMLHandler.countNodes( fields, "field" );

    allocate( nrFiles, nrFields );

    for ( int i = 0; i < nrFiles; i++ ) {
      Node filenamenode = XMLHandler.getSubNodeByNr( filenode, "name", i );
      Node filemasknode = XMLHandler.getSubNodeByNr( filenode, "filemask", i );
      Node fileRequirednode = XMLHandler.getSubNodeByNr( filenode, "file_required", i );
      Node includeSubFoldersnode = XMLHandler.getSubNodeByNr( filenode, "include_subfolders", i );
      fileName[i] = XMLHandler.getNodeValue( filenamenode );
      fileMask[i] = XMLHandler.getNodeValue( filemasknode );
      fileRequired[i] = XMLHandler.getNodeValue( fileRequirednode );
      includeSubFolders[i] = XMLHandler.getNodeValue( includeSubFoldersnode );
    }

    for ( int i = 0; i < nrFields; i++ ) {
      Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
      YamlInputField field = new YamlInputField( fnode );
      inputFields[i] = field;
    }

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, "limit" ), 0L );
    inFields = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "IsInFields" ) );
    IsAFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "IsAFile" ) );
    yamlField = XMLHandler.getTagValue( stepnode, "YamlField" );
  } catch ( Exception e ) {
    throw new KettleXMLException( BaseMessages.getString( PKG, "YamlInputMeta.Exception.ErrorLoadingXML", e
      .toString() ) );
  }
}

Source File: LoadFileInputMeta.java From pentaho-kettle with Apache License 2.0

4 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {
    includeFilename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, INCLUDE ) );
    filenameField = XMLHandler.getTagValue( stepnode, INCLUDE_FIELD );

    addresultfile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, ADDRESULTFILE ) );
    IsIgnoreEmptyFile = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, IS_IGNORE_EMPTY_FILE ) );
    IsIgnoreMissingPath = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, IS_IGNORE_MISSING_PATH ) );

    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, ROWNUM ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, ROWNUM_FIELD );
    encoding = XMLHandler.getTagValue( stepnode, ENCODING );

    Node filenode = XMLHandler.getSubNode( stepnode, FILE );
    Node fields = XMLHandler.getSubNode( stepnode, FIELDS );
    int nrFiles = XMLHandler.countNodes( filenode, NAME );
    int nrFields = XMLHandler.countNodes( fields, "field" );

    allocate( nrFiles, nrFields );

    for ( int i = 0; i < nrFiles; i++ ) {
      Node filenamenode = XMLHandler.getSubNodeByNr( filenode, NAME, i );
      Node filemasknode = XMLHandler.getSubNodeByNr( filenode, FILEMASK, i );
      Node excludefilemasknode = XMLHandler.getSubNodeByNr( filenode, EXCLUDE_FILEMASK, i );
      Node fileRequirednode = XMLHandler.getSubNodeByNr( filenode, FILE_REQUIRED, i );
      Node includeSubFoldersnode = XMLHandler.getSubNodeByNr( filenode, INCLUDE_SUBFOLDERS, i );
      fileName[i] = XMLHandler.getNodeValue( filenamenode );
      fileMask[i] = XMLHandler.getNodeValue( filemasknode );
      excludeFileMask[i] = XMLHandler.getNodeValue( excludefilemasknode );
      fileRequired[i] = XMLHandler.getNodeValue( fileRequirednode );
      includeSubFolders[i] = XMLHandler.getNodeValue( includeSubFoldersnode );
    }

    for ( int i = 0; i < nrFields; i++ ) {
      Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
      LoadFileInputField field = new LoadFileInputField( fnode );
      inputFields[i] = field;
    }

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, LIMIT ), 0L );

    fileinfield = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, IS_IN_FIELDS ) );

    DynamicFilenameField = XMLHandler.getTagValue( stepnode, DYNAMIC_FILENAME_FIELD );
    shortFileFieldName = XMLHandler.getTagValue( stepnode, SHORT_FILE_FIELD_NAME );
    pathFieldName = XMLHandler.getTagValue( stepnode, PATH_FIELD_NAME );
    hiddenFieldName = XMLHandler.getTagValue( stepnode, HIDDEN_FIELD_NAME );
    lastModificationTimeFieldName = XMLHandler.getTagValue( stepnode, LAST_MODIFICATION_TIME_FIELD_NAME );
    uriNameFieldName = XMLHandler.getTagValue( stepnode, URI_NAME_FIELD_NAME );
    rootUriNameFieldName = XMLHandler.getTagValue( stepnode, ROOT_URI_NAME_FIELD_NAME );
    extensionFieldName = XMLHandler.getTagValue( stepnode, EXTENSION_FIELD_NAME );

  } catch ( Exception e ) {
    throw new KettleXMLException( BaseMessages.getString( PKG, "LoadFileInputMeta.Exception.ErrorLoadingXML", e
        .toString() ) );
  }
}

Source File: XMLInputMeta.java From pentaho-kettle with Apache License 2.0

4 votes

private void readData( Node stepnode ) throws KettleXMLException {
  try {
    includeFilename = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "include" ) );
    filenameField = XMLHandler.getTagValue( stepnode, "include_field" );
    includeRowNumber = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "rownum" ) );
    rowNumberField = XMLHandler.getTagValue( stepnode, "rownum_field" );
    fileBaseURI = XMLHandler.getTagValue( stepnode, "file_base_uri" );
    ignoreEntities = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "ignore_entities" ) );
    namespaceAware = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "namespace_aware" ) );

    Node filenode = XMLHandler.getSubNode( stepnode, "file" );
    Node fields = XMLHandler.getSubNode( stepnode, "fields" );
    Node positions = XMLHandler.getSubNode( stepnode, "positions" );
    int nrFiles = XMLHandler.countNodes( filenode, "name" );
    int nrFields = XMLHandler.countNodes( fields, "field" );
    int nrPositions = XMLHandler.countNodes( positions, "position" );

    allocate( nrFiles, nrFields, nrPositions );

    for ( int i = 0; i < nrFiles; i++ ) {
      Node filenamenode = XMLHandler.getSubNodeByNr( filenode, "name", i );
      Node filemasknode = XMLHandler.getSubNodeByNr( filenode, "filemask", i );
      fileName[i] = XMLHandler.getNodeValue( filenamenode );
      fileMask[i] = XMLHandler.getNodeValue( filemasknode );
    }

    for ( int i = 0; i < nrFields; i++ ) {
      Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
      XMLInputField field = new XMLInputField( fnode );
      inputFields[i] = field;
    }

    for ( int i = 0; i < nrPositions; i++ ) {
      Node positionnode = XMLHandler.getSubNodeByNr( positions, "position", i );
      inputPosition[i] = XMLHandler.getNodeValue( positionnode );
    }

    // Is there a limit on the number of rows we process?
    rowLimit = Const.toLong( XMLHandler.getTagValue( stepnode, "limit" ), 0L );
    // Do we skip rows before starting to read
    nrRowsToSkip = Const.toInt( XMLHandler.getTagValue( stepnode, "skip" ), 0 );
  } catch ( Exception e ) {
    throw new KettleXMLException( "Unable to load step info from XML", e );
  }
}

Source File: SalesforceInput.java From pentaho-kettle with Apache License 2.0

4 votes

@Override
public boolean init( StepMetaInterface smi, StepDataInterface sdi ) {
  meta = (SalesforceInputMeta) smi;
  data = (SalesforceInputData) sdi;

  if ( super.init( smi, sdi ) ) {
    // get total fields in the grid
    data.nrfields = meta.getInputFields().length;

    // Check if field list is filled
    if ( data.nrfields == 0 ) {
      log.logError( BaseMessages.getString( PKG, "SalesforceInputDialog.FieldsMissing.DialogMessage" ) );
      return false;
    }

    String soSQL = environmentSubstitute( meta.getQuery() );
    try {

      if ( meta.isSpecifyQuery() ) {
        // Check if user specified a query
        if ( Utils.isEmpty( soSQL ) ) {
          log.logError( BaseMessages.getString( PKG, "SalesforceInputDialog.QueryMissing.DialogMessage" ) );
          return false;
        }
      } else {
        // check records filter
        if ( meta.getRecordsFilter() != SalesforceConnectionUtils.RECORDS_FILTER_ALL ) {
          String realFromDateString = environmentSubstitute( meta.getReadFrom() );
          if ( Utils.isEmpty( realFromDateString ) ) {
            log.logError( BaseMessages.getString( PKG, "SalesforceInputDialog.FromDateMissing.DialogMessage" ) );
            return false;
          }
          String realToDateString = environmentSubstitute( meta.getReadTo() );
          if ( Utils.isEmpty( realToDateString ) ) {
            log.logError( BaseMessages.getString( PKG, "SalesforceInputDialog.ToDateMissing.DialogMessage" ) );
            return false;
          }
          try {
            SimpleDateFormat dateFormat = new SimpleDateFormat( SalesforceInputMeta.DATE_TIME_FORMAT );
            data.startCal = new GregorianCalendar();
            data.startCal.setTime( dateFormat.parse( realFromDateString ) );
            data.endCal = new GregorianCalendar();
            data.endCal.setTime( dateFormat.parse( realToDateString ) );
            dateFormat = null;
          } catch ( Exception e ) {
            log.logError( BaseMessages.getString( PKG, "SalesforceInput.ErrorParsingDate" ), e );
            return false;
          }
        }
      }

      data.limit = Const.toLong( environmentSubstitute( meta.getRowLimit() ), 0 );

      // Do we have to query for all records included deleted records
      data.connection.setQueryAll( meta.isQueryAll() );

      // Build query if needed
      if ( meta.isSpecifyQuery() ) {
        // Free hand SOQL Query
        data.connection.setSQL( soSQL.replace( "\n\r", " " ).replace( "\n", " " ) );
      } else {
        // Set calendars for update or deleted records
        if ( meta.getRecordsFilter() != SalesforceConnectionUtils.RECORDS_FILTER_ALL ) {
          data.connection.setCalendar( meta.getRecordsFilter(), data.startCal, data.endCal );
        }

        if ( meta.getRecordsFilter() == SalesforceConnectionUtils.RECORDS_FILTER_UPDATED ) {
          // Return fields list
          data.connection.setFieldsList( BuiltSOQl() );
        } else {
          // Build now SOQL
          data.connection.setSQL( BuiltSOQl() );
        }
      }

      // Now connect ...
      data.connection.connect();

      return true;
    } catch ( KettleException ke ) {
      logError( BaseMessages.getString( PKG, "SalesforceInput.Log.ErrorOccurredDuringStepInitialize" )
        + ke.getMessage() );
      return false;
    }
  }
  return false;
}

Java Code Examples for org.pentaho.di.core.Const#toLong()