gvSIG projects pool

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

import java.util.HashMap;

import java.util.List;

import java.util.Map;

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

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

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

import org.gvsig.json.Json;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.VCSGisEntityEditable;

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

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

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

import org.gvsig.vcsgis.lib.VCSGisUser;

import org.gvsig.vcsgis.lib.VCSGisUtils;

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

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class EntitiesRepoTable extends AbstractRepoTable {

    public static final String TABLE_NAME = "VCSGISREPO_ENTITIES";

    public static final String COD_ENTITY = "COD_ENTITY";

    private static final String COD_USER = "COD_USER";

    private static final String COD_TOPOLOGYPLAN = "COD_TOPOLOGYPLAN";

    private static final String COD_REVISION = "COD_REVISION";

    public static final String ENTITY_NAME = "ENT_NAME";

    private static final String DATATABLE_NAME = "ENT_DATATABLE";

    private static final String FEATUREID_FIELD_NAME = "ENT_FEATURECODE";

    private static final String GEOMETRY_FIELD_NAME = "ENT_GEOMNAME";

    private static final String DESCRIPTION = "ENT_DESCRIPTION";

    private static final String FEATURETYPE = "ENT_FEATURETYPE";

    private static final String FIELD_FOR_LABEL = "ENT_FIELDFORLABEL";

    private static final String CATEGORY = "ENT_CATEGORY";

    private static final String LABEL = "ENT_LABEL";

    private static final String AUTHORIZATIONS = "ENT_AUTORIZATIONS";

    private static final String TOPOLOGYPLAN_MODE = "ENT_TOPOLOGYPLAN_MODE";

    public static final String RESOURCES = "ENT_RESOURCES";

    public static final String DATA_MODELS = "ENT_DATA_MODELS";

    public static class EntityRepoRow extends AbstractRow implements VCSGisEntityEditable {

        FeatureType featureType;

        public EntityRepoRow(VCSGisRepositoryLocaldb repository) {

            super(repository, TABLE_NAME, COD_ENTITY, null);

        }

        public EntityRepoRow(VCSGisRepositoryLocaldb repository, Feature feature) {

            super(repository, TABLE_NAME, COD_ENTITY, feature);

        }

        @Override

        public String getEntityCode() {

            return super.getCode();

        }

        @Override

        public VCSGisEntityEditable setEntityCode(String code) {

            super.setCode(code);

            return this;

        }

        @Override

        public String getEntityName() {

            return this.feature.getString(ENTITY_NAME);

        }

        @Override

        public String getRepositoryRevisionCode() {

            return this.feature.getString(COD_REVISION);

        }

        @Override

        public String getTopologyPlanCode() {

            return this.feature.getString(COD_TOPOLOGYPLAN);

        }

        @Override

        public String getUserCode() {

            return this.feature.getString(COD_USER);

        }

        @Override

        public String getDataTableName() {

            return this.feature.getString(DATATABLE_NAME);

        }

        @Override

        public String getFeatureIdFieldName() {

            return this.feature.getString(FEATUREID_FIELD_NAME);

        }

        @Override

        public String getGeometryFieldName() {

            return this.feature.getString(GEOMETRY_FIELD_NAME);

        }

        @Override

        public String getDescription() {

            return this.feature.getString(DESCRIPTION);

        }

        @Override

        public String getFieldForLabel() {

            return this.feature.getString(FIELD_FOR_LABEL);

        }

        @Override

        public String getCategory() {

            return this.feature.getString(CATEGORY);

        }

        @Override

        public List<String> getCategoriesAsList() {

            String s = getCategory();

            return VCSGisUtils.getAsList(s);

        }

        @Override

        public String getAuthorizations() {

            return this.feature.getString(AUTHORIZATIONS);

        }

        @Override

        public int getTopologyPlanMode() {

            return this.feature.getIntOrDefault(TOPOLOGYPLAN_MODE, TOPOLOGYPLAN_MODE_RECOMMENDED);

        }

        @Override

        public String getLabel() {

            return this.feature.getString(LABEL);

        }

        @Override

        public String getFeatureTypeAsJson() {

            return this.feature.getString(FEATURETYPE);

        }

        @Override

        public FeatureType getFeatureType() {

            if( this.featureType==null ) {

                JsonObject json = Json.createObject(this.getFeatureTypeAsJson());

                this.featureType = DALLocator.getDataManager().createFeatureType(json);

            }

            return this.featureType;

        }

        @Override

        public VCSGisEntityEditable setEntityName(String entityName) {

            this.feature.set(ENTITY_NAME, entityName);

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

                this.setLabel(entityName);

            }

            return this;

        }

        @Override

        public VCSGisEntityEditable setRepositoryRevisionCode(String code) {

            this.feature.set(COD_REVISION, code);

            return this;

        }

        @Override

        public VCSGisEntityEditable setDataTableName(String dataTableName) {

            this.feature.set(DATATABLE_NAME, dataTableName);

            return this;

        }

        @Override

        public VCSGisEntityEditable setFeatureIdFieldName(String name) {

            this.feature.set(FEATUREID_FIELD_NAME, name);

            return this;

        }

        @Override

        public VCSGisEntityEditable setGeometryFieldName(String name) {

            this.feature.set(GEOMETRY_FIELD_NAME, name);

            return this;

        }

        @Override

        public VCSGisEntityEditable setDescription(String description) {

            this.feature.set(DESCRIPTION, description);

            return this;

        }

        @Override

        public VCSGisEntityEditable setFieldForLabel(String fieldForLabel) {

            this.feature.set(FIELD_FOR_LABEL, fieldForLabel);

            return this;

        }

        @Override

        public VCSGisEntityEditable setFeatureTypeAsJson(String json) {

            this.feature.set(FEATURETYPE, json);

            this.featureType = null;

            return this;

        }

        public void setFeatureType(FeatureType featureType) {

            this.feature.set(FEATURETYPE, featureType.toJson().toString());

            this.featureType = featureType;

        }

        @Override

        public VCSGisEntityEditable setTopologyPlanCode(String code) {

            this.feature.set(COD_TOPOLOGYPLAN, code);

            return this;

        }

        @Override

        public VCSGisEntityEditable setUserCode(String code) {

            this.feature.set(COD_USER, code);

            return this;

        }

        @Override

        public VCSGisEntityEditable setCategory(String category) {

            this.feature.set(CATEGORY, category);

            return this;

        }

        @Override

        public VCSGisEntityEditable setAuthorizations(String authorizations) {

            this.feature.set(AUTHORIZATIONS, authorizations);

            return this;

        }

        @Override

        public VCSGisEntityEditable setTopologyPlanMode(int topologyPlanMode) {

            this.feature.set(TOPOLOGYPLAN_MODE, topologyPlanMode);

            return this;

        }

        @Override

        public VCSGisEntityEditable setLabel(String label) {

            this.feature.set(LABEL, label);

            return this;

        }

        @Override

        public void copyfrom(VCSGisEntity entity) {

            VCSGisUtils.copy(entity, this, null);

        }

        @Override

        public void copyto(VCSGisEntityEditable entity) {

            VCSGisUtils.copy(this, entity, null);

        }

        @Override

        public JsonObject toJson() {

            return VCSGisUtils.toJsonBuilder(this, null).build();

        }

        @Override

        public JsonObjectBuilder toJsonBuilder() {

            return VCSGisUtils.toJsonBuilder(this, null);

        }

        @Override

        public void fromJson(JsonObject json) {

            VCSGisUtils.fromJson(this, json);

        }

        @Override

        public EntityRepoRow getValue() {

            return this;

        }

        @Override

        public String toString() {

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

                return this.getEntityName();

            }

            return this.getLabel();

        }

        @Override

        public boolean isAuthorized(VCSGisUser user, String operation) {

            return VCSGisUtils.isAuthorized(this, operation, user);

        }

        @Override

        public VCSGisEntityEditable setResources(String resources) {

            this.feature.set(RESOURCES, resources);

            return this;

        }

        @Override

        public VCSGisEntityEditable setDataModels(String dataModels) {

            this.feature.set(DATA_MODELS, dataModels);

            return this;

        }

        @Override

        public String getResources() {

            return this.getString(RESOURCES);

        }

        @Override

        public String getDataModels() {

            return this.getString(DATA_MODELS);

        }

        @Override

        public List<String> getDataModelsAsList() {

            String s = getDataModels();

            return VCSGisUtils.getAsList(s, false);

        }

    }

    public EntitiesRepoTable() {

        super(TABLE_NAME, featureType());

    }

    public EntityRepoRow getByEntityCode(VCSGisRepositoryLocaldb repository, String entityCode) {

        FeatureStore store = null;

        try {

            store = repository.getFeatureStore(TABLE_NAME);

            Feature f = store.findFirst("\""+COD_ENTITY+"\"='"+entityCode+"'");

            if( f==null ) {

                return null;

            }

            EntityRepoRow row = new EntityRepoRow(repository, f);

            return row;

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve entity '"+entityCode+"'.", ex);

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    public EntityRepoRow getByEntityName(VCSGisRepositoryLocaldb repository, String entityName) {

        FeatureStore store = null;

        try {

            store = repository.getFeatureStore(TABLE_NAME);

            Feature f = store.findFirst("\""+ENTITY_NAME+"\"='"+entityName+"'");

            if( f==null ) {

                return null;

            }

            EntityRepoRow row = new EntityRepoRow(repository, f);

            return row;

        } catch (Exception ex) {

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

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    public Map<String, EntityRepoRow> getAllAsMap(VCSGisRepositoryLocaldb repository) {

        Map<String, EntityRepoRow> entitiesMap = new HashMap<>();

        DisposableFeatureSetIterable entities = this.getAll(repository);

        for (Feature fentity : entities) {

            EntityRepoRow entity = new EntityRepoRow(repository, fentity);

            entitiesMap.put(entity.getCode(), entity);

        }

        entities = null;

        DisposeUtils.disposeQuietly(entities);        

        return entitiesMap;

    }

    public DisposableFeatureSetIterable getAll(VCSGisRepositoryLocaldb repository) {

        FeatureStore store = null;

        try {

            store = repository.getFeatureStore(TABLE_NAME);

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

            return changes;

        } catch (Exception ex) {

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

        } finally {

            if( store!=null ) {

                DisposeUtils.dispose(store);

            }

        }

    }

    public static final FeatureType featureType() {

        DataManager dataManager = DALLocator.getDataManager();

        EditableFeatureType ft = dataManager.createFeatureType();

        ft.setLabel("VCSGIS Entities");

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

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

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

        ft.getTags().set(DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE, DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE_VALUE_TABS);

        ft.add(COD_ENTITY, DataTypes.STRING)

                .setSize(VCSGISCODELEN)

                .setIsPrimaryKey(true)

                .setLabel("Code")

                .setOrder(10);

        ft.add(COD_REVISION, DataTypes.STRING)

                .setForeingkey(

                        true, 

                        false, 

                        RevisionsRepoTable.TABLE_NAME, 

                        RevisionsRepoTable.COD_REVISION, 

                        "FORMAT('r%d %s', REV_NUMBER, REV_OPERATIONDATE)"

                )

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setSize(VCSGISCODELEN)

                .setLabel("Head revision of this entity")

                .setOrder(40);

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

                .setOrder(30);

        ft.add(COD_TOPOLOGYPLAN, DataTypes.STRING)

                .setForeingkey(

                        true, 

                        false, 

                        TopologyplanRepoTable.TABLE_NAME, 

                        TopologyplanRepoTable.COD_TOPOLOGYPLAN, 

                        TopologyplanRepoTable.TOPPLAN_NAME

                )

                .setSize(VCSGISCODELEN)

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(true)

                .setLabel("Topology plan")

                .setOrder(90);                  

        ft.add(ENTITY_NAME, DataTypes.STRING)

                .setIsIndexed(true)

                .setAllowIndexDuplicateds(false)

                .setSize(200)

                .setLabel("Name")

                .setOrder(20);

        ft.add(DATATABLE_NAME, DataTypes.STRING)

                .setSize(200)

                .setLabel("Name of the table in which the data is stored")

                .setOrder(50);

        ft.add(FEATUREID_FIELD_NAME, DataTypes.STRING)

                .setSize(200)

                .setLabel("Name of the primary key attribute.")

                .setOrder(60);

        ft.add(GEOMETRY_FIELD_NAME, DataTypes.STRING)

                .setSize(200)

                .setLabel("Name of the geometry attribute.")

                .setOrder(70);

        ft.add(FIELD_FOR_LABEL, DataTypes.STRING)

                .setSize(200)

                .setLabel("Field for label")

                .setOrder(10);

        ft.add(CATEGORY, DataTypes.STRING)

                .setSize(200)

                .setLabel("Category")

                .setOrder(80);

        ft.add(LABEL, DataTypes.STRING)

                .setSize(200)

                .setLabel("Label")

                .setOrder(25);

        ft.add(AUTHORIZATIONS, DataTypes.STRING)               

                .setTag(DynFormSPIManager.TAG_DYNFORM_RESIZEWEIGHT, 60) 

                .setTag(DynFormSPIManager.TAG_DYNFORM_LABEL_EMPTY, true) 

                .setDataProfileName("Text")

                .setSize(10240)

                .setLabel("Authorizations")

                .setGroup("Authorizations")

                .setOrder(10)

                .setDefaultFieldValue("{\n" +

"  \"add\": [ \"*\" ],\n" +

"  \"checkout\": [ \"*\" ],\n" +

"  \"commit\": [ \"*\" ],\n" +

"  \"entities\": [ \"*\" ],\n" +

"  \"history\": [ \"*\" ],\n" +

"  \"topologyplans\": [ \"*\" ],\n" +

"  \"update\": [ \"*\" ],\n" +

"  \"users\": [ \"*\" ]\n" +

"}")

                .setDescription("Json with the information of what operations the different users can do.\nExample:\n{\n" +

"  \"add\": [ \"user1\", \"$admin\"],\n" +

"  \"checkout\": [ \"user1\", \"user2\"],\n" +

"  \"commit\": [ \"user1\" ],\n" +

"  \"entities\": [ \"user1\", \"user2\"],\n" +

"  \"history\": [ \"user1\" ],\n" +

"  \"topologyplans\": [ \"user1\", \"user2\"],\n" +

"  \"update\": [ \"user1\", \"user2\"],\n" +

"  \"users\": [ \"user1\", \"user2\"]\n" +

"}\n\n" +

"use $ before the name to indicate a role name instead of a username."

                );

        ft.add(DESCRIPTION, DataTypes.STRING)

                .setTag(DynFormSPIManager.TAG_DYNFORM_RESIZEWEIGHT, 60)

                .setDataProfileName("Text")

                .setSize(10240)

                .setLabel("Description")

                .setOrder(110);

        ft.add(FEATURETYPE, DataTypes.STRING)

                .setTag(DynFormSPIManager.TAG_DYNFORM_RESIZEWEIGHT, 60)

                .setTag(DynFormSPIManager.TAG_DYNFORM_LABEL_EMPTY, true)

                .setDataProfileName("Text")

                .setSize(10240)

                .setLabel("Feature type")

                .setGroup("Feature type")

                .setOrder(10);

        ft.add(TOPOLOGYPLAN_MODE, DataTypes.INTEGER)

                .setLabel("Topology plan mode")                

                .setAvailableValues(new DynObjectValueItem[] {

                    new DynObjectValueItem(TOPOLOGYPLAN_MODE_RECOMMENDED, "Recommended"),

                    new DynObjectValueItem(TOPOLOGYPLAN_MODE_MANDATORY, "Mandatory")

                })

                .setOrder(100);

        ft.add(RESOURCES, DataTypes.STRING)

                .setSize(200)

                .setLabel("Resources");

        ft.add(DATA_MODELS, DataTypes.STRING)

                .setSize(200)

                .setLabel("Data models");

        return ft.getNotEditableCopy();

    }

}