Synchronisation de comptes utilisateurs

objectClass ( objectclassOid:1 NAME 'compte' 
	DESC 'Generalized account objectClass' 
	SUP inetOrgPerson 
	STRUCTURAL 
	MAY statut )
objectClass ( objectclassOid:1.1 NAME 'utilisateur' 
	DESC 'Common user account' 
	SUP compte
	STRUCTURAL 
	MAY ( civilite $ dateDebutContrat $ dateFinContrat ) )
objectClass ( objectclassOid:1.1.1 NAME 'salarie' 
	DESC 'Employee account' 
	SUP utilisateur 
	STRUCTURAL 
	MAY ( assistant $ fonction ) )

$ ant -DocName="compte" generator
[...]
$ ant -DocName="utilisateur" generator
[...]
$ ant -DocName="salarie" generator
[...]

public final class Configuration {
[...]
    public static final String DN_USERS =
		Configuration.getString("dn.users", "ou=ComptesUtilisateurs");
[...]

package org.linagora.ldap.lsc.objects;
public class compte extends inetOrgPerson {
	protected String statut;
	public compte() {
		super();
		objectClass.add("compte");
	}
	public String getStatut() { return statut; }
	public void setStatut(String value) { this.statut = value; }
}

package org.linagora.ldap.lsc.objects;
public class utilisateur extends compte {
   protected String civilite;
   protected String dateDebutContrat;
   protected String dateFinContrat;
   public utilisateur() {
		super();
		objectClass.add("utilisateur");
   }
   public String getCivilite() { return civilite; }
   public String getDateDebutContrat() { return dateDebutContrat; }
   public String getDateFinContrat() { return dateFinContrat; }
   public void setCivilite(String value) { this.civilite = value; }
   public void setDateDebutContrat(String value) {
       this.dateDebutContrat = value;
   }
   public void setDateFinContrat(String value) {
       this.dateFinContrat = value;
   }
}

package org.linagora.ldap.lsc.objects;
import java.util.List;
public class salarie extends utilisateur {
   protected List assistant;
   protected List fonction;
   public lapSalarie() {
		super();
		objectClass.add("salarie");
   }
   public List getAssistant() { return assistant; }
   public List getFonction() { return fonction; }
   public void setAssistant(List values) { this.assistant = values; }
   public void setFonction(List values) { this.fonction = values; }
}

package org.linagora.ldap.lsc.objects.flat;
public class fCompte extends fInetOrgPerson {
   protected String statut;
   public String getStatut() { return statut; }
   public void setStatut(String value) { this.statut = value; }
}

package org.linagora.ldap.lsc.objects.flat;
public class fUtilisateur extends fCompte {
   protected String civilite;
   protected String dateDebutContrat;
   protected String dateFinContrat;
   public String getCivilite() { return lapCiviliteCode; }
   public String getDateDebutContrat() { return dateDebutContrat; }
   public String getDateFinContrat() { return lapDateFinContrat; }
   public void setCivilite(String value) { this.civilite = value; }
   public void setDateDebutContrat(String value) {
       this.dateDebutContrat = value;
   }
   public void setDateFinContrat(String value) {
       this.dateFinContrat = value;
   }
}

package org.linagora.ldap.lsc.objects.flat;
public class fSalarie extends fUtilisateur {
   protected String assistant;
   protected String fonction;
   public String getAssistant() { return assistant; }
   public String getFonction() { return fonction; }
   public void setAssistant(String value) { this.assistant = value; }
   public void setFonction(String value) { this.fonction = value; }
}

package org.linagora.ldap.lsc.beans;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import javax.naming.NamingException;
import org.linagora.ldap.lsc.jndi.JndiModifications;
import org.linagora.ldap.lsc.objects.compte;
import org.linagora.utils.CharacterUnacceptedException;
import org.linagora.utils.Filters;
public class compteBean extends inetOrgPersonBean implements IBean {
	static {
			localMethods = new HashMap<String,Method>();
	}
	public static compteBean getInstance(compte myclass)
			throws IllegalArgumentException, IllegalAccessException,
			InvocationTargetException, CharacterUnacceptedException,
			NamingException {
		compteBean bean = new compteBean() ;
		AbstractBean.mapper(compteBean.class, localMethods, bean, myclass);
		bean.generateDn();
		return bean;
	}
	public compteBean() {
		super();
	}
	public JndiModifications[] checkDependenciesWithcompte(
			compte soc, JndiModifications jm) {
		return new JndiModifications[] {};
	}
}

public static void mapStatut(compte soc, IBean doc, String value)
			throws NamingException, CharacterUnacceptedException {
		if (value != null && value.trim().length() > 0) {
			mapString(doc, "statut", Filters.filterNumber(value));
		}
	}
	public static void generateStatut(compte soc, IBean doc) throws
			NamingException {}

package org.linagora.ldap.lsc.beans;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import javax.naming.NamingException;
import org.linagora.ldap.lsc.jndi.JndiModifications;
import org.linagora.ldap.lsc.objects.compte;
import org.linagora.utils.CharacterUnacceptedException;
import org.linagora.utils.Filters;
public class utilisateurBean extends compteBean implements IBean {
	static {
			localMethods = new HashMap<String,Method>();
	}
	public static utilisateurBean getInstance(utilisateur myclass)
			throws IllegalArgumentException, IllegalAccessException,
			InvocationTargetException, CharacterUnacceptedException,
			NamingException {
		utilisateurBean bean = new utilisateurBean() ;
		AbstractBean.mapper(utilisateurBean.class, localMethods,
				bean, myclass);
		bean.generateDn();
		return bean;
	}
	public utilisateurBean() {
		super();
	}
	public static void mapCivilite(utilisateur soc, IBean doc,
			String value)
			throws NamingException, CharacterUnacceptedException {
		if (value != null && value.trim().length() > 0) {
			mapString(doc, "civilite", Filters.filterNumber(value));
		}
	}
	public static void generateCivilite(utilisateur soc, IBean doc)
			throws NamingException {}
	public static void mapDateDebutContrat(utilisateur soc, IBean doc,
			String value)
			throws NamingException, CharacterUnacceptedException {
		if (value != null && value.trim().length() > 0) {
			// La donnée extraite de la base est au format
			// dd/MM/yyyy-HH:mm:ss
			mapString(doc, "dateDebutContrat",
				Filters.filterDate(value,"dd/MM/yyyy-HH:mm:ss")) ;
		}
	}
	public static void generateDateDebutContrat(utilisateur soc,
			IBean doc)
			throws NamingException {}

	public static void mapDateFinContrat(utilisateur soc, IBean doc,
			String value)
			throws NamingException, CharacterUnacceptedException {
		if (value != null && value.trim().length() > 0) {
			// La donnée extraite de la base est au format
			// dd/MM/yyyy-HH:mm:ss
			mapString(doc, "dateFinContrat",
				Filters.filterDate(value,"dd/MM/yyyy-HH:mm:ss")) ;
		}
	}
	public static void generateDateFinContrat(utilisateur soc, IBean doc)
			throws NamingException {}
	public JndiModifications[] checkDependenciesWithutilisateur(
			lapCompteUtilisateurSI soc, JndiModifications jm) {
		return new JndiModifications[] {};
	}
}

package org.linagora.ldap.lsc.beans;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import javax.naming.NamingException;
import org.linagora.ldap.lsc.Configuration;
import org.linagora.ldap.lsc.jndi.JndiModifications;
import org.linagora.ldap.lsc.objects.salarie;
import org.linagora.utils.CharacterUnacceptedException;
import org.linagora.utils.Filters;
public class salarieBean extends utilisateurBean implements IBean {
	static {
			localMethods = new HashMap<String,Method>();
	}
	public static salarieBean getInstance(salarie myclass)
			throws IllegalArgumentException, IllegalAccessException,
			InvocationTargetException, CharacterUnacceptedException,
			NamingException {
		salarieBean bean = new salarieBean() ;
		AbstractBean.mapper(salarieBean.class, localMethods,
				bean, myclass);
		bean.generateDn();
		return bean;
	}
	public salarieBean() {
		super();
	}
	public static void mapAssistant(salarie soc, IBean doc, List values)
			throws NamingException, CharacterUnacceptedException {
		if (values != null && values.size() > 0) {
			Vector<String> v = new Vector<String>() ;
			Iterator valuesIter = values.iterator() ;
	            while (valuesIter.hasNext()) {
            		String value = (String) valuesIter.next() ;
            		if (value != null && value.trim().length() > 0) {
            			v.add( "uid=" + value + ","
						+ Configuration.DN_USERS
						+ "," + Configuration.DN_REAL_ROOT );
            		}
            	}
			mapList(doc, "assistant", v) ;
		}
	}
	public static void generateAssistant(salarie soc, IBean doc)
			throws NamingException {}
	public static void mapFonction(salarie soc, IBean doc, List values)
			throws NamingException, CharacterUnacceptedException {
		if (values != null && values.size() > 0) {
			Vector<String> v = new Vector<String>() ;
			Iterator valuesIter = values.iterator() ;
	            while (valuesIter.hasNext()) {
            		String value = (String) valuesIter.next() ;
            		if (value != null && value.trim().length() > 0) {
            			v.add(Filters.filterString(value)) ;
            		}
            	}
			mapList(doc, "fonction", v) ;
		}
	}
	public static void generateFonction(salarie soc, IBean doc)
			throws NamingException {}
	public JndiModifications[] checkDependenciesWithsalarie(salarie soc,
			JndiModifications jm) {
		return new JndiModifications[] {};
	}
}

package org.linagora.ldap.lsc.jndi;
import javax.naming.NamingException;
import org.linagora.ldap.lsc.Configuration;
import org.linagora.ldap.lsc.beans.salarieBean;
import org.linagora.ldap.lsc.jndi.JndiServices;
public class SalarieJNDIService {
	private static final SalarieJNDIService instance
		= new SalarieJNDIService();
	public SalarieJNDIService() {}
	public static SalarieJNDIService getInstance() { return instance; }
	public salarieBean getSalarie(String id) throws NamingException {
		return (salarieBean) salarieBean.getInstance(
			JndiServices.getInstance().getEntry(
				Configuration.DN_USERS, "uid=" + id
			),
			Configuration.DN_USERS,
			salarieBean.class
		);
	}
}

<NomClasseObjectLDAP>JNDIService() ;
get<NomClasseObjectLDAP>(String id).

package org.linagora.ldap.lsc.service;
import java.sql.SQLException;
import java.util.List;
import org.apache.log4j.Logger;
import org.linagora.ldap.lsc.objects.flat.fSalarie;
import org.linagora.ldap.lsc.persistence.DaoConfig;
import com.ibatis.sqlmap.client.SqlMapClient;
public class SalarieJDBCService {
	private Logger LOGGER = Logger.getLogger(SalarieJDBCService.class);
	private static final SalarieJDBCService INSTANCE
			= new SalarieJDBCService();
	private SqlMapClient sqlMapper;
	public SalarieJDBCService() {
		sqlMapper = DaoConfig.getSqlMapClient();
	}
	public static SalarieJDBCService getInstance() { return INSTANCE;	}
	public final fSalarie getSalarie(final String id) {
		try {
			return (fSalarie) sqlMapper.queryForObject(
				"getSalarie", id);
		} catch (SQLException e) {
			LOGGER.warn("Unable to found salarie with id=" + id
				+ " (" + e + ")", e);
		}
		return null;
	}
	public final List getSalarieList() {
		try {
			return sqlMapper.queryForList("getSalarieList", null);
		} catch (SQLException e) {
			LOGGER.warn("Unable to return salarie list (" + e
				+ ")", e);
		}
		return null;
	}
}

<?xml version="1.0" encoding="UTF-8" standalone="no"?> 
<!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN"
	"http://www.ibatis.com/dtd/sql-map-2.dtd">
<sqlMap namespace="LapSalarie">
	<typeAlias alias="lsalarie"
			type="org.linagora.ldap.lsc.objects.flat.fSalarie" />
	<resultMap id="salarieResult" class="salarie"> 
		<result property="uid" column="COMPTE_UTILISATEUR_ID"/> 
		<result property="sn" column="NOM"/> 
		<result property="cn" column="NOM_COMPLET"/> 
		<result property="userPassword" column="MOT_DE_PASSE"/> 
		<result property="statut"
			column="STATUT_COMPTE_UTILISATEUR_ID"/> 
		<result property="givenName" column="PRENOM"/> 
		<result property="civilite" column="CIVILITE_ID"/> 
		<result property="dateDebutContrat"
			column="DATE_DEBUT_CONTRAT"/> 
		<result property="dateFinContrat" column="DATE_FIN_CONTRAT"/> 
		<result property="telephoneNumber"
			column="NUMERO_TELEPHONE_BUREAU"/> 
		<result property="assistant" column="ASSISTANT_ID"/> 
		<result property="fonction" column="TITRE_RH"/> 
	</resultMap>
	<select id="getSalarie" resultMap="salarieResult"
			parameterClass="string"> 
		select 
			C.COMPTE_UTILISATEUR_ID, 
			C.NOM, 
			C.NOM_COMPLET, 
			C.MOT_DE_PASSE, 
			C.STATUT_COMPTE_UTILISATEUR_ID, 
			C.PRENOM, 
			C.CIVILITE_ID, 
			TO_CHAR(C.DATE_DEBUT_CONTRAT, 'DD/MM/YYYY-HH24:MI:SS')
				AS DATE_DEBUT_CONTRAT, 
			TO_CHAR(C.DATE_FIN_CONTRAT, 'DD/MM/YYYY-HH24:MI:SS')
				AS DATE_FIN_CONTRAT, 
			C.NUMERO_TELEPHONE_BUREAU, 
			S.ASSISTANT_ID, 
			S.TITRE_RH 
		from COMPTE_UTILISATEUR_SI C, SALARIE S 
		where C.COMPTE_UTILISATEUR_ID = S.COMPTE_UTILISATEUR_ID 
		and C.COMPTE_UTILISATEUR_ID = #value# 
	</select>
	<select id="getSalarieList" resultClass="string"> 
		select C.COMPTE_UTILISATEUR_ID 
		from COMPTE_UTILISATEUR_SI C, SALARIE S 
		where C.COMPTE_UTILISATEUR_ID = S.COMPTE_UTILISATEUR_ID 
	</select> 
</sqlMap>

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN"
	"http://www.ibatis.com/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
	<properties resource="app/database.properties"/>
	<transactionManager type="JDBC">
		<dataSource type="SIMPLE">
			<property value="${driver}" name="JDBC.Driver" />
			<property value="${url}" name="JDBC.ConnectionURL" />
			<property value="${username}" name="JDBC.Username"/>
			<property value="${password}" name="JDBC.Password"/>
			<property value="15"
				name="Pool.MaximumActiveConnections"/>
			<property value="15" name="Pool.MaximumIdleConnections"/>
			<property value="1000" name="Pool.MaximumWait"/>
		</dataSource>
	</transactionManager>
	<sqlMap resource="org/linagora/ldap/lsc/persistence/xml/Site.xml"/>
	<sqlMap resource="org/linagora/ldap/lsc/persistence/xml/Salarie.xml"/>
</sqlMapConfig>

package org.linagora.ldap.lsc;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.linagora.ldap.lsc.beans.*;
import org.linagora.ldap.lsc.jndi.*;
import org.linagora.ldap.lsc.objects.*;
import org.linagora.ldap.lsc.objects.flat.*;
import org.linagora.ldap.lsc.service.*;
public final class Synchronize {
    public static final String LOG4J_CONFIGURATION_FILE
		= "app/log4j.properties";
    private static Logger LOGGER
		= Logger.getLogger(Synchronize.class);

    private Synchronize() {
		PropertyConfigurator.configure(LOG4J_CONFIGURATION_FILE);
    }
    private void launch(String args[]) {
		Iterator idsSalaries =
		SalarieJDBCService.getInstance().getSalarieList().iterator();
		while (idsSalaries.hasNext()) {
			synchronizeSalarie((String) idsSalaries.next()) ;
		}
	}
    private static void synchronizeSalarie(final String id) {
		try {
			fSalarie fSalarie =
				SalarieJDBCService.getInstance().getSalarie(id);
			salarie salarie = new salarie() ;
			salarie.setUpFromFlatObject(fSalarie) ;
			salarieBean jdbcObj =
				salarieBean.getInstance(salarie);
			salarieBean jndiObj =
				SalarieJNDIService.getInstance().getSalarie(id);
			JndiModifications jm =
				BeanComparator.calculateModifications(jdbcObj,
					jndiObj, true);
			if (jm != null) {
				JndiServices.getInstance().apply(jm) ;
			}
		} catch (Exception e) {
			LOGGER.error("Synchronization error for salarie with id '"
				+ id + "', " + e.toString() + ")", e) ;
		}
	}
    public static void main(final String[] args) {
        new Synchronize().launch(args);
    }

<select id="getSalarieMails" resultClass="string">
	select EMAIL
	from EMAIL_COMPTE_UTILISATEUR
	where COMPTE_UTILISATEUR_ID = #value#
</select>

public final List getSalarieMails(final String id) {
	try {
		return sqlMapper.queryForList("getSalarieMails", id);
	} catch (SQLException e) {
		LOGGER.warn("Unable to return mails for user id = " + id
			+ " (" + e + ")", e);
	}
	return null;
}

public static void mapMail(salarie soc, IBean doc, List values)
		throws NamingException, CharacterUnacceptedException {
	if (values != null && values.size() > 0) {
		Vector<String> v = new Vector<String>() ;
		Iterator valuesIter = values.iterator() ;
		while (valuesIter.hasNext()) {
			String value = (String) valuesIter.next() ;
			if (value != null && value.trim().length() > 0) {
				v.add(Filters.filterMail(value)) ;
         	  	}
		}
		mapList(doc, "mail", v) ;
	}
}

private static void synchronizeSalarie(final String id) {
	try {
		fSalarie fSalarie =
			SalarieJDBCService.getInstance().getSalarie(id);
		salarie salarie = new salarie() ;
		salarie.setUpFromFlatObject(fSalarie) ;
		// Fixe les mails :
		List mails =
			SalarieJDBCService.getInstance().getSalarieMails(id) ;
		salarie.setMail(mails) ;
		salarieBean jdbcObj =
			salarieBean.getInstance(salarie);
		salarieBean jndiObj =
			SalarieJNDIService.getInstance().getSalarie(id);
		JndiModifications jm =
			BeanComparator.calculateModifications(jdbcObj,
				jndiObj, true);
		if (jm != null) {
			JndiServices.getInstance().apply(jm) ;
		}
	} catch (Exception e) {
		LOGGER.error("Synchronization error for salarie with id '"
			+ id + "', " + e.toString() + ")", e) ;
	}
}