gvSIG projects pool

package org.gvsig.vcsgis.lib.repository.localdb.tables;

import java.sql.Timestamp;

import javax.json.JsonObject;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

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

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

import org.gvsig.json.JsonObjectBuilder;

import static org.gvsig.tools.dataTypes.DataTypeUtils.toTimestamp;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposableIterable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynform.spi.DynFormSPIManager;

import org.gvsig.tools.dynobject.DynObjectValueItem;

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

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

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

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

import org.gvsig.vcsgis.lib.VCSGisRevision;

import org.gvsig.vcsgis.lib.VCSGisRevisionImpl;

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

import org.gvsig.vcsgis.lib.repository.localdb.VCSGisRepositoryLocaldb;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class RevisionsRepoTable extends AbstractRepoTable {

    public static final String TABLE_NAME = "VCSGISREPO_REVISIONS";

    public static final String COD_REVISION = "COD_REVISION";

    private static final String COD_USER = "COD_USER";

    private static final String COD_ENTITY = "COD_ENTITY";

    public static final String REVISION_NUMBER = "REV_NUMBER";

    private static final String REVISION_COMMENT = "REV_COMMENT";

    private static final String REVISION_EFECTIVEDATE = "REV_EFECTIVEDATE";

    private static final String REVISION_OPERATIONDATE = "REV_OPERATIONDATE";

    private static final String REVISION_TAGS = "REV_TAGS";

    private static final String REVISION_TOPOLOGYPLAN = "REV_TOPPLAN";

    public static class RevisionRepoRow extends AbstractRow implements VCSGisRepositoryRevision{

        public RevisionRepoRow(VCSGisRepositoryLocaldb repository) {

            super(repository, TABLE_NAME, COD_REVISION, null);

        }

        public RevisionRepoRow(VCSGisRepositoryLocaldb repository, Feature feature) {

            super(repository, TABLE_NAME, COD_REVISION, feature);

        }

        @Override

        public String getUserCode() {

            return this.feature.getString(COD_USER);

        }

        @Override

        public String getRevisionCode() {

            return this.getCode();

        }

        @Override

        public String getEntityCode() {

            return this.feature.getString(COD_ENTITY);

        }

        @Override

        public Timestamp getRevisionDate() {

            return (Timestamp) this.feature.getTimestamp(REVISION_OPERATIONDATE);

        }

        @Override

        public Timestamp getEfectiveDate() {

            return (Timestamp) this.feature.getTimestamp(REVISION_EFECTIVEDATE);

        }

        @Override

        public String getTags() {

            return this.feature.getString(REVISION_TAGS);

        }

        @Override

        public long getNumber() {

            return this.feature.getLong(REVISION_NUMBER);

        }

        @Override

        public int getTopologyPlan() {

            return this.feature.getInt(REVISION_TOPOLOGYPLAN);

        }

        @Override

        public String getComment() {

            return this.feature.getString(REVISION_COMMENT);

        }

        public void setUserCode(String code) {

            this.feature.set(COD_USER, code);

        }

        public void setOperationDate(Timestamp date) {

            this.feature.set(REVISION_OPERATIONDATE, date);

        }

        public void setEfectiveDate(Timestamp date) {

            this.feature.set(REVISION_EFECTIVEDATE, date);

        }

        public void setRevisionDate(java.util.Date date) {

            this.feature.set(REVISION_OPERATIONDATE, toTimestamp(date));

        }

        public void setEfectiveDate(java.util.Date date) {

            this.feature.set(REVISION_EFECTIVEDATE, toTimestamp(date));

        }

        public void setTopologyPlan(int topologyPlan) {

            this.feature.set(REVISION_TOPOLOGYPLAN,topologyPlan);

        }

        public void setTags(String tags) {

            this.feature.set(REVISION_TAGS,tags);

        }

        public void setComment(String comment) {

            this.feature.set(REVISION_COMMENT, comment);

        }

        public void setEntityCode(String code) {

            this.feature.set(COD_ENTITY, code);

        }

        void calculateRevisionNumber() {

            FeatureStore store = null;

            FeatureSet fset = null;

            try {

                store = this.repository.getFeatureStore(TABLE_NAME);

                fset = store.getFeatureSet();

                this.feature.set(REVISION_NUMBER, fset.size64());                

//                FeatureQuery query = store.createFeatureQuery();

//                query.addAggregate("MAX", REVISION_NUMBER);

//                Feature f = store.first();

//                if( f == null ) {

//                    this.feature.set(REVISION_NUMBER, 1);                

//                } else {

//                    this.feature.set(REVISION_NUMBER, f.getInt(REVISION_NUMBER)+1);                

//                }

            } catch(Exception ex) {

                throw new RuntimeException("Can't calculate revision number.", ex);

            } finally {

                DisposeUtils.disposeQuietly(fset);

                DisposeUtils.disposeQuietly(store);

            }

        }

        @Override

        public void insert(FeatureStore store) {

            this.calculateRevisionNumber();

            super.insert(store);

        }

        @Override

        public void copyFrom(VCSGisRevision other) {

            this.setCode(other.getRevisionCode());

            this.setComment(other.getComment());

            this.setEfectiveDate(other.getEfectiveDate());

            this.setEntityCode(other.getEntityCode());

            this.setRevisionDate(other.getRevisionDate());

            this.setTags(other.getTags());

            this.setUserCode(other.getUserCode());

        }

        @Override

        public RevisionRepoRow getValue() {

            return this;

        }

        @Override

        public String getLabel() {

            return VCSGisRevisionImpl.getLabel(this);

        }

        @Override

        public JsonObject toJson() {

            return this.toJsonBuilder().build();

        }

        @Override

        public JsonObjectBuilder toJsonBuilder() {

            return VCSGisRevisionImpl.toJsonBuilder(this);

        }

        @Override

        public String toString() {

            return VCSGisRevisionImpl.toString(this);

        }

    }

    public RevisionsRepoTable() {

        super(TABLE_NAME, featureType());

    }

    public RevisionRepoRow getByRevisionCode(VCSGisRepositoryLocaldb repository, String revisionCode) {

        FeatureStore store = null;

        try {

            store = repository.getFeatureStore(TABLE_NAME);

            Feature f = store.findFirst("\""+COD_REVISION+"\"='"+revisionCode+"'");

            if( f==null ) {

                return null;

            }

            RevisionRepoRow row = new RevisionRepoRow(repository, f);

            return row;

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve revision '"+revisionCode+"'.", ex);

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    public static final FeatureType featureType() {

        DataManager dataManager = DALLocator.getDataManager();

        EditableFeatureType ft = dataManager.createFeatureType();

        ft.setLabel("VCSGIS Revisions");

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

        ft.getTags().set(DynFormSPIManager.TAG_DYNFORM_HEIGHT, 225);

        ft.getTags().set(DynFormSPIManager.TAG_DYNFORM_WIDTH, 570);

        ft.add(COD_REVISION, DataTypes.STRING)

                .setSize(VCSGISCODELEN)

                .setIsPrimaryKey(true)

                .setLabel("Code")

                .setReadOnly(false)

                .setDefaultFieldValue("<%=replace(UUID(),'-','')%>");

        ft.add(COD_USER, DataTypes.STRING)

                .setForeingkey(

                        true, 

                        false, 

                        UsersRepoTable.TABLE_NAME, 

                        UsersRepoTable.COD_USER, 

                        UsersRepoTable.USER_ID

                )                

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setSize(VCSGISCODELEN)

                .setLabel("Cod. user");

        ft.add(COD_ENTITY, DataTypes.STRING)

                .setForeingkey(

                        true, 

                        false, 

                        EntitiesRepoTable.TABLE_NAME, 

                        EntitiesRepoTable.COD_ENTITY, 

                        EntitiesRepoTable.ENTITY_NAME

                )                

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setSize(VCSGISCODELEN)

                .setLabel("Cod. entity");

        ft.add(REVISION_OPERATIONDATE, DataTypes.TIMESTAMP)

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setLabel("Revision date");

        ft.add(REVISION_EFECTIVEDATE, DataTypes.TIMESTAMP)

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setLabel("Efective Date");

        ft.add(REVISION_NUMBER, DataTypes.LONG)

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setLabel("Revision number");

        ft.add(REVISION_TOPOLOGYPLAN, DataTypes.INT)

                .setIsIndexed(false)

                .setLabel("Topology plan")

                .setAvailableValues(new DynObjectValueItem[] {

                    new DynObjectValueItem(TOPOLOGYPLAN_UNKNOWN, "Unknown"),

                    new DynObjectValueItem(TOPOLOGYPLAN_PASSED, "Passed"),

                    new DynObjectValueItem(TOPOLOGYPLAN_NOTPASSED, "Not passed"),

                });

        ft.add(REVISION_TAGS, DataTypes.STRING)

                .setSize(200)

                .setLabel("Tags");

        ft.add(REVISION_COMMENT, DataTypes.STRING)

                .setDataProfileName("Text")

                .setSize(500)

                .setLabel("Comment");

        return ft.getNotEditableCopy();

    }

    public RevisionsRepoTable(String tableName, FeatureType featureType) {

        super(tableName, featureType);

    }

    public DisposableIterable<Feature> getRevisionsByDate(VCSGisRepositoryLocaldb repository, String entityCode, Timestamp maxDate, Timestamp minDate, int maxNumberOfRevisions) {

        FeatureStore store = null;

        DisposableIterable<Feature> features = null;

        try {

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            builder.and(

                    builder.eq(

                            builder.column(COD_ENTITY), 

                            builder.constant(entityCode)

                    )

            );

            builder.and(

                    builder.ge(

                            builder.column(REVISION_OPERATIONDATE), 

                            builder.constant(minDate)

                    )

            );

            builder.and(

                    builder.le(

                            builder.column(REVISION_OPERATIONDATE), 

                            builder.constant(maxDate)

                    )

            );

            store = repository.openFeatureStore(TABLE_NAME, null);

            FeatureQuery query = store.createFeatureQuery(builder.toString(), REVISION_NUMBER, false);

            query.setLimit(maxNumberOfRevisions);

            FeatureSet fset = store.getFeatureSet(query);

            features = fset.iterable();

            return features;

        } catch (Exception ex) {

            DisposeUtils.disposeQuietly(features);

            throw new RuntimeException("Can't retrieve revisions of 'ENTITY["+entityCode+"].", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public DisposableIterable<Feature> getRevisionsByRevisionNumber(VCSGisRepositoryLocaldb repository, String entityCode, long maxRevisionNumber, long minRevisionNumber, int maxNumberOfRevisions) {

        FeatureStore store = null;

        DisposableIterable<Feature> features = null;

        try {

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            builder.and(

                    builder.eq(

                            builder.column(COD_ENTITY), 

                            builder.constant(entityCode)

                    )

            );

            if( minRevisionNumber>=0 ) {

                builder.and(

                        builder.ge(

                                builder.column(REVISION_NUMBER), 

                                builder.constant(minRevisionNumber)

                        )

                );

            }

            if( maxRevisionNumber>=0 ) {

                builder.and(

                        builder.lt(

                                builder.column(REVISION_NUMBER), 

                                builder.constant(maxRevisionNumber)

                        )

                );

            }

            store = repository.openFeatureStore(TABLE_NAME, null);

            FeatureQuery query = store.createFeatureQuery(builder.toString(), REVISION_NUMBER, false);

            query.setLimit(maxNumberOfRevisions);

            FeatureSet fset = store.getFeatureSet(query);

            features = fset.iterable();

            return features;

        } catch (Exception ex) {

            DisposeUtils.disposeQuietly(features);

            throw new RuntimeException("Can't retrieve revisions of 'ENTITY["+entityCode+"].", ex);

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

}