/ - Diff - D-Net - D-Net project tracking tool

     import java.util.Map;
     import java.util.Set;
     import javax.annotation.Resource;
     import org.apache.commons.lang.StringUtils;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.dom4j.Document;
     import org.dom4j.Element;
     import org.springframework.beans.factory.annotation.Required;
     import com.google.common.collect.Sets;
     import eu.dnetlib.conf.PropertyFetcher;
     import eu.dnetlib.msro.rmi.MSROException;
     import eu.dnetlib.msro.workflows.util.NodeHelper;
-...
     	private NodeHelper nodeHelper;
     	@Resource(name = "propertyFetcher")
     	private PropertyFetcher propertyFetcher;
     	private static final Log log = LogFactory.getLog(GraphLoader.class);
     	public Graph loadGraph(final Document doc, final Map<String, String> globalParams) throws MSROException {
     		final Graph graph = new Graph();
-...
     			final String pName = p.valueOf("@name");
     			final String pValue = p.valueOf("@value");
     			final String pRef = p.valueOf("@ref");
     			final String pProp = p.valueOf("@property");
     			if (StringUtils.isNotBlank(pRef) && StringUtils.isNotBlank(globalParams.get(pRef))) {
     				params.put(pName, globalParams.get(pRef));
     			} else if (StringUtils.isNotBlank(pValue)) {
     				params.put(pName, pValue);
     			} else if (StringUtils.isNotBlank(pProp)) {
     				params.put(pName, resolveProperty(pProp));
     			} else if (p.selectSingleNode("./MAP") != null) {
     				final Map<String, String> map = new HashMap<String, String>();
-...
     					final String eKey = entry.valueOf("@key");
     					final String eValue = entry.valueOf("@value");
     					final String eRef = entry.valueOf("@ref");
     					final String eProp = entry.valueOf("@property");
     					if (StringUtils.isNotBlank(eRef) && StringUtils.isNotBlank(globalParams.get(eRef))) {
     						map.put(eKey, globalParams.get(eRef));
     					} else if (StringUtils.isNotBlank(eValue)) {
     						map.put(eKey, eValue);
     					} else if (StringUtils.isNotBlank(eProp)) {
     						map.put(eKey, resolveProperty(eProp));
+    					}
+    				}
     				params.put(pName, map);
-...
     					final Element item = (Element) i;
     					final String iValue = item.valueOf("@value");
     					final String iRef = item.valueOf("@ref");
     					final String iProp = item.valueOf("@property");
     					if (StringUtils.isNotBlank(iRef) && StringUtils.isNotBlank(globalParams.get(iRef))) {
     						list.add(globalParams.get(iRef));
     					} else if (StringUtils.isNotBlank(iValue)) {
     						list.add(iValue);
     					} else if (StringUtils.isNotBlank(iProp)) {
     						list.add(resolveProperty(iProp));
+    					}
+    				}
     				params.put(pName, list);
-...
     		return params;
+    	}
     	private String resolveProperty(final String propertyName) {
     		if (!this.propertyFetcher.getProps().containsKey(propertyName)) {
     			log.warn("unable to find system property: " + propertyName);
+    		}
     		return this.propertyFetcher.getProperty(propertyName);
+    	}
     	private void checkValidity(final Graph graph) throws MSROException {
     		final Set<String> nodesFromArcs = new HashSet<String>();

     package eu.dnetlib.msro.workflows.nodes.db;
     import java.io.IOException;
     import javax.annotation.Resource;
     import org.apache.commons.io.IOUtils;
     import eu.dnetlib.enabling.database.rmi.DatabaseService;
     import eu.dnetlib.enabling.locators.UniqueServiceLocator;
     import eu.dnetlib.msro.workflows.graph.Arc;
     import eu.dnetlib.msro.workflows.nodes.AsyncJobNode;
     import eu.dnetlib.msro.workflows.procs.Env;
     import org.apache.commons.io.IOUtils;
     public class ExecuteSqlJobNode extends AsyncJobNode {
     	private String db;
     	private String dbParam;
     	private String dbProperty;
     	private String sql;
-...
     	@Override
     	protected String execute(final Env env) throws Exception {
     		serviceLocator.getService(DatabaseService.class).updateSQL(findDb(env), fetchSqlAsText(sql));
     		this.serviceLocator.getService(DatabaseService.class).updateSQL(findDb(env), fetchSqlAsText(this.sql));
     		return Arc.DEFAULT_ARC;
+    	}
-...
+    	}
     	private String findDb(final Env env) {
     		if (dbParam != null && !dbParam.isEmpty()) {
     			return env.getAttribute(dbParam, String.class);
     		} else if (dbProperty != null && !dbProperty.isEmpty()) {
     			return getPropertyFetcher().getProperty(dbProperty);
     		if (this.dbParam != null && !this.dbParam.isEmpty()) {
     			return env.getAttribute(this.dbParam, String.class);
     		} else {
     			return db;
     			return this.db;
+    		}
+    	}
     	public String getDb() {
     		return db;
     		return this.db;
+    	}
     	public void setDb(final String db) {
-...
+    	}
     	public String getDbParam() {
     		return dbParam;
     		return this.dbParam;
+    	}
     	public void setDbParam(final String dbParam) {
     		this.dbParam = dbParam;
+    	}
     	public String getDbProperty() {
     		return dbProperty;
+    	}
     	public void setDbProperty(final String dbProperty) {
     		this.dbProperty = dbProperty;
+    	}
     	public String getSql() {
     		return sql;
     		return this.sql;
+    	}
     	public void setSql(final String sql) {

     package eu.dnetlib.msro.workflows.nodes.db;
     import java.io.IOException;
     import javax.annotation.Resource;
     import javax.xml.ws.wsaddressing.W3CEndpointReference;
     import org.apache.commons.io.IOUtils;
     import org.apache.commons.lang.StringUtils;
     import eu.dnetlib.enabling.database.rmi.DatabaseService;
     import eu.dnetlib.enabling.locators.UniqueServiceLocator;
     import eu.dnetlib.msro.workflows.graph.Arc;
     import eu.dnetlib.msro.workflows.nodes.AsyncJobNode;
     import eu.dnetlib.msro.workflows.procs.Env;
     import org.apache.commons.io.IOUtils;
     import org.apache.commons.lang.StringUtils;
     public class QueryDbJobNode extends AsyncJobNode {
     	private String db;
     	private String dbParam;
     	private String dbProperty;
     	private String sql;
     	private String sqlForSize;
-...
     	@Override
     	protected String execute(final Env env) throws Exception {
     		final String sqlText = fetchSqlAsText(sql);
     		final String sqlText = fetchSqlAsText(this.sql);
     		W3CEndpointReference epr = null;
     		final DatabaseService dbService = serviceLocator.getService(DatabaseService.class);
     		final DatabaseService dbService = this.serviceLocator.getService(DatabaseService.class);
     		if (StringUtils.isNotBlank(xslt)) {
     			final String xsltText = IOUtils.toString(getClass().getResourceAsStream(xslt));
     		if (StringUtils.isNotBlank(this.xslt)) {
     			final String xsltText = IOUtils.toString(getClass().getResourceAsStream(this.xslt));
     			if (StringUtils.isBlank(sqlForSize)) {
     			if (StringUtils.isBlank(this.sqlForSize)) {
     				epr = dbService.xsltSearchSQL(findDb(env), sqlText, xsltText);
     			} else {
     				epr = dbService.alternativeXsltSearchSQL(findDb(env), sqlText, fetchSqlAsText(sqlForSize), xsltText);
     				epr = dbService.alternativeXsltSearchSQL(findDb(env), sqlText, fetchSqlAsText(this.sqlForSize), xsltText);
+    			}
     		} else {
     			if (StringUtils.isBlank(sqlForSize)) {
     			if (StringUtils.isBlank(this.sqlForSize)) {
     				epr = dbService.searchSQL(findDb(env), sqlText);
     			} else {
     				epr = dbService.alternativeSearchSQL(findDb(env), sqlText, fetchSqlAsText(sqlForSize));
     				epr = dbService.alternativeSearchSQL(findDb(env), sqlText, fetchSqlAsText(this.sqlForSize));
+    			}
+    		}
     		env.setAttribute(outputEprParam, epr.toString());
     		env.setAttribute(this.outputEprParam, epr.toString());
     		return Arc.DEFAULT_ARC;
+    	}
-...
+    	}
     	private String findDb(final Env env) {
     		if (dbParam != null && !dbParam.isEmpty()) {
     			return env.getAttribute(dbParam, String.class);
     		} else if (dbProperty != null && !dbProperty.isEmpty()) {
     			return getPropertyFetcher().getProperty(dbProperty);
     		if (this.dbParam != null && !this.dbParam.isEmpty()) {
     			return env.getAttribute(this.dbParam, String.class);
     		} else {
     			return db;
     			return this.db;
+    		}
+    	}
     	public String getDb() {
     		return db;
     		return this.db;
+    	}
     	public void setDb(final String db) {
-...
+    	}
     	public String getDbParam() {
     		return dbParam;
     		return this.dbParam;
+    	}
     	public void setDbParam(final String dbParam) {
-...
+    	}
     	public String getSql() {
     		return sql;
     		return this.sql;
+    	}
     	public void setSql(final String sql) {
-...
+    	}
     	public String getXslt() {
     		return xslt;
     		return this.xslt;
+    	}
     	public void setXslt(final String xslt) {
-...
+    	}
     	public String getOutputEprParam() {
     		return outputEprParam;
     		return this.outputEprParam;
+    	}
     	public void setOutputEprParam(final String outputEprParam) {
     		this.outputEprParam = outputEprParam;
+    	}
     	public String getDbProperty() {
     		return dbProperty;
+    	}
     	public void setDbProperty(final String dbProperty) {
     		this.dbProperty = dbProperty;
+    	}
     	public String getSqlForSize() {
     		return sqlForSize;
     		return this.sqlForSize;
+    	}
     	public void setSqlForSize(final String sqlForSize) {

     package eu.dnetlib.msro.workflows.nodes;
     import java.util.HashMap;
     import java.util.Map;
     import javax.annotation.Resource;
     import org.springframework.beans.factory.BeanNameAware;
     import com.google.gson.Gson;
     import eu.dnetlib.conf.PropertyFetcher;
     import eu.dnetlib.msro.workflows.procs.Env;
     import eu.dnetlib.msro.workflows.procs.Token;
     import org.apache.commons.lang.StringUtils;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.springframework.beans.factory.BeanNameAware;
     /**
      * Created by michele on 19/11/15.
      */
     public abstract class ProcessNode implements BeanNameAware {
     	private static final Log log = LogFactory.getLog(ProcessNode.class);
     	private String beanName;
     	@Resource(name = "propertyFetcher")
     	private PropertyFetcher propertyFetcher;
     	/**
     	 * parameter values injected as json map into subclasses instance beans.
     	 */
     	private String jsonParams;
     	/**
     	 * parameter values retrieved from the process Env.
     	 */
     	private String jsonEnvParams;
     	/**
     	 * parameter values retrieved from the system properties.
     	 */
     	private String jsonSystemPropertyParams;
     	public abstract void execute(final Token token);
     	protected final Map<String, Object> parseJsonParameters(final Env env) {
     		final Map<String, Object> res = new HashMap<String, Object>();
     		for (Map.Entry<?, ?> e : asMap(getJsonEnvParams()).entrySet()) {
     			final String propertyName = e.getValue().toString();
     			if (!getPropertyFetcher().getProps().containsKey(propertyName)) {
     				log.warn("unable to find system property: " + propertyName);
+    			}
     			final String propertyValue = getPropertyFetcher().getProperty(propertyName);
     			res.put(e.getKey().toString(), propertyValue);
+    		}
     		for (Map.Entry<?, ?> e : asMap(getJsonEnvParams()).entrySet()) {
     			res.put(e.getKey().toString(), env.getAttribute(e.getValue().toString()));
+    		}
     		for (Map.Entry<?, ?> e : asMap(getJsonParams()).entrySet()) {
     			res.put(e.getKey().toString(), e.getValue());
+    		}
     		return res;
+    	}
     	private Map<?, ?> asMap(final String s) {
     		return StringUtils.isNotBlank(s) ? new Gson().fromJson(s, Map.class) : new HashMap<String, Object>();
+    	}
     	public String getBeanName() {
     		return beanName;
     		return this.beanName;
+    	}
     	@Override
-...
     		this.beanName = beanName;
+    	}
     	public PropertyFetcher getPropertyFetcher() {
     		return propertyFetcher;
+    	}
     	public void setPropertyFetcher(final PropertyFetcher propertyFetcher) {
     		this.propertyFetcher = propertyFetcher;
+    	}
     	public String getJsonParams() {
     		return jsonParams;
+    	}
     	public void setJsonParams(final String jsonParams) {
     		this.jsonParams = jsonParams;
+    	}
     	public String getJsonEnvParams() {
     		return jsonEnvParams;
+    	}
     	public void setJsonEnvParams(final String jsonEnvParams) {
     		this.jsonEnvParams = jsonEnvParams;
+    	}
     	public String getJsonSystemPropertyParams() {
     		return jsonSystemPropertyParams;
+    	}
     	public void setJsonSystemPropertyParams(final String jsonSystemPropertyParams) {
     		this.jsonSystemPropertyParams = jsonSystemPropertyParams;
+    	}
     	@Override
     	public String toString() {
     		return String.format("[node beanName=%s]", beanName);
     		return String.format("[node beanName=%s]", this.beanName);
+    	}
+    }

     import java.util.HashMap;
     import java.util.Map;
     import javax.xml.ws.wsaddressing.W3CEndpointReference;
     import org.springframework.beans.factory.annotation.Required;
     import org.springframework.core.io.ClassPathResource;
     import eu.dnetlib.enabling.resultset.XSLTMappedResultSetFactory;
     import eu.dnetlib.enabling.resultset.client.utils.EPRUtils;
     import eu.dnetlib.msro.rmi.MSROException;
     import eu.dnetlib.msro.workflows.graph.Arc;
     import eu.dnetlib.msro.workflows.nodes.SimpleJobNode;
     import eu.dnetlib.msro.workflows.procs.Env;
     import org.springframework.beans.factory.annotation.Required;
     import org.springframework.core.io.ClassPathResource;
     public class ApplyXsltJobNode extends SimpleJobNode {
     	private String inputEprParam;
     	private String outputEprParam;
     	private String xsltClasspath;
     	private Map<String, String> xsltParams;
     	private XSLTMappedResultSetFactory xsltMappedResultSetFactory;
     	@Override
     	protected String execute(final Env env) throws Exception {
     		final String inputEpr = env.getAttribute(inputEprParam, String.class);
     		if ((inputEpr == null) || inputEpr.isEmpty()) throw new MSROException("InputEprParam (" + inputEprParam + ") not found in ENV");
     		final String inputEpr = env.getAttribute(this.inputEprParam, String.class);
     		if ((inputEpr == null) || inputEpr.isEmpty()) { throw new MSROException("InputEprParam (" + this.inputEprParam + ") not found in ENV"); }
     		final Map<String, String> xsltParams = new HashMap<String, String>();
     		final Map<String, String> params = new HashMap<String, String>();
     		for (Map.Entry<String, Object> e : env.getAttributes().entrySet()) {
     			xsltParams.put(e.getKey().replaceAll(":", "_"), e.getValue().toString());
     		if (this.xsltParams != null) {
     			params.putAll(this.xsltParams);
+    		}
     		for (Map.Entry<String, Object> e : parseJsonParameters(env).entrySet()) {
     			xsltParams.put(e.getKey(), e.getValue().toString());
     		for (final Map.Entry<String, Object> e : env.getAttributes().entrySet()) {
     			params.put(e.getKey().replaceAll(":", "_"), e.getValue().toString());
+    		}
     		final W3CEndpointReference epr = xsltMappedResultSetFactory.createMappedResultSet(new EPRUtils().getEpr(inputEpr),
     				(new ClassPathResource(xsltClasspath)), xsltParams);
     		final W3CEndpointReference epr = this.xsltMappedResultSetFactory.createMappedResultSet(new EPRUtils().getEpr(inputEpr),
     				(new ClassPathResource(this.xsltClasspath)), params);
     		env.setAttribute(outputEprParam, epr.toString());
     		env.setAttribute(this.outputEprParam, epr.toString());
     		return Arc.DEFAULT_ARC;
+    	}
     	public String getInputEprParam() {
     		return inputEprParam;
     		return this.inputEprParam;
+    	}
     	public void setInputEprParam(final String inputEprParam) {
-...
+    	}
     	public String getOutputEprParam() {
     		return outputEprParam;
     		return this.outputEprParam;
+    	}
     	public void setOutputEprParam(final String outputEprParam) {
-...
+    	}
     	public String getXsltClasspath() {
     		return xsltClasspath;
     		return this.xsltClasspath;
+    	}
     	public void setXsltClasspath(final String xsltClasspath) {
-...
+    	}
     	public XSLTMappedResultSetFactory getXsltMappedResultSetFactory() {
     		return xsltMappedResultSetFactory;
     		return this.xsltMappedResultSetFactory;
+    	}
     	@Required
-...
     		this.xsltMappedResultSetFactory = xsltMappedResultSetFactory;
+    	}
     	public Map<String, String> getXsltParams() {
     		return this.xsltParams;
+    	}
     	public void setXsltParams(final Map<String, String> xsltParams) {
     		this.xsltParams = xsltParams;
+    	}
+    }

     import java.io.IOException;
     import java.util.Map;
     import javax.annotation.Resource;
     import javax.xml.ws.wsaddressing.W3CEndpointReference;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.springframework.beans.factory.annotation.Required;
     import com.google.common.collect.Maps;
     import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;
     import eu.dnetlib.enabling.locators.UniqueServiceLocator;
     import eu.dnetlib.enabling.resultset.MappedResultSetFactory;
-...
     import eu.dnetlib.msro.workflows.procs.Env;
     import groovy.lang.GroovyShell;
     import groovy.util.GroovyScriptEngine;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.springframework.beans.factory.annotation.Required;
     public class GroovyJobNode extends SimpleJobNode {
-...
     	private String inputEprParam;
     	private String outputEprParam;
     	private String transformationRuleId;
     	// private String groovyParams;
     	private Map<String, String> groovyParams;
     	@Resource
     	private UniqueServiceLocator serviceLocator;
     	private Map<String, String> retrieveGroovyParameter() {
     		Map<String, String> out = Maps.newHashMap();
     		final Map<String, String> out = Maps.newHashMap();
     		String query = "for $x in collection('/db/DRIVER/GroovyProcessingDSResource/GroovyProcessingDSResourceType')"
     				+ "where $x[.//RESOURCE_IDENTIFIER/@value='" + transformationRuleId + "']"
     		final String query = "for $x in collection('/db/DRIVER/GroovyProcessingDSResource/GroovyProcessingDSResourceType')"
     				+ "where $x[.//RESOURCE_IDENTIFIER/@value='" + this.transformationRuleId + "']"
     				+ "return concat($x//GROOVY_CLASSPATH/text(),':::',$x//GROOVY_DNETCLASS/text())";
     		try {
     			String result = serviceLocator.getService(ISLookUpService.class).quickSearchProfile(query).get(0);
     			final String result = this.serviceLocator.getService(ISLookUpService.class).quickSearchProfile(query).get(0);
     			if (result == null) { return null; }
     			String[] data = result.trim().split(":::");
     			final String[] data = result.trim().split(":::");
     			if (data.length == 2) {
     				out.put("classpath", data[0]);
     				out.put("mainClass", data[1]);
+    			}
     			return out;
     		} catch (Exception e) {
     		} catch (final Exception e) {
     			log.error(e);
     			return null;
+    		}
-...
     	@Override
     	protected String execute(final Env env) throws Exception {
     		final String inputEprString = env.getAttribute(inputEprParam, String.class);
     		if (inputEprString == null || inputEprString.isEmpty()) { throw new MSROException("InputEprParam (" + inputEprParam + ") not found in ENV"); }
     		final String inputEprString = env.getAttribute(this.inputEprParam, String.class);
     		if (inputEprString == null || inputEprString.isEmpty()) { throw new MSROException("InputEprParam (" + this.inputEprParam + ") not found in ENV"); }
     		final W3CEndpointReference inputEpr = new EPRUtils().getEpr(inputEprString);
     		String groovyClasspath, groovyDnetClass;
     		Map<String, String> prop = retrieveGroovyParameter();
     		final Map<String, String> prop = retrieveGroovyParameter();
     		groovyClasspath = prop.get("classpath");
     		groovyDnetClass = prop.get("mainClass");
     		W3CEndpointReference epr = transformGroovy(inputEpr, groovyClasspath, groovyDnetClass, parseJsonParameters(env));
     		env.setAttribute(outputEprParam, epr.toString());
     		final W3CEndpointReference epr = transformGroovy(inputEpr, groovyClasspath, groovyDnetClass, this.groovyParams);
     		env.setAttribute(this.outputEprParam, epr.toString());
     		return Arc.DEFAULT_ARC;
+    	}
     	private W3CEndpointReference transformGroovy(final W3CEndpointReference source,
     			final String groovyClasspath,
     			final String groovyDnetClass,
     			final Map<String, Object> params) throws ClassNotFoundException, IOException {
     			final Map<String, String> params) throws ClassNotFoundException, IOException {
     		GroovyScriptEngine gse = new GroovyScriptEngine(groovyClasspath);
     		final GroovyScriptEngine gse = new GroovyScriptEngine(groovyClasspath);
     		gse.getGroovyClassLoader().loadClass(groovyDnetClass);
     		log.info("***********************************************");
     		log.info("Loaded Groovy classes:");
     		for (Class<?> c : gse.getGroovyClassLoader().getLoadedClasses()) {
     		for (final Class<?> c : gse.getGroovyClassLoader().getLoadedClasses()) {
     			log.info(c.getCanonicalName());
+    		}
     		log.info("***********************************************");
     		GroovyShell groovyShell = new GroovyShell(gse.getGroovyClassLoader());
     		final GroovyShell groovyShell = new GroovyShell(gse.getGroovyClassLoader());
     		Object go = groovyShell.evaluate("new " + groovyDnetClass + "()");
     		final Object go = groovyShell.evaluate("new " + groovyDnetClass + "()");
     		if (go instanceof GroovyUnaryFunction) {
     			GroovyUnaryFunction groovyUnaryFunction = (GroovyUnaryFunction) go;
     			final GroovyUnaryFunction groovyUnaryFunction = (GroovyUnaryFunction) go;
     			if (params != null) {
     				groovyUnaryFunction.setParams(params);
+    			}
     			return mappedResultSetFactory.createMappedResultSet(source, groovyUnaryFunction);
     			return this.mappedResultSetFactory.createMappedResultSet(source, groovyUnaryFunction);
     		} else {
     			throw new RuntimeException("Groovy object " + go + " is not supported");
+    		}
+    	}
     	public MappedResultSetFactory getMappedResultSetFactory() {
     		return mappedResultSetFactory;
     		return this.mappedResultSetFactory;
+    	}
     	@Required
-...
+    	}
     	public String getInputEprParam() {
     		return inputEprParam;
     		return this.inputEprParam;
+    	}
     	public void setInputEprParam(final String inputEprParam) {
-...
+    	}
     	public String getOutputEprParam() {
     		return outputEprParam;
     		return this.outputEprParam;
+    	}
     	public void setOutputEprParam(final String outputEprParam) {
-...
+    	}
     	public String getTransformationRuleId() {
     		return transformationRuleId;
     		return this.transformationRuleId;
+    	}
     	public void setTransformationRuleId(final String transformationRuleId) {
     		this.transformationRuleId = transformationRuleId;
+    	}
     	public Map<String, String> getGroovyParams() {
     		return this.groovyParams;
+    	}
     	public void setGroovyParams(final Map<String, String> groovyParams) {
     		this.groovyParams = groovyParams;
+    	}
+    }

     public abstract class GroovyUnaryFunction implements UnaryFunction<String, String> {
     	private Map<String, Object> params;
     	private Map<String, String> params;
     	@Override
     	abstract public String evaluate(String input);
     	public Map<String, Object> getParams() {
     		return params;
     	public Map<String, String> getParams() {
     		return this.params;
+    	}
     	public void setParams(final Map<String, Object> params) {
     	public void setParams(final Map<String, String> params) {
     		this.params = params;
+    	}

     																											<xs:attribute name="key" type="xs:NCName" use="required" />
     																											<xs:attribute name="ref" use="optional" type="xs:string" />
     																											<xs:attribute name="value" use="optional" type="xs:string" />
     																											<xs:attribute name="property" use="optional" type="xs:string" />
     																										</xs:complexType>
     																									</xs:element>
     																								</xs:sequence>
-...
     																										<xs:complexType>
     																											<xs:attribute name="ref" use="optional" type="xs:string" />
     																											<xs:attribute name="value" use="optional" type="xs:string" />
     																											<xs:attribute name="property" use="optional" type="xs:string" />
     																										</xs:complexType>
     																									</xs:element>
     																								</xs:sequence>
-...
     																					<xs:attribute name="name" use="required" type="xs:NCName" />
     																					<xs:attribute name="ref" use="optional" type="xs:string" />
     																					<xs:attribute name="value" use="optional" type="xs:string" />
     																					<xs:attribute name="property" use="optional" type="xs:string" />
     																				</xs:complexType>
     																			</xs:element>
     																		</xs:sequence>

     																											<xs:attribute name="key" type="xs:NCName" use="required" />
     																											<xs:attribute name="ref" use="optional" type="xs:string" />
     																											<xs:attribute name="value" use="optional" type="xs:string" />
     																											<xs:attribute name="property" use="optional" type="xs:string" />
     																										</xs:complexType>
     																									</xs:element>
     																								</xs:sequence>
-...
     																										<xs:complexType>
     																											<xs:attribute name="ref" use="optional" type="xs:string" />
     																											<xs:attribute name="value" use="optional" type="xs:string" />
     																											<xs:attribute name="property" use="optional" type="xs:string" />
     																										</xs:complexType>
     																									</xs:element>
     																								</xs:sequence>
-...
     																					<xs:attribute name="name" use="required" type="xs:NCName" />
     																					<xs:attribute name="ref" use="optional" type="xs:string" />
     																					<xs:attribute name="value" use="optional" type="xs:string" />
     																					<xs:attribute name="property" use="optional" type="xs:string" />
     																				</xs:complexType>
     																			</xs:element>
     																		</xs:sequence>

Project

General

Profile

D-Net

Revision 41502

Added by Michele Artini about 8 years ago