gvSIG projects pool

package org.gvsig.online.lib.impl.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 static org.gvsig.fmap.dal.DataManager.RECOMENDED_SIZE_FOR_CLOB;

import org.gvsig.fmap.dal.DataTransaction;

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

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

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.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.jdbc2.JDBCServerExplorer;

import org.gvsig.json.Json;

import org.gvsig.online.lib.api.workingcopy.OnlineEntity;

import org.gvsig.online.lib.api.OnlineManager;

import static org.gvsig.online.lib.api.OnlineManager.FEATURECODE_FIELD_NAME;

import static org.gvsig.online.lib.api.OnlineManager.ONLINECODELEN;

import static org.gvsig.online.lib.api.OnlineManager.OP_DELETE;

import static org.gvsig.online.lib.api.OnlineManager.OP_IGNORE;

import static org.gvsig.online.lib.api.OnlineManager.OP_INSERT;

import static org.gvsig.online.lib.api.OnlineManager.OP_UNKNOWN;

import static org.gvsig.online.lib.api.OnlineManager.OP_UPDATE;

import static org.gvsig.online.lib.api.OnlineManager.STATE_CONFLICT;

import static org.gvsig.online.lib.api.OnlineManager.STATE_LOCAL_MODIFIED;

import static org.gvsig.online.lib.api.OnlineManager.STATE_LOCAL_NEW;

import static org.gvsig.online.lib.api.OnlineManager.STATE_LOCAL_UNMODIFIED;

import org.gvsig.online.lib.api.OnlineRuntimeException;

import org.gvsig.online.lib.impl.OnlineUtils;

import org.gvsig.online.lib.impl.workspace.tables.RemoteChangesTable.RemoteChangeRow;

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.online.lib.api.workingcopy.OnlineWorkingcopy;

import org.gvsig.online.lib.api.workingcopy.OnlineWorkingcopyChange;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class WorkspaceChangesTable extends AbstractTable {

    public static final String TABLE_NAME = "ONLINE_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 PREVIOUS_OPERATION = "WSCH_PREVOPERATION";

    public static final String STATUS = "WSCH_STATUS";

    private static final String FEATURE_DATA = "WSCH_DATA";

    private static final String EDITING_SESSION = "WSCH_EDITINGSESSION";

    private static final String LABEL = "WSCH_LABEL";

    private static final int MAX_SIZE_LABEL = 40;

    @SuppressWarnings("UseSpecificCatch")

    public static class WorkspaceChangeRow extends AbstractRow implements OnlineWorkingcopyChange {

        protected OnlineEntity entity;

        public WorkspaceChangeRow(OnlineWorkingcopy workspace) {

            this(workspace, null);

            setStatus(OnlineManager.STATE_LOCAL_UNMODIFIED);

        }

        public WorkspaceChangeRow(OnlineWorkingcopy workspace, Feature feature) {

            super(workspace, TABLE_NAME, COD_CHANGE, feature);

        }

        @Override

        public String getEntityCode() {

            return this.getString(COD_ENTITY);

        }

        @Override

        public long getRelatedFeatureCode() {

            return this.getLong(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(long 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";

            long code = 0;

            FeatureStore store = null;

            try {

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

                code = this.getRelatedFeatureCode();

                store = workspace.getFeatureStore(entityName);

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

                if( f==null ) {

                    int op = this.getOperation();

                    if( op == OnlineManager.OP_INSERT || op == OnlineManager.OP_UPDATE ) {

                        LOGGER.warn("Can't retrieve feature data for an insert or update operation (ENT/VCSGISCODE='"+entityName+"/"+code+"')");

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

                    }

                    return ""; //null;

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

                }

                JsonObject json = f.toJson();

//                JsonObject json = f.toJson(Collections.singletonMap("geometryformat", this.workspace.getGeometryFormat()));

                String data = json.toString();

                return data;

            } catch (Exception ex) {

                LOGGER.warn("Can't retrieve feature data (ENT/ONLINECODE='"+entityName+"/"+code+"')");

                throw new RuntimeException("Can't retrieve feature data of ENT/ONLINECODE='"+entityName+"/"+code+"'.",ex);

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

        }    

        @Override

        public JsonObject getRelatedFeatureDataAsJson() {

            String s = this.getRelatedFeatureData();

            return Json.createObject(s);

        }

        @Override

        public String toString() {

            switch (this.getOperation()) {

//                case OnlineManager.OP_ADD_ENTITY:

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

                case OnlineManager.OP_INSERT:

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

                case OnlineManager.OP_UPDATE:

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

                case OnlineManager.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 OnlineEntity 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() == OnlineManager.STATE_LOCAL_UNMODIFIED){

                switch(this.getOperation()){

                    case OnlineManager.OP_INSERT:

//                    case OnlineManager.OP_ADD_ENTITY:

                        setStatus(OnlineManager.STATE_LOCAL_NEW);

                        return;

                    case OnlineManager.OP_DELETE:

                    case OnlineManager.OP_UPDATE:

                        setStatus(OnlineManager.STATE_LOCAL_MODIFIED);

                        return;

                }

            }

        }

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

            long code = this.getRelatedFeatureCode();

            EditableFeature editable;

            switch (this.getOperation()) {

                case OnlineManager.OP_INSERT:

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

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

                    break;

//                case OnlineManager.OP_ADD_ENTITY:

//                    break;

                case OnlineManager.OP_UPDATE:

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

                    if(feat == null) {

                        throw new OnlineRuntimeException(1, "xxx");

                    }

                    editable = feat.getEditable();

                    editable.copyFrom(this.getDataAsJson());

                    userStore.update(editable);

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

                    break;

                case OnlineManager.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 void setEditingSession(String editingSession) {

            this.set(EDITING_SESSION, editingSession);

        }

        public void setPreviousOperation(int operation) {

            this.set(PREVIOUS_OPERATION, operation);

        }

    }

    public WorkspaceChangesTable() {

        super(TABLE_NAME, featureType());

    }

    public DisposableFeatureSetIterable getByOperation(OnlineWorkingcopy 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(OnlineWorkingcopy 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(OnlineWorkingcopy 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(OnlineWorkingcopy workspace) {

//        return getSelectedsWithoutAddEntity(workspace, null);

//    }

//    

//    public DisposableFeatureSetIterable getSelectedsWithoutAddEntity(OnlineWorkingcopy 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+"\" <> "+OnlineManager.OP_ADD_ENTITY+" AND \""

//                    +OPERATION+"\" <> "+OnlineManager.OP_IGNORE);

//            } 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(OnlineManager.OP_ADD_ENTITY)))

//                        .and(expBuilder.ne(expBuilder.column(OPERATION), expBuilder.constant(OnlineManager.OP_IGNORE)));

//                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 {

//           DisposeUtils.disposeQuietly(store);

//        }

//    }

    public DisposableFeatureSetIterable getAll(OnlineWorkingcopy 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 {

            DisposeUtils.disposeQuietly(store);

        }

    }

    public GetItemWithSize64<Feature> getByEntityCode(OnlineWorkingcopy workspace, List<OnlineEntity> 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 (OnlineEntity 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 {

           DisposeUtils.disposeQuietly(store);

        }

    }

    public boolean hasLocalChangesByEntityCode(OnlineWorkingcopy workspace, List<OnlineEntity> entities) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            if( CollectionUtils.isEmpty(entities) ) {

                Feature f = store.findFirst((FeatureQuery)null);

                return f!=null;

            }

            ExpressionBuilder exprBuilder = ExpressionUtils.createExpressionBuilder();

            for (OnlineEntity entity : entities) {

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

            }

            Feature f = store.findFirst(exprBuilder.value().toString());

            return f!=null;

        } catch (Exception ex) {

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

        } finally {

           DisposeUtils.disposeQuietly(store);

        }

    }

    public long getCountLocalChangesOfEntity(OnlineWorkingcopy workspace, String entityCode) {

        return this.getCountLocalChangesOfEntity(workspace, null, entityCode);

    }

    public long getCountLocalChangesOfEntity(OnlineWorkingcopy workspace, DataTransaction transaction, String entityCode) {

        FeatureStore store = null;

        FeatureSet changes = null;

        try {

            if( transaction==null ) {

                store = workspace.getFeatureStore(TABLE_NAME);

            } else {

                store = transaction.getFeatureStore(TABLE_NAME);

                if( store == null ) {

                    store = workspace.getFeatureStore(TABLE_NAME);

                } else {

                    DisposeUtils.bind(store);

                }

            }

            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(

            OnlineWorkingcopy 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(OnlineWorkingcopy workspace) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            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(OnlineWorkingcopy workspace, List<String> entityCodes) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            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(OnlineWorkingcopy workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            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(OnlineWorkingcopy 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(OnlineWorkingcopy workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            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(OnlineWorkingcopy workspace, FeatureStore store, String entityCode, long 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("Online Local changes");

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

        ft.add(COD_CHANGE, DataTypes.STRING)

                .setSize(ONLINECODELEN)

                .setIsPrimaryKey(true)

                .setLabel("Code")

                .setReadOnly(false);        

        ft.add(COD_ENTITY, DataTypes.STRING)

//                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setSize(ONLINECODELEN)

                .setLabel("Entity code");

        ft.add(SELECTED, DataTypes.BOOLEAN)

//                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setLabel("Selected");

        ft.add(EDITING_SESSION, DataTypes.STRING)

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setLabel("Editing session");

        ft.add(FEATUREID, DataTypes.LONG)

                .setIsIndexed(true)

                .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"),

                    new DynObjectValueItem(OP_IGNORE, "Ignore")

                });

        ft.add(PREVIOUS_OPERATION, DataTypes.INTEGER)

                .setIsIndexed(true)

                .setLabel("Operation")

                .setAvailableValues(new DynObjectValueItem[] {

                    new DynObjectValueItem(OP_INSERT, "Insert"),

                    new DynObjectValueItem(OP_UPDATE, "Update"),

                    new DynObjectValueItem(OP_UNKNOWN, "Unknown")

                });

        ft.add(STATUS, DataTypes.INTEGER)

                .setLabel("Status")

                .setAvailableValues(new DynObjectValueItem[] {

                    new DynObjectValueItem(STATE_LOCAL_NEW, "New"),

                    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)

                .setSize(RECOMENDED_SIZE_FOR_CLOB)

                .setLabel("Data");

        return ft.getNotEditableCopy();

    }

    public void removeLocalChangesRelatedToSelectedRemoteChanges(OnlineWorkingcopy workspace, OnlineEntity lentity) {

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

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

    }

    public void removeLocalChanges(OnlineWorkingcopy workspace, OnlineEntity lentity, String editingSession) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            store.delete("\""+EDITING_SESSION+"\" = '"+editingSession+"'");

            store.finishEditingQuietly();

        } catch (Exception ex) {

            FeatureStore.cancelEditingQuietly(store);

            throw new RuntimeException("Can't remove local changes.", ex);

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    public void revertChangedLocalChanges(OnlineWorkingcopy workspace, OnlineEntity lentity, String editingSession) {

        FeatureStore store = null;

        FeatureSet features = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            features = store.getFeatureSet("\""+EDITING_SESSION+"\" = '"+editingSession+"' and \""+PREVIOUS_OPERATION+"\" <> "+OP_UNKNOWN);

            for (Feature feature : features) {

                EditableFeature eFeature = feature.getEditable();

                eFeature.set(OPERATION, eFeature.get(PREVIOUS_OPERATION));

                eFeature.set(PREVIOUS_OPERATION, OP_UNKNOWN);

                store.update(eFeature);

            }

            store.finishEditingQuietly();

        } catch (Exception ex) {

            FeatureStore.cancelEditingQuietly(store);

            throw new RuntimeException("Can't remove local changes.", ex);

        } finally {

            DisposeUtils.disposeQuietly(features);

            DisposeUtils.disposeQuietly(store);

        }

    };

    public void removeIgnoredLocalChanges(OnlineWorkingcopy workspace, OnlineEntity lentity, String editingSession) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            store.delete("\""+EDITING_SESSION+"\" = '"+editingSession+"' and \""+OPERATION+"\" = "+OP_IGNORE);

            store.finishEditingQuietly();

        } catch (Exception ex) {

            FeatureStore.cancelEditingQuietly(store);

            throw new RuntimeException("Can't remove local changes.", ex);

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    };

    public DisposableIterable<WorkspaceChangeRow> getChangesWidthUserData(OnlineWorkingcopy workspace, OnlineEntity lentity, RemoteChangeRow remoteChange, FeatureStore localChangesStore, DataTransaction transaction) {

        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;

        }

        JDBCServerExplorer serverExplorer = workspace.getExplorer(); 

        String sql = String.format(

                OnlineUtils.getSqlTemplate(

                        workspace.getExplorer().getProviderName(), 

                        "getChangesWidthUserData"

                ), 

                lentity.getEntityName(),

                lentity.getFeatureIdFieldName(),

                remoteChange.getRelatedFeatureCode(),

                builder.toString()

                );

        final ResultSet rs = (ResultSet) serverExplorer.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.getLong(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();

                    if(transaction != null && transaction.contains(serverExplorer) && transaction.isInProgress()){

                        return;

                    } 

                    conn.close();

                } catch (SQLException ex) {

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

                }

            }

        };

        return r;

    }

    public void changeState(FeatureStore localChangesStore, String entityCode, int searchState, int replaceState) {

        try {

            boolean needFinish = false;

            if(localChangesStore.getMode() == FeatureStore.MODE_QUERY){

                localChangesStore.edit(MODE_PASS_THROUGH);

                needFinish = true;

            }

            String filter = "\""+COD_ENTITY+"\"='"+entityCode+"' AND \""+STATUS+"\"="+searchState;

            localChangesStore.update(STATUS,replaceState,filter);

            if(needFinish) {

                localChangesStore.finishEditing();

            }

        } catch (Exception ex) {

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

        }

    }

}