public BeanInjectionInfo(Class<?> clazz) {
    LOG.logDebug("Collect bean injection info for " + clazz);
    try {
      this.clazz = clazz;
      clazzAnnotation = clazz.getAnnotation(InjectionSupported.class);
      if (clazzAnnotation == null) {
        throw new RuntimeException("Injection not supported in " + clazz);
      }

      Group gr0 = new Group("");
      groupsList.add(gr0);
      groupsMap.put(gr0.getName(), gr0);
      for (String group : clazzAnnotation.groups()) {
        Group gr = new Group(group);
        groupsList.add(gr);
        groupsMap.put(gr.getName(), gr);
      }

      BeanLevelInfo root = new BeanLevelInfo();
      root.leafClass = clazz;
      root.init(this);

      properties = Collections.unmodifiableMap(properties);
      groupsList = Collections.unmodifiableList(groupsList);
      groupsMap = null;
    } catch (Throwable ex) {
      LOG.logError(
          "Error bean injection info collection for " + clazz + ": " + ex.getMessage(), ex);
      throw ex;
    }
  }
 public void close() throws KettleException {
   try {
     if (!getQueryResult().isDone()) {
       this.qr.setDone(true);
       this.qr = null;
     }
     if (this.sObjects != null) {
       this.sObjects = null;
     }
     if (this.binding != null) {
       this.binding = null;
     }
     if (this.loginResult != null) {
       this.loginResult = null;
     }
     if (this.userInfo != null) {
       this.userInfo = null;
     }
     if (this.getDeletedList != null) {
       getDeletedList.clear();
       getDeletedList = null;
     }
     if (log.isDetailed()) {
       log.logDetailed(BaseMessages.getString(PKG, "SalesforceInput.Log.ConnectionClosed"));
     }
   } catch (Exception e) {
     throw new KettleException(
         BaseMessages.getString(PKG, "SalesforceInput.Error.ClosingConnection"), e);
   }
 }
  private void parseDocument() {
    // get a factory
    SAXParserFactory spf = SAXParserFactory.newInstance();
    try {
      // get a new instance of parser
      SAXParser sp = spf.newSAXParser();
      // parse the file and also register this class for call backs
      sp.parse(sourceFile, this);

    } catch (SAXException se) {
      log.logError(Const.getStackTracker(se));
    } catch (ParserConfigurationException pce) {
      log.logError(Const.getStackTracker(pce));
    } catch (IOException ie) {
      log.logError(Const.getStackTracker(ie));
    }
  }
  protected int getDataForRow(TableItem item, Object[] row) {
    int nrErrors = 0;

    // Display the correct line item...
    //
    String strNr;
    lineNr++;
    try {
      strNr = wFields.getNumberColumn().getValueMeta().getString(new Long(lineNr));
    } catch (Exception e) {
      strNr = Integer.toString(lineNr);
    }
    item.setText(0, strNr);

    for (int c = 0; c < rowMeta.size(); c++) {
      ValueMetaInterface v = rowMeta.getValueMeta(c);
      String show;
      try {
        show = v.getString(row[c]);
        if (v.isBinary() && show != null && show.length() > MAX_BINARY_STRING_PREVIEW_SIZE) {
          // We want to limit the size of the strings during preview to keep all SWT widgets happy.
          //
          show = show.substring(0, MAX_BINARY_STRING_PREVIEW_SIZE);
        }
      } catch (KettleValueException e) {
        nrErrors++;
        if (nrErrors < 25) {
          log.logError(Const.getStackTracker(e));
        }
        show = null;
      } catch (ArrayIndexOutOfBoundsException e) {
        nrErrors++;
        if (nrErrors < 25) {
          log.logError(Const.getStackTracker(e));
        }
        show = null;
      }

      if (show != null) {
        item.setText(c + 1, show);
      }
    }

    return nrErrors;
  }
示例#5
0
  protected String calculateString(
      String packageName, String key, Object[] parameters, Class<?> resourceClass) {
    String string = null;

    // First try the standard locale, in the local package
    try {
      string =
          findString(packageName, langChoice.getDefaultLocale(), key, parameters, resourceClass);
    } catch (MissingResourceException e) {
    }
    ;
    if (string != null) return string;

    // Then try to find it in the i18n package, in the system messages of the preferred language.
    try {
      string =
          findString(
              SYSTEM_BUNDLE_PACKAGE, langChoice.getDefaultLocale(), key, parameters, resourceClass);
    } catch (MissingResourceException e) {
    }
    ;
    if (string != null) return string;

    // Then try the failover locale, in the local package
    try {
      string =
          findString(packageName, langChoice.getFailoverLocale(), key, parameters, resourceClass);
    } catch (MissingResourceException e) {
    }
    ;
    if (string != null) return string;

    // Then try to find it in the i18n package, in the system messages of the failover language.
    try {
      string =
          findString(
              SYSTEM_BUNDLE_PACKAGE,
              langChoice.getFailoverLocale(),
              key,
              parameters,
              resourceClass);
    } catch (MissingResourceException e) {
    }
    ;
    if (string != null) return string;

    string = "!" + key + "!";
    String message =
        "Message not found in the preferred and failover locale: key=["
            + key
            + "], package="
            + packageName;
    log.logDetailed(Const.getStackTracker(new KettleException(message)));

    return string;
  }
  /** Construct a new Salesforce Connection */
  public SalesforceConnection(
      LogChannelInterface logInterface, String url, String username, String password)
      throws KettleException {
    this.log = logInterface;
    this.url = url;
    setUsername(username);
    setPassword(password);
    setTimeOut(0);

    this.binding = null;
    this.loginResult = null;
    this.userInfo = null;
    this.sql = null;
    this.serverTimestamp = null;
    this.qr = null;
    this.condition = null;
    this.startDate = null;
    this.endDate = null;
    this.sObjects = null;
    this.recordsFilter = SalesforceConnectionUtils.RECORDS_FILTER_ALL;
    this.fieldsList = null;
    this.queryResultSize = 0;
    this.recordsCount = 0;
    setUsingCompression(false);
    rollbackAllChangesOnError(false);

    // check target URL
    if (Const.isEmpty(getURL())) {
      throw new KettleException(
          BaseMessages.getString(PKG, "SalesforceInput.TargetURLMissing.Error"));
    }

    // check username
    if (Const.isEmpty(getUsername())) {
      throw new KettleException(
          BaseMessages.getString(PKG, "SalesforceInput.UsernameMissing.Error"));
    }

    if (log.isDetailed()) {
      logInterface.logDetailed(BaseMessages.getString(PKG, "SalesforceInput.Log.NewConnection"));
    }
  }
 public Repository connectRepository(String repositoryName, String username, String password)
     throws KettleException {
   // Verify that the repository exists on the slave server...
   //
   RepositoriesMeta repositoriesMeta = new RepositoriesMeta();
   repositoriesMeta.getLog().setLogLevel(log.getLogLevel());
   try {
     repositoriesMeta.readData();
   } catch (Exception e) {
     throw new KettleException(
         "Unable to get a list of repositories to locate repository '" + repositoryName + "'");
   }
   return connectRepository(repositoriesMeta, repositoryName, username, password);
 }
示例#8
0
 protected String findString(
     String packageName, Locale locale, String key, Object[] parameters, Class<?> resourceClass)
     throws MissingResourceException {
   try {
     ResourceBundle bundle = getBundle(locale, packageName + "." + BUNDLE_NAME, resourceClass);
     String unformattedString = bundle.getString(key);
     String string = MessageFormat.format(unformattedString, parameters);
     return string;
   } catch (IllegalArgumentException e) {
     String message =
         "Format problem with key=["
             + key
             + "], locale=["
             + locale
             + "], package="
             + packageName
             + " : "
             + e.toString();
     log.logError(message);
     log.logError(Const.getStackTracker(e));
     throw new MissingResourceException(message, packageName, key);
   }
 }
  public Repository connectRepository(
      RepositoriesMeta repositoriesMeta, String repositoryName, String username, String password)
      throws KettleException {
    RepositoryMeta repositoryMeta = repositoriesMeta.findRepository(repositoryName);
    if (repositoryMeta == null) {
      log.logBasic("I couldn't find the repository with name '" + repositoryName + "'");
      return null;
    }

    Repository rep =
        PluginRegistry.getInstance()
            .loadClass(RepositoryPluginType.class, repositoryMeta, Repository.class);
    rep.init(repositoryMeta);

    try {
      rep.connect(username, password);
      log.logBasic("Connected to " + repositoryName + " as " + username);
      setRepository(rep);
      return rep;
    } catch (Exception e) {
      log.logBasic("Unable to connect to the repository with name '" + repositoryName + "'");
      return null;
    }
  }
  @Override
  public void callExtensionPoint(LogChannelInterface log, Object object) throws KettleException {
    if (!(object instanceof CommandLineOption[])) {
      return;
    }
    CommandLineOption[] options = (CommandLineOption[]) object;
    StringBuilder optionRepname = getCommandLineOption(options, "rep").getArgument();
    StringBuilder optionFilename = getCommandLineOption(options, "file").getArgument();
    StringBuilder optionUsername = getCommandLineOption(options, "user").getArgument();
    StringBuilder optionPassword = getCommandLineOption(options, "pass").getArgument();

    if (!Utils.isEmpty(optionRepname) && Utils.isEmpty(optionFilename)) {
      RepositoryMeta repositoryMeta =
          repositoryConnectController.getRepositoryMetaByName(optionRepname.toString());
      if (repositoryMeta != null
          && !Utils.isEmpty(optionUsername)
          && !Utils.isEmpty(optionPassword)) {
        repositoryConnectController.connectToRepository(
            repositoryMeta, optionUsername.toString(), optionPassword.toString());
      } else if (repositoryMeta != null) {
        repositoryConnectController.connectToRepository(repositoryMeta, null, null);
      }
      if (!repositoryConnectController.isConnected()) {
        String msg = BaseMessages.getString(PKG, "Repository.NoConnected.Message");
        log.logError(msg); // "No repositories defined on this system."
        MessageBox mb = new MessageBox(getSpoon().getShell(), SWT.OK | SWT.ICON_ERROR);
        mb.setMessage(
            BaseMessages.getString(
                PKG, "Repository.NoConnected.Message", optionRepname.toString()));
        mb.setText(BaseMessages.getString(PKG, "Repository.NoConnected.Message.Title"));
        mb.open();
      }
    } else if (Utils.isEmpty(optionFilename)) {
      RepositoryMeta repositoryMeta = repositoryConnectController.getDefaultRepositoryMeta();
      if (repositoryMeta != null) {
        if (repositoryMeta.getId().equals("KettleFileRepository")) {
          repositoryConnectController.connectToRepository(repositoryMeta);
        } else {
          new RepositoryDialog(getSpoon().getShell(), repositoryConnectController)
              .openLogin(repositoryMeta);
        }
      }
    }
  }
  public void getUsedArguments(
      JobMeta jobMeta, String[] commandLineArguments, IMetaStore metaStore) {

    for (JobEntryCopy jobEntryCopy : jobMeta.jobcopies) {
      if (jobEntryCopy.isTransformation()) {
        JobEntryTrans jobEntryTrans = (JobEntryTrans) jobEntryCopy.getEntry();
        try {
          TransMeta transMeta = jobEntryTrans.getTransMeta(repository, metaStore, jobMeta);
          Map<String, String> map = transMeta.getUsedArguments(commandLineArguments);
          for (String key : map.keySet()) {
            String value = map.get(key);
            if (!arguments.containsKey(key)) {
              arguments.put(key, value);
            }
          }
        } catch (KettleException ke) {
          log.logBasic(ke.getMessage(), ke);
        }
      }
    }
  }
  // Event Handlers
  public void startElement(String uri, String localName, String qName, Attributes attributes)
      throws SAXException {
    // set the _counter level
    position[_counter + 1] += 1;
    _counter++;
    try {
      if (!rootFound) {
        XMLInputSaxFieldPosition el = null;

        try {
          el = (XMLInputSaxFieldPosition) pathToRootElement.get(counter);
        } catch (IndexOutOfBoundsException e) {
          throw new SAXException(e);
        }
        if ((counter == _counter) && qName.equalsIgnoreCase(el.getName())) {
          if (el.getType() == XMLInputSaxFieldPosition.XML_ELEMENT_ATT) {
            String att1 = attributes.getValue(el.getAttribute()); // must throw exception
            String att2 = el.getAttributeValue();
            if (att1.equals(att2)) {
              _pathToRootElement.add(
                  new XMLInputSaxFieldPosition(
                      qName, el.getAttribute(), el.getAttributeValue())); // to test with clone
              if (counter == pathToRootElement.size() - 1) {
                for (int i = 0; i < attributes.getLength(); i++) {
                  XMLInputSaxFieldPosition tempP =
                      new XMLInputSaxFieldPosition(
                          attributes.getQName(i), XMLInputSaxFieldPosition.XML_ATTRIBUTE, i + 1);
                  _pathToRootElement.add(tempP);
                  XMLInputSaxFieldPosition[] path =
                      new XMLInputSaxFieldPosition[_pathToRootElement.size()];
                  _pathToRootElement.toArray(path);
                  _pathToRootElement.remove(_pathToRootElement.size() - 1);
                  XMLInputSaxField tempF = new XMLInputSaxField(tempP.getName(), path);
                  if (!fields.contains(tempF)) {
                    fields.add(tempF);
                  }
                }
              }
              counterUp();
            } else {
              _pathToRootElement.add(
                  new XMLInputSaxFieldPosition(
                      qName, XMLInputSaxFieldPosition.XML_ELEMENT_POS, position[_counter] + 1));
            }
          } else {
            _pathToRootElement.add(
                new XMLInputSaxFieldPosition(
                    qName, XMLInputSaxFieldPosition.XML_ELEMENT_POS, position[_counter] + 1));
            counterUp();
          }
        } else {
          _pathToRootElement.add(
              new XMLInputSaxFieldPosition(
                  qName, XMLInputSaxFieldPosition.XML_ELEMENT_POS, position[_counter] + 1));
        }
      } else {
        XMLInputSaxField temp = null;
        if (attributes.getValue(meta.getDefiningAttribute(qName)) == null) {
          _pathToRootElement.add(
              new XMLInputSaxFieldPosition(
                  qName, XMLInputSaxFieldPosition.XML_ELEMENT_POS, position[_counter] + 1));
          XMLInputSaxFieldPosition[] path = new XMLInputSaxFieldPosition[_pathToRootElement.size()];
          _pathToRootElement.toArray(path);
          temp = new XMLInputSaxField(naming(path), path);
        } else {
          String attribute = meta.getDefiningAttribute(qName);
          _pathToRootElement.add(
              new XMLInputSaxFieldPosition(qName, attribute, attributes.getValue(attribute)));
          XMLInputSaxFieldPosition[] path = new XMLInputSaxFieldPosition[_pathToRootElement.size()];
          _pathToRootElement.toArray(path);
          temp = new XMLInputSaxField(naming(path), path);
        }

        if (!fields.contains(temp)) {
          fields.add(temp);
        }
      }
    } catch (KettleValueException e) {
      log.logError(Const.getStackTracker(e));
      throw new SAXException(
          _counter
              + ","
              + counter
              + ((XMLInputSaxFieldPosition) _pathToRootElement.get(_pathToRootElement.size() - 1))
                  .toString(),
          e);
    }
  }
示例#13
0
  public boolean validate() {

    boolean retval = false;

    FileObject xmlfile = null;
    FileObject DTDfile = null;

    ByteArrayInputStream ba = null;
    try {
      if (xmlfilename != null
          && ((getDTDFilename() != null && !isInternDTD()) || (isInternDTD()))) {
        xmlfile = KettleVFS.getFileObject(getXMLFilename());

        if (xmlfile.exists()) {

          URL xmlFile = new File(KettleVFS.getFilename(xmlfile)).toURI().toURL();
          StringBuffer xmlStringbuffer = new StringBuffer("");

          BufferedReader xmlBufferedReader = null;
          InputStreamReader is = null;
          try {
            // open XML File
            is = new InputStreamReader(xmlFile.openStream());
            xmlBufferedReader = new BufferedReader(is);

            char[] buffertXML = new char[1024];
            int LenXML = -1;
            while ((LenXML = xmlBufferedReader.read(buffertXML)) != -1) {
              xmlStringbuffer.append(buffertXML, 0, LenXML);
            }
          } finally {
            if (is != null) {
              is.close();
            }
            if (xmlBufferedReader != null) {
              xmlBufferedReader.close();
            }
          }

          // Prepare parsing ...
          DocumentBuilderFactory DocBuilderFactory = DocumentBuilderFactory.newInstance();
          DocumentBuilder DocBuilder = DocBuilderFactory.newDocumentBuilder();

          // Let's try to get XML document encoding

          DocBuilderFactory.setValidating(false);
          ba = new ByteArrayInputStream(xmlStringbuffer.toString().getBytes("UTF-8"));
          Document xmlDocDTD = DocBuilder.parse(ba);
          if (ba != null) {
            ba.close();
          }

          String encoding = null;
          if (xmlDocDTD.getXmlEncoding() == null) {
            encoding = "UTF-8";
          } else {
            encoding = xmlDocDTD.getXmlEncoding();
          }

          int xmlStartDTD = xmlStringbuffer.indexOf("<!DOCTYPE");

          if (isInternDTD()) {
            // DTD find in the XML document
            if (xmlStartDTD != -1) {
              log.logBasic(
                  BaseMessages.getString(
                      PKG, "JobEntryDTDValidator.ERRORDTDFound.Label", getXMLFilename()));
            } else {
              setErrorMessage(
                  BaseMessages.getString(
                      PKG, "JobEntryDTDValidator.ERRORDTDNotFound.Label", getXMLFilename()));
            }

          } else {
            // DTD in external document
            // If we find an intern declaration, we remove it
            DTDfile = KettleVFS.getFileObject(getDTDFilename());

            if (DTDfile.exists()) {
              if (xmlStartDTD != -1) {
                int EndDTD = xmlStringbuffer.indexOf(">", xmlStartDTD);
                // String DocTypeDTD = xmlStringbuffer.substring(xmlStartDTD, EndDTD + 1);
                xmlStringbuffer.replace(xmlStartDTD, EndDTD + 1, "");
              }

              String xmlRootnodeDTD = xmlDocDTD.getDocumentElement().getNodeName();

              String RefDTD =
                  "<?xml version='"
                      + xmlDocDTD.getXmlVersion()
                      + "' encoding='"
                      + encoding
                      + "'?>\n<!DOCTYPE "
                      + xmlRootnodeDTD
                      + " SYSTEM '"
                      + KettleVFS.getFilename(DTDfile)
                      + "'>\n";

              int xmloffsetDTD = xmlStringbuffer.indexOf("<" + xmlRootnodeDTD);
              xmlStringbuffer.replace(0, xmloffsetDTD, RefDTD);
            } else {
              log.logError(
                  BaseMessages.getString(PKG, "JobEntryDTDValidator.ERRORDTDFileNotExists.Subject"),
                  BaseMessages.getString(
                      PKG, "JobEntryDTDValidator.ERRORDTDFileNotExists.Msg", getDTDFilename()));
            }
          }

          if (!(isInternDTD() && xmlStartDTD == -1 || (!isInternDTD() && !DTDfile.exists()))) {

            // Let's parse now ...
            MyErrorHandler error = new MyErrorHandler();
            DocBuilderFactory.setValidating(true);
            DocBuilder = DocBuilderFactory.newDocumentBuilder();
            DocBuilder.setErrorHandler(error);

            ba = new ByteArrayInputStream(xmlStringbuffer.toString().getBytes(encoding));
            xmlDocDTD = DocBuilder.parse(ba);

            if (error.errorMessage == null) {
              log.logBasic(
                  BaseMessages.getString(PKG, "JobEntryDTDValidator.DTDValidatorOK.Subject"),
                  BaseMessages.getString(
                      PKG, "JobEntryDTDValidator.DTDValidatorOK.Label", getXMLFilename()));

              // Everything is OK
              retval = true;
            } else {
              // Invalid DTD
              setNrErrors(error.nrErrors);
              setErrorMessage(
                  BaseMessages.getString(
                      PKG,
                      "JobEntryDTDValidator.DTDValidatorKO",
                      getXMLFilename(),
                      error.nrErrors,
                      error.errorMessage));
            }
          }

        } else {
          if (!xmlfile.exists()) {
            setErrorMessage(
                BaseMessages.getString(
                    PKG, "JobEntryDTDValidator.FileDoesNotExist.Label", getXMLFilename()));
          }
        }
      } else {
        setErrorMessage(BaseMessages.getString(PKG, "JobEntryDTDValidator.AllFilesNotNull.Label"));
      }
    } catch (Exception e) {
      setErrorMessage(
          BaseMessages.getString(
              PKG,
              "JobEntryDTDValidator.ErrorDTDValidator.Label",
              getXMLFilename(),
              getDTDFilename(),
              e.getMessage()));
    } finally {
      try {
        if (xmlfile != null) {
          xmlfile.close();
        }
        if (DTDfile != null) {
          DTDfile.close();
        }
        if (ba != null) {
          ba.close();
        }
      } catch (IOException e) {
        // Ignore close errors
      }
    }
    return retval;
  }
 @Override
 public void setLabel(String labelText) {
   log.logBasic(labelText);
 }
 @Override
 public void showError(String title, String message, Exception e) {
   log.logError(message, e);
 }
 @Override
 public void addLog(String line) {
   log.logBasic(line);
 }
  public void query(boolean specifyQuery) throws KettleException {

    if (getBinding() == null) {
      throw new KettleException(
          BaseMessages.getString(PKG, "SalesforceInput.Exception.CanNotGetBiding"));
    }

    try {
      if (!specifyQuery) {
        // check if we can query this Object
        DescribeSObjectResult describeSObjectResult = getBinding().describeSObject(getModule());
        if (describeSObjectResult == null) {
          throw new KettleException(
              BaseMessages.getString(PKG, "SalesforceInput.ErrorGettingObject"));
        }
        if (!describeSObjectResult.isQueryable()) {
          throw new KettleException(
              BaseMessages.getString(PKG, "SalesforceInputDialog.ObjectNotQueryable", module));
        }
        if (this.recordsFilter == SalesforceConnectionUtils.RECORDS_FILTER_UPDATED
            || this.recordsFilter == SalesforceConnectionUtils.RECORDS_FILTER_DELETED) {
          // The object must be replicateable
          if (!describeSObjectResult.isReplicateable()) {
            throw new KettleException(
                BaseMessages.getString(
                    PKG, "SalesforceInput.Error.ObjectNotReplicateable", getModule()));
          }
        }
      }

      if (getSQL() != null && log.isDetailed()) {
        log.logDetailed(
            BaseMessages.getString(PKG, "SalesforceInput.Log.SQLString") + " : " + getSQL());
      }

      switch (this.recordsFilter) {
        case SalesforceConnectionUtils.RECORDS_FILTER_UPDATED:
          // Updated records ...
          GetUpdatedResult updatedRecords =
              getBinding().getUpdated(getModule(), this.startDate, this.endDate);

          if (updatedRecords.getIds() != null) {
            int nr = updatedRecords.getIds().length;
            if (nr > 0) {
              String[] ids = updatedRecords.getIds();
              // We can pass a maximum of 2000 object IDs
              if (nr > SalesforceConnectionUtils.MAX_UPDATED_OBJECTS_IDS) {
                this.sObjects = new SObject[nr];
                List<String> list = new ArrayList<String>();
                int desPos = 0;
                for (int i = 0; i < nr; i++) {
                  list.add(updatedRecords.getIds(i));

                  if (i % SalesforceConnectionUtils.MAX_UPDATED_OBJECTS_IDS == 0 || i == nr - 1) {
                    SObject[] s =
                        getBinding()
                            .retrieve(
                                this.fieldsList,
                                getModule(),
                                list.toArray(new String[list.size()]));
                    System.arraycopy(s, 0, this.sObjects, desPos, s.length);
                    desPos += s.length;
                    s = null;
                    list = new ArrayList<String>();
                  }
                }
              } else {
                this.sObjects = getBinding().retrieve(this.fieldsList, getModule(), ids);
              }
              if (this.sObjects != null) {
                this.queryResultSize = this.sObjects.length;
              }
            }
          }
          break;
        case SalesforceConnectionUtils.RECORDS_FILTER_DELETED:
          // Deleted records ...
          GetDeletedResult deletedRecordsResult =
              getBinding().getDeleted(getModule(), this.startDate, this.endDate);

          DeletedRecord[] deletedRecords = deletedRecordsResult.getDeletedRecords();

          if (log.isDebug()) {
            log.logDebug(
                toString(),
                BaseMessages.getString(
                    PKG,
                    "SalesforceConnection.DeletedRecordsFound",
                    String.valueOf(deletedRecords == null ? 0 : deletedRecords.length)));
          }

          if (deletedRecords != null && deletedRecords.length > 0) {
            getDeletedList = new HashMap<String, Date>();

            for (DeletedRecord dr : deletedRecords) {
              getDeletedList.put(dr.getId(), dr.getDeletedDate().getTime());
            }
            this.qr = getBinding().queryAll(getSQL());
            this.sObjects = getQueryResult().getRecords();
            if (this.sObjects != null) {
              this.queryResultSize = this.sObjects.length;
            }
          }
          break;
        default:
          // return query result
          this.qr = isQueryAll() ? getBinding().queryAll(getSQL()) : getBinding().query(getSQL());
          this.sObjects = getQueryResult().getRecords();
          this.queryResultSize = getQueryResult().getSize();
          break;
      }
      if (this.sObjects != null) {
        this.recordsCount = this.sObjects.length;
      }
    } catch (Exception e) {
      log.logError(Const.getStackTracker(e));
      throw new KettleException(
          BaseMessages.getString(PKG, "SalesforceConnection.Exception.Query"), e);
    }
  }
  public void connect() throws KettleException {

    try {
      this.binding = (SoapBindingStub) new SforceServiceLocator().getSoap();
      if (log.isDetailed()) {
        log.logDetailed(
            BaseMessages.getString(
                PKG,
                "SalesforceInput.Log.LoginURL",
                binding._getProperty(SoapBindingStub.ENDPOINT_ADDRESS_PROPERTY)));
      }

      // Set timeout
      if (getTimeOut() > 0) {
        this.binding.setTimeout(getTimeOut());
        if (log.isDebug()) {
          log.logDebug(
              BaseMessages.getString(PKG, "SalesforceInput.Log.SettingTimeout", "" + this.timeout));
        }
      }

      // Set URL
      this.binding._setProperty(SoapBindingStub.ENDPOINT_ADDRESS_PROPERTY, getURL());

      // Do we need compression?
      if (isUsingCompression()) {
        this.binding._setProperty(HTTPConstants.MC_ACCEPT_GZIP, useCompression);
        this.binding._setProperty(HTTPConstants.MC_GZIP_REQUEST, useCompression);
      }
      if (isRollbackAllChangesOnError()) {
        // Set the SOAP header to rollback all changes
        // unless all records are processed successfully.
        AllOrNoneHeader allOrNoneHeader = new AllOrNoneHeader();
        allOrNoneHeader.setAllOrNone(true);
        this.binding.setHeader(
            new SforceServiceLocator().getServiceName().getNamespaceURI(),
            "AllOrNoneHeader",
            allOrNoneHeader);
      }
      // Attempt the login giving the user feedback
      if (log.isDetailed()) {
        log.logDetailed(BaseMessages.getString(PKG, "SalesforceInput.Log.LoginNow"));
        log.logDetailed("----------------------------------------->");
        log.logDetailed(BaseMessages.getString(PKG, "SalesforceInput.Log.LoginURL", getURL()));
        log.logDetailed(
            BaseMessages.getString(PKG, "SalesforceInput.Log.LoginUsername", getUsername()));
        if (getModule() != null) {
          log.logDetailed(
              BaseMessages.getString(PKG, "SalesforceInput.Log.LoginModule", getModule()));
        }
        if (getCondition() != null) {
          log.logDetailed(
              BaseMessages.getString(PKG, "SalesforceInput.Log.LoginCondition", getCondition()));
        }
        log.logDetailed("<-----------------------------------------");
      }

      // Login
      this.loginResult = getBinding().login(getUsername(), getPassword());

      if (log.isDebug()) {
        log.logDebug(
            BaseMessages.getString(PKG, "SalesforceInput.Log.SessionId")
                + " : "
                + this.loginResult.getSessionId());
        log.logDebug(
            BaseMessages.getString(PKG, "SalesforceInput.Log.NewServerURL")
                + " : "
                + this.loginResult.getServerUrl());
      }

      // set the session header for subsequent call authentication
      this.binding._setProperty(
          SoapBindingStub.ENDPOINT_ADDRESS_PROPERTY, this.loginResult.getServerUrl());

      // Create a new session header object and set the session id to that
      // returned by the login
      SessionHeader sh = new SessionHeader();
      sh.setSessionId(loginResult.getSessionId());
      this.binding.setHeader(
          new SforceServiceLocator().getServiceName().getNamespaceURI(), "SessionHeader", sh);

      // Return the user Infos
      this.userInfo = this.binding.getUserInfo();
      if (log.isDebug()) {
        log.logDebug(
            BaseMessages.getString(PKG, "SalesforceInput.Log.UserInfos")
                + " : "
                + this.userInfo.getUserFullName());
        log.logDebug("----------------------------------------->");
        log.logDebug(
            BaseMessages.getString(PKG, "SalesforceInput.Log.UserName")
                + " : "
                + this.userInfo.getUserFullName());
        log.logDebug(
            BaseMessages.getString(PKG, "SalesforceInput.Log.UserEmail")
                + " : "
                + this.userInfo.getUserEmail());
        log.logDebug(
            BaseMessages.getString(PKG, "SalesforceInput.Log.UserLanguage")
                + " : "
                + this.userInfo.getUserLanguage());
        log.logDebug(
            BaseMessages.getString(PKG, "SalesforceInput.Log.UserOrganization")
                + " : "
                + this.userInfo.getOrganizationName());
        log.logDebug("<-----------------------------------------");
      }

      this.serverTimestamp = getBinding().getServerTimestamp().getTimestamp().getTime();
      if (log.isDebug()) {
        BaseMessages.getString(PKG, "SalesforceInput.Log.ServerTimestamp", getServerTimestamp());
      }

      if (log.isDetailed()) {
        log.logDetailed(BaseMessages.getString(PKG, "SalesforceInput.Log.Connected"));
      }

    } catch (LoginFault ex) {
      // The LoginFault derives from AxisFault
      ExceptionCode exCode = ex.getExceptionCode();
      if (exCode == ExceptionCode.FUNCTIONALITY_NOT_ENABLED
          || exCode == ExceptionCode.INVALID_CLIENT
          || exCode == ExceptionCode.INVALID_LOGIN
          || exCode == ExceptionCode.LOGIN_DURING_RESTRICTED_DOMAIN
          || exCode == ExceptionCode.LOGIN_DURING_RESTRICTED_TIME
          || exCode == ExceptionCode.ORG_LOCKED
          || exCode == ExceptionCode.PASSWORD_LOCKOUT
          || exCode == ExceptionCode.SERVER_UNAVAILABLE
          || exCode == ExceptionCode.TRIAL_EXPIRED
          || exCode == ExceptionCode.UNSUPPORTED_CLIENT) {
        throw new KettleException(
            BaseMessages.getString(PKG, "SalesforceInput.Error.InvalidUsernameOrPassword"));
      }
      throw new KettleException(
          BaseMessages.getString(PKG, "SalesforceInput.Error.Connection"), ex);
    } catch (Exception e) {
      throw new KettleException(BaseMessages.getString(PKG, "SalesforceInput.Error.Connection"), e);
    }
  }
  @Override
  public synchronized void importAll(
      RepositoryImportFeedbackInterface feedback,
      String fileDirectory,
      String[] filenames,
      RepositoryDirectoryInterface baseDirectory,
      boolean overwrite,
      boolean continueOnError,
      String versionComment) {
    this.baseDirectory = baseDirectory;
    this.overwrite = overwrite;
    this.continueOnError = continueOnError;
    this.versionComment = versionComment;

    String importPathCompatibility =
        System.getProperty(Const.KETTLE_COMPATIBILITY_IMPORT_PATH_ADDITION_ON_VARIABLES, "N");
    this.needToCheckPathForVariables = "N".equalsIgnoreCase(importPathCompatibility);

    askReplace = Props.getInstance().askAboutReplacingDatabaseConnections();

    if (askReplace) {
      if (feedback instanceof HasOverwritePrompter) {
        Props.getInstance().setProperty(IMPORT_ASK_ABOUT_REPLACE_CS, "Y");
        Props.getInstance().setProperty(IMPORT_ASK_ABOUT_REPLACE_DB, "Y");
        Props.getInstance().setProperty(IMPORT_ASK_ABOUT_REPLACE_PS, "Y");
        Props.getInstance().setProperty(IMPORT_ASK_ABOUT_REPLACE_SS, "Y");
        this.overwritePrompter = ((HasOverwritePrompter) feedback).getOverwritePrompter();
      } else {
        this.overwritePrompter =
            new OverwritePrompter() {

              @Override
              public boolean overwritePrompt(String arg0, String arg1, String arg2) {
                throw new RuntimeException(
                    BaseMessages.getString(PKG, "RepositoryImporter.CannotPrompt.Label"));
              }
            };
      }
    } else {
      final boolean replaceExisting = Props.getInstance().replaceExistingDatabaseConnections();
      this.overwritePrompter =
          new OverwritePrompter() {

            @Override
            public boolean overwritePrompt(String arg0, String arg1, String arg2) {
              return replaceExisting;
            }
          };
    }

    referencingObjects = new ArrayList<RepositoryObject>();

    feedback.setLabel(BaseMessages.getString(PKG, "RepositoryImporter.ImportXML.Label"));
    try {

      loadSharedObjects();

      RepositoryImportLocation.setRepositoryImportLocation(baseDirectory);

      for (int ii = 0; ii < filenames.length; ++ii) {

        final String filename =
            (!Const.isEmpty(fileDirectory))
                ? fileDirectory + Const.FILE_SEPARATOR + filenames[ii]
                : filenames[ii];
        if (log.isBasic()) {
          log.logBasic("Import objects from XML file [" + filename + "]");
        }
        feedback.addLog(BaseMessages.getString(PKG, "RepositoryImporter.WhichFile.Log", filename));

        // To where?
        feedback.setLabel(BaseMessages.getString(PKG, "RepositoryImporter.WhichDir.Label"));

        // Read it using SAX...
        //
        try {
          RepositoryExportSaxParser parser = new RepositoryExportSaxParser(filename, feedback);
          parser.parse(this);
        } catch (Exception e) {
          addException(e);
          feedback.showError(
              BaseMessages.getString(PKG, "RepositoryImporter.ErrorGeneral.Title"),
              BaseMessages.getString(PKG, "RepositoryImporter.ErrorGeneral.Message"),
              e);
        }
      }

      // Correct those jobs and transformations that contain references to other objects.
      for (RepositoryObject repoObject : referencingObjects) {
        switch (repoObject.getObjectType()) {
          case TRANSFORMATION:
            TransMeta transMeta = rep.loadTransformation(repoObject.getObjectId(), null);
            saveTransformationToRepo(transMeta, feedback);
            break;
          case JOB:
            JobMeta jobMeta = rep.loadJob(repoObject.getObjectId(), null);
            saveJobToRepo(jobMeta, feedback);
            break;
          default:
            throw new KettleException(
                BaseMessages.getString(PKG, "RepositoryImporter.ErrorDetectFileType"));
        }
      }

      feedback.addLog(BaseMessages.getString(PKG, "RepositoryImporter.ImportFinished.Log"));
    } catch (Exception e) {
      addException(e);
      feedback.showError(
          BaseMessages.getString(PKG, "RepositoryImporter.ErrorGeneral.Title"),
          BaseMessages.getString(PKG, "RepositoryImporter.ErrorGeneral.Message"),
          e);
    } finally {
      // set the repository import location to null when done!
      RepositoryImportLocation.setRepositoryImportLocation(null);
    }
  }