gvSIG projects pool

package org.gvsig.online.lib.impl.workspace.tables;

import java.sql.Timestamp;

import java.util.List;

import javax.json.JsonObject;

import javax.json.JsonString;

import javax.json.JsonValue;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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.feature.DisposableFeatureSetIterable;

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

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

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.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.json.Json;

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

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

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

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

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

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

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.util.GetItemWithSize64;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class RemoteChangesTable extends AbstractTable {

    public static final String TABLE_NAME = "ONLINE_REMOTECHANGES";

    private static final String COD_REMOTECHANGE = "COD_REMOTECHANGE";

    public static final String COD_ENTITY = "COD_ENTITY";

    public static final String SELECTED = "RCH_SELECTED";

    private static final String FEATUREID = "RCH_FEATURECODE";

    private static final String REVISION_NUMBER = "RCH_REVNUMBER";

    private static final String OPERATION = "RCH_OPERATION";

    private static final String REVISION_DATE = "RCH_DATE";

    private static final String FEATURE_DATA = "RCH_DATA";

    private static final String STATUS = "RCH_STATUS";

    @SuppressWarnings("UseSpecificCatch")

    public static class RemoteChangeRow extends AbstractRow implements OnlineRemoteChange {

        protected OnlineEntity entity;

        public RemoteChangeRow(OnlineWorkingcopy workspace) {

            super(workspace, TABLE_NAME, COD_REMOTECHANGE);

        }

        public RemoteChangeRow(OnlineWorkingcopy workspace, Feature feature) {

            super(workspace, TABLE_NAME, COD_REMOTECHANGE, feature);

        }

        @Override

        public String getEntityCode() {

            return this.getString(COD_ENTITY);

        }

        @Override

        public long getRelatedFeatureCode() {

            if( this.isNull(FEATUREID)){

                return 0l;

            }

            return this.getLong(FEATUREID);

        }

        private Feature getRelatedFeature() {

            String entityName;

            long code;

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

                    return null;

                }

                return f;

            } catch (Exception ex) {

                return null;

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

        }        

        @Override

        public long getRevisionNumber() {

            return this.getLong(REVISION_NUMBER);

        }

        @Override

        public Timestamp getRevisionDate() {

            return this.getTimestamp(REVISION_DATE);

        }

        @Override

        public int getOperation() {

            return this.getInt(OPERATION);

        }

        @Override

        public String getOperationLabel() {

            return OnlineUtils.getOperationLabel(this.getOperation());

        }

        @Override

        public boolean isSelected() {

            return this.getBoolean(SELECTED);

        }

        @Override

        public int getStatus() {

            return this.getInt(STATUS);

        }

        @Override

        public String getRelatedFeatureData() {

            return this.getString(FEATURE_DATA);

        }        

        @Override

        public JsonObject getRelatedFeatureDataAsJson() {

            JsonObject json = Json.createObject(this.getString(FEATURE_DATA));

            return json;

        }        

        public void setEntityCode(String code) {

            this.set(COD_ENTITY, code);

        }

//        public void setUserCode(String code) {

//            this.feature.set(COD_USER, code);

//        }

        public void setData(String data) {

            this.set(FEATURE_DATA, data);

        }

        public void setRevisionNumber(long revnum) {

            this.set(REVISION_NUMBER, revnum);

        }

        public void setEfectiveDate(Timestamp date) {

            this.set(REVISION_DATE, date);

        }

        public void setRelatedFeatureCode(long code) {

            this.set(FEATUREID, code);

        }

        public void setOperation(int op) {

            this.set(OPERATION, op);

        }

        @Override

        public void setSelected(boolean selected) {

            this.set(SELECTED, selected);

        }

        public void setStatus(int status) {

            this.set(STATUS, status);

        }

        public OnlineEntity getEntity() {

            if( this.entity == null ) {

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

            }

            return this.entity;

        }

        @Override

        public String getLabel() {

            if(StringUtils.isBlank(this.getRelatedFeatureData())){

                Feature f = getRelatedFeature();

                if(f==null){

                    return null;

                }

                return f.getString(this.getEntity().getFieldForLabel());

            }

            JsonValue jsonValue = this.getRelatedFeatureDataAsJson().get(this.getEntity().getFieldForLabel());

            return convertJsonValueToString(jsonValue);

        }

        private static String convertJsonValueToString(JsonValue jsonValue) {

            if( jsonValue==null ) {

                return "";

            }

            if (jsonValue instanceof JsonString) {

                String jsonString = jsonValue.toString();

                return jsonString.substring(1, jsonString.length() - 1);

            } else {

                return jsonValue.toString();

            }

        }

        @Override

        public String toString() {

            switch (this.getOperation()) {

                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 Geometry getGeometry() {

            Geometry geom = null;

            GeometryManager geometryManager = GeometryLocator.getGeometryManager();

            String geometryFieldName = getEntity().getGeometryFieldName();

            String data = getRelatedFeatureData();

            if( !StringUtils.isBlank(data) && !StringUtils.isBlank(geometryFieldName) ) {

                JsonObject dataJson = Json.createObject(data);

                geom = geometryManager.createFromQuietly(

                        dataJson.getString(geometryFieldName, null)

                );

            }

            return geom;

        }

    }

    public RemoteChangesTable() {

        super(TABLE_NAME, featureType());

    }

    public void deleteAll(OnlineWorkingcopy workspace) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            store.delete("TRUE");

        } catch (Exception ex) {

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

        } finally {

           DisposeUtils.disposeQuietly(store);

        }

    }

    public void delete(OnlineWorkingcopy workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

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

        } catch (Exception ex) {

            throw new RuntimeException("Can't delete remote changes of entity ENTITY["+entityCode+"].", ex);

        } finally {

           DisposeUtils.disposeQuietly(store);

        }

    }

    public void delete(FeatureStore store, String entityCode) {

        try {

            boolean needFinish = false;

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

                store.edit(MODE_PASS_THROUGH);

                needFinish = true;

            }

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

            if(needFinish) {

                store.finishEditing();

            }

        } catch (Exception ex) {

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

        }

    }

    public void deleteSelecteds(OnlineWorkingcopy workspace) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            store.delete("\""+SELECTED+"\"");

        } catch (Exception ex) {

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

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    public DisposableFeatureSetIterable getByEntityCodeAsIterator(OnlineWorkingcopy workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            FeatureSet changes;

            if( StringUtils.isBlank(entityCode) ) {

                changes = store.getFeatureSet();

            } else {

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

            }

            return changes.iterable();

        } catch (Exception ex) {

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

        } finally {

           DisposeUtils.disposeQuietly(store);

        }

    }

    public DisposableFeatureSetIterable getSelectedsByEntityCodeAsIterator(OnlineWorkingcopy workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            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 {

           DisposeUtils.disposeQuietly(store);

        }

    }

    public DisposableFeatureSetIterable getNotSelectedsByEntityCodeAsIterator(OnlineWorkingcopy workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            FeatureSet changes;

            if( StringUtils.isBlank(entityCode) ) {

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

            } else {

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

            }

            return changes.iterable();

        } catch (Exception ex) {

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

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    public GetItemWithSize64<Feature> getByEntityCode(OnlineWorkingcopy workspace, String[] entityCodes) {

        FeatureStore store = null;

        try {

            GetItemWithSize64<Feature>  changes;

            store = workspace.openFeatureStore(TABLE_NAME, true);

            FeatureQuery query = store.createFeatureQuery();

            query.getOrder().add(REVISION_NUMBER, true);

            if( ArrayUtils.isNotEmpty(entityCodes)  ) {

                ExpressionBuilder builder = store.createExpressionBuilder();

                for (String entityCode : entityCodes) {

                    if(StringUtils.isNotBlank(entityCode)){

                        builder.or( 

                                builder.eq(

                                        builder.column(COD_ENTITY), 

                                        builder.constant(entityCode)

                                )

                        );

                    }

                }

                String expression = builder.toString();

                if(StringUtils.isNotBlank(expression)){

                    query.setFilter(expression);

                }

            }            

            query.retrievesAllAttributes();

            changes = store.getFeatures64(query,-1);

            return changes;

        } catch (Exception ex) {

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

        } finally {

           DisposeUtils.disposeQuietly(store);

        }

    }

    public GetItemWithSize64<Feature> getByEntityCodes(OnlineWorkingcopy workspace, List<String> entityCodes) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            GetItemWithSize64<Feature>  changes;

            if( entityCodes == null || entityCodes.isEmpty()) {

                changes = store.getFeatures64();

            } else {

                StringBuilder filter = new StringBuilder();

                for (String entityCode : entityCodes) {

                    if(filter.length()>0){

                        filter.append(" OR "); 

                    }

                    filter.append("\"" + COD_ENTITY + "\"='").append(entityCode).append("'");

                }

                changes = store.getFeatures64(filter.toString());

            }

            return changes;

        } catch (Exception ex) {

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

        } finally {

           DisposeUtils.disposeQuietly(store);

        }

    }

    public static final FeatureType featureType() {

        DataManager dataManager = DALLocator.getDataManager();

        EditableFeatureType ft = dataManager.createFeatureType();

        ft.setLabel("Online Remote changes");

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

        ft.add(COD_REMOTECHANGE, 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(FEATUREID, DataTypes.LONG)

                .setIsIndexed(false)

                .setLabel("Identifier")

                .setDescription("Feature code");

        ft.add(OPERATION, DataTypes.INTEGER)

                .setLabel("Operation")

                .setAvailableValues(new DynObjectValueItem[] {

                    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(REVISION_NUMBER, DataTypes.LONG)

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setLabel("Revision number");

        ft.add(FEATURE_DATA, DataTypes.STRING)

                .setSize(RECOMENDED_SIZE_FOR_CLOB)

                .setLabel("Data");

        return ft.getNotEditableCopy();

    }

    public DisposableFeatureSetIterable getGroupedByEntity(OnlineWorkingcopy workspace) {

        FeatureStore store = null;

        try {

            store = workspace.openFeatureStore(TABLE_NAME, true);

            FeatureQuery query = store.createFeatureQuery();

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

            query.getGroupByColumns().add(COD_ENTITY);

            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 {

            DisposeUtils.disposeQuietly(store);

        }

    }

    public boolean updateNeedMerge(OnlineWorkingcopy workspace, String entityCode) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            FeatureQuery query = store.createFeatureQuery("NOT \""+SELECTED+"\" AND \""+COD_ENTITY+"\"='"+entityCode+"'");

            query.setLimit(1);

            Feature f = store.findFirst(query);

            return f != null;

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve if need merge for entity code (ENTITY["+entityCode+"]).", ex);

        } finally {

           DisposeUtils.disposeQuietly(store);

        }

    }

    public boolean updateStateFromLocalChanges(OnlineWorkingcopy workspace, int status) {

        String sql = String.format(OnlineUtils.getSqlTemplate(workspace.getExplorer().getProviderName(), "updateStateFromLocalChanges"), status);

        workspace.getExplorer().execute(sql);

        return true;

    }

    public long getCountRemoteChangesOfEntity(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);

        }

    }

}