~yuanhung/xdgnjobs.git

			@@ -10,7 +10,9 @@
			import it.geosolutions.geoserver.rest.GeoServerRESTPublisher;
			import it.geosolutions.geoserver.rest.GeoServerRESTReader;
			import it.geosolutions.geoserver.rest.decoder.RESTDataStore;
			import it.geosolutions.geoserver.rest.decoder.RESTLayerList;
			import it.geosolutions.geoserver.rest.decoder.RESTStyleList;
			import it.geosolutions.geoserver.rest.decoder.utils.NameLinkElem;
			import it.geosolutions.geoserver.rest.encoder.GSLayerEncoder;
			import it.geosolutions.geoserver.rest.encoder.GSResourceEncoder;
			import it.geosolutions.geoserver.rest.encoder.datastore.GSPostGISDatastoreEncoder;
			@@ -35,10 +37,8 @@
			import java.net.URISyntaxException;
			import java.net.URL;
			import java.sql.*;
			import java.util.ArrayList;
			import java.util.HashMap;
			import java.util.List;
			import java.util.Map;
			import java.util.*;
			import java.util.Date;

			public class GeoserverIntegrateConfigJob extends OracleConvertDgn2PostGISJob {
			final static Log logger = LogFactory.getLog(GeoserverIntegrateConfigJob.class);
			@@ -123,6 +123,11 @@
			return xgeosDataConfigMapping;
			}

			private void logTimeDiff(String message, long tBefore, long tCurrent) {
			logger.warn(message + ":use time = " + ((int) ((tCurrent - tBefore) / 60000.0)) + " min - " +
			(((int) ((tCurrent - tBefore) % 60000.0)) / 1000) + " sec");
			}

			@Override
			public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

			@@ -143,8 +148,20 @@
			String targetSchemaName;

			try {
			logger.info("-- step:resetPostgisViewMapping --");
			long tStep = System.currentTimeMillis();
			resetPostgisViewMapping(jobExecutionContext);
			if (isProfileMode()) {
			long tStepEnd = System.currentTimeMillis();
			logTimeDiff("Profile-resetPostgisViewMapping", tStep, tStepEnd);
			}
			logger.info("-- step:resetGeoServerConfig --");
			tStep = System.currentTimeMillis();
			resetGeoServerConfig(jobExecutionContext);
			if (isProfileMode()) {
			long tStepEnd = System.currentTimeMillis();
			logTimeDiff("Profile-resetGeoServerConfig", tStep, tStepEnd);
			}
			} finally {
			disconnect();
			}
			@@ -406,22 +423,6 @@
			}
			}

			/*
			private boolean checkCurrentRepositoryStatus(DataStore dataStore, short status) {
			try {
			if (dataStore instanceof PostgisDataStore) {
			PostgisDataStore pgDataStore = (PostgisDataStore) dataStore;
			DataSource dataSource = pgDataStore.getDataSource();
			Connection connection = dataSource.getConnection();
			return checkCurrentRepositoryStatus(connection, status);
			}
			} catch (SQLException e) {
			logger.warn(e.getMessage(), e);
			}
			return false;
			}
			*/

			private boolean checkCurrentRepositoryStatus(Connection connection, short status) {
			try {
			return (retrieveCurrentSchemaName(connection, status) != null);
			@@ -453,6 +454,32 @@
			} finally {
			if (rs != null) rs.close();
			if (stmt != null) stmt.close();
			}
			}

			protected void transferXGeosVersionStatus(Connection connection,
			short vsstatusBefore, short vsstatusAfter, boolean exclusive) throws JobExecutionException {

			try {
			String currentTargetSchema = retrieveCurrentSchemaName(connection, vsstatusBefore);
			if (currentTargetSchema == null) {
			logger.info("Cannot found target schema in dataStore.");
			return;
			}
			String existTargetSchema = null;
			if (exclusive)
			existTargetSchema = retrieveCurrentSchemaName(connection, vsstatusAfter);


			updateCurrentRepositoryStatus(connection, currentTargetSchema, vsstatusAfter);
			if ((exclusive) && (existTargetSchema != null)) {
			updateCurrentRepositoryStatus(connection, existTargetSchema,
			DataReposVersionManager.VSSTATUS_AVAILABLE);
			}
			} catch (SQLException e) {
			logger.warn(e.getMessage(), e);
			throw new JobExecutionException("Update " + DataReposVersionManager.XGVERSIONTABLE_NAME +
			" has error-", e);
			}
			}

			@@ -524,8 +551,11 @@
			}
			}

			private void resetGeoServerConfig(JobExecutionContext jobExecutionContext) {
			private void resetGeoServerConfig(JobExecutionContext jobExecutionContext) throws JobExecutionException {
			try {
			Connection connection = targetDataStore.getConnection(Transaction.AUTO_COMMIT);
			transferXGeosVersionStatus(connection, DataReposVersionManager.VSSTATUS_LINKVIEW,
			DataReposVersionManager.VSSTATUS_CONFIG, false);
			URL geoServerURL = new URL(_geoServerURL);
			GeoServerRESTManager manager = new GeoServerRESTManager(geoServerURL, _geoServerUser, _geoServerPass);
			GeoServerRESTReader reader = manager.getReader();
			@@ -559,26 +589,18 @@

			resetFeatureTypesMapping(jobExecutionContext, reader);

			XGeosDataConfigMapping configMapping = getConfigMapping();
			MultiMap configMultiMap = configMapping.getMapping();
			for (Object key : configMultiMap.keySet()) {
			List values = (List) configMultiMap.get(key);
			for (Object value : values) {
			XGeosDataConfig xgeosConfig = (XGeosDataConfig) value;
			resetGeoserverWMSConfig(jobExecutionContext, connection, manager, true);
			resetWMSVirtualLayerMapping(jobExecutionContext, connection, manager, true);

			/*
			publishPostGISLayer(publisher, DEFAULT_NAMESPACE, DEFAULT_STORENAME,
			xgeosConfig.getPG(),
			"EPSG:" + SRSID_TWD97_ZONE121, "");
			*/
			}
			}


			} catch (MalformedURLException e) {
			transferXGeosVersionStatus(connection, DataReposVersionManager.VSSTATUS_CONFIG,
			DataReposVersionManager.VSSTATUS_USING, true);
			Date lastUpdate = Calendar.getInstance().getTime();
			} catch (IOException e) {
			logger.warn(e.getMessage(), e);
			throw new JobExecutionException("resetGeoServerConfig has error-" + e.getMessage(), e);
			} catch (URISyntaxException e) {
			logger.warn(e.getMessage(), e);
			throw new JobExecutionException("resetGeoServerConfig has error-" + e.getMessage(), e);
			}
			}

			@@ -693,4 +715,188 @@
			return defaultStyleName;
			}

			protected void resetGeoserverWMSConfig(JobExecutionContext executionContext, Connection connection,
			GeoServerRESTManager manager, boolean masterMode)
			throws JobExecutionException, IOException {

			if ((masterMode) && (!checkCurrentRepositoryStatus(connection, DataReposVersionManager.VSSTATUS_CONFIG))) {
			return;
			}

			GeoServerRESTReader reader = manager.getReader();
			RESTLayerList layers = reader.getLayers();

			ArrayList<String> baseMapNames = new ArrayList<String>();
			for (NameLinkElem elm : layers) {
			baseMapNames.add(elm.getName());
			}

			XGeosDataConfigMapping configMapping = getConfigMapping();
			if (configMapping.getMapping().isEmpty()) {
			logger.warn("XGeosDataConfigMapping is empty! Pleace check XGeosDataConfig file.");
			return;
			}

			LinkedList defaultMapNames = new LinkedList(configMapping.getMapping().keySet());
			if (defaultMapNames.isEmpty()) {
			logger.warn("DefaultMapNames is emptyin XGeosDataConfigMapping! Pleace check XGeosDataConfig file.");
			}

			for (Object key : baseMapNames) {
			String baseMapTitle = (String) key;
			if (configMapping.getMapping().containsKey(baseMapTitle)) {
			int index = defaultMapNames.indexOf(baseMapTitle);
			if (index != -1)
			defaultMapNames.remove(index);

			List configs = (List) configMapping.getMapping().get(baseMapTitle);
			String defaultLayerNames = buildDefaultWMSLayerNames(DEFAULTNAMESPACE, configs);
			wmsConfig.getBaseMapLayers().put(baseMapTitle, defaultLayerNames);
			} else {
			logger.warn("lv='" + baseMapTitle + "' cannot found config information in XGeosDataConfigMapping.");
			}
			}

			for (Object key : defaultMapNames) {
			List configs = (List) configMapping.getMapping().get(key);
			String defaultLayerNames = buildDefaultWMSLayerNames(DEFAULTNAMESPACE, configs);
			wmsConfig.getBaseMapLayers().put(key, defaultLayerNames);
			}
			}

			private void resetWMSVirtualLayerMapping(JobExecutionContext jobExecutionContext, Connection connection,
			GeoServerRESTManager manager, boolean masterMode)
			throws JobExecutionException, IOException {
			if ((masterMode) && (!checkCurrentRepositoryStatus(connection, DataReposVersionManager.VSSTATUS_CONFIG))) {
			return;
			}

			GeoServerRESTReader reader = manager.getReader();
			RESTLayerList layers = reader.getLayers();

			Map baseMapLayers = wmsConfig.getBaseMapLayers();
			Map baseMapEnvelopes = wmsConfig.getBaseMapEnvelopes();
			ArrayList baseMapNames = new ArrayList(baseMapLayers.keySet());

			for (Object key : baseMapNames) {
			String baseMapTitle = (String) key;
			if (baseMapTitle.startsWith("pg")) {
			GeneralEnvelope envelope = (GeneralEnvelope) baseMapEnvelopes.get(baseMapTitle);

			GeneralEnvelope selectedEnvelope = null;
			String baseLayersValue = (String) wmsConfig.getBaseMapLayers().get(baseMapTitle);
			String[] layerNames = null;
			if (baseLayersValue != null) {
			layerNames = baseLayersValue.split(",");
			} else {
			LOGGER.info("vl='" + baseMapTitle + "' is empty value.");
			continue;
			}

			ArrayList<String> newLayerNames = new ArrayList<String>();
			for (int i = 0; i < layerNames.length; i++) {
			String layerName = layerNames[i].trim();

			Integer layerType = catalog.getLayerType(layerName);
			if (layerType != null) {
			newLayerNames.add(layerName);
			if (layerType.intValue() == MapLayerInfo.TYPE_VECTOR) {
			FeatureTypeInfo ftype = catalog.getFeatureTypeInfo(layerName);
			ftype = ((ftype != null) ? ftype
			: catalog.getFeatureTypeInfo(layerName
			.substring(layerName.indexOf(":") + 1, layerName.length())));

			if (selectedEnvelope == null) {
			ReferencedEnvelope ftEnvelope = null;

			try {
			if (ftype.getBoundingBox() instanceof ReferencedEnvelope
			&& !ftype.getBoundingBox().isNull()) {
			ftEnvelope = ftype.getBoundingBox();
			} else {
			// TODO Add Action Errors
			return;
			}
			} catch (IOException e) {
			LOGGER.log(Level.WARNING, e.getMessage(), e);
			return;
			}

			selectedEnvelope = new GeneralEnvelope(new double[]{
			ftEnvelope.getMinX(), ftEnvelope.getMinY()
			},
			new double[]{ftEnvelope.getMaxX(), ftEnvelope.getMaxY()});
			selectedEnvelope.setCoordinateReferenceSystem(ftEnvelope
			.getCoordinateReferenceSystem());
			} else {
			final CoordinateReferenceSystem dstCRS = selectedEnvelope
			.getCoordinateReferenceSystem();

			ReferencedEnvelope ftEnvelope = null;

			try {
			if (ftype.getBoundingBox() instanceof ReferencedEnvelope) {
			ftEnvelope = (ReferencedEnvelope) ftype.getBoundingBox();
			ftEnvelope.transform(dstCRS, true);
			} else {
			// TODO Add Action Errors
			return;
			}
			} catch (TransformException e) {
			LOGGER.log(Level.WARNING, e.getMessage(), e);
			return;
			} catch (FactoryException e) {
			LOGGER.log(Level.WARNING, e.getMessage(), e);
			return;
			} catch (IOException e) {
			LOGGER.log(Level.WARNING, e.getMessage(), e);
			return;
			}

			ReferencedEnvelope newEnvelope = new ReferencedEnvelope(dstCRS);
			newEnvelope.init(selectedEnvelope.getLowerCorner().getOrdinate(0),
			selectedEnvelope.getUpperCorner().getOrdinate(0),
			selectedEnvelope.getLowerCorner().getOrdinate(1),
			selectedEnvelope.getUpperCorner().getOrdinate(1));

			newEnvelope.expandToInclude(ftEnvelope);

			selectedEnvelope = new GeneralEnvelope(new double[]{
			newEnvelope.getMinX(), newEnvelope.getMinY()
			},
			new double[]{newEnvelope.getMaxX(), newEnvelope.getMaxY()});
			selectedEnvelope.setCoordinateReferenceSystem(dstCRS);
			}
			}
			} else {
			LOGGER.warning("Cannot found layer " + layerName + " in " + baseMapTitle);
			}
			}

			if (layerNames.length != newLayerNames.size()) {
			StringBuilder layerBuilder = new StringBuilder();
			boolean bFirst = true;
			for (String newlayerName : newLayerNames) {
			if (!bFirst) {
			layerBuilder.append(',');
			} else bFirst = false;
			layerBuilder.append(newlayerName);
			}
			baseMapLayers.put(baseMapTitle, layerBuilder.toString());
			}

			if (selectedEnvelope != null) {
			if (envelope != null) {
			envelope.setCoordinateReferenceSystem(selectedEnvelope
			.getCoordinateReferenceSystem());
			envelope.setEnvelope(selectedEnvelope);
			baseMapEnvelopes.put(baseMapTitle, envelope);
			} else {
			baseMapEnvelopes.put(baseMapTitle, selectedEnvelope);
			}
			}
			}
			}
			}

			}