org.pentaho.di.trans.steps.ldapoutput.LDAPOutputMeta Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of kettle-engine Show documentation
Show all versions of kettle-engine Show documentation
Container pom for Pentaho Data Integration modules
The newest version!
/*! ******************************************************************************
*
* Pentaho Data Integration
*
* Copyright (C) 2002-2017 by Hitachi Vantara : http://www.pentaho.com
*
*******************************************************************************
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
package org.pentaho.di.trans.steps.ldapoutput;
import java.util.List;
import org.pentaho.di.core.CheckResult;
import org.pentaho.di.core.CheckResultInterface;
import org.pentaho.di.core.Const;
import org.pentaho.di.core.util.Utils;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.encryption.Encr;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleXMLException;
import org.pentaho.di.core.row.RowMetaInterface;
import org.pentaho.di.core.variables.VariableSpace;
import org.pentaho.di.core.xml.XMLHandler;
import org.pentaho.di.i18n.BaseMessages;
import org.pentaho.di.repository.ObjectId;
import org.pentaho.di.repository.Repository;
import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.step.BaseStepMeta;
import org.pentaho.di.trans.step.StepDataInterface;
import org.pentaho.di.trans.step.StepInterface;
import org.pentaho.di.trans.step.StepMeta;
import org.pentaho.di.trans.steps.ldapinput.LdapMeta;
import org.pentaho.di.trans.steps.ldapinput.LdapProtocolFactory;
import org.pentaho.metastore.api.IMetaStore;
import org.w3c.dom.Node;
public class LDAPOutputMeta extends BaseStepMeta implements LdapMeta {
private static Class PKG = LDAPOutputMeta.class; // for i18n purposes, needed by Translator2!!
/** Flag indicating that we use authentication for connection */
private boolean useAuthentication;
/** The Host name */
private String Host;
/** The User name */
private String userName;
/** The Password to use in LDAP authentication */
private String password;
/** The Port */
private String port;
/** The name of DN field */
private String dnFieldName;
private boolean failIfNotExist;
/** Field value to update */
private String[] updateLookup;
/** Stream name to update value with */
private String[] updateStream;
/** boolean indicating if field needs to be updated */
private Boolean[] update;
/** Operations type */
private String searchBase;
/** Multi valued separator **/
private String multiValuedSeparator;
private int operationType;
private String oldDnFieldName;
private String newDnFieldName;
private boolean deleteRDN;
/**
* The operations description
*/
public static final String[] operationTypeDesc = {
BaseMessages.getString( PKG, "LDAPOutputMeta.operationType.Insert" ),
BaseMessages.getString( PKG, "LDAPOutputMeta.operationType.Upsert" ),
BaseMessages.getString( PKG, "LDAPOutputMeta.operationType.Update" ),
BaseMessages.getString( PKG, "LDAPOutputMeta.operationType.Add" ),
BaseMessages.getString( PKG, "LDAPOutputMeta.operationType.Delete" ),
BaseMessages.getString( PKG, "LDAPOutputMeta.operationType.Rename" ) };
/**
* The operations type codes
*/
public static final String[] operationTypeCode = { "insert", "upsert", "update", "add", "delete", "rename" };
public static final int OPERATION_TYPE_INSERT = 0;
public static final int OPERATION_TYPE_UPSERT = 1;
public static final int OPERATION_TYPE_UPDATE = 2;
public static final int OPERATION_TYPE_ADD = 3;
public static final int OPERATION_TYPE_DELETE = 4;
public static final int OPERATION_TYPE_RENAME = 5;
private int referralType;
/**
* The referrals description
*/
public static final String[] referralTypeDesc = {
BaseMessages.getString( PKG, "LDAPOutputMeta.referralType.Follow" ),
BaseMessages.getString( PKG, "LDAPOutputMeta.referralType.Ignore" ) };
/**
* The referrals type codes
*/
public static final String[] referralTypeCode = { "follow", "ignore" };
public static final int REFERRAL_TYPE_FOLLOW = 0;
public static final int REFERRAL_TYPE_IGNORE = 1;
private int derefAliasesType;
/**
* The derefAliasess description
*/
public static final String[] derefAliasesTypeDesc = {
BaseMessages.getString( PKG, "LDAPOutputMeta.derefAliasesType.Always" ),
BaseMessages.getString( PKG, "LDAPOutputMeta.derefAliasesType.Never" ),
BaseMessages.getString( PKG, "LDAPOutputMeta.derefAliasesType.Searching" ),
BaseMessages.getString( PKG, "LDAPOutputMeta.derefAliasesType.Finding" ) };
/**
* The derefAliasess type codes
*/
public static final String[] derefAliasesTypeCode = { "always", "never", "searching", "finding" };
public static final int DEREFALIASES_TYPE_ALWAYS = 0;
public static final int DEREFALIASES_TYPE_NEVER = 1;
public static final int DEREFALIASES_TYPE_SEARCHING = 2;
public static final int DEREFALIASES_TYPE_FINDING = 3;
/** Protocol **/
private String protocol;
/** Trust store **/
private boolean useCertificate;
private String trustStorePath;
private String trustStorePassword;
private boolean trustAllCertificates;
public LDAPOutputMeta() {
super(); // allocate BaseStepMeta
}
/**
* @return Returns the input useCertificate.
*/
public boolean isUseCertificate() {
return useCertificate;
}
/**
* @return Returns the useCertificate.
*/
public void setUseCertificate( boolean value ) {
this.useCertificate = value;
}
/**
* @return Returns the input trustAllCertificates.
*/
public boolean isTrustAllCertificates() {
return trustAllCertificates;
}
/**
* @return Returns the input trustAllCertificates.
*/
public void setTrustAllCertificates( boolean value ) {
this.trustAllCertificates = value;
}
/**
* @return Returns the trustStorePath.
*/
public String getTrustStorePassword() {
return trustStorePassword;
}
/**
* @param value
* the trustStorePassword to set.
*/
public void setTrustStorePassword( String value ) {
this.trustStorePassword = value;
}
/**
* @return Returns the trustStorePath.
*/
public String getTrustStorePath() {
return trustStorePath;
}
/**
* @param value
* the trustStorePath to set.
*/
public void setTrustStorePath( String value ) {
this.trustStorePath = value;
}
/**
* @return Returns the protocol.
*/
public String getProtocol() {
return protocol;
}
/**
* @param value
* the protocol to set.
*/
public void setProtocol( String value ) {
this.protocol = value;
}
public Boolean[] getUpdate() {
return update;
}
public void setUpdate( Boolean[] update ) {
this.update = update;
}
public int getOperationType() {
return operationType;
}
public int getReferralType() {
return referralType;
}
public int getDerefAliasesType() {
return derefAliasesType;
}
public static int getOperationTypeByDesc( String tt ) {
if ( tt == null ) {
return 0;
}
for ( int i = 0; i < operationTypeDesc.length; i++ ) {
if ( operationTypeDesc[i].equalsIgnoreCase( tt ) ) {
return i;
}
}
// If this fails, try to match using the code.
return getOperationTypeByCode( tt );
}
public static int getReferralTypeByDesc( String tt ) {
if ( tt == null ) {
return 0;
}
for ( int i = 0; i < referralTypeDesc.length; i++ ) {
if ( referralTypeDesc[i].equalsIgnoreCase( tt ) ) {
return i;
}
}
// If this fails, try to match using the code.
return getReferralTypeByCode( tt );
}
public static int getDerefAliasesTypeByDesc( String tt ) {
if ( tt == null ) {
return 0;
}
for ( int i = 0; i < derefAliasesTypeDesc.length; i++ ) {
if ( derefAliasesTypeDesc[i].equalsIgnoreCase( tt ) ) {
return i;
}
}
// If this fails, try to match using the code.
return getReferralTypeByCode( tt );
}
private static int getOperationTypeByCode( String tt ) {
if ( tt == null ) {
return 0;
}
for ( int i = 0; i < operationTypeCode.length; i++ ) {
if ( operationTypeCode[i].equalsIgnoreCase( tt ) ) {
return i;
}
}
return 0;
}
private static int getReferralTypeByCode( String tt ) {
if ( tt == null ) {
return 0;
}
for ( int i = 0; i < referralTypeCode.length; i++ ) {
if ( referralTypeCode[i].equalsIgnoreCase( tt ) ) {
return i;
}
}
return 0;
}
private static int getDerefAliasesTypeByCode( String tt ) {
if ( tt == null ) {
return 0;
}
for ( int i = 0; i < derefAliasesTypeCode.length; i++ ) {
if ( derefAliasesTypeCode[i].equalsIgnoreCase( tt ) ) {
return i;
}
}
return 0;
}
public void setOperationType( int operationType ) {
this.operationType = operationType;
}
public void setReferralType( int value ) {
this.referralType = value;
}
public void setDerefAliasesType( int value ) {
this.derefAliasesType = value;
}
public static String getOperationTypeDesc( int i ) {
if ( i < 0 || i >= operationTypeDesc.length ) {
return operationTypeDesc[0];
}
return operationTypeDesc[i];
}
public static String getReferralTypeDesc( int i ) {
if ( i < 0 || i >= referralTypeDesc.length ) {
return referralTypeDesc[0];
}
return referralTypeDesc[i];
}
public static String getDerefAliasesTypeDesc( int i ) {
if ( i < 0 || i >= derefAliasesTypeDesc.length ) {
return derefAliasesTypeDesc[0];
}
return derefAliasesTypeDesc[i];
}
/**
* @return Returns the updateStream.
*/
public String[] getUpdateStream() {
return updateStream;
}
/**
* @param updateStream
* The updateStream to set.
*/
public void setUpdateStream( String[] updateStream ) {
this.updateStream = updateStream;
}
/**
* @return Returns the updateLookup.
*/
public String[] getUpdateLookup() {
return updateLookup;
}
/**
* @param updateLookup
* The updateLookup to set.
*/
public void setUpdateLookup( String[] updateLookup ) {
this.updateLookup = updateLookup;
}
/**
* @return Returns the input useAuthentication.
* Deprecated as it doesn't follow standards
*/
@Deprecated
public boolean UseAuthentication() {
return useAuthentication;
}
/**
* @return Returns the input useAuthentication.
*/
public boolean getUseAuthentication() {
return useAuthentication;
}
/**
* @param useAuthentication
* The useAuthentication to set.
*/
public void setUseAuthentication( boolean useAuthentication ) {
this.useAuthentication = useAuthentication;
}
/**
* @return Returns the host name.
*/
public String getHost() {
return Host;
}
/**
* @param host
* The host to set.
*/
public void setHost( String host ) {
this.Host = host;
}
/**
* @return Returns the user name.
*/
public String getUserName() {
return userName;
}
/**
* @param userName
* The username to set.
*/
public void setUserName( String userName ) {
this.userName = userName;
}
/**
* @param password
* The password to set.
*/
public void setPassword( String password ) {
this.password = password;
}
/**
* @return Returns the password.
*/
public String getPassword() {
return password;
}
public void setDnField( String value ) {
this.dnFieldName = value;
}
public String getDnField() {
return this.dnFieldName;
}
/**
* @return Returns the Port.
*/
public String getPort() {
return port;
}
/**
* @param port
* The port to set.
*/
public void setPort( String port ) {
this.port = port;
}
/**
* @return Returns the failIfNotExist.
*/
public boolean isFailIfNotExist() {
return failIfNotExist;
}
/**
* @param failIfNotExist
* The failIfNotExist to set.
*/
public void setFailIfNotExist( boolean value ) {
this.failIfNotExist = value;
}
public void loadXML( Node stepnode, List databases, IMetaStore metaStore ) throws KettleXMLException {
readData( stepnode );
}
public Object clone() {
LDAPOutputMeta retval = (LDAPOutputMeta) super.clone();
int nrvalues = updateLookup.length;
retval.allocate( nrvalues );
System.arraycopy( updateLookup, 0, retval.updateLookup, 0, nrvalues );
System.arraycopy( updateStream, 0, retval.updateStream, 0, nrvalues );
System.arraycopy( update, 0, retval.update, 0, nrvalues );
return retval;
}
/**
* @param value
* The deleteRDN filed.
*/
public void setDeleteRDN( boolean value ) {
this.deleteRDN = value;
}
/**
* @return Returns the deleteRDN.
*/
public boolean isDeleteRDN() {
return deleteRDN;
}
/**
* @param value
* The newDnFieldName filed.
*/
public void setNewDnFieldName( String value ) {
this.newDnFieldName = value;
}
/**
* @return Returns the newDnFieldName.
*/
public String getNewDnFieldName() {
return newDnFieldName;
}
/**
* @param value
* The oldDnFieldName filed.
*/
public void setOldDnFieldName( String value ) {
this.oldDnFieldName = value;
}
/**
* @return Returns the oldDnFieldName.
*/
public String getOldDnFieldName() {
return oldDnFieldName;
}
/**
* @param searchBase
* The searchBase filed.
*/
public void setSearchBaseDN( String searchBase ) {
this.searchBase = searchBase;
}
/**
* @return Returns the searchBase.
*/
public String getSearchBaseDN() {
return searchBase;
}
/**
* @param multiValuedSeparator
* The multi-valued separator filed.
*/
public void setMultiValuedSeparator( String multiValuedSeparator ) {
this.multiValuedSeparator = multiValuedSeparator;
}
/**
* @return Returns the multi valued separator.
*/
public String getMultiValuedSeparator() {
return multiValuedSeparator;
}
public void allocate( int nrvalues ) {
updateLookup = new String[nrvalues];
updateStream = new String[nrvalues];
update = new Boolean[nrvalues];
}
private static String getOperationTypeCode( int i ) {
if ( i < 0 || i >= operationTypeCode.length ) {
return operationTypeCode[0];
}
return operationTypeCode[i];
}
public static String getReferralTypeCode( int i ) {
if ( i < 0 || i >= referralTypeCode.length ) {
return referralTypeCode[0];
}
return referralTypeCode[i];
}
public static String getDerefAliasesCode( int i ) {
if ( i < 0 || i >= derefAliasesTypeCode.length ) {
return derefAliasesTypeCode[0];
}
return derefAliasesTypeCode[i];
}
public String getXML() {
StringBuilder retval = new StringBuilder( 500 );
retval.append( " " ).append( XMLHandler.addTagValue( "useauthentication", useAuthentication ) );
retval.append( " " ).append( XMLHandler.addTagValue( "host", Host ) );
retval.append( " " ).append( XMLHandler.addTagValue( "username", userName ) );
retval.append( " " ).append(
XMLHandler.addTagValue( "password", Encr.encryptPasswordIfNotUsingVariables( password ) ) );
retval.append( " " ).append( XMLHandler.addTagValue( "port", port ) );
retval.append( " " ).append( XMLHandler.addTagValue( "dnFieldName", dnFieldName ) );
retval.append( " " ).append( XMLHandler.addTagValue( "failIfNotExist", failIfNotExist ) );
retval.append( " " ).append(
XMLHandler.addTagValue( "operationType", getOperationTypeCode( operationType ) ) );
retval.append( " " ).append( XMLHandler.addTagValue( "multivaluedseparator", multiValuedSeparator ) );
retval.append( " " ).append( XMLHandler.addTagValue( "searchBase", searchBase ) );
retval.append( " " ).append( XMLHandler.addTagValue( "referralType", getReferralTypeCode( referralType ) ) );
retval.append( " " ).append(
XMLHandler.addTagValue( "derefAliasesType", getDerefAliasesCode( derefAliasesType ) ) );
retval.append( " " ).append( XMLHandler.addTagValue( "oldDnFieldName", oldDnFieldName ) );
retval.append( " " ).append( XMLHandler.addTagValue( "newDnFieldName", newDnFieldName ) );
retval.append( " " ).append( XMLHandler.addTagValue( "deleteRDN", deleteRDN ) );
retval.append( " " + Const.CR );
for ( int i = 0; i < updateLookup.length; i++ ) {
retval.append( " " ).append( Const.CR );
retval.append( " " ).append( XMLHandler.addTagValue( "name", updateLookup[i] ) );
retval.append( " " ).append( XMLHandler.addTagValue( "field", updateStream[i] ) );
retval.append( " " ).append( XMLHandler.addTagValue( "update", update[i].booleanValue() ) );
retval.append( " " ).append( Const.CR );
}
retval.append( " " + Const.CR );
retval.append( " " ).append( XMLHandler.addTagValue( "protocol", protocol ) );
retval.append( " " ).append( XMLHandler.addTagValue( "trustStorePath", trustStorePath ) );
retval.append( " " ).append(
XMLHandler
.addTagValue( "trustStorePassword", Encr.encryptPasswordIfNotUsingVariables( trustStorePassword ) ) );
retval.append( " " ).append( XMLHandler.addTagValue( "trustAllCertificates", trustAllCertificates ) );
retval.append( " " ).append( XMLHandler.addTagValue( "useCertificate", useCertificate ) );
return retval.toString();
}
private void readData( Node stepnode ) throws KettleXMLException {
try {
useAuthentication = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "useauthentication" ) );
Host = XMLHandler.getTagValue( stepnode, "host" );
userName = XMLHandler.getTagValue( stepnode, "username" );
setPassword( Encr.decryptPasswordOptionallyEncrypted( XMLHandler.getTagValue( stepnode, "password" ) ) );
port = XMLHandler.getTagValue( stepnode, "port" );
dnFieldName = XMLHandler.getTagValue( stepnode, "dnFieldName" );
failIfNotExist = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "failIfNotExist" ) );
operationType =
getOperationTypeByCode( Const.NVL( XMLHandler.getTagValue( stepnode, "operationType" ), "" ) );
multiValuedSeparator = XMLHandler.getTagValue( stepnode, "multivaluedseparator" );
searchBase = XMLHandler.getTagValue( stepnode, "searchBase" );
referralType = getReferralTypeByCode( Const.NVL( XMLHandler.getTagValue( stepnode, "referralType" ), "" ) );
derefAliasesType =
getDerefAliasesTypeByCode( Const.NVL( XMLHandler.getTagValue( stepnode, "derefAliasesType" ), "" ) );
oldDnFieldName = XMLHandler.getTagValue( stepnode, "oldDnFieldName" );
newDnFieldName = XMLHandler.getTagValue( stepnode, "newDnFieldName" );
deleteRDN = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "deleteRDN" ) );
Node fields = XMLHandler.getSubNode( stepnode, "fields" );
int nrFields = XMLHandler.countNodes( fields, "field" );
allocate( nrFields );
for ( int i = 0; i < nrFields; i++ ) {
Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
updateLookup[i] = XMLHandler.getTagValue( fnode, "name" );
updateStream[i] = XMLHandler.getTagValue( fnode, "field" );
if ( updateStream[i] == null ) {
updateStream[i] = updateLookup[i]; // default: the same name!
}
String updateValue = XMLHandler.getTagValue( fnode, "update" );
if ( updateValue == null ) {
// default TRUE
update[i] = Boolean.TRUE;
} else {
if ( updateValue.equalsIgnoreCase( "Y" ) ) {
update[i] = Boolean.TRUE;
} else {
update[i] = Boolean.FALSE;
}
}
}
protocol = XMLHandler.getTagValue( stepnode, "protocol" );
trustStorePath = XMLHandler.getTagValue( stepnode, "trustStorePath" );
trustStorePassword =
Encr.decryptPasswordOptionallyEncrypted( XMLHandler.getTagValue( stepnode, "trustStorePassword" ) );
trustAllCertificates = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "trustAllCertificates" ) );
useCertificate = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "useCertificate" ) );
} catch ( Exception e ) {
throw new KettleXMLException( BaseMessages.getString( PKG, "LDAPOutputMeta.UnableToLoadFromXML" ), e );
}
}
public void setDefault() {
useAuthentication = false;
Host = "";
userName = "";
password = "";
port = "389";
dnFieldName = null;
failIfNotExist = true;
multiValuedSeparator = ";";
searchBase = null;
oldDnFieldName = null;
newDnFieldName = null;
deleteRDN = true;
int nrFields = 0;
allocate( nrFields );
for ( int i = 0; i < nrFields; i++ ) {
updateLookup[i] = "name" + ( i + 1 );
updateStream[i] = "field" + ( i + 1 );
update[i] = Boolean.TRUE;
}
operationType = OPERATION_TYPE_INSERT;
referralType = REFERRAL_TYPE_FOLLOW;
derefAliasesType = DEREFALIASES_TYPE_ALWAYS;
this.trustStorePath = null;
this.trustStorePassword = null;
this.trustAllCertificates = false;
this.protocol = LdapProtocolFactory.getConnectionTypes( log ).get( 0 );
this.useCertificate = false;
}
public void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, List databases ) throws KettleException {
try {
useAuthentication = rep.getStepAttributeBoolean( id_step, "useauthentication" );
Host = rep.getStepAttributeString( id_step, "host" );
userName = rep.getStepAttributeString( id_step, "username" );
password = Encr.decryptPasswordOptionallyEncrypted( rep.getStepAttributeString( id_step, "password" ) );
port = rep.getStepAttributeString( id_step, "port" );
dnFieldName = rep.getStepAttributeString( id_step, "dnFieldName" );
failIfNotExist = rep.getStepAttributeBoolean( id_step, "failIfNotExist" );
operationType =
getOperationTypeByCode( Const.NVL( rep.getStepAttributeString( id_step, "operationType" ), "" ) );
multiValuedSeparator = rep.getStepAttributeString( id_step, "multivaluedseparator" );
searchBase = rep.getStepAttributeString( id_step, "searchBase" );
referralType =
getReferralTypeByCode( Const.NVL( rep.getStepAttributeString( id_step, "referralType" ), "" ) );
derefAliasesType =
getDerefAliasesTypeByCode( Const.NVL( rep.getStepAttributeString( id_step, "referralType" ), "" ) );
newDnFieldName = rep.getStepAttributeString( id_step, "newDnFieldName" );
oldDnFieldName = rep.getStepAttributeString( id_step, "oldDnFieldName" );
deleteRDN = rep.getStepAttributeBoolean( id_step, "deleteRDN" );
int nrFields = rep.countNrStepAttributes( id_step, "field_name" );
allocate( nrFields );
for ( int i = 0; i < nrFields; i++ ) {
updateLookup[i] = rep.getStepAttributeString( id_step, i, "field_name" );
updateStream[i] = rep.getStepAttributeString( id_step, i, "field_attribut" );
update[i] = Boolean.valueOf( rep.getStepAttributeBoolean( id_step, i, "value_update", true ) );
}
protocol = rep.getStepAttributeString( id_step, "protocol" );
trustStorePath = rep.getStepAttributeString( id_step, "trustStorePath" );
trustStorePassword =
Encr.decryptPasswordOptionallyEncrypted( rep.getStepAttributeString( id_step, "trustStorePassword" ) );
trustAllCertificates = rep.getStepAttributeBoolean( id_step, "trustAllCertificates" );
useCertificate = rep.getStepAttributeBoolean( id_step, "useCertificate" );
} catch ( Exception e ) {
throw new KettleException(
BaseMessages.getString( PKG, "LDAPOutputMeta.Exception.ErrorReadingRepository" ), e );
}
}
public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transformation, ObjectId id_step ) throws KettleException {
try {
rep.saveStepAttribute( id_transformation, id_step, "useauthentication", useAuthentication );
rep.saveStepAttribute( id_transformation, id_step, "host", Host );
rep.saveStepAttribute( id_transformation, id_step, "username", userName );
rep.saveStepAttribute( id_transformation, id_step, "password", Encr
.encryptPasswordIfNotUsingVariables( password ) );
rep.saveStepAttribute( id_transformation, id_step, "port", port );
rep.saveStepAttribute( id_transformation, id_step, "dnFieldName", dnFieldName );
rep.saveStepAttribute( id_transformation, id_step, "failIfNotExist", failIfNotExist );
rep.saveStepAttribute( id_transformation, id_step, "operationType", getOperationTypeCode( operationType ) );
rep.saveStepAttribute( id_transformation, id_step, "multivaluedseparator", multiValuedSeparator );
rep.saveStepAttribute( id_transformation, id_step, "searchBase", searchBase );
rep.saveStepAttribute( id_transformation, id_step, "referralType", getReferralTypeCode( referralType ) );
rep.saveStepAttribute(
id_transformation, id_step, "derefAliasesType", getDerefAliasesCode( derefAliasesType ) );
rep.saveStepAttribute( id_transformation, id_step, "oldDnFieldName", oldDnFieldName );
rep.saveStepAttribute( id_transformation, id_step, "newDnFieldName", newDnFieldName );
rep.saveStepAttribute( id_transformation, id_step, "deleteRDN", deleteRDN );
for ( int i = 0; i < updateLookup.length; i++ ) {
rep.saveStepAttribute( id_transformation, id_step, i, "field_name", updateLookup[i] );
rep.saveStepAttribute( id_transformation, id_step, i, "field_attribut", updateStream[i] );
rep.saveStepAttribute( id_transformation, id_step, i, "value_update", update[i].booleanValue() );
}
rep.saveStepAttribute( id_transformation, id_step, "protocol", protocol );
rep.saveStepAttribute( id_transformation, id_step, "trustStorePath", trustStorePath );
rep.saveStepAttribute( id_transformation, id_step, "trustStorePassword", Encr
.encryptPasswordIfNotUsingVariables( trustStorePassword ) );
rep.saveStepAttribute( id_transformation, id_step, "trustAllCertificates", trustAllCertificates );
rep.saveStepAttribute( id_transformation, id_step, "useCertificate", useCertificate );
} catch ( Exception e ) {
throw new KettleException( BaseMessages.getString(
PKG, "LDAPOutputMeta.Exception.ErrorSavingToRepository", "" + id_step ), e );
}
}
public void check( List remarks, TransMeta transMeta, StepMeta stepMeta,
RowMetaInterface prev, String[] input, String[] output, RowMetaInterface info, VariableSpace space,
Repository repository, IMetaStore metaStore ) {
CheckResult cr;
// See if we get input...
if ( input.length > 0 ) {
cr =
new CheckResult( CheckResult.TYPE_RESULT_ERROR, BaseMessages.getString(
PKG, "LDAPOutputMeta.CheckResult.NoInputExpected" ), stepMeta );
} else {
cr =
new CheckResult( CheckResult.TYPE_RESULT_OK, BaseMessages.getString(
PKG, "LDAPOutputMeta.CheckResult.NoInput" ), stepMeta );
}
remarks.add( cr );
// Check hostname
if ( Utils.isEmpty( Host ) ) {
cr =
new CheckResult( CheckResult.TYPE_RESULT_ERROR, BaseMessages.getString(
PKG, "LDAPOutputMeta.CheckResult.HostnameMissing" ), stepMeta );
} else {
cr =
new CheckResult( CheckResult.TYPE_RESULT_OK, BaseMessages.getString(
PKG, "LDAPOutputMeta.CheckResult.HostnameOk" ), stepMeta );
}
remarks.add( cr );
// check return fields
if ( updateLookup.length == 0 ) {
cr =
new CheckResult( CheckResult.TYPE_RESULT_ERROR, BaseMessages.getString(
PKG, "LDAPOutputUpdateMeta.CheckResult.NoFields" ), stepMeta );
} else {
cr =
new CheckResult( CheckResult.TYPE_RESULT_OK, BaseMessages.getString(
PKG, "LDAPOutputUpdateMeta.CheckResult.FieldsOk" ), stepMeta );
}
}
public StepInterface getStep( StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta tr,
Trans trans ) {
return new LDAPOutput( stepMeta, stepDataInterface, cnr, tr, trans );
}
public StepDataInterface getStepData() {
return new LDAPOutputData();
}
public boolean supportsErrorHandling() {
return true;
}
public String toString() {
return "LDAPConnection " + getName();
}
@Override
public String getDerefAliases() {
return LDAPOutputMeta.getDerefAliasesCode( getDerefAliasesType() );
}
@Override
public String getReferrals() {
return getReferralTypeCode( getReferralType() );
}
}