gvSIG projects pool

package org.gvsig.vcsgis.lib.workspace.tables;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.Iterator;

import java.util.List;

import javax.json.JsonObject;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.exception.DataException;

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.FeatureQuery;

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

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.json.Json;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposableIterable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.util.GetItemWithSize64;

import org.gvsig.tools.util.GetItemWithSizeAndIterator64;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.VCSGisManager;

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

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

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

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

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

import org.gvsig.vcsgis.lib.VCSGisRuntimeException;

import org.gvsig.vcsgis.lib.VCSGisUtils;

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

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

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

import org.gvsig.vcsgis.lib.workspace.tables.AbstractTable.AbstractRow;

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

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class WorkspaceChangesTable extends AbstractTable {

    public static final String TABLE_NAME = "VCSGIS_WSCHANGES";

    public static final String COD_CHANGE = "COD_WSCHANGE";

    public static final String COD_ENTITY = "COD_ENTITY";

    public static final String SELECTED = "WSCH_SELECTED";

    public static final String FEATUREID = "WSCH_FEATURECODE";

    public static final String OPERATION = "WSCH_OPERATION";

    public static final String STATUS = "WSCH_STATUS";

    private static final String FEATURE_DATA = "WSCH_DATA";

    private static final String LABEL = "WSCH_LABEL";

    private static final int MAX_SIZE_LABEL = 40;

    @SuppressWarnings("UseSpecificCatch")

    public static class WorkspaceChangeRow extends AbstractRow implements VCSGisWorkspaceChange {

        protected VCSGisWorkspaceEntity entity;

        public WorkspaceChangeRow(VCSGisWorkspace workspace) {

            this(workspace, null);

            setStatus(STATE_LOCAL_UNMODIFIED);

        }

        public WorkspaceChangeRow(VCSGisWorkspace workspace, Feature feature) {

            super(workspace, TABLE_NAME, COD_CHANGE, feature);

        }

        @Override

        public String getEntityCode() {

            return this.getString(COD_ENTITY);

        }

        @Override

        public String getRelatedFeatureCode() {

            return this.getString(FEATUREID);

        }

        @Override

        public int getOperation() {

            return this.getInt(OPERATION);

        }

        @Override

        public String getOperationLabel() {

            return this.getLabelOfValue(OPERATION);

        }

        @Override

        public String getLabel() {

            return this.getString(LABEL);

        }

        @Override

        public boolean isSelected() {

            return this.getBoolean(SELECTED);

        }

        public void setEntityCode(String code) {

            this.set(COD_ENTITY, code);

        }

        public void setFeatureCode(String code) {

            this.set(FEATUREID, code);

        }

        public void setOperation(int op) {

            this.set(OPERATION, op);

        }

        public void setStatus(int status) {

            this.set(STATUS, status);

        }

        @Override

        public void setSelected(boolean selected) {

            this.set(SELECTED, selected);

        }

        public void setLabel(String label) {

            this.set(LABEL, StringUtils.abbreviate(label, MAX_SIZE_LABEL));

        }

        @Override

        public String getRelatedFeatureData() {

            String entityName = "unknown";

            String code = "unknown";

            try {

                entityName = this.getEntity().getEntityName();

                code = this.getRelatedFeatureCode();

                FeatureStore store = workspace.getFeatureStore(entityName);

                Feature f = store.findFirst("\""+this.getEntity().getFeatureIdFieldName()+"\"='"+code+"'");

                if( f==null ) {

                    return ""; //null;

//                    throw new RuntimeException("Feature '"+entityName+"/"+code+"'not found.");

                }

                return f.toJson().toString();

            } catch (Exception ex) {

                throw new RuntimeException("Can't retrieve feature '"+entityName+"/"+code+"'.",ex);

            }

        }    

        @Override

        public JsonObject getRelatedFeatureDataAsJson() {

            String s = this.getRelatedFeatureData();

            return Json.createObject(s);

        }

        @Override

        public String toString() {

            switch (this.getOperation()) {

                case OP_ADD_ENTITY:

                    return "{ OP:'ADD_ENTITY', ENTITYCODE:'"+this.getEntityCode()+"', }";

                case OP_INSERT:

                    return "{ OP:'INSERT', ENTITYCODE:'"+this.getEntityCode()+"', FEATURECODE:'"+this.getRelatedFeatureCode()+"', DATA:'"+this.getRelatedFeatureData()+"' }";

                case OP_UPDATE:

                    return "{ OP:'UPDATE', ENTITYCODE:'"+this.getEntityCode()+"', FEATURECODE:'"+this.getRelatedFeatureCode()+"', DATA:'"+this.getRelatedFeatureData()+"' }";

                case OP_DELETE:

                    return "{ OP:'DELETE', ENTITYCODE:'"+this.getEntityCode()+"', FEATURECODE:'"+this.getRelatedFeatureCode()+"' }";

                default:

                    return "{ OP:'"+this.getOperation()+"', ENTITYCODE:'"+this.getEntityCode()+"', FEATURECODE:'"+this.getRelatedFeatureCode()+"' }";

            }

        }

        @Override

        public Feature getRelatedFeature() {

            Feature f = this.workspace.getRelatedFeature(this.getEntity(), this.getRelatedFeatureCode());

            if (f == null) {

                throw new RuntimeException("Feature '" + this.getEntity().getEntityName() + "/" + this.getRelatedFeatureCode() + "'not found.");

            }

            return f;

        }        

        public VCSGisWorkspaceEntity getEntity() {

            if( this.entity == null ) {

                this.entity = this.workspace.getWorkspaceEntityByCode(this.getEntityCode());

            }

            return this.entity;

        }

        @Override

        public int getStatus() {

            return this.getInt(STATUS);

        }

        @Override

        public void update(FeatureStore store) {

            this.updateStatus();

            super.update(store);

        }

        @Override

        public void insert(FeatureStore store) {

            this.updateStatus();

            super.insert(store);

        }

        private void updateStatus() {

            if(getStatus() == STATE_LOCAL_UNMODIFIED){

                switch(this.getOperation()){

                    case OP_INSERT:

                    case OP_ADD_ENTITY:

                        setStatus(STATE_LOCAL_NEW);

                        return;

                    case OP_DELETE:

                    case OP_UPDATE:

                        setStatus(STATE_LOCAL_MODIFIED);

                        return;

                }

            }

        }

        public void revert(FeatureStore userStore, FeatureStore changesStore) throws DataException {

            String code = this.getRelatedFeatureCode();

            EditableFeature editable;

            switch (this.getOperation()) {

                case OP_INSERT:

                    userStore.delete("\""+VCSGisManager.FEATURECODE_FIELD_NAME+"\" = '"+code+"'");

                    changesStore.delete("\""+COD_CHANGE+"\" = '"+this.getCode()+"'");

                    break;

                case OP_ADD_ENTITY:

                    break;

                case OP_UPDATE:

                    Feature feat = userStore.findFirst("\""+VCSGisManager.FEATURECODE_FIELD_NAME+"\" = '"+code+"'");

                    if(feat == null) {

                        throw new VCSGisRuntimeException(1, "xxx");

                    }

                    editable = feat.getEditable();

                    editable.copyFrom(this.getDataAsJson());

                    userStore.update(editable);

                    changesStore.delete("\""+COD_CHANGE+"\" = '"+this.getCode()+"'");

                    break;

                case OP_DELETE:

                    editable = userStore.createNewFeature(this.getDataAsJson());

                    userStore.insert(editable);

                    changesStore.delete("\""+COD_CHANGE+"\" = '"+this.getCode()+"'");

                    break;

            }

        }

        public void setData(String data) {

            this.set(FEATURE_DATA, data);

        }

        @Override

        public String getData() {

            return this.getString(FEATURE_DATA);

        }

        @Override

        public JsonObject getDataAsJson() {

            String s = this.getData();

            return Json.createObject(s);

        }

    }

    public WorkspaceChangesTable() {

        super(TABLE_NAME, featureType());

    }

    public DisposableFeatureSetIterable getByOperation(VCSGisWorkspace workspace, int op) {

        return getByOperation(workspace, null, op);

//        FeatureStore store = null;

//        try {

//            store = workspace.getFeatureStore(TABLE_NAME);

//            FeatureQuery query = store.createFeatureQuery();

//            query.addFilter("\""+WorkspaceChangesTable.OPERATION+"\"="+op);

//            query.retrievesAllAttributes();

//            DisposableFeatureSetIterable changes = store.getFeatureSet(query).iterable();

//            return changes;

//        } catch (Exception ex) {

//            throw new RuntimeException("Can't retrieve changes for operartion "+op+".", ex);

//        } finally {

//            if( store!=null ) {

//                DisposeUtils.dispose(store);

//            }

//        }

    }

    public DisposableFeatureSetIterable getByOperation(VCSGisWorkspace workspace, String entityCode, int op) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            FeatureQuery query = store.createFeatureQuery();

            if( !StringUtils.isBlank(entityCode) ) {

                query.addFilter("\""+COD_ENTITY+"\" ='"+entityCode+"' AND \""+WorkspaceChangesTable.OPERATION+"\"="+op);

            } else {

                query.addFilter("\""+WorkspaceChangesTable.OPERATION+"\"="+op);

            }

            query.retrievesAllAttributes();

            DisposableFeatureSetIterable changes = store.getFeatureSet(query).iterable();

            return changes;

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve changes for operartion "+op+".", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public DisposableFeatureSetIterable getGroupedByEntity(VCSGisWorkspace workspace) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            FeatureQuery query = store.createFeatureQuery();

            query.getOrder().add(WorkspaceChangesTable.COD_ENTITY,true);

            query.getGroupByColumns().add(WorkspaceChangesTable.COD_ENTITY);

            query.getAggregateFunctions().put(SELECTED, "MAX");

            query.retrievesAllAttributes();

            DisposableFeatureSetIterable changes = store.getFeatureSet(query).iterable();

            return changes;

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve changes grouped by entity.", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public DisposableFeatureSetIterable getSelectedsWithoutAddEntity(VCSGisWorkspace workspace) {

        return getSelectedsWithoutAddEntity(workspace, null);

//        FeatureStore store = null;

//        try {

//            store = workspace.getFeatureStore(TABLE_NAME);

//            FeatureQuery query = store.createFeatureQuery();

//

//            //FIXME: No enviar al servidor cambios repetidos sobre la misma feature

//            query.setFilter("\""+SELECTED+"\" AND \""+OPERATION+"\" <> "+OP_ADD_ENTITY);

//            query.retrievesAllAttributes();

//            DisposableFeatureSetIterable changes = store.getFeatureSet(query).iterable();

//            if( changes.isEmpty() ) {

//                DisposeUtils.disposeQuietly(changes);

//                return null;

//            }

//            return changes;

//        } catch (Exception ex) {

//            throw new RuntimeException("Can't retrieve all changes.", ex);

//        } finally {

//            if( store!=null ) {

//                DisposeUtils.dispose(store);

//            }

//        }

    }

    public DisposableFeatureSetIterable getSelectedsWithoutAddEntity(VCSGisWorkspace workspace, List<String> entityCodes) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            FeatureQuery query = store.createFeatureQuery();

            if(CollectionUtils.isEmpty(entityCodes)){

                query.setFilter("\""+SELECTED+"\" AND \""+OPERATION+"\" <> "+OP_ADD_ENTITY);

            } else {

                ExpressionBuilder expBuilder = ExpressionUtils.createExpressionBuilder();

                for (String entityCode : entityCodes) {

                    expBuilder.or(expBuilder.eq(expBuilder.column(COD_ENTITY), expBuilder.constant(entityCode)));

                }

                expBuilder.and(expBuilder.column(SELECTED)).and(expBuilder.ne(expBuilder.column(OPERATION), expBuilder.constant(OP_ADD_ENTITY)));

                query.setFilter(expBuilder.value().toString());

            }

            query.retrievesAllAttributes();

            DisposableFeatureSetIterable changes = store.getFeatureSet(query).iterable();

            if( changes.isEmpty() ) {

                DisposeUtils.disposeQuietly(changes);

                return null;

            }

            return changes;

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve all changes.", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public DisposableFeatureSetIterable getAll(VCSGisWorkspace workspace) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            DisposableFeatureSetIterable changes = store.getFeatureSet().iterable();

            return changes;

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve all changes.", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public GetItemWithSize64<Feature> getByEntityCode(VCSGisWorkspace workspace, List<VCSGisEntity> entities) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            if( CollectionUtils.isEmpty(entities) ) {

                GetItemWithSizeAndIterator64<Feature> changes = store.getFeatures64(

                        null, 

                        "\""+COD_ENTITY+"\",-\""+OPERATION+"\",\""+COD_CHANGE+"\"", 

                        true);

                return changes;

            }

            ExpressionBuilder exprBuilder = ExpressionUtils.createExpressionBuilder();

            for (VCSGisEntity entity : entities) {

                exprBuilder.or(exprBuilder.eq(exprBuilder.column(COD_ENTITY), exprBuilder.constant(entity.getEntityCode())));

            }

            GetItemWithSizeAndIterator64<Feature> changes = store.getFeatures64(

                    exprBuilder.value().toString(),

                    "\""+COD_ENTITY+"\",-\""+OPERATION+"\",\""+COD_CHANGE+"\"", 

                    true

            );

            return changes;

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve changes by entity.", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public long getCountLocalChangesOfEntity(VCSGisWorkspace workspace, String entityCode) {

        FeatureStore store = null;

        FeatureSet changes = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            if( StringUtils.isBlank(entityCode) ) {

                throw new IllegalArgumentException("entityCode is required.");

            }

            changes = store.getFeatureSet(

                    "\""+COD_ENTITY+"\"='"+entityCode+"'"

            );

            return changes.size64();

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve changes by entity.", ex);

        } finally {

            DisposeUtils.disposeQuietly(changes);

            DisposeUtils.disposeQuietly(store);

        }

    }

    public WorkspaceChangeRow getByEntityAndDataCode(

            VCSGisWorkspace workspace, 

            String entityCode, 

            String featureCode,

            FeatureStore localChangesStore

        ) {

        FeatureStore store = localChangesStore;

        try {

            if(store == null){

                store = workspace.getFeatureStore(TABLE_NAME);

            }

            Feature f = store.findFirst(

                    "\"" + COD_ENTITY + "\"='" + entityCode + "' AND \""+FEATUREID+"\"='"+featureCode+"'"

            );

            if (f == null) {

                return null;

            }

            WorkspaceChangeRow row = new WorkspaceChangeRow(workspace, f);

            return row;

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve change for 'FEATURECODE[" + featureCode + "]'.", ex);

        } finally {

            if(localChangesStore == null){

                DisposeUtils.disposeQuietly(store);

            }

        }

    }

    public void deleteAll(VCSGisWorkspace workspace) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME);

            store.edit(MODE_PASS_THROUGH);

            store.delete("TRUE");

            store.finishEditing();

        } catch (Exception ex) {

            FeatureStore.cancelEditingQuietly(store);

            throw new RuntimeException("Can't delete all changes.", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public void deleteSelecteds(VCSGisWorkspace workspace, List<String> entityCodes) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME);

            store.edit(MODE_PASS_THROUGH);

            ExpressionBuilder expBuilder = ExpressionUtils.createExpressionBuilder();

            if(CollectionUtils.isNotEmpty(entityCodes)){

                for (String entityCode : entityCodes) {

                    expBuilder.or(expBuilder.eq(expBuilder.column(COD_ENTITY), expBuilder.constant(entityCode)));

                }

            }

            expBuilder.and(expBuilder.column(SELECTED));

            store.delete(expBuilder.value().toString());

            store.finishEditing();

        } catch (Exception ex) {

            FeatureStore.cancelEditingQuietly(store);

            throw new RuntimeException("Can't delete selected changes.", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public void deleteByEntity(VCSGisWorkspace workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME);

            store.edit(MODE_PASS_THROUGH);

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

            store.finishEditing();

        } catch (Exception ex) {

            FeatureStore.cancelEditingQuietly(store);

            throw new RuntimeException("Can't delete selected changes.", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

        public DisposableFeatureSetIterable getSelectedsByEntityCodeAsIterator(VCSGisWorkspace workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            FeatureSet changes;

            if( StringUtils.isBlank(entityCode) ) {

                changes = store.getFeatureSet("\""+SELECTED+"\"");

            } else {

                changes = store.getFeatureSet("\""+SELECTED+"\" AND \""+COD_ENTITY+"\"='"+entityCode+"'");

            }

            return changes.iterable();

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve selected remote changes by entity code (ENTITY["+entityCode+"]).", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public void deleteSelectedsByEntity(VCSGisWorkspace workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME);

            store.edit(MODE_PASS_THROUGH);

            store.delete("\""+COD_ENTITY+"\"='"+entityCode+"'"+" AND "+"\""+SELECTED+"\"");

            store.finishEditing();

        } catch (Exception ex) {

            FeatureStore.cancelEditingQuietly(store);

            throw new RuntimeException("Can't delete selected changes.", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public WorkspaceChangeRow find(VCSGisWorkspace workspace, FeatureStore store, String entityCode, String featureCode) {

        try {

            Feature f = store.findFirst(

                    "\""+FEATUREID+"\"='"+featureCode+"'"

//                    "\""+COD_ENTITY+"\"='"+entityCode+"' AND \""+FEATUREID+"\"='"+featureCode+"'"

            );

            if(f==null){

                return null;

            }

            return new WorkspaceChangeRow(workspace, f);

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve change.", ex);

        }

    }

    public static final FeatureType featureType() {

        DataManager dataManager = DALLocator.getDataManager();

        EditableFeatureType ft = dataManager.createFeatureType();

        ft.setLabel("VCSGIS Local changes");

        ft.getTags().set("ID", TABLE_NAME);

        ft.add(COD_CHANGE, DataTypes.STRING)

                .setSize(VCSGISCODELEN)

                .setIsPrimaryKey(true)

                .setLabel("Code")

                .setReadOnly(false);        

        ft.add(COD_ENTITY, DataTypes.STRING)

//                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setSize(VCSGISCODELEN)

                .setLabel("Entity code");

        ft.add(SELECTED, DataTypes.BOOLEAN)

//                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setLabel("Selected");

        ft.add(FEATUREID, DataTypes.STRING)

                .setIsIndexed(true)

                .setSize(VCSGISCODELEN)

                .setLabel("Identifier")

                .setDescription("The identifier of the feature");

        ft.add(OPERATION, DataTypes.INTEGER)

                .setIsIndexed(true)

                .setLabel("Operation")

                .setAvailableValues(new DynObjectValueItem[] {

                    new DynObjectValueItem(OP_ADD_ENTITY, "Add entity"),

                    new DynObjectValueItem(OP_INSERT, "Insert"),

                    new DynObjectValueItem(OP_UPDATE, "Update"),

                    new DynObjectValueItem(OP_DELETE, "Delete")

                });

        ft.add(STATUS, DataTypes.INTEGER)

                .setLabel("Status")

                .setAvailableValues(new DynObjectValueItem[] {

                    new DynObjectValueItem(STATE_LOCAL_UNMODIFIED, "Unmodified"),

                    new DynObjectValueItem(STATE_LOCAL_MODIFIED, "Modified"),

                    new DynObjectValueItem(STATE_CONFLICT, "Conflict")

                });

        ft.add(LABEL, DataTypes.STRING)

                .setIsIndexed(false)

                .setSize(MAX_SIZE_LABEL)

                .setLabel("Label")

                .setDescription("The label of the feature");

        ft.add(FEATURE_DATA, DataTypes.STRING)

                .setLabel("Data");

        return ft.getNotEditableCopy();

    }

    public void removeLocalChangesRelatedToSelectedRemoteChanges(VCSGisWorkspace workspace, VCSGisEntity lentity) {

        String sql = String.format(VCSGisUtils.getSqlTemplate(workspace.getExplorer().getProviderName(), "removeLocalChangesRelatedToSelectedRemoteChanges"), lentity.getEntityCode());

        Object res = workspace.getExplorer().execute(sql);

    }

    public DisposableIterable<WorkspaceChangeRow> getChangesWidthUserData(VCSGisWorkspace workspace, VCSGisEntity lentity, RemoteChangeRow remoteChange, FeatureStore localChangesStore) {

        FeatureType featType = lentity.getFeatureType();

        JsonObject data = remoteChange.getRelatedFeatureDataAsJson();

        ExpressionEvaluatorManager expManager = ExpressionEvaluatorLocator.getManager();

        ExpressionBuilder builder = expManager.createExpressionBuilder();

        builder.set(null);

        for (FeatureAttributeDescriptor attr : featType) {

            if(StringUtils.equalsAnyIgnoreCase(lentity.getFeatureIdFieldName(),attr.getName())){

                continue;

            }

            if(attr.isIndexed() && !attr.allowIndexDuplicateds()){

                Object value = Json.toObject(data, attr.getName());

                builder.or(

                    builder.eq(

                        builder.column(attr.getName()), 

                        builder.constant(value)

                    )

                );

            }

        }

        ExpressionBuilder.Value value = builder.value();

        if(value == null){

            return null;

        }

        String sql = String.format(

                VCSGisUtils.getSqlTemplate(

                        workspace.getExplorer().getProviderName(), 

                        "getChangesWidthUserData"

                ), 

                lentity.getEntityName(),

                lentity.getFeatureIdFieldName(),

                remoteChange.getRelatedFeatureCode(),

                builder.toString()

                );

        final ResultSet rs = (ResultSet) workspace.getExplorer().execute(sql);

        if(rs == null){

            return null;

        }

        final WorkspaceChangeRow row;

        try {

            row = new WorkspaceChangeRow(workspace, localChangesStore.createNewFeature());

        } catch (DataException ex) {

            try {

                rs.close();

            } catch (SQLException ex2) {

            }

            return null;

        }

        DisposableIterable<WorkspaceChangeRow> r = new DisposableIterable<WorkspaceChangeRow>() {

            @Override

            public Iterator<WorkspaceChangeRow> iterator() {

                Iterator<WorkspaceChangeRow> it = new Iterator<WorkspaceChangeRow>() {

                    @Override

                    public boolean hasNext() {

                        try {

                            return rs.next();

                        } catch (SQLException ex) {

                            return false;

                        }

                    }

                    @Override

                    public WorkspaceChangeRow next() {

                        try {

                            row.setCode(rs.getString(COD_CHANGE));

                            row.setEntityCode(rs.getString(COD_ENTITY));

                            row.setFeatureCode(rs.getString(FEATUREID));

                            row.setLabel(rs.getString(LABEL));

                            row.setOperation(rs.getInt(OPERATION));

                            row.setSelected(rs.getBoolean(SELECTED));

                            row.setStatus(rs.getInt(STATUS));

                            return row;

                        } catch (SQLException ex) {

                            return null;

                        }

                    }

                };

                return it;

            }

            @Override

            public void dispose() {

                try {

                    Connection conn = rs.getStatement().getConnection();

                    rs.close();

                    conn.close();

                } catch (SQLException ex) {

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

                }

            }

        };

        return r;

    }

}