gvSIG projects pool

package org.gvsig.vcsgis.lib.workspace;

import java.io.File;

import java.sql.Timestamp;

import java.time.LocalDateTime;

import java.time.ZoneOffset;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.json.JsonObject;

import org.apache.commons.lang3.Range;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.FeatureSet.DisposableFeatureSetIterable;

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

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

import org.gvsig.json.Json;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposableIterable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.logger.FilteredLogger;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.ContainerUtils;

import org.gvsig.tools.util.GetItemWithSizeAndIterator64;

import org.gvsig.tools.util.HasAFile;

import org.gvsig.vcsgis.lib.DisposableIterableAdapter;

import org.gvsig.vcsgis.lib.VCSGisChange;

import org.gvsig.vcsgis.lib.VCSGisCodeGenerator;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import static org.gvsig.vcsgis.lib.VCSGisManager.DEFAULT_DATA_TABLE;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_ADD_CHANGE;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_COMMIT;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_INSERT_CHANGE;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_INSERT_FEATURES;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_OPEN_CHANGES;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_OPEN_ENTITIES;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_OPEN_STORE;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_PREPARE_UPDATE;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_RETRIEVE_SOURCE_FEATURES;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_UPDATE;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_UPDATE_CLEAN;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_CANT_UPDATE_ENTITIES;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_ENTITY_ALREADY_EXISTS;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_ENTITY_NOT_EXISTS;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_ENTITY_NOT_HAS_VCSGISCODE;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_NO_ERROR;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_OK;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_STORE_NOT_IN_VERSION_CONTROL;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_UPDATE_NEED_MERGE;

import static org.gvsig.vcsgis.lib.VCSGisManager.FEATURECODE_FIELD_NAME;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_ADD_ENTITY;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_DELETE;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_INSERT;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_UPDATE;

import static org.gvsig.vcsgis.lib.VCSGisManager.STATE_MODIFIED;

import static org.gvsig.vcsgis.lib.VCSGisManager.STATE_NEW;

import static org.gvsig.vcsgis.lib.VCSGisManager.STATE_OUTDATED;

import static org.gvsig.vcsgis.lib.VCSGisManager.STATE_OUTDATED_AND_MODIFIED;

import static org.gvsig.vcsgis.lib.VCSGisManager.STATE_UNMODIFIED;

import static org.gvsig.vcsgis.lib.VCSGisManagerImpl.INTERNAL_TABLES;

import org.gvsig.vcsgis.lib.VCSGisRevision;

import org.gvsig.vcsgis.lib.VCSGisRuntimeException;

import org.gvsig.vcsgis.lib.VCSGisUtils;

import org.gvsig.vcsgis.lib.repository.VCSGisRepository;

import org.gvsig.vcsgis.lib.repository.VCSGisRepositoryChange;

import org.gvsig.vcsgis.lib.repository.VCSGisRepositoryData;

import org.gvsig.vcsgis.lib.repository.localdb.VCSGisRepositoryLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.tables.EntitiesRepoTable;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisCheckoutRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisCommitRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisEntitiesRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisLogRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisUpdateRequest;

import org.gvsig.vcsgis.lib.workspace.tables.EntitiesTable;

import org.gvsig.vcsgis.lib.workspace.tables.EntitiesTable.EntityRow;

import org.gvsig.vcsgis.lib.workspace.tables.LocalRevisionsTable;

import org.gvsig.vcsgis.lib.workspace.tables.LocalRevisionsTable.LocalRevisionRow;

import org.gvsig.vcsgis.lib.workspace.tables.RemoteChangesTable;

import static org.gvsig.vcsgis.lib.workspace.tables.RemoteChangesTable.COD_ENTITY;

import org.gvsig.vcsgis.lib.workspace.tables.RemoteChangesTable.RemoteChangeRow;

import org.gvsig.vcsgis.lib.workspace.tables.VarsTable;

import org.gvsig.vcsgis.lib.workspace.tables.WorkspaceChangesTable;

import org.gvsig.vcsgis.lib.workspace.tables.WorkspaceChangesTable.WorkspaceChangeRow;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings({"UseSpecificCatch", "UnusedAssignment"})

public class VCSGisWorkspaceImpl implements VCSGisWorkspace {

    private static final Logger LOGGER = LoggerFactory.getLogger(VCSGisWorkspaceImpl.class);

    private final Map<String, FeatureStore> storesCache;

    private Map<String, EntityRow> workspaceEntitiesByName;

    private Map<String, EntityRow> workspaceEntitiesByCode;

    private Map<String, VCSGisEntity> repositoryEntitiesByCode;

    private Set<FeatureStore> storeIgnoreChanges;

    private JDBCServerExplorer wsexplorer;

    private String code;

    private final VCSGisRepository repository;

    private final String label;

    private final FilteredLogger logger;

    private final VCSGisCodeGenerator codeGenerator;

    public VCSGisWorkspaceImpl(JDBCServerExplorer wsexplorer, VCSGisCodeGenerator codeGenerator, VCSGisRepository repository, String label) {

        this.logger = new FilteredLogger(LOGGER, "VCSGisWorkspace", 100);

        this.logger.setInterval(10000);

        this.codeGenerator = codeGenerator;

        this.storesCache = new HashMap<>();

        this.code = createUniqueCode();

        this.wsexplorer = wsexplorer;

        this.repository = repository;

        this.label = label;

//        LOGGER.debug("===: CREATE WORKSPACE "+ hexId(this)+ " (init label='"+this.label+"')");

    }

    public VCSGisWorkspaceImpl(JDBCServerExplorer wsexplorer, VCSGisCodeGenerator codeGenerator) {

        this.logger = new FilteredLogger(LOGGER, "VCSGisWorkspace", 100);

        this.logger.setInterval(10000);

        this.codeGenerator = codeGenerator;

        this.storesCache = new HashMap<>();

        this.wsexplorer = wsexplorer;

        this.loadEntities();

        VarsTable varsTable = new VarsTable();

        this.code = varsTable.get(this, "WORKSPACE_CODE");

        if (this.code == null) {

            throw new RuntimeException("Can't retrieve code from workspace '" + this.getMessageLabel() + "'");

        }

        this.repository = (VCSGisRepository) Json.toObject(varsTable.get(this, "REPOSITORY"));

        if (this.repository == null) {

            throw new RuntimeException("Can't retrieve repository from workspace '" + this.getMessageLabel() + "'");

        }

        this.label = varsTable.get(this, "WORKSPACE_LABEL");

//        LOGGER.debug("===: CREATE WORKSPACE "+ hexId(this)+ " (open code='"+this.code+"', label='"+this.label+"')");

    }

    public void initialize() throws Exception {

        DataManager dataManager = DALLocator.getDataManager();

//        List<VCSGisEntity> rentities = this.getRepositoryEntities();

//        if (!rentities.isEmpty()) {

//            JDBCStoreParameters storeParams = wsexplorer.get(EntitiesTable.TABLE_NAME);

//            FeatureStore storeEntities = (FeatureStore) dataManager.openStore(

//                    DataStore.H2SPATIAL_PROVIDER_NAME,

//                    storeParams

//            );

//            storeEntities.edit(FeatureStore.MODE_APPEND);

//            for (VCSGisEntity rentity : rentities) {

//                EntityRow entity = new EntityRow(this, storeEntities.createNewFeature());

//                entity.copyfrom(rentity);

//                entity.setLocalRevisionCode(null);

//                entity.insert(storeEntities);

//            }

//            storeEntities.finishEditing();

//        }

        VarsTable varsTable = new VarsTable();

        varsTable.set(this, "WORKSPACE_CODE", code);

        varsTable.set(this, "WORKSPACE_LABEL", label);

        varsTable.set(this, "REPOSITORY", repository.toJson().toString());

    }

    private String getMessageLabel() {

        return this.wsexplorer.getParameters().getUrl();

    }

    @Override

    public String getCode() {

        return this.code;

    }

    @Override

    public String getLabel() {

        return this.label;

    }

    @Override

    public void dispose() {

        for (Map.Entry<String, FeatureStore> entry : storesCache.entrySet()) {

            FeatureStore store = entry.getValue();

            if (store != null) {

                DisposeUtils.disposeQuietly(store);

            }

        }

        this.storesCache.clear();

        DisposeUtils.dispose(this.wsexplorer);

        this.wsexplorer= null;

        this.code = null;

    }

    @Override

    public JDBCServerExplorerParameters getExplorerParameters() {

        return this.wsexplorer.getParameters();

    }

    private boolean isInStoreIgnoreChanges(FeatureStore store) {

        if (this.storeIgnoreChanges == null) {

            return false;

        }

        return this.storeIgnoreChanges.contains(store);

    }

    private void addStoreIgnoreChanges(FeatureStore store) {

        if (this.storeIgnoreChanges == null) {

            this.storeIgnoreChanges = new HashSet<>();

        }

        this.storeIgnoreChanges.add(store);

    }

    private void removeStoreIgnoreChanges(FeatureStore store) {

        if (this.storeIgnoreChanges == null) {

            this.storeIgnoreChanges = new HashSet<>();

        }

        this.storeIgnoreChanges.remove(store);

    }

//    private boolean contains(FeatureStore store) {

//        return this.getEntity(store) != null;

//    }

//

    private EntityRow getEntity(FeatureStore store) {

        String s = (String) store.getProperty("VCSGIS_WORKSPACE");

        if (s != null) {

            if (StringUtils.equalsIgnoreCase(code, s)) {

                return this.getWorkspaceEntityByName((String) store.getProperty("VCSGIS_ENTITY"));

            }

            return null;

        }

        DataStoreParameters params = store.getParameters();

        if (!DataStore.H2SPATIAL_PROVIDER_NAME.equalsIgnoreCase(params.getProviderName())) {

            store.setProperty("VCSGIS_WORKSPACE", "#########");

            return null;

        }

        File f = ((HasAFile) params).getFile();

        if (f == null) {

            store.setProperty("VCSGIS_WORKSPACE", "#########");

            return null;

        }

        EntityRow entity = this.getWorkspaceEntityByName(((JDBCStoreParameters) params).getTable());

        if (entity == null) {

            store.setProperty("VCSGIS_WORKSPACE", "#########");

            return null;

        }

        store.setProperty("VCSGIS_WORKSPACE", this.code);

        store.setProperty("VCSGIS_ENTITY", entity.getEntityName());

        return entity;

    }

    private void loadEntities() {

        FeatureStore store = null;

        try {

            Map<String, EntityRow> theEntitiesByName = new HashMap<>();

            Map<String, EntityRow> theEntitiesByCode = new HashMap<>();

            store = getFeatureStore(EntitiesTable.TABLE_NAME);

            for (Feature feature : store.getFeatureSet().iterable()) {

                EntityRow entity = new EntityRow(this, feature);

                theEntitiesByName.put(entity.getEntityName(), entity);

                theEntitiesByCode.put(entity.getCode(), entity);

                LOGGER.debug("===: loadEntities: "+entity.getEntityName()+" entity code "+entity.getEntityCode()+", repo rev. "+entity.getRepositoryRevisionCode()+", local rev. "+entity.getLocalRevisionCode());            

            }

            this.workspaceEntitiesByName = theEntitiesByName;

            this.workspaceEntitiesByCode = theEntitiesByCode;

        } catch (Exception ex) {

            LOGGER.warn("Can't load entity information.", ex);

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public List<VCSGisWorkspaceEntity> getWorkspaceEntities() {

        List<VCSGisWorkspaceEntity> entities = new ArrayList<>();

        entities.addAll(this.getEntitiesAsEntityRow());

        return entities;

    }

    private Collection<EntityRow> getEntitiesAsEntityRow() {

        if (this.workspaceEntitiesByName == null) {

            loadEntities();

        }

        return this.workspaceEntitiesByName.values();

    }

    @Override

    public EntityRow getWorkspaceEntityByName(String name) {

        if (this.workspaceEntitiesByName == null) {

            this.loadEntities();

        }

        return this.workspaceEntitiesByName.get(name);

    }

    @Override

    public EntityRow getWorkspaceEntityByCode(String code) {

        if (this.workspaceEntitiesByCode == null) {

            this.loadEntities();

        }

        return this.workspaceEntitiesByCode.get(code);

    }

    @Override

    public EntityRow getWorkspaceEntity(String entity) {

        EntityRow wsentity = this.getWorkspaceEntityByCode(entity);

        if( wsentity==null ) {

            wsentity = this.getWorkspaceEntityByName(entity);

        }

        return wsentity;

    }

    @Override

    public VCSGisEntity getRepositoryEntityByCode(String entityCode) {

        if (this.repositoryEntitiesByCode == null) {

            reloadRepositoryEntities(null);

        }

        return this.repositoryEntitiesByCode.get(entityCode);

    }

    @Override

    public VCSGisEntity getRepositoryEntityByName(String entityName) {

        if (this.repositoryEntitiesByCode == null) {

            reloadRepositoryEntities(null);

        }

        for (VCSGisEntity entity : this.repositoryEntitiesByCode.values()) {

            if( StringUtils.equalsIgnoreCase(entity.getEntityName(), entityName) ) {

                return entity;

            }

        }

        return null;

    }

    @Override

    public VCSGisEntity getEntity(String entityName) {

        VCSGisEntity entity = this.getWorkspaceEntity(entityName);

        if(entity == null){

            entity = this.getRepositoryEntity(entityName);

        }

        return entity;

    }

    @Override

    public VCSGisEntity getRepositoryEntity(String entity) {

        VCSGisEntity rentity = this.getRepositoryEntityByCode(entity);

        if( rentity==null ) {

            rentity = this.getRepositoryEntityByName(entity);

        }

        return rentity;

    }

    public void reloadRepositoryEntities(SimpleTaskStatus status) {

        //Esto recarga el map

        this.getRepositoryEntities(status);

    }

    public void reloadWorkspaceEntities() {

        this.workspaceEntitiesByCode = null;

        this.workspaceEntitiesByName = null;

    }

    @Override

    public void create_table(String name) {

        EntityRow entity = this.getWorkspaceEntityByName(name);

        if (entity == null) {

            throw new IllegalArgumentException("Can't locate informacion of table '" + name + "'.");

        }

        create_table(entity);

    }

    @Override

    public void create_table(VCSGisEntity entity) {

        if (entity == null) {

            throw new IllegalArgumentException("Entity is null.");

        }

        try {

            DataManager dataManager = DALLocator.getDataManager();

            JDBCNewStoreParameters addparams = (JDBCNewStoreParameters) this.wsexplorer.getAddParameters(entity.getEntityName());

            addparams.setDefaultFeatureType(entity.getFeatureType());

            this.wsexplorer.add(DataStore.H2SPATIAL_PROVIDER_NAME, addparams, true);

        } catch (Exception ex) {

            throw new RuntimeException("Can't create table '" + entity.getEntityName() + "'.", ex);

        }

    }

    @Override

    public FeatureStore getFeatureStore(String tableName) {

        EntityRow entity = null;

        if( !INTERNAL_TABLES.contains(tableName) ) {

            entity = this.getWorkspaceEntityByName(tableName);

            if (entity == null) {

                return null;

            }

            return getFeatureStore(entity);

        }

        FeatureStore store = this.storesCache.get(tableName);

        if (store != null) {

            DisposeUtils.bind(store);

            return store;

        }

        DataManager dataManager = DALLocator.getDataManager();

        try {

            JDBCStoreParameters params = this.wsexplorer.get(tableName);

            store = (FeatureStore) dataManager.openStore(

                    DataStore.H2SPATIAL_PROVIDER_NAME,

                    params

            );

            this.storesCache.put(tableName, store);

            DisposeUtils.bind(store);

            return store;

        } catch (Exception ex) {

            String msg = "can't open store from '" + this.getMessageLabel() + "'.";

            throw new RuntimeException(msg, ex);

        }

    }

    private FeatureStore getFeatureStore(VCSGisEntity entity) {

        FeatureStore store = this.storesCache.get(entity.getEntityName());

        if (store != null) {

            DisposeUtils.bind(store);

            return store;

        }

        DataManager dataManager = DALLocator.getDataManager();

        try {

            JDBCStoreParameters params = this.wsexplorer.get(entity.getEntityName());

            store = (FeatureStore) dataManager.openStore(

                    DataStore.H2SPATIAL_PROVIDER_NAME,

                    params

            );

            StoreProperties.set(store, this, entity.getEntityName());

            this.storesCache.put(entity.getEntityName(), store);

            DisposeUtils.bind(store);

            return store;

        } catch (Exception ex) {

            String msg = "can't open store from '" + this.getMessageLabel() + "'.";

            throw new RuntimeException(msg, ex);

        }

    }

    @Override

    public String createUniqueCode() {

        return this.codeGenerator.generateCode();

    }

    @Override

    public String getErrorMessage(int errcode) {

        return VCSGisUtils.getErrorMessage(errcode);

    }

    @Override

    public int addChange(int operation, FeatureStore userStore, Feature feature) {

        String entityName = StoreProperties.getEntityName(userStore);

        if (StringUtils.isBlank(entityName)) {

            return ERR_STORE_NOT_IN_VERSION_CONTROL;

        }

        if (this.isInStoreIgnoreChanges(userStore)) {

            LOGGER.debug("===: ADD_CHANGE: Skip ("+userStore.getName()+")");

            return ERR_NO_ERROR;

        }

        EntityRow entity = this.getWorkspaceEntityByName(entityName);

        FeatureStore changesStore = this.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        try {

            changesStore.edit(MODE_PASS_THROUGH);

            return addChange(entity, operation, changesStore, feature);

        } catch(Exception ex) {

            LOGGER.warn("Can't add change (op "+VCSGisUtils.getOperationLabel(operation)+", "+entity.getEntityName()+")", ex);

            changesStore.cancelEditingQuietly();

            return ERR_CANT_ADD_CHANGE;

        } finally {

            changesStore.finishEditingQuietly();

            DisposeUtils.dispose(changesStore);

        }

    }

    private int addChange(VCSGisWorkspaceEntity entity, int operation, FeatureStore changesStore, Feature feature) {

        try {

            WorkspaceChangeRow change = new WorkspaceChangeRow(this, changesStore.createNewFeature());

            change.newCode();

            change.setEntityCode(entity.getEntityCode());

            change.setFeatureCode(feature.getString(entity.getFeatureIdFieldName()));

            change.setOperation(operation);

            change.setLabel(feature.getString(entity.getFieldForLabel()));

            change.setSelected(true);

            change.insert(changesStore);

            return ERR_OK;

        } catch(Exception ex) {

            LOGGER.warn("Can't add change (op "+VCSGisUtils.getOperationLabel(operation)+", "+entity.getEntityName()+")", ex);

            return ERR_CANT_ADD_CHANGE;

        }

    }

    private int addDeleteChange(VCSGisWorkspaceEntity entity, FeatureStore changesStore, String featureCode, String label) {

        try {

            WorkspaceChangeRow change = new WorkspaceChangeRow(this, changesStore.createNewFeature());

            change.newCode();

            change.setEntityCode(entity.getEntityCode());

            change.setFeatureCode(featureCode);

            change.setOperation(OP_DELETE);

            change.setLabel(label);

            change.setSelected(true);

            change.insert(changesStore);

            return ERR_OK;

        } catch(Exception ex) {

            LOGGER.warn("Can't add delete change ("+entity.getEntityName()+")", ex);

            return ERR_CANT_ADD_CHANGE;

        }

    }

    @Override

    public int addEntity(FeatureType featureType, String name, String description, String fieldForLabel) {

        return this.addEntity(featureType, name, description, fieldForLabel, null);

    }

    @Override

    public int addEntity(FeatureType featureType, String name, String description, String fieldForLabel, String pkName) {

        FeatureStore store = null;

        int err = ERR_NO_ERROR;

        try {

            LOGGER.debug("===: ADD_ENTITY "+this.getCode()+", '"+this.getLabel()+"', "+name);

            EditableFeatureType ft = featureType.getCopy().getEditable();

            for (FeatureAttributeDescriptor attr : ft.getPrimaryKey()) {

                EditableFeatureAttributeDescriptor editAttr = (EditableFeatureAttributeDescriptor)attr;

                editAttr.setIsPrimaryKey(false);

                editAttr.setAllowNull(false);

                editAttr.setIsIndexed(true);

                editAttr.setAllowIndexDuplicateds(false);

            }

            EditableFeatureAttributeDescriptor attr = (EditableFeatureAttributeDescriptor)ft.getAttributeDescriptor(FEATURECODE_FIELD_NAME);

            if (attr == null) {

                err = ERR_ENTITY_NOT_HAS_VCSGISCODE;

                ft.add(FEATURECODE_FIELD_NAME, DataTypes.STRING)

                        .setSize(40)

                        .setIsPrimaryKey(true)

                        .setIsIndexed(true)

                        .setAllowIndexDuplicateds(false)

                        .setLabel("VCSGIS Code");

                ft.setHasOID(false);

            } else {

                if(!attr.isPrimaryKey()){

                    attr.setIsPrimaryKey(true);

                    ft.setHasOID(false);

                }

            }

            featureType = ft.getNotEditableCopy();

            if (featureType.getAttributeDescriptor(fieldForLabel) == null) {

                FeatureAttributeDescriptor[] pk = featureType.getPrimaryKey();

                if( pk == null || pk.length<1 ) {

                    fieldForLabel = featureType.getAttributeName(0);

                } else {

                    fieldForLabel = pk[0].getName();

                }

            }

            err = ERR_CANT_OPEN_ENTITIES;

            EntityRow entity = new EntityRow(this);

            entity.setEntityName(name);

            entity.setDataTableName(DEFAULT_DATA_TABLE);

            entity.setFeatureIdFieldName(FEATURECODE_FIELD_NAME);

            entity.setGeometryFieldName(featureType.getDefaultGeometryAttributeName());

            entity.setDescription(description);

            entity.setFieldForLabel(fieldForLabel);

            entity.setFeatureTypeAsJson(featureType.toJsonBuilder().toString());

            entity.setLocalRevisionCode(null); 

            entity.setRepositoryRevisionCode(null); 

            entity.setState(STATE_NEW);

            entity.insert();

            this.reloadWorkspaceEntities();

            err = ERR_CANT_INSERT_CHANGE;

            entity = this.getWorkspaceEntityByName(name);

            WorkspaceChangeRow change = new WorkspaceChangeRow(this);

            change.setEntityCode(entity.getCode());

            change.setFeatureCode(null);

            change.setOperation(OP_ADD_ENTITY);

            change.setSelected(true);

            change.insert();

            this.create_table(entity);

        } catch (VCSGisRuntimeException ex) {

            LOGGER.warn("can't add entity '" + name + "'.", ex);

            if (store != null) {

                store.cancelEditingQuietly();

            }

            return ex.getErrnum();

        } catch (Exception ex) {

            LOGGER.warn("can't add entity '" + name + "'.", ex);

            if (store != null) {

                store.cancelEditingQuietly();

            }

            return err;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

        return ERR_NO_ERROR;

    }

    @Override

    public int addChanges(FeatureStore store, Iterator<Feature> insertedsFeatures, Iterator<Feature> updatedsFeatures, Iterator<FeatureReference> deletedsFeatures) {

        String entityName = StoreProperties.getEntityName(store);

        if (StringUtils.isBlank(entityName)) {

            return ERR_STORE_NOT_IN_VERSION_CONTROL;

        }

        if (this.isInStoreIgnoreChanges(store)) {

            LOGGER.debug("===: ADD_CHANGE: Skip ("+store.getName()+")");

            return ERR_NO_ERROR;

        }

        EntityRow entity = this.getWorkspaceEntityByName(entityName);

        if (entity == null) {

            return ERR_STORE_NOT_IN_VERSION_CONTROL;

        }

        WorkspaceChangesTable changesTable = new WorkspaceChangesTable();

        FeatureStore changes_store = null;

        int err = ERR_CANT_OPEN_CHANGES;

        try {

            changes_store = this.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

            err = ERR_CANT_INSERT_CHANGE;

            changes_store.edit(FeatureStore.MODE_PASS_THROUGH);

            if (insertedsFeatures != null) {

                while (insertedsFeatures.hasNext()) {

                    Feature f = insertedsFeatures.next();

                    if (f == null) {

                        continue;

                    }

                    WorkspaceChangeRow change = new WorkspaceChangeRow(this);

                    change.setEntityCode(entity.getCode());

                    change.setFeatureCode(f.getString(entity.getFeatureIdFieldName()));

                    change.setOperation(OP_INSERT);

                    change.setLabel(f.getString(entity.getFieldForLabel()));

                    change.setSelected(true);

                    change.insert(changes_store);

                }

            }

            if (updatedsFeatures != null) {

                while (updatedsFeatures.hasNext()) {

                    Feature f = updatedsFeatures.next();

                    if (f == null) {

                        continue;

                    }

                    WorkspaceChangeRow change = new WorkspaceChangeRow(this);

                    String featureCode = f.getString(entity.getFeatureIdFieldName());

                    WorkspaceChangeRow previousChange = changesTable.find(this, changes_store, entity.getCode(), featureCode);

                    if(previousChange == null) {

                        change.setEntityCode(entity.getCode());

                        change.setFeatureCode(f.getString(entity.getFeatureIdFieldName()));

                        change.setOperation(OP_UPDATE);

                        change.setLabel(f.getString(entity.getFieldForLabel()));

                        change.setSelected(true);

                        change.insert(changes_store);

                    }

                }

            }

            if (deletedsFeatures != null) {

                while (deletedsFeatures.hasNext()) {

                    FeatureReference fr = deletedsFeatures.next();

                    if (fr == null) {

                        continue;

                    }

                    Feature f = fr.getFeatureQuietly();

                    if (f == null) {

                        continue;

                    }

                    WorkspaceChangeRow change = new WorkspaceChangeRow(this);

                    String featureCode = f.getString(entity.getFeatureIdFieldName());

                    WorkspaceChangeRow previousChange = changesTable.find(this, changes_store, entity.getCode(), featureCode);

                    if(previousChange == null) {

                        change.setEntityCode(entity.getCode());

                        change.setFeatureCode(f.getString(entity.getFeatureIdFieldName()));

                        change.setOperation(OP_DELETE);

                        change.setLabel(f.getString(entity.getFieldForLabel()));

                        change.setSelected(true);

                        change.insert(changes_store);

                    } else {

                        switch(previousChange.getOperation()){

                            case OP_INSERT:

                                previousChange.delete(changes_store);

                                break;

                            case OP_DELETE:

                                LOGGER.warn("Try delete feature already deleted (.'"+previousChange.getRelatedFeature().toJson().toString()+"'");

                                break;

                            case OP_UPDATE:

                                previousChange.setOperation(OP_DELETE);

                                previousChange.setSelected(true);

                                previousChange.update();

                                break;

                        }

                    }

                }

            }

            changes_store.finishEditing();

            err = ERR_NO_ERROR;

        } catch (Exception ex) {

            this.logger.warn("Can't add changes.", ex);

            if (changes_store != null) {

                changes_store.cancelEditingQuietly();

            }

        } finally {

            DisposeUtils.disposeQuietly(changes_store);

        }

        return err;

    }

    @Override

    public int add(String name, FeatureStore source, String fieldForLabel) {

        return this.add(name, source, fieldForLabel, null);

    }

    @Override

    public int add(String name, FeatureStore source, String fieldForLabel, String pkName) {

        FeatureStore target = null;

        DisposableFeatureSetIterable features = null;

        int errcode = ERR_NO_ERROR;

        try {

            LOGGER.debug("===: ADD "+this.getCode()+", '"+this.getLabel()+"', "+name);

            EntityRow entity = this.getWorkspaceEntityByName(name);

            if (entity != null) {

                return ERR_ENTITY_ALREADY_EXISTS;

            }

            FeatureType ft = source.getDefaultFeatureTypeQuietly();

            errcode = this.addEntity(ft, name, null, fieldForLabel, pkName);

            if (errcode != ERR_NO_ERROR) {

                return errcode;

            }

            errcode = ERR_CANT_OPEN_STORE;

            target = this.getFeatureStore(name);

            errcode = ERR_CANT_RETRIEVE_SOURCE_FEATURES;

            features = source.getFeatureSet().iterable();

            errcode = ERR_CANT_INSERT_FEATURES;

            target.edit(FeatureStore.MODE_APPEND);

            for (Feature feature : features) {

                EditableFeature f = target.createNewFeature(feature);

                target.insert(f);

            }

            target.finishEditing();

            return ERR_NO_ERROR;

        } catch (Exception ex) {

            LOGGER.warn("Can't add features to '" + name + "' in '" + this.getMessageLabel() + "'.", ex);

            return errcode;

        } finally {

            DisposeUtils.disposeQuietly(features);

            DisposeUtils.disposeQuietly(target);

        }

    }

    @Override

    public VCSGisWorkspaceChanges<VCSGisWorkspaceChange> getLocalChanges() {

        WorkspaceChangesTable changesTable = new WorkspaceChangesTable();

        ChangesImpl changes = new ChangesImpl<WorkspaceChangeRow>(changesTable.getByEntityCode(this,null), WorkspaceChangesTable.SELECTED) {

            @Override

            protected WorkspaceChangeRow createChange(Feature f) {

                return new WorkspaceChangeRow(VCSGisWorkspaceImpl.this, f);

            }

            @Override

            protected void updateChange(FeatureStore store, WorkspaceChangeRow change) {

                change.update(store);

            }            

        };

        return changes;

    }

    @Override

    public VCSGisWorkspaceChanges<VCSGisWorkspaceChange> getLocalChangesByEntityName(String entityName) {

        EntityRow entity = this.getWorkspaceEntityByName(entityName);

        return getLocalChangesByEntityCode(entity.getEntityCode());

    }

    @Override

    public VCSGisWorkspaceChanges<VCSGisWorkspaceChange> getLocalChangesByEntityCode(String entityCode) {

        WorkspaceChangesTable changesTable = new WorkspaceChangesTable();

        ChangesImpl changes = new ChangesImpl<WorkspaceChangeRow>(changesTable.getByEntityCode(this,entityCode),WorkspaceChangesTable.SELECTED) {

            @Override

            protected WorkspaceChangeRow createChange(Feature f) {

                return new WorkspaceChangeRow(VCSGisWorkspaceImpl.this, f);

            }

            @Override

            protected void updateChange(FeatureStore store, WorkspaceChangeRow change) {

                change.update(store);

            }

        };

        return changes;

    }

    @Override

    public VCSGisRepository getRepository() {

        return repository;

    }

    @Override

    public List<VCSGisEntity> getEntitiesOfRemoteChanges() {

        ArrayList<VCSGisEntity> res = new ArrayList<>();

        RemoteChangesTable changesTable = new RemoteChangesTable();

        DisposableFeatureSetIterable features = changesTable.getGroupedByEntity(this);

        EntitiesRepoTable entitiesRepoTable = new EntitiesRepoTable();

        for (Feature feature : features) {

            VCSGisEntity entity = entitiesRepoTable.getByEntityCode((VCSGisRepositoryLocaldb) this.getRepository(), feature.getString(RemoteChangesTable.COD_ENTITY));

            res.add(entity);

        }

        DisposeUtils.disposeQuietly(features);

        return res;

    }

    @Override

    public VCSGisWorkspaceChanges<VCSGisRepositoryChange> getRemoteChanges() {

        return getRemoteChangesByEntity(null);

    }

    @Override

    public VCSGisWorkspaceChanges<VCSGisRepositoryChange> getRemoteChangesByEntity(String entityName) {

        String entityCode;

        if(StringUtils.isBlank(entityName)){

            entityCode = null;

        } else {

            VCSGisEntity entity = this.getWorkspaceEntity(entityName);

            if(entity == null){

                entity = this.getRepositoryEntity(entityName);

                if(entity == null){

                    return null;

                }

            }

            entityCode = entity.getEntityCode();

        }

        RemoteChangesTable changesTable = new RemoteChangesTable();

        ChangesImpl changes = new ChangesImpl<RemoteChangeRow>(changesTable.getByEntityCode(this,entityCode),RemoteChangesTable.SELECTED) {

            @Override

            protected RemoteChangeRow createChange(Feature f) {

                return new RemoteChangeRow(VCSGisWorkspaceImpl.this, f);

            }

            @Override

            protected void updateChange(FeatureStore store, RemoteChangeRow change) {

                change.update(store);

            }

        };

        return changes;

    }

    private Timestamp now() {

        return Timestamp.from(LocalDateTime.now().toInstant(ZoneOffset.UTC));

    }

    public boolean prepareCommitRequest(VCSGisCommitRequest request, Timestamp efectivedate, String comment, SimpleTaskStatus status) {

        if( status==null ) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Prepare commit request");

            status.setAutoremove(true);

            status.add();

        }

        request.setEfectiveDate(efectivedate);

        request.setComment(comment);

        WorkspaceChangesTable changesTable = new WorkspaceChangesTable();

        LOGGER.debug("===: COMMIT: Adding changed local entities");

        status.message("Searching changed entities");

        // adicionamos las entidades que vamos a actualizar con las revisiones que tenemos.

        DisposableFeatureSetIterable changesGroupedByEntity = changesTable.getGroupedByEntity(this);

        for (Feature fchange : changesGroupedByEntity) {

            WorkspaceChangeRow change = new WorkspaceChangeRow(this, fchange);

            VCSGisEntity localEntity = change.getEntity();

            LOGGER.debug("===: COMMIT: add used entity = "+fchange.toJson().toString().replace('\n', ' '));

            request.add(request.createEntity(localEntity));

        }

        changesGroupedByEntity.dispose();

        LOGGER.debug("===: COMMIT: Mark new local entities");

        status.message("Searching new entities");

        // Marcamos como nuevas las entidades que se han dado de alta.

        DisposableFeatureSetIterable changesOfAddEntities = changesTable.getByOperation(this, OP_ADD_ENTITY);

        for (Feature fchange : changesOfAddEntities) {

            WorkspaceChangeRow change = new WorkspaceChangeRow(this, fchange);

            request.markAsNew(change.getEntity());

        }

        changesOfAddEntities.dispose();

        LOGGER.debug("===: COMMIT: Adding data");

        status.message("Searching changed data");

        // adicionamos los datos

        boolean useSeleccion = true;

        DisposableFeatureSetIterable changes = changesTable.getSelectedsWithoutAddEntity(this);

        if (changes == null) {

            changes = changesTable.getAll(this);

            useSeleccion = false;

        }

        request.add(new DisposableIterableAdapter(

                changes, 

                new DisposableIterableAdapter.ItemConverter<Feature, VCSGisChange>() {

                    @Override

                    public VCSGisChange convert(Feature f) {

                        return new WorkspaceChangeRow(VCSGisWorkspaceImpl.this, f);

                    }

                }

            )

        );

        return useSeleccion;

    }

    @Override

    public int commit() {

        return commit(now(),null, null);

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public int commit(Timestamp efectivedate, String comment, SimpleTaskStatus status) {

        VCSGisCommitRequest request = null;

        if( status==null ) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Commit");

            status.setAutoremove(true);

            status.add();

        }

        try {

            LOGGER.debug("===: COMMIT "+this.getCode()+", "+this.getLabel());

            EntitiesTable entitiesTable = new EntitiesTable();

            WorkspaceChangesTable changesTable = new WorkspaceChangesTable();

            status.message("Preparing commit");

            reloadRepositoryEntities(status);

            request = this.repository.createCommitRequest();

            boolean useSeleccion = this.prepareCommitRequest(request, efectivedate, comment, status);

            LOGGER.debug("===: COMMIT: Do execute request");

            status.message("Executing commit request");

            if( request.execute()!=ERR_NO_ERROR ) {

                status.message("Can't commit changes (error "+request.getLastErrorCode()+")");

                status.abort();

                return request.getLastErrorCode();

            }

            LOGGER.debug("===: COMMIT: update local entities table");

            status.message("Updating local metadata");

            FeatureStore store = null;

            try {

                store = this.getFeatureStore(EntitiesTable.TABLE_NAME);

                store.edit(FeatureStore.MODE_FULLEDIT);

                for (VCSGisEntity rentity : request.getChangedLocalEntities()) {

                    EntityRow entityRow = entitiesTable.getByEntityName(this, rentity.getEntityName());

                    if (entityRow != null) {

                        entityRow.copyfrom(rentity);

                        entityRow.setLocalRevisionCode(rentity.getRepositoryRevisionCode());

                        entityRow.update(store);

                    }

                }

                store.finishEditing();

                reloadWorkspaceEntities();

            } finally {

                DisposeUtils.disposeQuietly(store);

                store = null;

            }

            LOGGER.debug("===: COMMIT: clean local changes");

            status.message("Removing local list of changes");

            if (useSeleccion) {

                changesTable.deleteSelecteds(this);

            } else {

                changesTable.deleteAll(this);

            }

            status.message("Commit completed");

            status.terminate();

            return ERR_NO_ERROR;

        } catch (Exception ex) {

            LOGGER.warn("Can't commit changes.", ex);

            status.message("Can't commit changes");

            status.abort();

            return ERR_CANT_COMMIT;

        } finally {

            DisposeUtils.disposeQuietly(request);

        }

    }

    @Override

    public int checkout(String tableName) {

        return checkout(tableName, null);

    }

    @Override

    public int checkout(String tableName, SimpleTaskStatus status) {

        FeatureStore target = null;

        int errcode = ERR_OK;

        VCSGisCheckoutRequest request = null;

        if( status==null ) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Checkout");

            status.setAutoremove(true);

            status.add();

        }

        try {

            LOGGER.debug("===: CHECKOUT "+this.getCode()+", '"+this.getLabel()+"', "+tableName);

            status.message("Preparing checkout");

            EntityRow lentity = this.getWorkspaceEntityByName(tableName);

            if(lentity != null){

                status.message("Table "+tableName+" already exists");

                status.abort();

                return ERR_ENTITY_ALREADY_EXISTS;

            }

            reloadRepositoryEntities(status);

            request = this.repository.createCheckoutRequest(tableName);

            request.setEfectiveDate((Timestamp)null);

            request.setRevisionCode(null);

            status.message("Executing checkout request for "+tableName);

            if( request.execute()!=ERR_OK ) {

                status.message("Can't checkout "+tableName+" (error "+request.getLastErrorCode()+")");

                status.abort();

                return request.getLastErrorCode();

            }

            status.message("Updating "+tableName+" metadata");

            VCSGisEntity rentity = request.getEntity();            

            lentity = new EntityRow(this);

            rentity.copyto(lentity);

            lentity.insert();

            LOGGER.debug("===: CHECKOUT "+this.getCode()+", '"+this.getLabel()+"', "+tableName+", rev."+rentity.getRepositoryRevisionCode());

            this.reloadWorkspaceEntities();

            status.message("Creating table "+tableName);

            this.create_table(lentity);

            status.message("Adding features in "+tableName);

            errcode = ERR_CANT_OPEN_STORE;

            target = this.getFeatureStore(tableName);

            this.addStoreIgnoreChanges(target);

            DisposableIterable<VCSGisRepositoryData> data = request.getData();

            long sz = ContainerUtils.size64(data);

            status.setRangeOfValues(0, sz);

            status.setCurValue(0);

            errcode = ERR_CANT_INSERT_FEATURES;

            target.edit(FeatureStore.MODE_APPEND);

            for (VCSGisRepositoryData d : data) {

                EditableFeature f = target.createNewFeature(d.getDataAsJson());

                target.insert(f);

                status.incrementCurrentValue();

            }

            target.finishEditing();

            status.message("Updating "+tableName+" metadata");

            lentity.setLocalRevisionCode(rentity.getRepositoryRevisionCode());

            lentity.update();

            this.reloadWorkspaceEntities();

            request.dispose();

            status.message("Checkout completed");

            status.terminate();

            return ERR_NO_ERROR;

        } catch (Exception ex) {

            LOGGER.warn("Can't checkout.", ex);

            status.message("Can't checkout");

            status.abort();

            return errcode;

        } finally {

            DisposeUtils.disposeQuietly(request);

            if(target != null) {

                this.removeStoreIgnoreChanges(target);

            }

            DisposeUtils.disposeQuietly(target);

        }

    }

    @Override

    public int updateEntities() {

        return this.updateEntities(null);

    }

    @Override

    public int updateEntities(SimpleTaskStatus status) {

        LOGGER.debug("===: UPDATE_ENTITIES "+this.getCode()+", '"+this.getLabel()+"'");

        FeatureStore store = null;

        EntitiesTable entitiesTable = new EntitiesTable();

        if( status==null ) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Update metadata tables");

            status.setAutoremove(true);

            status.add();

        }

        try {

            status.message("Preparing update metadata tables");

            store = this.getFeatureStore(EntitiesTable.TABLE_NAME);

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            for (VCSGisEntity rentity : this.getRepositoryEntities(status)) {

                EntityRow entityRow = entitiesTable.getByEntityName(this, rentity.getEntityName());

                if (entityRow != null) {

                    rentity.copyto(entityRow);

                    entityRow.update(store);

                }

            }

            reloadWorkspaceEntities();

            store.finishEditingQuietly();

            status.message("Update metadata tables completed");

            status.terminate();

            return ERR_OK;

        } catch (Exception ex) {

            LOGGER.warn("Can't update metadata tables.", ex);

            status.message("Can't update metadata tables");

            status.abort();

            return ERR_CANT_UPDATE_ENTITIES;

        } finally {

            DisposeUtils.disposeQuietly(store);

            store = null;

        }

    }

    @Override

    public int updatePrepare(String tableName) {

        return updatePrepare(tableName, null);

    }

    @Override

    public int updatePrepare(String tableName, SimpleTaskStatus status) {

        LOGGER.debug("===: UPDATE_PREPARE: "+tableName+" WS "+this.getCode()+", '"+this.getLabel()+"'");

        if( status==null ) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Update-prepare "+tableName);

            status.setAutoremove(true);

            status.add();

        }

        FeatureStore target = null;

        VCSGisUpdateRequest request = null;

        DisposableIterable<VCSGisRepositoryData> remoteChanges = null;

        WorkspaceChangesTable changesTable = new WorkspaceChangesTable();

        try {

            status.message("Preparing update-prepare");

            reloadRepositoryEntities(status);

            request = this.repository.createUpdateRequest(tableName);

            EntityRow lentity = this.getWorkspaceEntityByName(tableName);

            if(lentity != null){

                request.setLocalRevisionCode(lentity.getLocalRevisionCode());

            }

            status.message("Executing update-prepare request");

            if( request.execute()!=ERR_OK ) {

                status.message("Can't update-prepare "+tableName+" (error "+request.getLastErrorCode()+")");

                status.abort();

                return request.getLastErrorCode();

            }

            status.message("Updating "+tableName+" metadata");

            LOGGER.debug("===: UPDATE_PREPARE: "+tableName+" request code "+request.getCode());

            VCSGisEntity rentity = request.getEntity();

            if(lentity == null){

                lentity = new EntityRow(this);

                lentity.copyfrom(rentity);

                lentity.setLocalRevisionCode(null);

            } else {

                lentity.copyfrom(rentity);

                lentity.update();

            }

            this.reloadWorkspaceEntities();

            String entityCode = lentity.getCode();

            LOGGER.debug("===: UPDATE_PREPARE: "+tableName+" entity code "+entityCode+", repo rev. "+lentity.getRepositoryRevisionCode()+", local rev. "+lentity.getLocalRevisionCode());            

            status.message("Preparing remote changes container");

            target = this.getFeatureStore(RemoteChangesTable.TABLE_NAME);

            target.edit(MODE_PASS_THROUGH);

            status.message("Deleting previous temporary remote changes");

            LOGGER.debug("===: UPDATE_PREPARE: Delete updates table");

            target.delete("\""+COD_ENTITY+"\"='"+entityCode+"'");

            remoteChanges = request.getData();

            long sz = ContainerUtils.size64(remoteChanges);

            status.setRangeOfValues(0, sz);

            status.setCurValue(0);

            LOGGER.debug("===: UPDATE_PREPARE: Inserting updates");

            for (VCSGisRepositoryData remoteChange : remoteChanges) {

                RemoteChangeRow remoteChangeRow = new RemoteChangeRow(this);

                LOGGER.debug("===: UPDATE_PREPARE: insert "+remoteChange.getFeatureRelatedCode()+", "+remoteChange.getOperation()+", "+remoteChange.getData());

                remoteChangeRow.setCode(remoteChange.getFeatureRelatedCode());

                remoteChangeRow.setData(remoteChange.getData());

                remoteChangeRow.setEntityCode(remoteChange.getEntityCode());

                remoteChangeRow.setDataCode(remoteChange.getFeatureRelatedCode());

                remoteChangeRow.setOperation(remoteChange.getOperation());

                remoteChangeRow.setRevisionCode(remoteChange.getRevisionCode());

                remoteChangeRow.setRevisionNumber(remoteChange.getRevisionNumber());

                LOGGER.debug("===: UPDATE_PREPARE: row code = "+remoteChangeRow.getRelatedFeatureCode());

                LOGGER.debug("===: UPDATE_PREPARE: row state = "+lentity.getState()+", "+lentity.getStateLabel());

                LOGGER.debug("===: UPDATE_PREPARE: row operation = "+remoteChangeRow.getOperation()+", "+remoteChangeRow.getOperationLabel());

                switch (lentity.getState()) {

                    case STATE_OUTDATED:

                    case STATE_UNMODIFIED: 

                        remoteChangeRow.setSelected(true);

                        break;

                    case STATE_NEW:

                    case STATE_OUTDATED_AND_MODIFIED:

                    case STATE_MODIFIED: 

                        WorkspaceChangeRow change = changesTable.getByEntityAndDataCode(this,

                                entityCode,

                                remoteChangeRow.getRelatedFeatureCode()