org.geojsf.mbean.handler.SldRuleHandler Maven / Gradle / Ivy

Go to download
package org.geojsf.mbean.handler;

import java.io.Serializable;
import java.util.Hashtable;
import java.util.Map;

import org.geojsf.factory.ejb.sld.EjbGeoSldRuleFactory;
import org.geojsf.factory.txt.TxtSldRuleFactory;
import org.geojsf.interfaces.facade.GeoJsfFacade;
import org.geojsf.interfaces.model.core.GeoJsfCategory;
import org.geojsf.interfaces.model.core.GeoJsfLayer;
import org.geojsf.interfaces.model.core.GeoJsfMap;
import org.geojsf.interfaces.model.core.GeoJsfService;
import org.geojsf.interfaces.model.core.GeoJsfView;
import org.geojsf.interfaces.model.meta.GeoJsfDataSource;
import org.geojsf.interfaces.model.meta.GeoJsfViewPort;
import org.geojsf.interfaces.model.sld.GeoJsfSld;
import org.geojsf.interfaces.model.sld.GeoJsfSldRule;
import org.geojsf.interfaces.model.sld.GeoJsfSldTemplate;
import org.primefaces.event.ReorderEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.sf.ahtutils.exception.ejb.UtilsConstraintViolationException;
import net.sf.ahtutils.exception.ejb.UtilsLockingException;
import net.sf.ahtutils.exception.ejb.UtilsNotFoundException;
import net.sf.ahtutils.factory.ejb.status.EjbDescriptionFactory;
import net.sf.ahtutils.factory.ejb.status.EjbLangFactory;
import net.sf.ahtutils.factory.ejb.symbol.EjbGraphicFactory;
import net.sf.ahtutils.interfaces.model.graphic.UtilsGraphic;
import net.sf.ahtutils.interfaces.model.graphic.UtilsGraphicStyle;
import net.sf.ahtutils.interfaces.model.graphic.UtilsGraphicType;
import net.sf.ahtutils.interfaces.model.status.UtilsDescription;
import net.sf.ahtutils.interfaces.model.status.UtilsLang;
import net.sf.ahtutils.interfaces.model.status.UtilsStatus;
import net.sf.ahtutils.jsf.util.PositionListReorderer;
import net.sf.ahtutils.web.mbean.util.AbstractLogMessage;

public class SldRuleHandler ,
							GT extends UtilsStatus,
							GS extends UtilsStatus,
							CATEGORY extends GeoJsfCategory,
							SERVICE extends GeoJsfService,
							LAYER extends GeoJsfLayer,
							MAP extends GeoJsfMap,
							VIEW extends GeoJsfView,
							VP extends GeoJsfViewPort,
							DS extends GeoJsfDataSource,
							SLDTEMPLATE extends GeoJsfSldTemplate,
							SLDTYPE extends UtilsStatus,
							SLD extends GeoJsfSld,
							RULE extends GeoJsfSldRule>
	implements Serializable
{
	private static final long serialVersionUID = 1L;
	final static Logger logger = LoggerFactory.getLogger(SldRuleHandler.class);
	
	private GeoJsfFacade fGeo;
	
	final String[] defaultLangs;
	
	final Class cSld;
	final Class cRule;
	final Class cGraphic;
	final Class cGraphicType;
	final Class cGraphicStyle;
	
	private EjbLangFactory efLang;
	private EjbDescriptionFactory efDescription;
	private EjbGraphicFactory efGraphic;
	
	private EjbGeoSldRuleFactory efRule;
	private TxtSldRuleFactory tfRule;
	
	private Map mapBounds; public Map getMapBounds() {return mapBounds;}
	
	private SLD sld; public SLD getSld(){return sld;} public void setSld(SLD sld){this.sld = sld;}
	private RULE rule; public RULE getRule(){return rule;} public void setRule(RULE rule){this.rule = rule;}
	private String lowerBound; public String getLowerBound() {return lowerBound;} public void setLowerBound(String lowerBound) {this.lowerBound = lowerBound;}
	private String upperBound; public String getUpperBound() {return upperBound;} public void setUpperBound(String upperBound) {this.upperBound = upperBound;}
	
	public SldRuleHandler(GeoJsfFacade fGeo,
			final String[] defaultLangs,
			final Class cL,
			final Class cD,
			final Class cRule,
			final Class cSld,
			final Class cGraphic,
			final Class cGraphicType,
			final Class cGraphicStyle)
	{
		this.fGeo=fGeo;
		this.defaultLangs=defaultLangs;
		
		this.cRule=cRule;
		this.cSld=cSld;
		this.cGraphic=cGraphic;
		this.cGraphicType=cGraphicType;
		this.cGraphicStyle=cGraphicStyle;
		
		mapBounds = new Hashtable();
		
		efLang = EjbLangFactory.createFactory(cL);
		efDescription = EjbDescriptionFactory.createFactory(cD);
		efGraphic = EjbGraphicFactory.factory(cGraphic);
		efRule = EjbGeoSldRuleFactory.factory(cRule);
		tfRule = TxtSldRuleFactory.factory();
	}
	
	public static ,
					GT extends UtilsStatus,
					GS extends UtilsStatus,
					CATEGORY extends GeoJsfCategory,
					SERVICE extends GeoJsfService,
					LAYER extends GeoJsfLayer,
					MAP extends GeoJsfMap,
					VIEW extends GeoJsfView,
					VP extends GeoJsfViewPort,
					DS extends GeoJsfDataSource,
					SLD extends GeoJsfSld,
					RULE extends GeoJsfSldRule,
					SLDTYPE extends UtilsStatus,
					SLDTEMPLATE extends GeoJsfSldTemplate> 
		SldRuleHandler factory(GeoJsfFacade fGeo,final String[] defaultLangs,final Class cL, final Class cD,final Class cRule,final Class cSld,final Class cGraphic,final Class cGraphicType,final Class cGraphicStyle)
	{
		return new SldRuleHandler(fGeo,defaultLangs,cL,cD,cRule,cSld,cGraphic,cGraphicType,cGraphicStyle);
	}
	
	public void reloadSld()
	{
		sld = fGeo.load(cSld,sld);
		logger.trace("Rules: "+sld.getRules().size());
		
		mapBounds.clear();
		for(RULE r : sld.getRules())
		{
			mapBounds.put(r, tfRule.build(r));
		}
	}
	
	public void onRowReorder(ReorderEvent event) throws UtilsConstraintViolationException, UtilsLockingException
	{
        logger.trace( "Row Moved", "From: " + event.getFromIndex() + ", To:" + event.getToIndex());
        PositionListReorderer.reorder(fGeo, sld.getRules());
        reloadSld();
    }
	
	
	public void addRule() throws UtilsNotFoundException
	{
		logger.info(AbstractLogMessage.addEntity(cRule));
		rule = efRule.build(sld);
		rule.setName(efLang.createEmpty(defaultLangs));
		rule.setDescription(efDescription.createEmpty(defaultLangs));
		
		GT type = fGeo.fByCode(cGraphicType, UtilsGraphicType.Code.symbol.toString());
		GS style = fGeo.fByCode(cGraphicStyle, UtilsGraphicStyle.Code.circle.toString());
		G g = efGraphic.buildSymbol(type, style);
		rule.setGraphic(g);
	}
	
	private void reloadRule()
	{
		rule = fGeo.load(cRule, rule);
	}
	
	public void selectRule()
	{
		reloadRule();
		logger.info(AbstractLogMessage.selectEntity(rule,rule.getGraphic()));
		rule = efLang.persistMissingLangs(fGeo, defaultLangs, rule);
		rule = efDescription.persistMissingLangs(fGeo, defaultLangs, rule);
		rule2String();
	}
	
	public void cancelRule()
	{
		rule=null;
	}
	
	public void saveRule() throws UtilsConstraintViolationException, UtilsLockingException
	{
		logger.info(AbstractLogMessage.saveEntity(rule));
		if(rule.getGraphic()!=null)
		{
			rule.getGraphic().setType(fGeo.find(cGraphicType, rule.getGraphic().getType()));
			if(rule.getGraphic().getStyle()!=null)
			{
				rule.getGraphic().setStyle(fGeo.find(cGraphicStyle, rule.getGraphic().getStyle()));
			}
			
		}
		string2Rule();
		rule = fGeo.save(cSld,sld,rule);
		reloadRule();
		reloadSld();
		rule2String();
	}
	
	public void rmRule() throws UtilsConstraintViolationException, UtilsLockingException
	{
		logger.info(AbstractLogMessage.rmEntity(rule));
		fGeo.rm(cSld,sld,rule);
		rule = null;
		reloadSld();
	}

	private void rule2String()
	{
		lowerBound = null; if(rule.getLowerBound()!=null){lowerBound = ""+rule.getLowerBound();}
		upperBound = null; if(rule.getUpperBound()!=null){upperBound = ""+rule.getUpperBound();}
	}
	
	private void string2Rule()
	{
		rule.setLowerBound(null);
		rule.setUpperBound(null);
		
		try
		{
			if(lowerBound!=null && lowerBound.length()>0){rule.setLowerBound(new Double(lowerBound));}
			if(upperBound!=null && upperBound.length()>0){rule.setUpperBound(new Double(upperBound));}
		}
		catch (NumberFormatException e){}
	}
}