Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.app.extension.copytable;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class CopyTable2ProcessParametersImpl extends AbstractDisposable implements CopyTable2ProcessParameters{

    final static private org.slf4j.Logger LOGGER = LoggerFactory.getLogger(CopyTable2ProcessParametersImpl.class);

    public static class ProcessFieldParametersImpl implements ProcessFieldParameters {

        private String name;

        private boolean copyThisField;

        private Expression expression;

        public ProcessFieldParametersImpl() {

            //For persistence only

        }

        public ProcessFieldParametersImpl(String name, boolean update, Expression expression) {

            this.name = name;

            this.copyThisField = update;

            this.expression = expression;

        }

        /**

         * @return the name

         */

        @Override

        public String getName() {

            return name;

        }

        /**

         * @return the update

         */

        @Override

        public boolean isCopyThisFieldActive() {

            return copyThisField;

        }

        /**

         * @return the expression

         */

        @Override

        public Expression getExpression() {

            return expression;

        }

        public static void selfRegister() {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            DynStruct definition

                    = manager.addDefinition(ProcessFieldParametersImpl.class,

                            "ProcessFieldParameters",

                            "ProcessFieldParameters Persistence definition",

                            null,

                            null);

            definition.addDynFieldString("name")

                    .setMandatory(true);

            definition.addDynFieldBoolean("copyThisField")

                    .setMandatory(true);

            definition.addDynFieldObject("expression")

                    .setClassOfValue(Expression.class)

                    .setMandatory(false);

        }

        @Override

        public void loadFromState(PersistentState state) throws PersistenceException {

        this.name = state.getString("name");

        this.copyThisField = state.getBoolean("copyThisField");

        this.expression = (Expression)state.get("expression");

        }

        @Override

        public void saveToState(PersistentState state) throws PersistenceException {

            state.set("name", this.name );

            state.set("copyThisField", this.copyThisField);

            state.set("expression", this.expression);

        }

    }

    private Expression sourceFilter;

    private FeatureStore sourceStore;

    private FeatureStore targetStore;

    private Map<String,ProcessFieldParameters> fields;

    private int editMode;

    private int finishAndRestarEditEach;

    private boolean finishAndRestarEdit;

    private boolean beginEditIfNeed;

    private boolean finishEditAfterTerminate;

    private boolean notifyUserIfNeedBeginEditing;

    private String sourceFieldJoin;

    private String targetFieldJoin;

    private boolean insertIfNotExistsTarget;

    private boolean updateIfExistsTarget;

    private boolean deleteIfNotExiststInSource;

    private Expression updateIfExistsInTargetCondition;

    public CopyTable2ProcessParametersImpl() {

        super();

        this.sourceFilter = null;

        this.sourceStore = null;

        this.fields = new LinkedHashMap<>();

    }

    @Override

    protected void doDispose() throws BaseException {

        DisposeUtils.dispose(sourceStore);

        DisposeUtils.dispose(targetStore);

        this.sourceStore = null;

        this.targetStore = null;

        this.sourceFilter = null;

    }

    @Override

    public CopyTable2ProcessParameters add(String name, boolean copyField, Expression expression) {

        ProcessFieldParametersImpl x = new ProcessFieldParametersImpl(name, copyField, expression);

        this.fields.put(name,x);

        return this;

    }

    @Override

    public ProcessFieldParameters get(String name) {

        return this.fields.get(name);

    }

    @Override

    public Iterator<ProcessFieldParameters> iterator() {

        return this.fields.values().iterator();

    }

    @Override

    public CopyTable2ProcessParameters setSourceStore(FeatureStore store) {

        DisposeUtils.dispose(this.sourceStore);

        this.sourceStore = store;

        DisposeUtils.bind(this.sourceStore);

        return this;

    }

    @Override

    public FeatureStore getSourceStore() {

        return sourceStore;

    }

    /**

     * @return the filter

     */

    @Override

    public Expression getSourceFilter() {

        return sourceFilter;

    }

    /**

     * @param filter the filter to set

     */

    @Override

    public CopyTable2ProcessParameters setSourceFilter(Expression filter) {

        this.sourceFilter = filter;

        return this;

    }

    /**

     * @return the editMode

     */

    @Override

    public int getEditMode() {

        return editMode;

    }

    /**

     * @param editMode the editMode to set

     */

    @Override

    public CopyTable2ProcessParameters setEditMode(int editMode) {

        this.editMode = editMode;

        return this;

    }

    /**

     * @return the finishAndRestarEditEach

     */

    @Override

    public int getFinishAndRestarEditEach() {

        return finishAndRestarEditEach;

    }

    /**

     * @param finishAndRestarEditEach the finishAndRestarEditEach to set

     */

    @Override

    public CopyTable2ProcessParameters setFinishAndRestarEditEach(int finishAndRestarEditEach) {

        this.finishAndRestarEditEach = finishAndRestarEditEach;

        return this;

    }

    /**

     * @return the beginEditIfNeed

     */

    @Override

    public boolean isBeginEditIfNeed() {

        return beginEditIfNeed;

    }

    /**

     * @param beginEditIfNeed the beginEditIfNeed to set

     */

    @Override

    public CopyTable2ProcessParameters setBeginEditIfNeed(boolean beginEditIfNeed) {

        this.beginEditIfNeed = beginEditIfNeed;

        return this;

    }

    /**

     * @return the finishEditAfterTerminate

     */

    @Override

    public boolean isFinishEditAfterTerminate() {

        return finishEditAfterTerminate;

    }

    /**

     * @param finishEditAfterTerminate the finishEditAfterTerminate to set

     */

    @Override

    public CopyTable2ProcessParameters setFinishEditAfterTerminate(boolean finishEditAfterTerminate) {

        this.finishEditAfterTerminate = finishEditAfterTerminate;

        return this;

    }

    /**

     * @return the notifyUserIfNeedBeginEditing

     */

    @Override

    public boolean isNotifyUserIfNeedBeginEditing() {

        return notifyUserIfNeedBeginEditing;

    }

    /**

     * @param notifyUserIfNeedBeginEditing the notifyUserIfNeedBeginEditing to set

     */

    @Override

    public CopyTable2ProcessParameters setNotifyUserIfNeedBeginEditing(boolean notifyUserIfNeedBeginEditing) {

        this.notifyUserIfNeedBeginEditing = notifyUserIfNeedBeginEditing;

        return this;

    }

    /**

     * @return the finishAndRestarEdit

     */

    @Override

    public boolean isFinishAndRestarEdit() {

        return finishAndRestarEdit;

    }

    /**

     * @param finishAndRestarEdit the finishAndRestarEdit to set

     */

    @Override

    public CopyTable2ProcessParameters setFinishAndRestarEdit(boolean finishAndRestarEdit) {

        this.finishAndRestarEdit = finishAndRestarEdit;

        return this;

    }

    @Override

    public FeatureStore getTargetStore() {

        return this.targetStore;

    }

    @Override

    public boolean isInsertIfNotExistsTargetActive() {

        return this.insertIfNotExistsTarget;

    }

    @Override

    public boolean isUpdateIfExistsTargetActive() {

        return this.updateIfExistsTarget;

    }

    @Override

    public boolean isDeleteIfNotExiststInSourceActive() {

        return this.deleteIfNotExiststInSource;

    }

    @Override

    public String getSourceFieldForJoin() {

        return this.sourceFieldJoin;

    }

    @Override

    public String getTargetFieldForJoin() {

        return this.targetFieldJoin;

    }

    @Override

    public Expression getUpdateIfExistsInTargetCondition() {

        return this.updateIfExistsInTargetCondition;

    }

    @Override

    public CopyTable2ProcessParameters setTargetStore(FeatureStore store) {

        DisposeUtils.dispose(this.targetStore);

        this.targetStore = store;

        DisposeUtils.bind(this.targetStore);

        return this;

    }

    @Override

    public CopyTable2ProcessParameters setInsertIfNotExistsTargetActive(boolean active) {

        this.insertIfNotExistsTarget = active;

        return this;

    }

    @Override

    public CopyTable2ProcessParameters setUpdateIfExistsTargetActive(boolean active) {

        this.updateIfExistsTarget = active;

        return this;

    }

    @Override

    public CopyTable2ProcessParameters setSourceFieldForJoin(String fieldName) {

        this.sourceFieldJoin = fieldName;

        return this;

    }

    @Override

    public CopyTable2ProcessParameters setTargetFieldForJoin(String fieldName) {

        this.targetFieldJoin = fieldName;

        return this;

    }

    @Override

    public CopyTable2ProcessParameters setUpdateIfExistsInTargetCondition(Expression condition) {

        this.updateIfExistsInTargetCondition = condition;

        return this;

    }

    @Override

    public CopyTable2ProcessParameters setDeleteIfNotExiststInSourceActive(boolean active) {

        this.deleteIfNotExiststInSource = active;

        return this;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

            state.set("sourceFilter", this.sourceFilter );

            if(this.sourceStore != null){

                state.set("sourceStoreParams", this.sourceStore.getParameters());

            }

            if(this.targetStore != null){

                state.set("targetStoreParams", this.targetStore.getParameters());

            }

            state.set("fields", this.fields );

            state.set("editMode", this.editMode );

            state.set("finishAndRestarEditEach", this.finishAndRestarEditEach );

            state.set("finishAndRestarEdit", this.finishAndRestarEdit );

            state.set("beginEditIfNeed", this.beginEditIfNeed );

            state.set("finishEditAfterTerminate", this.finishEditAfterTerminate );

            state.set("notifyUserIfNeedBeginEditing", this.notifyUserIfNeedBeginEditing );

            state.set("sourceFieldJoin", this.sourceFieldJoin );

            state.set("targetFieldJoin", this.targetFieldJoin );

            state.set("insertIfNotExistsTarget", this.insertIfNotExistsTarget );

            state.set("updateIfExistsTarget", this.updateIfExistsTarget );

            state.set("deleteIfNotExiststInSource", this.deleteIfNotExiststInSource );

            state.set("updateIfExistsInTargetCondition", this.updateIfExistsInTargetCondition );

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.sourceFilter = (Expression)state.get("sourceFilter");

        DataManager dataManager = DALLocator.getDataManager();

        DataStoreParameters sourceStoreParams = (DataStoreParameters) state.get("sourceStoreParams");

        if (sourceStoreParams != null && sourceStoreParams instanceof DataStoreParameters) {

            try {

                this.sourceStore = (FeatureStore) dataManager.openStore(sourceStoreParams.getProviderName(), sourceStoreParams);

            } catch (Exception ex) {

                LOGGER.warn("Can't open source store '"+sourceStoreParams.getDescription()+"'", ex);

            }

        }

        DataStoreParameters targetStoreParams = (DataStoreParameters)state.get("targetStoreParams");

        if(targetStoreParams != null && targetStoreParams instanceof DataStoreParameters){

            try {

                this.targetStore = (FeatureStore) dataManager.openStore(targetStoreParams.getProviderName(), targetStoreParams);

            } catch (Exception ex) {

                LOGGER.warn("Can't open target store '"+sourceStoreParams.getDescription()+"'", ex);

            }

        }

        this.fields = state.getMap("fields");

        this.editMode = state.getInt("editMode");

        this.finishAndRestarEditEach = state.getInt("finishAndRestarEditEach");

        this.finishAndRestarEdit = state.getBoolean("finishAndRestarEdit");

        this.beginEditIfNeed = state.getBoolean("beginEditIfNeed");

        this.finishEditAfterTerminate = state.getBoolean("finishEditAfterTerminate");

        this.notifyUserIfNeedBeginEditing = state.getBoolean("notifyUserIfNeedBeginEditing");

        this.sourceFieldJoin = state.getString("sourceFieldJoin");

        this.targetFieldJoin = state.getString("targetFieldJoin");

        this.insertIfNotExistsTarget = state.getBoolean("insertIfNotExistsTarget");

        this.updateIfExistsTarget = state.getBoolean("updateIfExistsTarget");

        this.deleteIfNotExiststInSource = state.getBoolean("deleteIfNotExiststInSource");

        this.updateIfExistsInTargetCondition = (Expression)state.get("updateIfExistsInTargetCondition");

    }

    public static void selfRegister() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        DynStruct definition

                = manager.addDefinition(CopyTable2ProcessParametersImpl.class,

                        "CopyTable2ProcessParameters",

                        "CopyTable2ProcessParameters Persistence definition",

                        null,

                        null);

        ProcessFieldParametersImpl.selfRegister();

        definition.addDynFieldObject("sourceStoreParams")

                .setClassOfValue(DataParameters.class)

                .setMandatory(true);

        definition.addDynFieldObject("targetStoreParams")

                .setClassOfValue(DataParameters.class)

                .setMandatory(true);

        definition.addDynFieldObject("sourceFilter")

                .setClassOfValue(Expression.class)

                .setMandatory(false);

        definition.addDynFieldObject("updateIfExistsInTargetCondition")

                .setClassOfValue(Expression.class)

                .setMandatory(false);

        definition.addDynFieldMap("fields")

                .setClassOfItems(ProcessFieldParametersImpl.class)

                .setMandatory(true);

        definition.addDynFieldInt("editMode")

                .setMandatory(true);

        definition.addDynFieldInt("finishAndRestarEditEach")

                .setMandatory(true);

        definition.addDynFieldBoolean("finishAndRestarEdit")

                .setMandatory(true);

        definition.addDynFieldBoolean("beginEditIfNeed")

                .setMandatory(true);

        definition.addDynFieldBoolean("finishEditAfterTerminate")

                .setMandatory(true);

        definition.addDynFieldBoolean("notifyUserIfNeedBeginEditing")

                .setMandatory(true);

        definition.addDynFieldString("sourceFieldJoin")

                .setMandatory(true);

        definition.addDynFieldString("targetFieldJoin")

                .setMandatory(true);

        definition.addDynFieldBoolean("insertIfNotExistsTarget")

                .setMandatory(true);

        definition.addDynFieldBoolean("updateIfExistsTarget")

                .setMandatory(true);

        definition.addDynFieldBoolean("deleteIfNotExiststInSource")

                .setMandatory(true);

    }

    public String toString() {

        StringBuilder builder = new StringBuilder();

        builder.append("SOURCE: ");

        DataStoreParameters sourceParameters = this.sourceStore.getParameters();

        if(sourceParameters instanceof JDBCStoreParameters) {

            builder.append(((JDBCStoreParameters)sourceParameters).getUrl());

            builder.append(" -> ");

            builder.append(((JDBCStoreParameters) sourceParameters).getTable());

        } else if(sourceParameters instanceof FilesystemStoreParameters) {

            builder.append(((FilesystemStoreParameters)sourceParameters).getFile().getAbsolutePath());

        }

        builder.append("\n");

        builder.append("TARGET: ");

        DataStoreParameters targetParameters = this.targetStore.getParameters();

        if(targetParameters instanceof JDBCStoreParameters) {

            builder.append(((JDBCStoreParameters)targetParameters).getUrl());

            builder.append(" -> ");

            builder.append(((JDBCStoreParameters) targetParameters).getTable());

        } else if(targetParameters instanceof FilesystemStoreParameters) {

            builder.append(((FilesystemStoreParameters)sourceParameters).getFile().getAbsolutePath());

        }

        builder.append("\n");

        builder.append("FIELDS: ");

        for (Map.Entry<String, ProcessFieldParameters> entry : this.fields.entrySet()) {

            builder.append("\n");

            builder.append("  ");

            builder.append(entry.getKey());

            builder.append(": ");

            ProcessFieldParameters value = entry.getValue();

            if(value != null){

                Expression expression = value.getExpression();

                if(expression != null){

                    builder.append(expression.getPhrase());

                }

            }

        }

        builder.append("\n");

        builder.append("EDIT MODE: ");

        builder.append(this.editMode);

        builder.append("\n");

        builder.append("FINISH AND RESTART EDIT EACH: ");

        builder.append(this.finishAndRestarEditEach);

        builder.append("\n");

        builder.append("FINISH AND RESTART EDIT: ");

        builder.append(this.finishAndRestarEdit);

        builder.append("\n");

        builder.append("BEGIN EDIT IF NEED: ");

        builder.append(this.beginEditIfNeed);

        builder.append("\n");

        builder.append("FINISH EDIT AFTER TERMINATE: ");

        builder.append(this.finishEditAfterTerminate);

        builder.append("\n");

        builder.append("NOTIFY USER IF NEED BEGIN EDITING: ");

        builder.append(this.notifyUserIfNeedBeginEditing);

        builder.append("\n");

        builder.append("SOURCE FIELD JOIN: ");

        builder.append(this.sourceFieldJoin);

        builder.append("\n");

        builder.append("TARGET FIELD JOIN: ");

        builder.append(this.targetFieldJoin);

        builder.append("\n");

        builder.append("INSERT IF NOT EXISTS TARGET: ");

        builder.append(this.insertIfNotExistsTarget);

        builder.append("\n");

        builder.append("UPDATE IF EXISTS TARGET: ");

        builder.append(this.updateIfExistsTarget);

        builder.append("\n");

        builder.append("DELETE IF NOT EXISTS IN SOURCE: ");

        builder.append(this.deleteIfNotExiststInSource);

        builder.append("\n");

        builder.append("UPDATE IF EXISTS IN TARGET CONDITION: ");

        if(this.updateIfExistsInTargetCondition != null){

            builder.append(this.updateIfExistsInTargetCondition.getPhrase());

        }

        return builder.toString();

    }

}