[Observe-commits] 02/12: Implantation efficace de réplication de données

30 Dec 2015

This is an automated email from the git hooks/post-receive script.

New commit to branch feature/7470_mise_en_place_de_la_date_de_derniere_mise_a_jour in repository tutti.

See http://git.codelutin.com/tutti.git

commit 1fc64bb2d669887492e84bf983ef42a192da667c
Author: Tony CHEMIT <chemit@codelutin.com>
Date:   Tue Dec 29 01:14:58 2015 +0100

    Implantation efficace de réplication de données
---
 .../replication/ObserveReplicationAction.java      | 127 +++++++++++
 .../ObserveReplicationActionContext.java           | 236 +++++++++++++++++++++
 .../replication/ObserveReplicationContext.java     |  48 +++++
 .../replication/ObserveReplicationEngine.java      |  58 +++++
 .../ReplicationActionContextsBuilderSupport.java   |  91 ++++++++
 ...ipLonglineReplicationActionContextsBuilder.java | 174 +++++++++++++++
 .../TripSeineReplicationActionContextsBuilder.java | 145 +++++++++++++
 7 files changed, 879 insertions(+)

diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationAction.java b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationAction.java
new file mode 100644
index 0000000..bcbaf44
--- /dev/null
+++ b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationAction.java
@@ -0,0 +1,127 @@
+package fr.ird.observe.entities.replication;
+
+import fr.ird.observe.ObserveTopiaPersistenceContext;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.nuiton.topia.persistence.support.TopiaSqlSupport;
+import org.nuiton.topia.persistence.support.TopiaSqlWork;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+/**
+ * Created on 28/12/15.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ */
+public class ObserveReplicationAction {
+
+    /** Logger. */
+    private static final Log log = LogFactory.getLog(ObserveReplicationAction.class);
+
+    protected final ObserveReplicationActionContext replicationActionContext;
+
+    public static void replicate(ObserveReplicationActionContext replicationActionContext) {
+        ObserveReplicationAction action = new ObserveReplicationAction(replicationActionContext);
+        action.replicate();
+    }
+
+    public ObserveReplicationAction(ObserveReplicationActionContext replicationActionContext) {
+        this.replicationActionContext = replicationActionContext;
+    }
+
+    public void replicate() {
+
+        ObserveTopiaPersistenceContext sourcePersistenceContext = replicationActionContext.getSourcePersistenceContext();
+        TopiaSqlSupport sqlSupport = sourcePersistenceContext.getSqlSupport();
+        ReadSqlWork sqlWork = new ReadSqlWork();
+        sqlSupport.doSqlWork(sqlWork);
+
+    }
+
+    protected class ReadSqlWork implements TopiaSqlWork {
+
+        @Override
+        public void execute(Connection connection) throws SQLException {
+
+            ObserveTopiaPersistenceContext targetPersistenceContext = replicationActionContext.getTargetPersistenceContext();
+
+            try (PreparedStatement readStatement = replicationActionContext.createReadStatement(connection)) {
+
+                readStatement.execute();
+                CopySqlWork sqlWork = new CopySqlWork(readStatement);
+                targetPersistenceContext.getSqlSupport().doSqlWork(sqlWork);
+
+            }
+
+        }
+
+    }
+
+    protected class CopySqlWork implements TopiaSqlWork {
+
+        protected final Statement readStatement;
+
+        public CopySqlWork(Statement readStatement) {
+            this.readStatement = readStatement;
+        }
+
+        @Override
+        public void execute(Connection connection) throws SQLException {
+
+            ResultSet readResultSet = readStatement.getResultSet();
+
+            ResultSetMetaData readResultSetMetaData = readResultSet.getMetaData();
+            int columnCount = readResultSetMetaData.getColumnCount();
+
+            int fetchSize = replicationActionContext.getFetchSize();
+            String tableName = replicationActionContext.getFullyTableName();
+
+            try (PreparedStatement writeStatement = replicationActionContext.createWriteStatement(connection, readResultSetMetaData)) {
+
+
+                long index = 0;
+                while (readResultSet.next()) {
+
+                    copyRow(readResultSet, writeStatement, columnCount);
+
+                    if ((++index % fetchSize) == 0) {
+
+                        flush(writeStatement, tableName, index);
+
+                    }
+                }
+
+                flush(writeStatement, tableName, index);
+            }
+
+        }
+
+        protected void copyRow(ResultSet readResultSet, PreparedStatement writeStatement, int columnCount) throws SQLException {
+            writeStatement.clearParameters();
+
+            if (log.isDebugEnabled()) {
+                log.debug("Copy " + readResultSet.getString(1));
+            }
+            for (int i = 1; i <= columnCount; i++) {
+                Object object = readResultSet.getObject(i);
+                writeStatement.setObject(i, object);
+            }
+            writeStatement.addBatch();
+        }
+
+        protected void flush(PreparedStatement writeStatement, String tableName, long index) throws SQLException {
+
+            if (log.isInfoEnabled()) {
+                log.info("Flush for : " + tableName + " (size: " + index + ")");
+            }
+            writeStatement.executeBatch();
+            writeStatement.clearBatch();
+
+        }
+    }
+}
diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationActionContext.java b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationActionContext.java
new file mode 100644
index 0000000..a6da8ed
--- /dev/null
+++ b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationActionContext.java
@@ -0,0 +1,236 @@
+package fr.ird.observe.entities.replication;
+
+import com.google.common.collect.Sets;
+import fr.ird.observe.ObserveEntityEnum;
+import fr.ird.observe.ObserveTopiaPersistenceContext;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/**
+ * Created on 28/12/15.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ */
+public class ObserveReplicationActionContext {
+
+    /** Logger. */
+    private static final Log log = LogFactory.getLog(ObserveReplicationActionContext.class);
+
+    protected final ObserveReplicationContext replicationContext;
+
+    protected final ObserveReplicationActionContext parentActionContext;
+
+    protected final Set<String> joinClauses;
+
+    protected String whereClause;
+
+    protected String fromClause;
+
+    protected final String queryArg;
+
+    protected final String schemaName;
+
+    protected final String tableName;
+
+    protected final String parentTableName;
+
+    protected final int order;
+
+    public static ObserveReplicationActionContext onJoin(
+            ObserveReplicationActionContext parentActionContext,
+            String tableName,
+            int order) {
+
+        String schemaName = parentActionContext.schemaName;
+
+        return new ObserveReplicationActionContext(
+                parentActionContext.replicationContext,
+                schemaName,
+                tableName,
+                parentActionContext,
+                parentActionContext.joinClauses,
+                parentActionContext.fromClause,
+                parentActionContext.whereClause,
+                parentActionContext.queryArg,
+                order
+        );
+
+    }
+
+    public static ObserveReplicationActionContext onAssociationJoin(
+            ObserveReplicationActionContext parentActionContext,
+            String tableName,
+            int order) {
+
+        String schemaName = parentActionContext.schemaName;
+        tableName = getAssociationTableName(tableName, parentActionContext.tableName);
+
+        return new ObserveReplicationActionContext(
+                parentActionContext.replicationContext,
+                schemaName,
+                tableName,
+                parentActionContext,
+                parentActionContext.joinClauses,
+                parentActionContext.fromClause,
+                parentActionContext.whereClause,
+                parentActionContext.queryArg,
+                order
+        );
+    }
+
+    public static ObserveReplicationActionContext onTrip(ObserveReplicationContext replicationContext,
+                                                         ObserveEntityEnum entityEnum,
+                                                         String id,
+                                                         int order) {
+
+
+        return new ObserveReplicationActionContext(
+                replicationContext,
+                entityEnum.dbSchemaName(),
+                entityEnum.dbTableName(),
+                null,
+                new LinkedHashSet<String>(),
+                null,
+                null,
+                id,
+                order);
+    }
+
+    private ObserveReplicationActionContext(ObserveReplicationContext replicationContext,
+                                           String schemaName,
+                                           String tableName,
+                                           ObserveReplicationActionContext parentActionContext,
+                                           Set<String> joinClauses,
+                                           String fromClause,
+                                           String whereClause,
+                                           String queryArg,
+                                           int order) {
+        this.replicationContext = replicationContext;
+        this.parentActionContext = parentActionContext;
+        this.joinClauses = Sets.newLinkedHashSet(joinClauses);
+        this.fromClause = fromClause;
+        this.whereClause = whereClause;
+        this.queryArg = queryArg;
+        this.order = order;
+        this.parentTableName = parentActionContext == null ? null : parentActionContext.tableName;
+        this.schemaName = schemaName;
+        this.tableName = tableName;
+    }
+
+    public ObserveTopiaPersistenceContext getSourcePersistenceContext() {
+        return replicationContext.getSourcePersistenceContext();
+    }
+
+    public ObserveTopiaPersistenceContext getTargetPersistenceContext() {
+        return replicationContext.getTargetPersistenceContext();
+    }
+
+    public int getFetchSize() {
+        return replicationContext.getFetchSize();
+    }
+
+    public String getTableName() {
+        return tableName;
+    }
+
+    public String getFullyTableName() {
+        return schemaName + "." + tableName;
+    }
+
+    public PreparedStatement createReadStatement(Connection connection) throws SQLException {
+
+        StringBuilder sqlBuilder = new StringBuilder("SELECT " + tableName + ".*");
+
+        sqlBuilder.append(" FROM ").append(fromClause);
+        for (String joinClause : joinClauses) {
+            sqlBuilder.append(" ").append(joinClause);
+        }
+        sqlBuilder.append(" WHERE ").append(whereClause);
+
+        String sql = sqlBuilder.toString();
+        if (log.isInfoEnabled()) {
+            log.info("Read sql: " + sql);
+        }
+        PreparedStatement statement = connection.prepareStatement(sql);
+        statement.setString(1, queryArg);
+        statement.setFetchSize(replicationContext.getFetchSize());
+        return statement;
+    }
+
+    public PreparedStatement createWriteStatement(Connection connection, ResultSetMetaData readResultTatMetaData) throws SQLException {
+
+        int columnCount = readResultTatMetaData.getColumnCount();
+
+        StringBuilder sqlBuilder = new StringBuilder("INSERT INTO ");
+        sqlBuilder.append(schemaName).append(".").append(tableName);
+
+        StringBuilder columnNamesBuilder = new StringBuilder();
+        StringBuilder argsBuilder = new StringBuilder();
+
+        columnNamesBuilder.append(" ").append(readResultTatMetaData.getColumnName(1));
+        argsBuilder.append("?");
+
+        for (int i = 2; i <= columnCount; i++) {
+
+            String columnName = readResultTatMetaData.getColumnName(i);
+            columnNamesBuilder.append(", ").append(columnName);
+            argsBuilder.append(", ?");
+        }
+
+        sqlBuilder.append("(")
+                .append(columnNamesBuilder)
+                .append(")")
+                .append("VALUES (")
+                .append(argsBuilder)
+                .append(")");
+
+        String sql = sqlBuilder.toString();
+        if (log.isInfoEnabled()) {
+            log.info("Write sql: " + sql);
+        }
+        PreparedStatement statement = connection.prepareStatement(sql);
+
+        return statement;
+
+    }
+
+    public void addInnerJoinClause() {
+        String joinClause = " INNER JOIN " + schemaName + "." + tableName + " " + tableName + " ON " + tableName + "." + parentTableName + " = " + parentTableName + ".topiaId";
+        joinClauses.add(joinClause);
+    }
+
+    public void addInverseInnerJoinClause() {
+        String joinClause = " INNER JOIN " + schemaName + "." + tableName + " " + tableName + " ON " + tableName + ".topiaId = " + parentTableName + "." + tableName;
+        joinClauses.add(joinClause);
+    }
+
+    public void setWhereTopiaIdEqualsClause() {
+        this.whereClause = tableName + ".topiaid = ?";
+    }
+
+    public void setWhereJoinTopiaIdEqualsClause() {
+        this.whereClause = tableName + "." + parentTableName + " = ?";
+    }
+
+    public void setFromClause() {
+        this.fromClause = schemaName + "." + tableName + " " + tableName;
+    }
+
+    protected static String getAssociationTableName(String tableName, String parentTableName) {
+        String associationTableName;
+        if (tableName.toLowerCase().compareTo(parentTableName.toLowerCase()) < 0) {
+            associationTableName = tableName + "_" + parentTableName;
+        } else {
+            associationTableName = parentTableName + "_" + tableName;
+        }
+        return associationTableName;
+    }
+
+}
diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationContext.java b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationContext.java
new file mode 100644
index 0000000..ff26576
--- /dev/null
+++ b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationContext.java
@@ -0,0 +1,48 @@
+package fr.ird.observe.entities.replication;
+
+import fr.ird.observe.ObserveTopiaApplicationContext;
+import fr.ird.observe.ObserveTopiaPersistenceContext;
+
+/**
+ * Created on 28/12/15.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ */
+public class ObserveReplicationContext {
+
+    protected final ObserveTopiaApplicationContext sourceTopiaApplicationContext;
+
+    protected final ObserveTopiaApplicationContext targetTopiaApplicationContext;
+
+    protected final int fetchSize;
+
+    protected ObserveTopiaPersistenceContext sourcePersistenceContext;
+
+    protected ObserveTopiaPersistenceContext targetPersistenceContext;
+
+    public ObserveReplicationContext(ObserveTopiaApplicationContext sourceTopiaApplicationContext,
+                                     ObserveTopiaApplicationContext targetTopiaApplicationContext,
+                                     int fetchSize) {
+        this.sourceTopiaApplicationContext = sourceTopiaApplicationContext;
+        this.targetTopiaApplicationContext = targetTopiaApplicationContext;
+        this.fetchSize=fetchSize;
+    }
+
+    public ObserveTopiaPersistenceContext getSourcePersistenceContext() {
+        if (sourcePersistenceContext == null) {
+            sourcePersistenceContext = sourceTopiaApplicationContext.newPersistenceContext();
+        }
+        return sourcePersistenceContext;
+    }
+
+    public ObserveTopiaPersistenceContext getTargetPersistenceContext() {
+        if (targetPersistenceContext == null) {
+            targetPersistenceContext = targetTopiaApplicationContext.newPersistenceContext();
+        }
+        return targetPersistenceContext;
+    }
+
+    public int getFetchSize() {
+        return fetchSize;
+    }
+}
diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationEngine.java b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationEngine.java
new file mode 100644
index 0000000..9a283bc
--- /dev/null
+++ b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ObserveReplicationEngine.java
@@ -0,0 +1,58 @@
+package fr.ird.observe.entities.replication;
+
+import com.google.common.collect.ImmutableSet;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Created on 28/12/15.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ */
+public class ObserveReplicationEngine {
+
+    /** Logger. */
+    private static final Log log = LogFactory.getLog(ObserveReplicationEngine.class);
+
+    protected final ObserveReplicationContext replicationContext;
+
+    public ObserveReplicationEngine(ObserveReplicationContext replicationContext) {
+        this.replicationContext = replicationContext;
+    }
+
+    public ImmutableSet<ObserveReplicationActionContext> replicateTripSeine(String id) {
+
+        ImmutableSet<ObserveReplicationActionContext> actionContexts = TripSeineReplicationActionContextsBuilder
+                .of(replicationContext, id);
+
+        execute(actionContexts);
+
+        return actionContexts;
+
+    }
+
+    public ImmutableSet<ObserveReplicationActionContext> replicateTripLongline(String id) {
+
+        ImmutableSet<ObserveReplicationActionContext> actionContexts = TripLonglineReplicationActionContextsBuilder
+                .of(replicationContext, id);
+
+        execute(actionContexts);
+
+        return actionContexts;
+    }
+
+    protected void execute(ImmutableSet<ObserveReplicationActionContext> actionContexts) {
+
+        for (ObserveReplicationActionContext actionContext : actionContexts) {
+
+            if (log.isInfoEnabled()) {
+                log.info("Replicate: " + actionContext.tableName);
+            }
+            ObserveReplicationAction.replicate(actionContext);
+        }
+
+        replicationContext.getTargetPersistenceContext().commit();
+
+    }
+
+}
diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/replication/ReplicationActionContextsBuilderSupport.java b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ReplicationActionContextsBuilderSupport.java
new file mode 100644
index 0000000..b7f9b3a
--- /dev/null
+++ b/observe-entities/src/main/java/fr/ird/observe/entities/replication/ReplicationActionContextsBuilderSupport.java
@@ -0,0 +1,91 @@
+package fr.ird.observe.entities.replication;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import fr.ird.observe.ObserveEntityEnum;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Created on 28/12/15.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ */
+public abstract class ReplicationActionContextsBuilderSupport<Context extends ReplicationActionContextsBuilderSupport> {
+
+    protected final ObserveReplicationContext replicationContext;
+
+    protected final Map<String, ObserveReplicationActionContext> actionContexts;
+
+    protected ReplicationActionContextsBuilderSupport(ObserveReplicationContext replicationContext) {
+        this.replicationContext = replicationContext;
+        this.actionContexts = new LinkedHashMap<>();
+    }
+
+    public ImmutableSet<ObserveReplicationActionContext> build() {
+
+        ArrayList<ObserveReplicationActionContext> actionContextList = Lists.newArrayList(this.actionContexts.values());
+        Collections.sort(actionContextList, new Comparator<ObserveReplicationActionContext>() {
+
+            @Override
+            public int compare(ObserveReplicationActionContext o1, ObserveReplicationActionContext o2) {
+                return o1.order - o2.order;
+            }
+        });
+        return ImmutableSet.copyOf(actionContextList);
+    }
+
+    protected Context createFirstActionContext(ObserveEntityEnum entityEnum, String id) {
+        ObserveReplicationActionContext actionContext =
+                ObserveReplicationActionContext.onTrip(
+                        replicationContext,
+                        entityEnum,
+                        id,
+                        0);
+
+        actionContext.setFromClause();
+        actionContext.setWhereTopiaIdEqualsClause();
+
+        registerActionContext(actionContext);
+        return (Context) this;
+    }
+
+    protected ObserveReplicationActionContext createActionContext(ObserveEntityEnum parentEntityEnum, ObserveEntityEnum entityEnum, int order) {
+
+        ObserveReplicationActionContext parentActionContext = getActionContext(parentEntityEnum);
+
+        ObserveReplicationActionContext actionContext =
+                ObserveReplicationActionContext.onJoin(parentActionContext,
+                                                       entityEnum.dbTableName(),
+                                                       order);
+        registerActionContext(actionContext);
+        return actionContext;
+    }
+
+    protected ObserveReplicationActionContext createAssociationActionContext(ObserveEntityEnum parentEntityEnum, String associationName, int order) {
+
+        ObserveReplicationActionContext parentActionContext = getActionContext(parentEntityEnum);
+
+        ObserveReplicationActionContext actionContext =
+                ObserveReplicationActionContext.onAssociationJoin(parentActionContext,
+                                                                  associationName,
+                                                                  order);
+        registerActionContext(actionContext);
+        return actionContext;
+    }
+
+    protected ObserveReplicationActionContext getActionContext(ObserveEntityEnum entityEnum) {
+        String fullyTableName = entityEnum.dbSchemaName().toLowerCase() + "." + entityEnum.dbTableName().toLowerCase();
+        ObserveReplicationActionContext parentactioncontext = actionContexts.get(fullyTableName);
+        return parentactioncontext;
+    }
+
+    protected void registerActionContext(ObserveReplicationActionContext actionContext) {
+        actionContexts.put(actionContext.getFullyTableName(), actionContext);
+    }
+
+}
diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/replication/TripLonglineReplicationActionContextsBuilder.java b/observe-entities/src/main/java/fr/ird/observe/entities/replication/TripLonglineReplicationActionContextsBuilder.java
new file mode 100644
index 0000000..90cfc5c
--- /dev/null
+++ b/observe-entities/src/main/java/fr/ird/observe/entities/replication/TripLonglineReplicationActionContextsBuilder.java
@@ -0,0 +1,174 @@
+package fr.ird.observe.entities.replication;
+
+import com.google.common.collect.ImmutableSet;
+import fr.ird.observe.ObserveEntityEnum;
+
+/**
+ * Created on 28/12/15.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ */
+public class TripLonglineReplicationActionContextsBuilder extends ReplicationActionContextsBuilderSupport<TripLonglineReplicationActionContextsBuilder> {
+
+    public static ImmutableSet<ObserveReplicationActionContext> of(ObserveReplicationContext replicationContext, String tripId) {
+        return new TripLonglineReplicationActionContextsBuilder(replicationContext)
+                .createFirstActionContext(ObserveEntityEnum.TripLongline, tripId)
+                .addGearUseFeaturesActionContext()
+                .addGearUseFeatureMeasurementActionContext()
+                .addActivityActionContext()
+                .addSetActionContext()
+                .addEncounterActionContext()
+                .addSensorUsedActionContext()
+                .addTdrActionContext()
+                .addBaitsCompositionActionContext()
+                .addFloatlinesCompositionActionContext()
+                .addHooksCompositionActionContext()
+                .addBranchlinesCompositionActionContext()
+                .addCatchActionContext()
+
+                .addSectionActionContext()
+                .addBasketActionContext()
+                .addBranchlineActionContext()
+
+                .addSetMitigationTypeActionContext()
+                .addSizeMeasureActionContext()
+                .addWeightMeasureActionContext()
+                .addCatchPredatorActionContext()
+                .addTdrRecordActionContext()
+                .addTdrSpeciesActionContext()
+                .build();
+    }
+
+    protected TripLonglineReplicationActionContextsBuilder(ObserveReplicationContext replicationContext) {
+        super(replicationContext);
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addGearUseFeaturesActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.TripLongline, ObserveEntityEnum.GearUseFeaturesLongline, 1);
+        actionContext.setFromClause();
+        actionContext.setWhereJoinTopiaIdEqualsClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addGearUseFeatureMeasurementActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.GearUseFeaturesLongline, ObserveEntityEnum.GearUseFeaturesMeasurementLongline, 2);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+
+    public TripLonglineReplicationActionContextsBuilder addSetActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.ActivityLongline, ObserveEntityEnum.SetLongline, 10);
+        actionContext.addInverseInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addActivityActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.TripLongline, ObserveEntityEnum.ActivityLongline, 11);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addEncounterActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.ActivityLongline, ObserveEntityEnum.Encounter, 12);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addSensorUsedActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.ActivityLongline, ObserveEntityEnum.SensorUsed, 13);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addTdrActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetLongline, ObserveEntityEnum.Tdr, 20);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addBaitsCompositionActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetLongline, ObserveEntityEnum.BaitsComposition, 21);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addFloatlinesCompositionActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetLongline, ObserveEntityEnum.FloatlinesComposition, 22);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addHooksCompositionActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetLongline, ObserveEntityEnum.HooksComposition, 23);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addBranchlinesCompositionActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetLongline, ObserveEntityEnum.BranchlinesComposition, 24);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addSectionActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetLongline, ObserveEntityEnum.Section, 25);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addBasketActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.Section, ObserveEntityEnum.Basket, 26);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addBranchlineActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.Basket, ObserveEntityEnum.Branchline, 27);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addCatchActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetLongline, ObserveEntityEnum.CatchLongline, 28);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addSetMitigationTypeActionContext() {
+        ObserveReplicationActionContext actionContext = createAssociationActionContext(ObserveEntityEnum.SetLongline, ObserveEntityEnum.MitigationType.name(), 29);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addSizeMeasureActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.CatchLongline, ObserveEntityEnum.SizeMeasure, 30);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addWeightMeasureActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.CatchLongline, ObserveEntityEnum.WeightMeasure, 31);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addCatchPredatorActionContext() {
+        ObserveReplicationActionContext actionContext = createAssociationActionContext(ObserveEntityEnum.CatchLongline, "Predator", 32);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addTdrRecordActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.Tdr, ObserveEntityEnum.TdrRecord, 40);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripLonglineReplicationActionContextsBuilder addTdrSpeciesActionContext() {
+        ObserveReplicationActionContext actionContext = createAssociationActionContext(ObserveEntityEnum.Tdr, ObserveEntityEnum.Species.name(), 41);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+}
diff --git a/observe-entities/src/main/java/fr/ird/observe/entities/replication/TripSeineReplicationActionContextsBuilder.java b/observe-entities/src/main/java/fr/ird/observe/entities/replication/TripSeineReplicationActionContextsBuilder.java
new file mode 100644
index 0000000..9f92fce
--- /dev/null
+++ b/observe-entities/src/main/java/fr/ird/observe/entities/replication/TripSeineReplicationActionContextsBuilder.java
@@ -0,0 +1,145 @@
+package fr.ird.observe.entities.replication;
+
+import com.google.common.collect.ImmutableSet;
+import fr.ird.observe.ObserveEntityEnum;
+
+/**
+ * Created on 28/12/15.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ */
+public class TripSeineReplicationActionContextsBuilder extends ReplicationActionContextsBuilderSupport<TripSeineReplicationActionContextsBuilder> {
+
+    public static ImmutableSet<ObserveReplicationActionContext> of(ObserveReplicationContext replicationContext, String tripId) {
+        return new TripSeineReplicationActionContextsBuilder(replicationContext)
+                .createFirstActionContext(ObserveEntityEnum.TripSeine, tripId)
+                .addGearUseFeaturesActionContext()
+                .addGearUseFeatureMeasurementActionContext()
+                .addRouteActionContext()
+                .addActivityActionContext()
+                .addActivityObservedSystemActionContext()
+                .addSetActionContext()
+                .addSchoolEstimateActionContext()
+                .addNonTargetCatchActionContext()
+                .addNonTargetSampleActionContext()
+                .addNonTargetLengthActionContext()
+                .addTargetCatchActionContext()
+                .addTargetSampleActionContext()
+                .addTargetLengthActionContext()
+
+                .addFloatingObjectActionContext()
+                .addObjectObservedSpeciesActionContext()
+                .addObjectSchoolEstimateActionContext()
+                .addTransmittingBuoyActionContext()
+                .build();
+    }
+
+    protected TripSeineReplicationActionContextsBuilder(ObserveReplicationContext replicationContext) {
+        super(replicationContext);
+    }
+
+    public TripSeineReplicationActionContextsBuilder addGearUseFeaturesActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.TripSeine, ObserveEntityEnum.GearUseFeaturesSeine, 1);
+        actionContext.setFromClause();
+        actionContext.setWhereJoinTopiaIdEqualsClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addGearUseFeatureMeasurementActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.GearUseFeaturesSeine, ObserveEntityEnum.GearUseFeaturesMeasurementSeine, 2);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addRouteActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.TripSeine, ObserveEntityEnum.Route, 3);
+        actionContext.setFromClause();
+        actionContext.setWhereJoinTopiaIdEqualsClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addSetActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.ActivitySeine, ObserveEntityEnum.SetSeine, 4);
+        actionContext.addInverseInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addActivityActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.Route, ObserveEntityEnum.ActivitySeine, 5);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addActivityObservedSystemActionContext() {
+        ObserveReplicationActionContext actionContext = createAssociationActionContext(ObserveEntityEnum.ActivitySeine, "ObservedSystem", 6);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addFloatingObjectActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.ActivitySeine, ObserveEntityEnum.FloatingObject, 7);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addSchoolEstimateActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetSeine, ObserveEntityEnum.SchoolEstimate, 10);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addNonTargetCatchActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetSeine, ObserveEntityEnum.NonTargetCatch, 11);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addNonTargetSampleActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetSeine, ObserveEntityEnum.NonTargetSample, 12);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addNonTargetLengthActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.NonTargetSample, ObserveEntityEnum.NonTargetLength, 13);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addTargetCatchActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetSeine, ObserveEntityEnum.TargetCatch, 14);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addTargetSampleActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.SetSeine, ObserveEntityEnum.TargetSample, 15);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addTargetLengthActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.TargetSample, ObserveEntityEnum.TargetLength, 16);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addObjectObservedSpeciesActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.FloatingObject, ObserveEntityEnum.ObjectObservedSpecies, 20);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addObjectSchoolEstimateActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.FloatingObject, ObserveEntityEnum.ObjectSchoolEstimate, 21);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+    public TripSeineReplicationActionContextsBuilder addTransmittingBuoyActionContext() {
+        ObserveReplicationActionContext actionContext = createActionContext(ObserveEntityEnum.FloatingObject, ObserveEntityEnum.TransmittingBuoy, 22);
+        actionContext.addInnerJoinClause();
+        return this;
+    }
+
+}

-- 
To stop receiving notification emails like this one, please contact
codelutin.com SCM administrator <admin+scm@codelutin.com>.

    

[Observe-commits] 02/12: Implantation efficace de réplication de données

codelutin.com scm