gvSIG projects pool

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

import javax.json.JsonObject;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

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

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

import org.gvsig.json.Json;

import org.gvsig.tools.dataTypes.DataTypes;

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.workspace.tables.AbstractTable.AbstractRow;

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

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

/**

 *

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

    private static final String COD_ENTITY = "COD_ENTITY";

    public static final String SELECTED = "WSCH_SELECTED";

    private static final String FEATUREID = "WSCH_FEATURECODE";

    private static final String OPERATION = "WSCH_OPERATION";

    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 {

        public WorkspaceChangeRow(VCSGisWorkspace workspace) {

            this(workspace, null);

        }

        public WorkspaceChangeRow(VCSGisWorkspace workspace, Feature feature) {

            super(workspace, TABLE_NAME, COD_CHANGE, feature);

        }

        @Override

        public String getEntityCode() {

            return this.feature.getString(COD_ENTITY);

        }

        @Override

        public String getRelatedFeatureCode() {

            return this.feature.getString(FEATUREID);

        }

        @Override

        public int getOperation() {

            return this.feature.getInt(OPERATION);

        }

        @Override

        public String getOperationLabel() {

            return this.feature.getLabelOfValue(OPERATION);

        }

        @Override

        public String getLabel() {

            return this.feature.getString(LABEL);

        }

        @Override

        public boolean isSelected() {

            return this.feature.getBoolean(SELECTED);

        }

        public void setEntityCode(String code) {

            this.feature.set(COD_ENTITY, code);

        }

        public void setFeatureCode(String code) {

            this.feature.set(FEATUREID, code);

        }

        public void setOperation(int op) {

            this.feature.set(OPERATION, op);

        }

        @Override

        public void setSelected(boolean selected) {

            this.feature.set(SELECTED, selected);

        }

        public void setLabel(String label) {

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

        }

        @Override

        public String getData() {

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

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

            String s = this.getData();

            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.getData()+"' }";

                case OP_UPDATE:

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

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

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

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

                }

                return f;

            } catch (Exception ex) {

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

            }

        }        

        public EntityRow getEntity() {

            if( this.entity == null ) {

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

            }

            return this.entity;

        }

    }

    public WorkspaceChangesTable() {

        super(TABLE_NAME, featureType());

    }

    public DisposableFeatureSetIterable getByOperation(VCSGisWorkspace workspace, int 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 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.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) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            FeatureQuery query = store.createFeatureQuery();

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

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            if( StringUtils.isBlank(entityCode) ) {

                GetItemWithSizeAndIterator64<Feature> changes = store.getFeatures64(

                        null, 

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

                        true);

                return changes;

            }

            GetItemWithSizeAndIterator64<Feature> changes = store.getFeatures64(

                    ""+COD_ENTITY+"='"+entityCode+"'",

                    "-\""+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 store = null;

        try {

            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 {

            DisposeUtils.disposeQuietly(store);

        }

    }

    public void deleteAll(VCSGisWorkspace workspace) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

            store.delete("TRUE");

        } catch (Exception ex) {

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

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public void deleteSelecteds(VCSGisWorkspace workspace) {

        FeatureStore store = null;

        try {

            store = workspace.getFeatureStore(TABLE_NAME);

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

        } catch (Exception ex) {

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

                .setIsPrimaryKey(true)

                .setLabel("Code")

                .setReadOnly(false);        

        ft.add(COD_ENTITY, DataTypes.STRING)

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setSize(40)

                .setLabel("Entity code");

        ft.add(SELECTED, DataTypes.BOOLEAN)

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setLabel("Selected");

        ft.add(FEATUREID, DataTypes.STRING)

                .setIsIndexed(false)

                .setSize(40)

                .setLabel("Identifier")

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

        ft.add(OPERATION, DataTypes.INTEGER)

                .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(LABEL, DataTypes.STRING)

                .setIsIndexed(false)

                .setSize(MAX_SIZE_LABEL)

                .setLabel("Label")

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

        return ft.getNotEditableCopy();

    }

}