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 java.util.UUID;

import org.apache.commons.lang3.StringUtils;

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.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.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposableIterable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.logger.FilteredLogger;

import org.gvsig.tools.util.HasAFile;

import org.gvsig.vcsgis.lib.VCSGisRuntimeException;

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

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

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

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

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

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 org.gvsig.vcsgis.lib.workspace.tables.RemoteChangesTable.RemoteChangeRow;

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

import org.gvsig.vcsgis.lib.DisposableIterableAdapter;

import org.gvsig.vcsgis.lib.VCSGisChange;

import org.gvsig.vcsgis.lib.VCSGisUtils;

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

import org.gvsig.vcsgis.lib.VCSGisEntity;

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 org.gvsig.vcsgis.lib.workspace.VCSGisWorkspace;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceEntity;

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

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

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

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

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

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceChange;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceChanges;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceRevision;

/**

 *

 * @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> entitiesByName;

    private Map<String, EntityRow> entitiesByCode;

    private Set<FeatureStore> storeIgnoreChanges;

    private JDBCServerExplorer wsexplorer;

    private String code;

    private final VCSGisRepository repository;

    private final String label;

    private final FilteredLogger logger;

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

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

        this.logger.setInterval(10000);

        this.storesCache = new HashMap<>();

        this.code = createUniqueID();

        this.wsexplorer = wsexplorer;

        this.repository = repository;

        this.label = label;

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

    }

    public VCSGisWorkspaceImpl(JDBCServerExplorer wsexplorer) {

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

        this.logger.setInterval(10000);

        this.storesCache = new HashMap<>();

        this.wsexplorer = wsexplorer;

        this.loadEntities();

        VarsTable varsTable = new VarsTable();

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

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

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

        if (this.repository == null) {

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

        }

//        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.entitiesByName = theEntitiesByName;

            this.entitiesByCode = 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.entitiesByName == null) {

            loadEntities();

        }

        return this.entitiesByName.values();

    }

    @Override

    public EntityRow getWorkspaceEntityByName(String name) {

        if (this.entitiesByName == null) {

            this.loadEntities();

        }

        return this.entitiesByName.get(name);

    }

    @Override

    public EntityRow getWorkspaceEntityByCode(String code) {

        if (this.entitiesByCode == null) {

            this.loadEntities();

        }

        return this.entitiesByCode.get(code);

    }

    public void reloadEntities() {

        this.entitiesByCode = null;

        this.entitiesByName = 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 + "'.");

        }

        try {

            DataManager dataManager = DALLocator.getDataManager();

            JDBCNewStoreParameters addparams = (JDBCNewStoreParameters) this.wsexplorer.getAddParameters(name);

            addparams.setDefaultFeatureType(entity.getFeatureType());

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

        } catch (Exception ex) {

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

        }

    }

    @Override

    public FeatureStore getFeatureStore(String tableName) {

        EntityRow entity = null;

        if( !INTERNAL_TABLES.contains(tableName) ) {

            entity = this.getWorkspaceEntityByName(tableName);

            if (entity == null) {

                return null;

            }

        }

        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

            );

            if( entity!=null ) {

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

            }

            this.storesCache.put(tableName, store);

            DisposeUtils.bind(store);

            return store;

        } catch (Exception ex) {

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

            LOGGER.warn(msg, ex);

            throw new RuntimeException(msg, ex);

        }

    }

    @Override

    public String createUniqueFeatureCode() {

        UUID x = UUID.randomUUID();

        String s = x.toString().replace("-", "");

        return s;

    }

    private String createUniqueID() {

        UUID x = UUID.randomUUID();

        String s = x.toString().replace("-", "");

        return s;

    }

    @Override

    public String getErrorMessage(int errcode) {

        return VCSGisUtils.getErrorMessage(errcode);

    }

    @Override

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

        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);

        WorkspaceChangeRow change = new WorkspaceChangeRow(this);

        change.setEntityCode(entity.getCode());

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

        change.setOperation(operation);

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

        change.setSelected(true);

        change.insert();

        return ERR_NO_ERROR;

    }

    @Override

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

        FeatureStore store = null;

        int err = ERR_NO_ERROR;

        try {

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

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

                err = ERR_ENTITY_NOT_HAS_VCSGISCODE;

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

                ft.add(FEATURECODE_FIELD_NAME, DataTypes.STRING)

                        .setSize(40)

                        .setIsIndexed(true)

                        .setAllowIndexDuplicateds(false)

                        .setLabel("VCSGIS Code");

                ft.setHasOID(false);

                featureType = ft.getNotEditableCopy();

            }

            if(!featureType.hasPrimaryKey()){

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

                ft.getEditableAttributeDescriptor(FEATURECODE_FIELD_NAME).setIsPrimaryKey(true);

                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.insert();

            this.reloadEntities();

            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(name);

        } 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) {

        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);

            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<VCSGisWorkspaceEntity> getEntitiesOfRemoteChanges() {

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

        RemoteChangesTable changesTable = new RemoteChangesTable();

        DisposableFeatureSetIterable features = changesTable.getGroupedByEntity(this);

        EntitiesTable entitiesTable = new EntitiesTable();

        for (Feature feature : features) {

            EntityRow entity = entitiesTable.getByEntityCode(this, feature.getString(RemoteChangesTable.COD_ENTITY));

            res.add(entity);

        }

        DisposeUtils.disposeQuietly(features);

        return res;

    }

    @Override

    public VCSGisWorkspaceChanges<VCSGisRepositoryChange> getRemoteChanges() {

        RemoteChangesTable changesTable = new RemoteChangesTable();

        ChangesImpl changes = new ChangesImpl<RemoteChangeRow>(changesTable.getByEntityCode(this,null),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));

    }

    @Override

    public int commit() {

        return commit(now(),null);

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public int commit(Timestamp efectivedate, String comment) {

        VCSGisCommitRequest request = null;

        try {

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

            request = this.repository.createCommitRequest();

            request.setEfectiveDate(efectivedate);

            request.setComment(comment);

            WorkspaceChangesTable changesTable = new WorkspaceChangesTable();

            EntitiesTable entitiesTable = new EntitiesTable();

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

            // A?adimos 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);

                EntityRow 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");

            // 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");

            // A?adimos 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);

                        }

                    }

                )

            );

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

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

                return request.getLastErrorCode();

            }

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

            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();

                reloadEntities();

            } finally {

                DisposeUtils.disposeQuietly(store);

                store = null;

            }

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

            if (useSeleccion) {

                changesTable.deleteSelecteds(this);

            } else {

                changesTable.deleteAll(this);

            }

            return ERR_NO_ERROR;

        } catch (Exception ex) {

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

            return ERR_CANT_COMMIT;

        } finally {

            DisposeUtils.disposeQuietly(request);

        }

    }

    @Override

    public int checkout(String tableName) {

        FeatureStore target = null;

        int errcode = ERR_NO_ERROR;

        VCSGisCheckoutRequest request = null;

        try {

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

            request = this.repository.createCheckoutRequest(tableName);

            request.setEfectiveDate(null);

            request.setRepositoryRevisionCode(null);

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

                return request.getLastErrorCode();

            }

            VCSGisEntity rentity = request.getRepositoryEntity();            

            EntityRow lentity = this.getWorkspaceEntityByName(tableName);

            if (lentity == null) {

                lentity = new EntityRow(this);

                rentity.copyto(lentity);

                lentity.insert();

            } else {

                rentity.copyto(lentity);

                lentity.update();

            }

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

            this.reloadEntities();

            this.create_table(lentity.getEntityName());

            errcode = ERR_CANT_OPEN_STORE;

            target = this.getFeatureStore(tableName);

            this.addStoreIgnoreChanges(target);

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

            errcode = ERR_CANT_INSERT_FEATURES;

            target.edit(FeatureStore.MODE_APPEND);

            for (VCSGisRepositoryData d : data) {

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

                target.insert(f);

            }

            target.finishEditing();

            request.dispose();

            return ERR_NO_ERROR;

        } catch (Exception ex) {

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

            return errcode;

        } finally {

            DisposeUtils.disposeQuietly(request);

            if(target != null) {

                this.removeStoreIgnoreChanges(target);

            }

            DisposeUtils.disposeQuietly(target);

        }

    }

    @Override

    public int updateEntities() {

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

        FeatureStore store = null;

        EntitiesTable entitiesTable = new EntitiesTable();

        try {

            store = this.getFeatureStore(EntitiesTable.TABLE_NAME);

            store.edit(FeatureStore.MODE_FULLEDIT);

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

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

                if (entityRow != null) {

                    rentity.copyto(entityRow);

                    entityRow.update(store);

                }

            }

            reloadEntities();

            store.finishEditingQuietly();

            return ERR_NO_ERROR;

        } catch (Exception ex) {

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

            return ERR_CANT_UPDATE_ENTITIES;

        } finally {

            DisposeUtils.disposeQuietly(store);

            store = null;

        }

    }

    @Override

    public int updatePrepare(String tableName) {

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

        FeatureStore target = null;

        VCSGisUpdateRequest request = null;

        DisposableIterable<VCSGisRepositoryData> updates = null;

        RemoteChangesTable updatesTable = new RemoteChangesTable();

        try {

            EntityRow lentity = this.getWorkspaceEntityByName(tableName);

            if(lentity == null){

                updateEntities();

                lentity = this.getWorkspaceEntityByName(tableName);

                if(lentity == null){

                    return ERR_ENTITY_NOT_EXISTS;

                }

            }

            request = this.repository.createUpdateRequest(lentity);

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

                return request.getLastErrorCode();

            }

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

            VCSGisEntity rentity = request.getRepositoryEntity();

            lentity.copyfrom(rentity);

            lentity.update();

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

            this.reloadEntities();

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

            updatesTable.delete(this, lentity.getCode());

            WorkspaceChangesTable changesTable = new WorkspaceChangesTable();

            String entityCode = lentity.getCode();

            updates = request.getRepositoryData();

            target = this.getFeatureStore(RemoteChangesTable.TABLE_NAME);

            target.edit(MODE_PASS_THROUGH);

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

            for (VCSGisRepositoryData update : updates) {

                RemoteChangeRow updateRow = new RemoteChangeRow(this);

                LOGGER.debug("===: UPDATE_PREPARE: insert "+update.getCode()+", "+update.getOperation()+", "+update.getData());

                updateRow.setCode(update.getCode());

                updateRow.setData(update.getData());

                updateRow.setEntityCode(update.getEntityCode());

                updateRow.setDataCode(update.getDataCode());

                updateRow.setOperation(update.getOperation());

                updateRow.setRevisionCode(update.getRevisionCode());

                updateRow.setRevisionNumber(update.getRevisionNumber());

                LOGGER.debug("===: UPDATE_PREPARE: row code = "+updateRow.getDataCode());

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

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

                switch (lentity.getState()) {

                    case STATE_OUTDATED:

                    case STATE_UNMODIFIED: 

                        updateRow.setSelected(true);

                        break;

                    case STATE_NEW:

                    case STATE_OUTDATED_AND_MODIFIED:

                    case STATE_MODIFIED: 

                        WorkspaceChangeRow change = changesTable.getByEntityAndDataCode(

                                this,

                                entityCode,

                                updateRow.getDataCode()

                        );

                        if( change==null ) {

                            LOGGER.debug("===: UPDATE_PREPARE: no local modificacion, update local data");

                            // Solo actualizamos si no ha sido modificado localmente.

                            updateRow.setSelected(true);

                        } else {

                            LOGGER.debug("===: UPDATE_PREPARE: not update. Local data is modified. "+change.getData().replace('\n', ' '));

                            updateRow.setSelected(false);

                        }

                        break;

                }

                updateRow.insert(target);

            }

            LOGGER.debug("===: UPDATE_PREPARE: finish inserting updates");

            target.finishEditing();

            return ERR_NO_ERROR;

        } catch (Exception ex) {

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

            if( target!=null ) {

                target.cancelEditingQuietly();

            }

            return ERR_CANT_PREPARE_UPDATE;

        } finally {

            DisposeUtils.disposeQuietly(updates);

            DisposeUtils.disposeQuietly(request);

            DisposeUtils.disposeQuietly(target);

        }

    }

    @Override

    public int updateClean(String tableName) {

        RemoteChangesTable remoteChangesTable = new RemoteChangesTable();

        remoteChangesTable.deleteAll(this);

        return ERR_NO_ERROR;

    }

    @Override

    public int update(String tableName) {

        return this.update(tableName, true);

    }

    @Override

    public int update(String tableName, boolean prepare) {

        int errcode = ERR_NO_ERROR;

        if( prepare ) {

            errcode = this.updatePrepare(tableName);

            if (errcode != ERR_NO_ERROR) {

                return errcode;

            }

        }

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

        RemoteChangesTable updatesTable = new RemoteChangesTable();

        EditableFeature ef;

        FeatureStore target = null;

        DisposableFeatureSetIterable features = null;

        try {

            EntityRow lentity = this.getWorkspaceEntityByName(tableName);

            String dataCodeFieldName = lentity.getFeatureIdFieldName();

            try {

                target = this.getFeatureStore(tableName);

            } catch (Exception e){

                LOGGER.warn("Can't get feature store from '"+tableName+"'", e);

            }

            if(target == null) {

                this.create_table(lentity.getEntityName());

                target = this.getFeatureStore(tableName);

            }

            features = updatesTable.getSelectedsByEntityCodeAsIterator(this,lentity.getCode());

            if(!features.isEmpty()){

                target.edit(MODE_PASS_THROUGH);

                this.addStoreIgnoreChanges(target);

                for (Feature feature : features) {

                    RemoteChangeRow updateRow = new RemoteChangeRow(this, feature);

                    switch (updateRow.getOperation()) {

                        case OP_INSERT:

                            LOGGER.debug("===: UPDATE: insert");

                            ef = target.createNewFeature(updateRow.getDataAsJson());

                            target.insert(ef);

                            break;

                        case OP_UPDATE:

                            LOGGER.debug("===: UPDATE: update");                            

                            ef = target.createNewFeature(updateRow.getDataAsJson());

                            ef.setUpdatable(true);

                            target.update(ef);

                            break;

                        case OP_DELETE:

                            LOGGER.debug("===: UPDATE: delete");

                            target.delete("\"" + dataCodeFieldName + "\"='" + updateRow.getDataCode() + "'");

                            break;

                    }

                }

                target.finishEditing();

            }

            lentity.setLocalRevisionCode(lentity.getRepositoryRevisionCode());

            lentity.update();

            return ERR_NO_ERROR;

        } catch (Exception ex) {

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

            if(target != null){

                target.cancelEditingQuietly();

            }

            return ERR_CANT_UPDATE;

        } finally {

            this.removeStoreIgnoreChanges(target);

            DisposeUtils.disposeQuietly(features);

            DisposeUtils.disposeQuietly(target);

        }

    }

    @Override

    public JDBCServerExplorer getExplorer() {

        return this.wsexplorer;

    }

    @Override

    public int log(String tableName) {

        FeatureStore target = null;

        int errcode = ERR_NO_ERROR;

        VCSGisLogRequest request = null;

        try {

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

            EntityRow entity = this.getWorkspaceEntityByName(tableName);

            request = this.repository.createLogRequest(tableName);

            //TODO: BORRAR LOS REGISTROS DE LOCAL REVISIONS TABLE de la entidad TABLE_NAME/entity.getCode

            errcode = ERR_CANT_OPEN_STORE;

            target = this.getFeatureStore(LocalRevisionsTable.TABLE_NAME);

            errcode = ERR_CANT_RETRIEVE_SOURCE_FEATURES;

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

            errcode = ERR_CANT_INSERT_FEATURES;

            target.edit(FeatureStore.MODE_APPEND);

            for (VCSGisRepositoryRevision d : data) {

                EditableFeature f = target.createNewFeature();

                LocalRevisionRow row = new LocalRevisionRow(this, f);

                row.setUserCode(d.getUserCode());

                //TODO: ...

                row.insert(target);

            }

            target.finishEditing();

            return ERR_NO_ERROR;

        } catch (Exception ex) {

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

            return errcode;

        } finally {

            DisposeUtils.disposeQuietly(request);

            if(target != null) {

                this.removeStoreIgnoreChanges(target);

            }

            DisposeUtils.disposeQuietly(target);

        }

    }

    @Override

    public List<VCSGisWorkspaceRevision> getRemoteRevisions(String tableName) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public List<VCSGisEntity> getRepositoryEntities() {

        VCSGisEntitiesRequest request = this.getRepository().createEntitiesRequest();

        request.execute();

        List<VCSGisEntity> entities = request.getRepositoryEntities();

        request.dispose();

        return entities;

    }

}