diff --git a/changelog.txt b/changelog.txt
index 1984155e5af590c1ac970be8970ac7489ce7016b..a90f7aa7d7a4277d4fc9bf01b66c34e4e764eaef 100644
--- a/changelog.txt
+++ b/changelog.txt
@@ -2,8 +2,9 @@ eDelivery SMP 5.0
- added new properties:
smp.truststore.type: Truststore type as JKS/PKCS12
smp.keystore.type: Keystore type as JKS/PKCS12
- document.restriction.allowed.certificate.types: Allowed key algorithms for certificates to be used in service metadata.Empty value means no restrictions, for other values see the java KeyFactory Algorithms for example: RSA|EC|Ed25519|Ed448;
- smp.certificate.validation.allowed.certificate.type: Allowed user certificate JCE types. Empty value means no restrictions, for other values see the java KeyFactory Algorithms for examples: RSA|EC|Ed25519|Ed448;
+ document.restriction.allowed.certificate.types: Allowed key algorithms for certificates to be used in service metadata.Empty value means no restrictions, for other values see the java KeyFactory Algorithms for example: RSA|EC|Ed25519|Ed448.
+ smp.certificate.validation.allowed.certificate.type: Allowed user certificate JCE types. Empty value means no restrictions, for other values see the java KeyFactory Algorithms for example: RSA|EC|Ed25519|Ed448.
+ identifiersBehaviour.splitPattern: Regular expression with groups scheme and identifier for splitting the URN identifiers to scheme and identifier part.
eDelivery SMP 4.2
- added new properties:
diff --git a/smp-api/pom.xml b/smp-api/pom.xml
index cd69fc7973c4d5f97b26c699753faf3378ff74cd..16138c2af4230ea06dc507bc76deb8ed6a45d49b 100644
--- a/smp-api/pom.xml
+++ b/smp-api/pom.xml
@@ -43,11 +43,6 @@
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</dependency>
- <dependency>
- <groupId>pl.pragmatists</groupId>
- <artifactId>JUnitParams</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/Identifiers.java b/smp-api/src/main/java/eu/europa/ec/smp/api/Identifiers.java
deleted file mode 100644
index fac0a443755e72352092481a6fee83e84f419dae..0000000000000000000000000000000000000000
--- a/smp-api/src/main/java/eu/europa/ec/smp/api/Identifiers.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * Copyright 2017 European Commission | CEF eDelivery
- *
- * Licensed under the EUPL, Version 1.2 or – as soon they will be approved by the European Commission - subsequent versions of the EUPL (the "Licence");
- * You may not use this work except in compliance with the Licence.
- *
- * You may obtain a copy of the Licence attached in file: LICENCE-EUPL-v1.2.pdf
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the Licence is distributed on an "AS IS" basis,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the Licence for the specific language governing permissions and limitations under the Licence.
- */
-
-package eu.europa.ec.smp.api;
-
-import eu.europa.ec.smp.api.exceptions.MalformedIdentifierException;
-import org.apache.commons.lang3.StringUtils;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.DocumentIdentifier;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ProcessIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.web.util.UriUtils;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-/**
- * Factory and utility methods for API classes generated from OASIS XSD.
- * <p>
- * Created by gutowpa on 12/01/2017.
- */
-public class Identifiers {
- private static final Logger LOG = LoggerFactory.getLogger(Identifiers.class);
-
- public static final String EBCORE_IDENTIFIER_PREFIX = "urn:oasis:names:tc:ebcore:partyid-type:";
- public static final String EBCORE_IDENTIFIER_FORMAT = "%s:%s";
- public static final String EBCORE_IDENTIFIER_ISO6523_SCHEME = "iso6523";
- public static final String DOUBLE_COLON_IDENTIFIER_FORMAT = "%s::%s";
-
- private static final String EMPTY_IDENTIFIER = "Null/Empty";
-
-
- public static ParticipantIdentifierType asParticipantId(String participantIdentifier, boolean schemeMandatory) {
- LOG.debug("Parse participant identifier [{}] with scheme mandatory [{}]", participantIdentifier, schemeMandatory);
- String[] res = splitParticipantIdentifier(participantIdentifier, schemeMandatory);
- return new ParticipantIdentifierType(res[1], res[0]);
- }
-
- public static DocumentIdentifier asDocumentId(String doubleColonDelimitedId) {
- LOG.debug("Parse document identifier [{}]", doubleColonDelimitedId);
- String[] res = splitDoubleColonIdentifier(doubleColonDelimitedId, false);
- return new DocumentIdentifier(res[1], res[0]);
- }
-
- public static ProcessIdentifier asProcessId(String doubleColonDelimitedId) {
- LOG.debug("Parse process identifier [{}]", doubleColonDelimitedId);
- String[] res = splitDoubleColonIdentifier(doubleColonDelimitedId, false);
- return new ProcessIdentifier(res[1], res[0]);
- }
-
- public static String asString(ParticipantIdentifierType participantId) {
- if (StringUtils.isBlank(participantId.getScheme())) {
- // if scheme is empty just return value (see section 3.4.1 of [SMP-v1.0]) MUST include neither an {identifier scheme} nor the :: separator )
- return participantId.getValue();
- }
- String format =
- StringUtils.startsWithIgnoreCase(participantId.getScheme(), EBCORE_IDENTIFIER_PREFIX) ?
- EBCORE_IDENTIFIER_FORMAT : DOUBLE_COLON_IDENTIFIER_FORMAT;
-
- return String.format(format, participantId.getScheme(), participantId.getValue());
- }
-
- public static String asString(DocumentIdentifier docId) {
- return String.format(DOUBLE_COLON_IDENTIFIER_FORMAT, docId.getScheme() != null ? docId.getScheme() : "", docId.getValue());
- }
-
- public static String asUrlEncodedString(ParticipantIdentifierType participantId) {
- return urlEncode(asString(participantId));
- }
-
- public static String asUrlEncodedString(DocumentIdentifier docId) {
- return urlEncode(asString(docId));
- }
-
- private static String urlEncode(String s) {
- return UriUtils.encode(s, UTF_8.name());
- }
-
- private static String[] splitParticipantIdentifier(String participantIdentifier, boolean schemeMandatory) {
- LOG.debug("Split participant identifier [{}] with mandatory scheme [{}]", participantIdentifier, schemeMandatory);
- String[] idResult;
- if (StringUtils.isBlank(participantIdentifier)) {
- throw new MalformedIdentifierException(EMPTY_IDENTIFIER, null);
- }
- String identifier = participantIdentifier.trim();
- if (identifier.startsWith(EBCORE_IDENTIFIER_PREFIX)
- || identifier.startsWith("::" + EBCORE_IDENTIFIER_PREFIX)) {
- idResult = splitEbCoreIdentifier(identifier);
- } else {
- idResult = splitDoubleColonIdentifier(identifier, schemeMandatory);
- }
-
- return idResult;
-
- }
-
- /**
- * Method splits identifier at first occurrence of double colon :: and returns array size of 2. The first value is
- * schema and the second is identifier. If identifier is blank or with missing :: MalformedIdentifierException is thrown
- *
- * @param doubleColonDelimitedId
- * @return array with two elements. First is schema and second is id
- */
-
- private static String[] splitDoubleColonIdentifier(String doubleColonDelimitedId, boolean schemeMandatory) {
- LOG.debug("Split identifier [{}] with scheme mandatory [{}]", doubleColonDelimitedId, schemeMandatory);
- if (StringUtils.isBlank(doubleColonDelimitedId)) {
- throw new MalformedIdentifierException(EMPTY_IDENTIFIER, null);
- }
-
- String[] idResult = new String[2];
-
- int delimiterIndex = doubleColonDelimitedId.indexOf("::");
- if (schemeMandatory && delimiterIndex <= 0) {
- LOG.debug("Missing mandatory scheme part for the identifier [{}]!", doubleColonDelimitedId);
- throw new MalformedIdentifierException(doubleColonDelimitedId, null);
- }
- idResult[0] = delimiterIndex <= 0 ? null : doubleColonDelimitedId.substring(0, delimiterIndex);
- idResult[1] = doubleColonDelimitedId.substring(delimiterIndex + (delimiterIndex < 0 ? 1 : 2));
-
- if (StringUtils.isBlank(idResult[1])) {
- LOG.debug("Missing id part for the identifier [{}]!", doubleColonDelimitedId);
- throw new MalformedIdentifierException(doubleColonDelimitedId, null);
- }
- return idResult;
- }
-
- public static String[] splitEbCoreIdentifier(final String partyId) {
-
- String partyIdPrivate = partyId.trim();
- if (partyIdPrivate.startsWith("::")) {
- partyIdPrivate = StringUtils.removeStart(partyIdPrivate, "::");
- }
-
- if (!partyIdPrivate.startsWith(EBCORE_IDENTIFIER_PREFIX)) {
- throw new MalformedIdentifierException(partyId, null);
- }
- boolean isIso6523 = partyIdPrivate.startsWith(EBCORE_IDENTIFIER_PREFIX + EBCORE_IDENTIFIER_ISO6523_SCHEME + ":");
-
- int isSchemeDelimiter = partyIdPrivate.indexOf(':', EBCORE_IDENTIFIER_PREFIX.length());
- if (isSchemeDelimiter < 0) {
- // invalid scheme
- throw new IllegalArgumentException(String.format("Invalid ebCore id [%s] ebcoreId must have prefix 'urn:oasis:names:tc:ebcore:partyid-type', " +
- "and parts <catalog-identifier>, <scheme-in-catalog>, <scheme-specific-identifier> separated by colon. " +
- "Example: urn:oasis:names:tc:ebcore:partyid-type:<catalog-identifier>:(<scheme-in-catalog>)?:<scheme-specific-identifier>.", partyIdPrivate));
- }
- int isPartDelimiter = partyIdPrivate.indexOf(':', isSchemeDelimiter + 1);
-
- String[] result = new String[2];
- if (isPartDelimiter < 0 && isIso6523) { // for iso scheme-in-catalog is mandatory
- // invalid scheme
- throw new IllegalArgumentException(String.format("Invalid ebCore id [%s] ebcoreId must have prefix 'urn:oasis:names:tc:ebcore:partyid-type', " +
- "and parts <catalog-identifier>, <scheme-in-catalog>, <scheme-specific-identifier> separated by colon. " +
- "Example: urn:oasis:names:tc:ebcore:partyid-type:<catalog-identifier>:(<scheme-in-catalog>)?:<scheme-specific-identifier>.", partyIdPrivate));
- } else if (isPartDelimiter < 0) {
- result[0] = partyIdPrivate.substring(0, isSchemeDelimiter).trim();
- result[1] = partyIdPrivate.substring(isSchemeDelimiter + 1).trim();
- } else {
- result[0] = partyIdPrivate.substring(0, isPartDelimiter).trim();
- result[1] = partyIdPrivate.substring(isPartDelimiter + 1).trim();
- }
-
- //check if double colon was used for identifier separator in ebecoreid
- if (result[1].startsWith(":")) {
- result[1] = StringUtils.removeStart(result[1], ":");
- }
- //check if double colon was used for identifier separator in ebecoreid
- if (result[0].endsWith(":")) {
- result[0] = StringUtils.removeEnd(result[0], ":");
- }
- return result;
- }
-}
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/exceptions/MalformedIdentifierException.java b/smp-api/src/main/java/eu/europa/ec/smp/api/exceptions/MalformedIdentifierException.java
index bd808706b591bc42f4fdd4d8afc6eedc79a73b69..c5f159e00ed13e1d713b525f65b6818d246c9c61 100644
--- a/smp-api/src/main/java/eu/europa/ec/smp/api/exceptions/MalformedIdentifierException.java
+++ b/smp-api/src/main/java/eu/europa/ec/smp/api/exceptions/MalformedIdentifierException.java
@@ -28,4 +28,8 @@ public class MalformedIdentifierException extends IllegalArgumentException {
public MalformedIdentifierException(String malformedId, Exception cause){
super(buildMessage(malformedId), cause);
}
+
+ public MalformedIdentifierException(String message){
+ super(message);
+ }
}
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/AbstractIdentifierFormatter.java b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/AbstractIdentifierFormatter.java
new file mode 100644
index 0000000000000000000000000000000000000000..a68ec98d831a458cb0c69417a75bbb0dd5d7da83
--- /dev/null
+++ b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/AbstractIdentifierFormatter.java
@@ -0,0 +1,250 @@
+package eu.europa.ec.smp.api.identifiers;
+
+
+import eu.europa.ec.smp.api.exceptions.MalformedIdentifierException;
+import eu.europa.ec.smp.api.identifiers.types.FormatterType;
+import eu.europa.ec.smp.api.identifiers.types.OasisSMPFormatterType;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.util.UriUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.commons.lang3.StringUtils.*;
+
+/**
+ * Formatter for printing and parsing identifier objects.
+ * <p>
+ * This class provides parsing and formatting method for identifier objects as:
+ * ParticipantIdentifierType, DocumentIdentifier, and ProcessIdentifier.
+ *
+ * <b>Parsing the identifier</b>
+ * Parse method tries to detect the scheme and identifier part of the identifier string using the
+ * regular expression and separator sequence.
+ * The regular expression allows setting complex parsing templates, while the split separator is much raster.
+ *
+ * <ul>
+ * <li>Using <b>Regular expressing:</b>Regular expression uses named groups <scheme> and <identifier> to identify the scheme and identifier.
+ * if the regular expression is null or does not match, the parsing fallback to "split" with separator."
+ * </li>
+ * <li>Using <b>separator:</b>Separator splits regular expression on the first occurrence of the 'separator' sequence.</li>
+ * </ul>
+ * If no parsing is successful, then the scheme is set to null, and the identifier part has the input value.
+ * In case the schemeMandatory is set to true and the scheme is null, the MalformedIdentifierException is thrown.
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+public abstract class AbstractIdentifierFormatter<T> {
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractIdentifierFormatter.class);
+
+ protected static final FormatterType DEFAULT_FORMATTER = new OasisSMPFormatterType();
+
+ protected boolean schemeMandatory = false;
+ protected Pattern schemeValidationPattern;
+ protected List<String> caseSensitiveSchemas;
+ protected List<FormatterType> formatterTypes = new ArrayList<>();
+
+
+ /**
+ * Formats the object according to formatTemplate. If template is 'blank' the scheme and identifier are concatenated
+ * with separator
+ *
+ * @param value Identifier object to format it to string
+ * @return String representation of the identifier
+ */
+ public String format(T value) {
+ return format(getSchemeFromObject(value), getIdentifierFromObject(value));
+ }
+
+ /**
+ * Formats the object according to formatTemplate. If template is 'blank' the scheme and identifier are concatenated
+ * with separator
+ *
+ * @param scheme scheme part to format it to string
+ * @param identifier Identifier part to format it to string
+ * @return String representation of the identifier
+ */
+ public String format(String scheme, String identifier) {
+ // find the formatter
+ Optional<FormatterType> optionalFormatterType = formatterTypes.stream().filter(formatterType ->
+ formatterType.isTypeByScheme(scheme)).findFirst();
+
+ if (optionalFormatterType.isPresent()) {
+ return optionalFormatterType.get().format(scheme, identifier);
+ }
+ return DEFAULT_FORMATTER.format(scheme, identifier);
+ }
+
+ /**
+ * Formats the object according to formatTemplate. If template is 'blank' the scheme and identifier are concatenated
+ * with separator
+ *
+ * @param scheme scheme part to format it to string
+ * @param identifier Identifier part to format it to string
+ * @param noDelimiterOnBlankScheme if true not delimiter is added when scheme is blankl
+ * @return String representation of the identifier
+ */
+ public String format(String scheme, String identifier, boolean noDelimiterOnBlankScheme) {
+ // find the formatter
+ Optional<FormatterType> optionalFormatterType = formatterTypes.stream().filter(formatterType ->
+ formatterType.isTypeByScheme(scheme)).findFirst();
+
+ if (optionalFormatterType.isPresent()) {
+ return optionalFormatterType.get().format(scheme, identifier, noDelimiterOnBlankScheme);
+ }
+ return DEFAULT_FORMATTER.format(scheme, identifier, noDelimiterOnBlankScheme);
+ }
+
+ /**
+ * Parse identifier.
+ * <p>
+ * Method parse the identifier.
+ *
+ * @param value
+ * @return
+ */
+ public T parse(final String value) {
+ if (isBlank(value)) {
+ throw new MalformedIdentifierException("Can not parse empty identifier value!");
+ }
+
+ String pValue = trim(value);
+
+ // find the formatter
+ Optional<FormatterType> optionalFormatterType = formatterTypes.stream().filter(formatterType ->
+ formatterType.isType(pValue)).findFirst();
+
+ String[] parseResult;
+ if (optionalFormatterType.isPresent()) {
+ parseResult = optionalFormatterType.get().parse(pValue);
+ } else {
+ parseResult = DEFAULT_FORMATTER.parse(pValue);
+ }
+ boolean isSchemeBlank = isBlank(parseResult[0]);
+ if (isSchemeMandatory() && isSchemeBlank) {
+ throw new MalformedIdentifierException("Invalid Identifier: [" + pValue + "]. Can not detect schema!");
+ }
+
+ if (!isSchemeBlank && schemeValidationPattern != null) {
+ Matcher schemeMatcher = schemeValidationPattern.matcher(parseResult[0]);
+ if (!schemeMatcher.matches()) {
+ throw new MalformedIdentifierException("Invalid Identifier: [" + pValue + "]. Scheme does not match pattern: [" + schemeValidationPattern.pattern() + "]!");
+ }
+ }
+
+ return createObject(parseResult[0], parseResult[1]);
+ }
+
+ /**
+ * Method parses the object then it validates if scheme is case sensitive and lower case the values accordingly.
+ *
+ * @param value
+ * @return
+ */
+ public T normalizeIdentifier(final String value) {
+ T result = parse(value);
+ String schema = getSchemeFromObject(result);
+
+ if (isCaseInsensitiveSchema(schema)) {
+ String identifier = getIdentifierFromObject(result);
+ updateObject(result, lowerCase(schema), lowerCase(identifier));
+ }
+
+ return result;
+ }
+
+ /**
+ * Method normalize the identifier using the format/parse and sets schema and identifier to lower case if
+ * identifier is case insensitive.
+ *
+ * <ul>
+ * <li><b>eDelivery example:</b> scheme [null], party id: [urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789]</li>
+ * <li><b>oasis SMP example:</b> scheme [urn:oasis:names:tc:ebcore:partyid-type:iso6523], party id: [0088:123456789]</li>
+ * <li><b>ebCore party ID example:</b>scheme [urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088], party id: [123456789]/li>
+ * </ul>
+ * <p>
+ * Must always result in the same normalized object:
+ * scheme [urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088]: party id: [123456789]
+ *
+ * @param value
+ * @return
+ */
+ public T normalize(final T value) {
+ return normalize(getSchemeFromObject(value),getIdentifierFromObject(value));
+ }
+
+ public T normalize(String scheme, String identifier) {
+ return normalizeIdentifier(format(scheme, identifier));
+ }
+
+ /**
+ * Return true if identifier schema is not defined in list of case sensitive schemas, else return false.
+ *
+ * @param schema
+ * @return
+ */
+ public boolean isCaseInsensitiveSchema(String schema) {
+ if (StringUtils.isEmpty(schema)) {
+ LOG.debug("Empty/null schemas are case insensitive.");
+ return true;
+ }
+ if (caseSensitiveSchemas == null || caseSensitiveSchemas.isEmpty()) {
+ LOG.debug("Case sensitive schemas are not configure. return default value [false] for schema's [{}] case sensitive validation!", schema);
+ return true;
+ }
+ return caseSensitiveSchemas.stream().noneMatch(schema::equalsIgnoreCase);
+ }
+
+ public String urlEncodedFormat(T value) {
+ return urlEncode(format(value));
+ }
+
+ public String urlEncode(String s) {
+ return UriUtils.encode(s, UTF_8.name());
+ }
+
+ protected abstract String getSchemeFromObject(T object);
+
+ protected abstract String getIdentifierFromObject(T object);
+
+ protected abstract T createObject(String scheme, String identifier);
+
+ protected abstract void updateObject(T object, String scheme, String identifier);
+
+
+ public List<String> getCaseSensitiveSchemas() {
+ return caseSensitiveSchemas;
+ }
+
+ public AbstractIdentifierFormatter<T> caseSensitiveSchemas(List<String> caseSensitiveSchemas) {
+ this.caseSensitiveSchemas = caseSensitiveSchemas;
+ return this;
+ }
+
+ public void setCaseSensitiveSchemas(List<String> caseSensitiveSchemas) {
+ this.caseSensitiveSchemas = caseSensitiveSchemas;
+ }
+
+ public boolean isSchemeMandatory() {
+ return schemeMandatory;
+ }
+
+ public void setSchemeMandatory(boolean schemeMandatory) {
+ this.schemeMandatory = schemeMandatory;
+ }
+
+ public Pattern getSchemeValidationPattern() {
+ return schemeValidationPattern;
+ }
+
+ public void setSchemeValidationPattern(Pattern schemeValidationPattern) {
+ this.schemeValidationPattern = schemeValidationPattern;
+ }
+}
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/DocumentIdentifierFormatter.java b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/DocumentIdentifierFormatter.java
new file mode 100644
index 0000000000000000000000000000000000000000..0fcacfe3e3fa4c20fcbf694a8067d2bfdf3e6412
--- /dev/null
+++ b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/DocumentIdentifierFormatter.java
@@ -0,0 +1,38 @@
+package eu.europa.ec.smp.api.identifiers;
+
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.DocumentIdentifier;
+
+/**
+ * Formatter for the DocumentIdentifier with default null split regular expression and
+ * '::' as split separator. For details see the {@link AbstractIdentifierFormatter}
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+public class DocumentIdentifierFormatter extends AbstractIdentifierFormatter<DocumentIdentifier> {
+
+
+ @Override
+ protected String getSchemeFromObject(DocumentIdentifier object) {
+ return object != null ? object.getScheme() : null;
+ }
+
+ @Override
+ protected String getIdentifierFromObject(DocumentIdentifier object) {
+ return object != null ? object.getValue() : null;
+ }
+
+ @Override
+ protected DocumentIdentifier createObject(String scheme, String identifier) {
+ DocumentIdentifier identifierObject = new DocumentIdentifier();
+ identifierObject.setScheme(scheme);
+ identifierObject.setValue(identifier);
+ return identifierObject;
+ }
+
+ @Override
+ protected void updateObject(DocumentIdentifier identifierObject, String scheme, String identifier) {
+ identifierObject.setScheme(scheme);
+ identifierObject.setValue(identifier);
+ }
+}
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/ParticipantIdentifierFormatter.java b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/ParticipantIdentifierFormatter.java
new file mode 100644
index 0000000000000000000000000000000000000000..70290592f3c8ec0286f96a77627878d191cca2e6
--- /dev/null
+++ b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/ParticipantIdentifierFormatter.java
@@ -0,0 +1,45 @@
+package eu.europa.ec.smp.api.identifiers;
+
+import eu.europa.ec.smp.api.identifiers.types.EBCorePartyIdFormatterType;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
+
+import java.util.regex.Pattern;
+
+/**
+ * Formatter for the ParticipantIdentifier with default "ebCoreParty" split regular expression and
+ * '::' as split separator. For details see the {@link AbstractIdentifierFormatter}
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+public class ParticipantIdentifierFormatter extends AbstractIdentifierFormatter<ParticipantIdentifierType> {
+
+ public ParticipantIdentifierFormatter() {
+
+ this.formatterTypes.add(new EBCorePartyIdFormatterType());
+ }
+
+ @Override
+ protected String getSchemeFromObject(ParticipantIdentifierType object) {
+ return object != null ? object.getScheme() : null;
+ }
+
+ @Override
+ protected String getIdentifierFromObject(ParticipantIdentifierType object) {
+ return object != null ? object.getValue() : null;
+ }
+
+ @Override
+ protected ParticipantIdentifierType createObject(String scheme, String identifier) {
+ ParticipantIdentifierType identifierObject = new ParticipantIdentifierType();
+ identifierObject.setScheme(scheme);
+ identifierObject.setValue(identifier);
+ return identifierObject;
+ }
+
+ @Override
+ protected void updateObject(ParticipantIdentifierType identifierObject, String scheme, String identifier){
+ identifierObject.setScheme(scheme);
+ identifierObject.setValue(identifier);
+ }
+}
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/ProcessIdentifierFormatter.java b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/ProcessIdentifierFormatter.java
new file mode 100644
index 0000000000000000000000000000000000000000..a97ef0d8eef13877c089192dedbd2e667cf9c408
--- /dev/null
+++ b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/ProcessIdentifierFormatter.java
@@ -0,0 +1,38 @@
+package eu.europa.ec.smp.api.identifiers;
+
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.ProcessIdentifier;
+
+/**
+ * Formatter for the ProcessIdentifier with default null split regular expression and
+ * '::' as split separator. For details see the {@link AbstractIdentifierFormatter}
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+public class ProcessIdentifierFormatter extends AbstractIdentifierFormatter<ProcessIdentifier> {
+
+
+ @Override
+ protected String getSchemeFromObject(ProcessIdentifier object) {
+ return object != null ? object.getScheme() : null;
+ }
+
+ @Override
+ protected String getIdentifierFromObject(ProcessIdentifier object) {
+ return object != null ? object.getValue() : null;
+ }
+
+ @Override
+ protected ProcessIdentifier createObject(String scheme, String identifier) {
+ ProcessIdentifier identifierObject = new ProcessIdentifier();
+ identifierObject.setScheme(scheme);
+ identifierObject.setValue(identifier);
+ return identifierObject;
+ }
+
+ @Override
+ protected void updateObject(ProcessIdentifier identifierObject, String scheme, String identifier) {
+ identifierObject.setScheme(scheme);
+ identifierObject.setValue(identifier);
+ }
+}
\ No newline at end of file
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/EBCorePartyIdFormatterType.java b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/EBCorePartyIdFormatterType.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8431c030738a4dd6a07c3806b9240103fe7f388
--- /dev/null
+++ b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/EBCorePartyIdFormatterType.java
@@ -0,0 +1,113 @@
+package eu.europa.ec.smp.api.identifiers.types;
+
+import eu.europa.ec.smp.api.exceptions.MalformedIdentifierException;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+
+import static org.apache.commons.lang3.StringUtils.*;
+
+
+/**
+ * EBCorePartyID implementation Formatter type. The formatter supports
+ *
+ * <ul>
+ * <li><b>Basic:</b>urn:oasis:names:tc:ebcore:partyid-type:<catalog-identifier>:(<scheme-in-catalog>)?:<scheme-specific-identifier></li>
+ * <li><b>"Empty "SMP scheme" started with double colon (eDelivery URL variant):</b> ::urn:oasis:names:tc:ebcore:partyid-type:<catalog-identifier>:(<scheme-in-catalog>)?:<scheme-specific-identifier></li>
+ * <li><b>Double colon separator (Oasis SMP variant):</b> urn:oasis:names:tc:ebcore:partyid-type:<catalog-identifier>::(<scheme-in-catalog>)?:<scheme-specific-identifier></li>
+ * </ul>
+ * <p>
+ * Currently allowed <catalog-identifier> are iso6523 and unregistered
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+public class EBCorePartyIdFormatterType implements FormatterType {
+ private static final Logger LOG = LoggerFactory.getLogger(EBCorePartyIdFormatterType.class);
+
+ public static final String EBCORE_IDENTIFIER_PREFIX = "urn:oasis:names:tc:ebcore:partyid-type:";
+ public static final String EBCORE_IDENTIFIER_ISO6523_SCHEME = "iso6523";
+ public static final String EBCORE_IDENTIFIER_UNREGISTERED_SCHEME = "unregistered";
+ private static final String EBCORE_SEPARATOR = ":";
+ private static final String OASIS_SMP_SEPARATOR = "::";
+
+
+ @Override
+ public boolean isTypeByScheme(final String scheme) {
+ String partyIdPrivate = StringUtils.trim(scheme);
+ if (StringUtils.isBlank(scheme)) {
+ LOG.debug("EBCorePartyIdFormatterType does not support identifiers with Null/Blank scheme");
+ return false;
+ }
+ partyIdPrivate = removeStart(partyIdPrivate, OASIS_SMP_SEPARATOR);
+
+ return startsWithIgnoreCase(partyIdPrivate, EBCORE_IDENTIFIER_PREFIX);
+ }
+
+ @Override
+ public boolean isType(final String value) {
+ // the value should start with valid scheme
+ return isTypeByScheme(value);
+ }
+
+ @Override
+ public String format(String scheme, String identifier, boolean noDelimiterOnEmptyScheme) {
+ return (isBlank(scheme) && noDelimiterOnEmptyScheme ? "" : trimToEmpty(scheme) + EBCORE_SEPARATOR) + trimToEmpty(identifier);
+ }
+
+ @Override
+ public String format(final String scheme, final String identifier) {
+ return format(scheme, identifier, true);
+ }
+
+ @Override
+ public String[] parse(final String value) {
+
+ String partyIdPrivate = trimToEmpty(value);
+ // ebcore party can start with OASIS_SMP_SEPARATOR - remove it of exists.
+ partyIdPrivate = removeStart(partyIdPrivate, OASIS_SMP_SEPARATOR);
+
+ // replace first OASIS_SMP_SEPARATOR :: with OASIS_SMP_SEPARATOR
+ partyIdPrivate = StringUtils.replace(partyIdPrivate, OASIS_SMP_SEPARATOR, EBCORE_SEPARATOR, 1);
+
+ if (!StringUtils.startsWithIgnoreCase(partyIdPrivate, EBCORE_IDENTIFIER_PREFIX)) {
+ throw new MalformedIdentifierException(value, null);
+ }
+ boolean isIso6523 = StringUtils.startsWithIgnoreCase(partyIdPrivate, EBCORE_IDENTIFIER_PREFIX + EBCORE_IDENTIFIER_ISO6523_SCHEME +EBCORE_SEPARATOR);
+ boolean isUnregistered = StringUtils.startsWithIgnoreCase(partyIdPrivate, EBCORE_IDENTIFIER_PREFIX + EBCORE_IDENTIFIER_UNREGISTERED_SCHEME + EBCORE_SEPARATOR);
+ if (!isIso6523 && !isUnregistered) {
+ throw new MalformedIdentifierException("Invalid ebCore id [" + partyIdPrivate + "] ebcoreId <scheme-in-catalog> must be must one from the list " + Arrays.asList(EBCORE_IDENTIFIER_ISO6523_SCHEME, EBCORE_IDENTIFIER_UNREGISTERED_SCHEME) + "!");
+ }
+
+ int isSchemeDelimiter = partyIdPrivate.indexOf(EBCORE_SEPARATOR, EBCORE_IDENTIFIER_PREFIX.length());
+ if (isSchemeDelimiter < 0) {
+ // invalid scheme
+ throw new MalformedIdentifierException(String.format("Invalid ebCore id [%s] ebcoreId must have prefix 'urn:oasis:names:tc:ebcore:partyid-type', " +
+ "and parts <catalog-identifier>, <scheme-in-catalog>, <scheme-specific-identifier> separated by colon. " +
+ "Example: urn:oasis:names:tc:ebcore:partyid-type:<catalog-identifier>:(<scheme-in-catalog>)?:<scheme-specific-identifier>.", partyIdPrivate));
+ }
+ int isPartDelimiter = partyIdPrivate.indexOf(':', isSchemeDelimiter + 1);
+
+ String[] result = new String[2];
+ if (isPartDelimiter < 0 && isIso6523) { // for iso scheme-in-catalog is mandatory
+ // invalid scheme
+ throw new MalformedIdentifierException(String.format("Invalid ebCore id [%s] ebcoreId must have prefix 'urn:oasis:names:tc:ebcore:partyid-type', " +
+ "and parts <catalog-identifier>, <scheme-in-catalog>, <scheme-specific-identifier> separated by colon. " +
+ "Example: urn:oasis:names:tc:ebcore:partyid-type:<catalog-identifier>:(<scheme-in-catalog>)?:<scheme-specific-identifier>.", partyIdPrivate));
+ } else if (isPartDelimiter < 0) {
+ result[0] = partyIdPrivate.substring(0, isSchemeDelimiter).trim();
+ result[1] = partyIdPrivate.substring(isSchemeDelimiter + 1).trim();
+ } else {
+ result[0] = partyIdPrivate.substring(0, isPartDelimiter).trim();
+ result[1] = partyIdPrivate.substring(isPartDelimiter + 1).trim();
+ }
+
+ // Final cleaning: remove separator on end of scheme part and start of id part
+ result[1] = removeStart(result[1], EBCORE_SEPARATOR);
+ result[0] = StringUtils.removeEnd(result[0], EBCORE_SEPARATOR);
+
+ return result;
+ }
+}
\ No newline at end of file
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/FormatterType.java b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/FormatterType.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc8b1648472268f111dc1e9838d88016515c41ca
--- /dev/null
+++ b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/FormatterType.java
@@ -0,0 +1,31 @@
+package eu.europa.ec.smp.api.identifiers.types;
+
+
+/**
+ * Formatter type interface for formatting and parsing party identifiers
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+public interface FormatterType {
+
+ /**
+ * Method returns true if scheme is supported by the formatter for parsing and formatting, else it return false:.
+ * @param scheme identifier scheme part
+ * @return return true if identifier is supported by the formatter else return false
+ */
+ boolean isTypeByScheme(final String scheme);
+
+ /**
+ * Method returns true if identifier is supported by the formatter for parsing and formatting, else it return false:.
+ * @param value identifier value
+ * @return return true if identifier is supported by the formatter else return false
+ */
+ boolean isType(final String value);
+
+ String format(final String scheme, final String identifier);
+ String format(final String scheme, final String identifier, boolean noDelimiterOnEmptyScheme);
+
+ // always returns array size 2 with first element as scheme and second as identifier part.
+ String[] parse(final String value);
+}
\ No newline at end of file
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/OasisSMPFormatterType.java b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/OasisSMPFormatterType.java
new file mode 100644
index 0000000000000000000000000000000000000000..50e9c94cf23931e7a0dd89f5d7901c0f60521e5a
--- /dev/null
+++ b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/OasisSMPFormatterType.java
@@ -0,0 +1,51 @@
+package eu.europa.ec.smp.api.identifiers.types;
+
+import org.apache.commons.lang3.StringUtils;
+
+import static org.apache.commons.lang3.StringUtils.*;
+
+/**
+ * Simple OSASIS SMP party identifier formatter.
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+public class OasisSMPFormatterType implements FormatterType {
+ private static final String SEPARATOR = "::";
+
+ @Override
+ public boolean isTypeByScheme(final String scheme) {
+ // by default format all identifier as defined in OasisSMP
+ return true;
+ }
+
+ @Override
+ public boolean isType(final String value){
+ // the value should start with valid scheme
+ return true;
+ }
+
+ @Override
+ public String format(String scheme, String identifier, boolean noDelimiterOnEmptyScheme) {
+ return (isBlank(scheme) && noDelimiterOnEmptyScheme ? "" : trimToEmpty(scheme) + SEPARATOR) + trimToEmpty(identifier);
+
+ }
+
+ @Override
+ public String format(final String scheme, final String identifier) {
+ // for OASIS SMP 1.0 the separator :: is mandatory also when scheme is null!
+ return format(scheme, identifier, false);
+ }
+
+ @Override
+ public String[] parse(final String value) {
+ String pValue = trim(value);
+ String[] splitValue = StringUtils.splitByWholeSeparatorPreserveAllTokens(pValue, SEPARATOR, 2);
+ // if only one value is returned set it to identifier
+ // else the first element is scheme and second identifier
+ String scheme = trim(splitValue.length == 1 ? null : splitValue[0]);
+ String identifier = trim(splitValue[splitValue.length == 1 ? 0 : 1]);
+ return new String[]{trimToNull(scheme), trimToNull(identifier)};
+
+ }
+}
\ No newline at end of file
diff --git a/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/TemplateFormatterType.java b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/TemplateFormatterType.java
new file mode 100644
index 0000000000000000000000000000000000000000..812d3ebd4285c90fd71a19b5bd5d256174deba1e
--- /dev/null
+++ b/smp-api/src/main/java/eu/europa/ec/smp/api/identifiers/types/TemplateFormatterType.java
@@ -0,0 +1,96 @@
+package eu.europa.ec.smp.api.identifiers.types;
+
+import eu.europa.ec.smp.api.exceptions.MalformedIdentifierException;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.apache.commons.lang3.StringUtils.trim;
+
+/**
+ * Configurable formatter for parsing and serializing identifiers.
+ * <p>
+ * Example for formatTemplate "${" + SPLIT_GROUP_SCHEME_NAME + "}:${" + SPLIT_GROUP_SCHEME_NAME + "}";
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+public class TemplateFormatterType implements FormatterType {
+ private static final Logger LOG = LoggerFactory.getLogger(TemplateFormatterType.class);
+ public static final String SPLIT_GROUP_SCHEME_NAME = "scheme";
+ public static final String SPLIT_GROUP_IDENTIFIER_NAME = "identifier";
+ protected static final String[] REPLACE_TAGS = new String[]{"${" + SPLIT_GROUP_SCHEME_NAME + "}", "${" + SPLIT_GROUP_IDENTIFIER_NAME + "}"};
+
+ private final Pattern splitRegularExpression;
+ private final Pattern schemaPattern;
+ private final String formatTemplate;
+
+ public TemplateFormatterType(Pattern matchSchema, String formatTemplate, Pattern splitRegularExpression) {
+ this.schemaPattern = matchSchema;
+ this.formatTemplate = formatTemplate;
+ this.splitRegularExpression = splitRegularExpression;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean isTypeByScheme(final String scheme) {
+ if (StringUtils.isBlank(scheme)) {
+ LOG.debug("TemplateFormatterType does not support identifiers with Null/Blank scheme");
+ return false;
+ }
+ Matcher matcher = schemaPattern.matcher(scheme);
+ return matcher.matches();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean isType(final String value) {
+ if (StringUtils.isBlank(value)) {
+ LOG.debug("Formatter does not support Null/Blank identifiers ");
+ return false;
+ }
+ Matcher matcher = schemaPattern.matcher(value);
+ return matcher.matches();
+ }
+
+ @Override
+ public String format(String scheme, String identifier, boolean noDelimiterOnEmptyScheme) {
+ return StringUtils.replaceEach(formatTemplate, REPLACE_TAGS, new String[]{scheme, identifier});
+
+ }
+
+ @Override
+ public String format(final String scheme, final String identifier) {
+ return format(scheme, identifier, false);
+ }
+
+ @Override
+ public String[] parse(final String value) {
+ String partyIdPrivate = value.trim();
+ Matcher matcher = splitRegularExpression.matcher(trim(partyIdPrivate));
+ if (!matcher.matches()) {
+ throw new MalformedIdentifierException("Identifier: [" + partyIdPrivate + "] does not match regular expression [" + splitRegularExpression.pattern() + "]");
+ }
+ return new String[]{
+ getGroupByName(matcher, SPLIT_GROUP_SCHEME_NAME),
+ getGroupByName(matcher, SPLIT_GROUP_IDENTIFIER_NAME)
+ };
+ }
+
+ private String getGroupByName(Matcher matcher, String groupName) {
+ String result = null;
+ try {
+ result = matcher.group(groupName);
+ } catch (IllegalArgumentException arg) {
+ LOG.debug("Group [{}] was not found for pattern: [{}].", groupName, matcher.pattern());
+ }
+ return result;
+ }
+}
diff --git a/smp-api/src/test/java/eu/europa/ec/smp/api/GeneratedCodeTest.java b/smp-api/src/test/java/eu/europa/ec/smp/api/GeneratedCodeTest.java
index 55da9a45bab4e2114073057a6ccce3bac417fa55..ba85f5de1dc440cff9faf20a11b6f5c90f2047b6 100644
--- a/smp-api/src/test/java/eu/europa/ec/smp/api/GeneratedCodeTest.java
+++ b/smp-api/src/test/java/eu/europa/ec/smp/api/GeneratedCodeTest.java
@@ -85,7 +85,7 @@ public class GeneratedCodeTest {
}
public static ServiceGroup loadServiceGroup(String path) throws JAXBException {
- InputStream inputStream = IdentifiersTest.class.getResourceAsStream(path);
+ InputStream inputStream = GeneratedCodeTest.class.getResourceAsStream(path);
JAXBContext jaxbContext = JAXBContext.newInstance(ServiceGroup.class);
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
Object serviceGroup = unmarshaller.unmarshal(inputStream);
diff --git a/smp-api/src/test/java/eu/europa/ec/smp/api/IdentifiersTest.java b/smp-api/src/test/java/eu/europa/ec/smp/api/IdentifiersTest.java
deleted file mode 100644
index 1c28003c62865c2858900da435de7927328c793a..0000000000000000000000000000000000000000
--- a/smp-api/src/test/java/eu/europa/ec/smp/api/IdentifiersTest.java
+++ /dev/null
@@ -1,316 +0,0 @@
-/*
- * Copyright 2017 European Commission | CEF eDelivery
- *
- * Licensed under the EUPL, Version 1.2 or – as soon they will be approved by the European Commission - subsequent versions of the EUPL (the "Licence");
- * You may not use this work except in compliance with the Licence.
- *
- * You may obtain a copy of the Licence attached in file: LICENCE-EUPL-v1.2.pdf
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the Licence is distributed on an "AS IS" basis,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the Licence for the specific language governing permissions and limitations under the Licence.
- */
-
-package eu.europa.ec.smp.api;
-
-import eu.europa.ec.smp.api.exceptions.MalformedIdentifierException;
-import junitparams.JUnitParamsRunner;
-import junitparams.Parameters;
-import junitparams.naming.TestCaseName;
-import org.apache.commons.lang3.StringUtils;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.DocumentIdentifier;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ProcessIdentifier;
-
-import static org.junit.Assert.*;
-
-/**
- * Created by gutowpa on 12/01/2017.
- */
-@RunWith(JUnitParamsRunner.class)
-public class IdentifiersTest {
-
- @Rule
- public ExpectedException expectedEx = ExpectedException.none();
-
- public static final String MALFORMED_INPUT_MSG = "Malformed identifier, scheme and id should be delimited by double colon: ";
-
- private static final Object[] participantIdentifierPositiveCases() {
- return new Object[][]{
- {"ebCore unregistered", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain:ec.europa.eu", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain", "ec.europa.eu"},
- {"ebCore iso6523", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
- {"ebCore with space 1", " urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
- {"ebCore with space 2", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789 ", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
- {"ebCore with space 3", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088::123456789 ", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
-
- {"ebCore unregistered with urn and colons", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth:urn:ehealth:pl:ncp-idp", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth", "urn:ehealth:pl:ncp-idp"},
- {"ebCore unregistered with dash", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth:pl:ncp-idp", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth", "pl:ncp-idp"},
- {"ebCore unregistered example double colon", "urn:oasis:names:tc:ebcore:partyid-type:unregistered::blue-gw", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "blue-gw"},
- {"ebCore unregistered example", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:blue-gw", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "blue-gw"},
- {"ebCore unregistered domain example", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ec.europa.eu", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "ec.europa.eu"},
- {"ebCore unregistered email scheme example", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:email:test@my.mail.com", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:email", "test@my.mail.com"},
- {"ebCore unregistered email example", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:test@my.mail.com", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "test@my.mail.com"},
- {"ebCore with double colon", " urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088::123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
- {"ebCore with double colon start", " ::urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
- {"Double colon basic", "a::b", "a", "b"},
- {"Double colon twice", "a::b::c", "a", "b::c"},
- {"Double colon iso6523", "iso6523-actorid-upis::0002:gutek", "iso6523-actorid-upis", "0002:gutek"},
- {"Double colon ehealth", "ehealth-actorid-qns::urn:poland:ncpb", "ehealth-actorid-qns", "urn:poland:ncpb"},
- {"Double colon ehealth 2", "ehealth-actorid-qns::urn:ehealth:hr:ncpb-idp", "ehealth-actorid-qns", "urn:ehealth:hr:ncpb-idp"},
- {"Double colon ehealth 3", "scheme::urn:ehealth:pt:ncpb-idp", "scheme", "urn:ehealth:pt:ncpb-idp"},
- {"Double colon custom scheme", "otherscheme::urn:ehealth:be:ncpb-idp", "otherscheme", "urn:ehealth:be:ncpb-idp"},
- };
- }
-
- private static final Object[][] participantIdentifierNegativeCases() {
- return new Object[][]{
- {"Null value", null, false},
- {"Empty value", "", false},
- {"Missing identifier", "a::", false},
- // following are false only if scheme is mandatory!
- {"Not double colon and not ebCoreId", "a", true},
- {"Constant and is not ebCoreId 2", "abc", true},
- {"Only one colon", "a:b", true},
- {"Not double colon and not ebCoreId", "ehealth-actorid-qns", true},
- {"Not double colon and not ebCoreId", "urn:poland:ncpb", true},
- {"Not double colon and not ebCoreId", "ehealth-resid-qns", true},
- {"Not double colon and not ebCoreId", "epsos##services:extended:epsos:51", true},
- };
- }
-
- private static final Object[] testCases() {
- return new Object[][]{
- {"a::b", "a", "b"},
- {"a::b::c", "a", "b::c"},
- {"a:b::c", "a:b", "c"},
- {"NoSchemeIdentifier", null, "NoSchemeIdentifier"},
- {"ehealth-actorid-qns::urn:poland:ncpb", "ehealth-actorid-qns", "urn:poland:ncpb"},
- {"ehealth-resid-qns::urn::epsos##services:extended:epsos::51", "ehealth-resid-qns", "urn::epsos##services:extended:epsos::51"},
- {"iso6523-actorid-upis::0002:gutek", "iso6523-actorid-upis", "0002:gutek"},
- {"ehealth-actorid-qns::urn:ehealth:hr:ncpb-idp", "ehealth-actorid-qns", "urn:ehealth:hr:ncpb-idp"},
- {"scheme::urn:ehealth:pt:ncpb-idp", "scheme", "urn:ehealth:pt:ncpb-idp"},
- {"otherscheme::urn:ehealth:be:ncpb-idp", "otherscheme", "urn:ehealth:be:ncpb-idp"},
- {"ehealth-resid-qns::urn:ehealth:IdentityService::XCPD::CrossGatewayPatientDiscovery##ITI-55", "ehealth-resid-qns", "urn:ehealth:IdentityService::XCPD::CrossGatewayPatientDiscovery##ITI-55"},
- {"ehealth-resid-qns::urn:XCPD::CrossGatewayPatientDiscovery", "ehealth-resid-qns", "urn:XCPD::CrossGatewayPatientDiscovery"},
- {"ehealth-resid-qns::urn:ehealth:PatientService::XCA::CrossGatewayQuery##ITI-38", "ehealth-resid-qns", "urn:ehealth:PatientService::XCA::CrossGatewayQuery##ITI-38"},
- {"ehealth-resid-qns::urn:XCA::CrossGatewayQuery", "ehealth-resid-qns", "urn:XCA::CrossGatewayQuery"},
- {"ehealth-resid-qns::urn:ehealth:OrderService::XCA::CrossGatewayQuery##ITI-38", "ehealth-resid-qns", "urn:ehealth:OrderService::XCA::CrossGatewayQuery##ITI-38"},
- {"ehealth-resid-qns::urn:ehealth:DispensationService:Initialize::XDR::ProvideandRegisterDocumentSet-b##ITI-41", "ehealth-resid-qns", "urn:ehealth:DispensationService:Initialize::XDR::ProvideandRegisterDocumentSet-b##ITI-41"},
- {"ehealth-resid-qns::urn:XDR::ProvideandRegisterDocumentSet-b", "ehealth-resid-qns", "urn:XDR::ProvideandRegisterDocumentSet-b"},
- {"ehealth-resid-qns::urn:ehealth:DispensationService:Discard::XDR::ProvideandRegisterDocumentSet-b##ITI-41", "ehealth-resid-qns", "urn:ehealth:DispensationService:Discard::XDR::ProvideandRegisterDocumentSet-b##ITI-41"},
- {"ehealth-resid-qns::urn:ehealth:ConsentService:Put::XDR::BPPCProvideandRegisterDocumentSet-b##ITI-41", "ehealth-resid-qns", "urn:ehealth:ConsentService:Put::XDR::BPPCProvideandRegisterDocumentSet-b##ITI-41"},
- {"ehealth-resid-qns::urn:XDR::BPPCProvideandRegisterDocumentSet-b", "ehealth-resid-qns", "urn:XDR::BPPCProvideandRegisterDocumentSet-b"},
- {"ehealth-resid-qns::urn:ehealth:ConsentService:Discard::XDR::BPPCProvideandRegisterDocumentSet-b##ITI-41", "ehealth-resid-qns", "urn:ehealth:ConsentService:Discard::XDR::BPPCProvideandRegisterDocumentSet-b##ITI-41"},
- {"ehealth-resid-qns::urn:ehealth:IdP::identityProvider::HPAuthentication##epsos-91", "ehealth-resid-qns", "urn:ehealth:IdP::identityProvider::HPAuthentication##epsos-91"},
- {"ehealth-resid-qns::urn:identityProvider::HPAuthentication", "ehealth-resid-qns", "urn:identityProvider::HPAuthentication"},
- {"ehealth-resid-qns::urn:ehealth:IdP::XUA::ProvideX-UserAssertion##ITI-40", "ehealth-resid-qns", "urn:ehealth:IdP::XUA::ProvideX-UserAssertion##ITI-40"},
- {"ehealth-resid-qns::urn:XUA::ProvideX-UserAssertion", "ehealth-resid-qns", "urn:XUA::ProvideX-UserAssertion"},
- {"ehealth-resid-qns::urn:ehealth:VPN::VPNGatewayServer##epsos-105", "ehealth-resid-qns", "urn:ehealth:VPN::VPNGatewayServer##epsos-105"},
- {"ehealth-resid-qns::urn:ehealth:ncp::vpngateway", "ehealth-resid-qns", "urn:ehealth:ncp::vpngateway"},
- {"ehealth-resid-qns::urn:ehealth:VPN::VPNGatewayClient##epsos-106", "ehealth-resid-qns", "urn:ehealth:VPN::VPNGatewayClient##epsos-106"},
- {"ehealth-resid-qns::urn:ehealth:ISM::InternationalSearchMask##epsos-107", "ehealth-resid-qns", "urn:ehealth:ISM::InternationalSearchMask##epsos-107"},
- {"ehealth-resid-qns::urn:ehealth:ncp::pt:ism", "ehealth-resid-qns", "urn:ehealth:ncp::pt:ism"}
- };
- }
-
- private static final Object[] ebCoreIdentifiersCases() {
- return new Object[][]{
- {"ebCore unregistered", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain:ec.europa.eu", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain", "ec.europa.eu"},
- {"ebCore iso6523", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
- {"ebCore with space 1", " urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
- {"ebCore with space 2", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789 ", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
- {"ebCore unregistered with urn and colons", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth:urn:ehealth:pl:ncp-idp", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth", "urn:ehealth:pl:ncp-idp"},
- {"ebCore unregistered with dash", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth:pl:ncp-idp", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth", "pl:ncp-idp"},
- {"ebCore unregistered example", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:blue-gw", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "blue-gw"},
- {"ebCore unregistered domain example", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ec.europa.eu", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "ec.europa.eu"},
- {"ebCore unregistered email scheme example", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:email:test@my.mail.com", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:email", "test@my.mail.com"},
- {"ebCore unregistered email example", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:test@my.mail.com", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "test@my.mail.com"},
- {"ebCore with double colon", " urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088::123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
- {"ebCore with double colon start", " ::urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
-
- };
- }
-
- private static final Object[] ebCoreIdentifiersNegativeCases() {
- return new Object[][]{
- //{"Not an ebCore ", "urn:my:space:tc:ebcore:partyid-type:unregistered:domain:ec.europa.eu", MalformedIdentifierException.class},
- {"ebCore iso6523", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:Illegal-value-without-scheme", IllegalArgumentException.class},
- {"ebCore with no catalog", " urn:oasis:names:tc:ebcore:partyid-type:0088123456789", IllegalArgumentException.class},
- };
- }
-
- private static final Object[] negativeCases() {
- return new Object[]{
- null,
- "a::",
- };
- }
-
- private static final Object[] documentTestCases() {
- Object[] commonTests = testCases();
- Object[] res = new Object[commonTests.length + 2];
- System.arraycopy(commonTests, 0, res, 0, commonTests.length);
- //add new test with empty schema
- res[commonTests.length] = new Object[]{"::a", null, "a"};
- res[commonTests.length + 1] = new Object[]{"::urn:ehealth:ncp::pt:ism", null, "urn:ehealth:ncp::pt:ism"};
- return res;
- }
-
- private static final Object[] negativeDocumentCases() {
- Object[] commonNegativeTests = negativeCases();
- Object[] res = new Object[commonNegativeTests.length - 1]; // skip last one
- System.arraycopy(commonNegativeTests, 0, res, 0, commonNegativeTests.length - 1);
-
- return res;
- }
-
- @Test
- @Parameters(method = "participantIdentifierPositiveCases")
- @TestCaseName("{0}")
- public void testParticipantIdPositive(String caseName, String input, String scheme, String value) {
- //when
- ParticipantIdentifierType participantId = Identifiers.asParticipantId(input, true);
-
- //then
- assertEquals(scheme, participantId.getScheme());
- assertEquals(value, participantId.getValue());
- }
-
- @Test
- @Parameters(method = "ebCoreIdentifiersCases")
- @TestCaseName("{0}")
- public void testSplitEbCoreIdentifier(String caseName, String input, String scheme, String value) {
- //when
- String[] values = Identifiers.splitEbCoreIdentifier(input);
-
- //then
- assertEquals(2, values.length);
- assertEquals(scheme, values[0]);
- assertEquals(value, values[1]);
- }
-
- @Test
- @Parameters(method = "participantIdentifierNegativeCases")
- @TestCaseName("{0}")
- public void testParticipantIdNegative(String caseName, String negativeInput, boolean schemeMandatory) {
- try {
- //when
- Identifiers.asParticipantId(negativeInput, schemeMandatory);
- System.out.println(negativeInput);
- } catch (Exception e) {
- //then
- negativeAssertions(negativeInput, e);
- return;
- }
- fail();
- }
-
- @Test
- @Parameters(method = "ebCoreIdentifiersNegativeCases")
- @TestCaseName("{0}")
- public void testSplitEbCoreIdentifierNegative(String caseName, String negativeInput, Class clz) {
-
- expectedEx.expect(clz);
- //when
- Identifiers.asParticipantId(negativeInput, false);
-
- }
-
- @Test
- @Parameters(method = "documentTestCases")
- public void testDocumentIdPositive(String input, String scheme, String value) {
- //when
- DocumentIdentifier documentId = Identifiers.asDocumentId(input);
-
- //then
- assertEquals(scheme, documentId.getScheme());
- assertEquals(value, documentId.getValue());
- }
-
- @Test
- @Parameters(method = "testCases")
- public void testProcessIdPositive(String input, String scheme, String value) {
- //when
- ProcessIdentifier processId = Identifiers.asProcessId(input);
-
- //then
- assertEquals(scheme, processId.getScheme());
- assertEquals(value, processId.getValue());
- }
-
- @Test
- @Parameters(method = "negativeCases")
- public void testProcessIdNegative(String negativeInput) {
- try {
- //when
- Identifiers.asProcessId(negativeInput);
- } catch (Exception e) {
- //then
- negativeAssertions(negativeInput, e);
- return;
- }
- fail();
- }
-
- @Test
- @Parameters(method = "negativeDocumentCases")
- public void testDocumentIdNegative(String negativeInput) {
- try {
- //when
- Identifiers.asDocumentId(negativeInput);
- } catch (Exception e) {
- ///then
- negativeAssertions(negativeInput, e);
- return;
- }
- fail();
- }
-
- private void negativeAssertions(String negativeInput, Exception e) {
- assertTrue(e instanceof MalformedIdentifierException);
- assertEquals(MALFORMED_INPUT_MSG + (StringUtils.isBlank(negativeInput) ? "Null/Empty" : negativeInput), e.getMessage());
- }
-
- @Test
- public void testUrlEncodingParticipantId() {
- //given
- ParticipantIdentifierType participantId = new ParticipantIdentifierType("0088:conformance:sg01#", "ehealth:actorid:qns");
-
- //when-then
- assertEquals("ehealth%3Aactorid%3Aqns%3A%3A0088%3Aconformance%3Asg01%23", Identifiers.asUrlEncodedString(participantId));
- }
-
- @Test
- public void testUrlEncodingParticipantIdWithSpace() {
- //given
- ParticipantIdentifierType participantId = new ParticipantIdentifierType("GPR: 0088:conformance:sg01#", "ehealth:actorid:qns");
-
- //when-then
- //Because this is path segment spaces must be percent encoded (not with +)!
- assertEquals("ehealth%3Aactorid%3Aqns%3A%3AGPR%3A%200088%3Aconformance%3Asg01%23", Identifiers.asUrlEncodedString(participantId));
- }
-
- @Test
- public void testUrlEncodingDocumentId() {
- //given
- DocumentIdentifier docId = new DocumentIdentifier("urn::ehealth##services:extended:epsos01::101", "busdox:docid:qns");
-
- //when-then
- assertEquals("busdox%3Adocid%3Aqns%3A%3Aurn%3A%3Aehealth%23%23services%3Aextended%3Aepsos01%3A%3A101", Identifiers.asUrlEncodedString(docId));
- }
-
- @Test
- public void testUrlEncodingDocumentIdWithSpace() {
- //given
- DocumentIdentifier docId = new DocumentIdentifier("urn::ehealth##services:extended:epsos01:: 101", "busdox:docid:qns");
-
- //when-then
- //Because this is path segment spaces must be percent encoded (not with +)!
- assertEquals("busdox%3Adocid%3Aqns%3A%3Aurn%3A%3Aehealth%23%23services%3Aextended%3Aepsos01%3A%3A%20101", Identifiers.asUrlEncodedString(docId));
- }
-
-}
diff --git a/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/DocumentIdentifierFormatterTest.java b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/DocumentIdentifierFormatterTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..28091cbfd808b875b5882f2c796647e5a9f700d3
--- /dev/null
+++ b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/DocumentIdentifierFormatterTest.java
@@ -0,0 +1,166 @@
+package eu.europa.ec.smp.api.identifiers;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.DocumentIdentifier;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+@RunWith(Parameterized.class)
+public class DocumentIdentifierFormatterTest {
+
+ @Parameterized.Parameters(name = "{index}: {0}")
+ public static Collection documentIdentifierCases() {
+ return Arrays.asList(new Object[][]{
+ {"Basic example",
+ new DocumentIdentifier("b", "a"),
+ "a::b",
+ "a%3A%3Ab",
+ "a::b",
+ false},
+ {"Double separator example",
+ new DocumentIdentifier("b::c", "a"),
+ "a::b::c",
+ "a%3A%3Ab%3A%3Ac",
+ "a::b::c",
+ false},
+ {"Char : in scheme colon basic",
+ new DocumentIdentifier("c","a:b"),
+ "a:b::c",
+ "a%3Ab%3A%3Ac",
+ "a:b::c",
+ false},
+ {"No Scheme Identifier ",
+ new DocumentIdentifier("NoSchemeIdentifier", null),
+ "::NoSchemeIdentifier",
+ "%3A%3ANoSchemeIdentifier",
+ "NoSchemeIdentifier",
+ false},
+ {"No Scheme Identifier with ::",
+ new DocumentIdentifier("NoSchemeIdentifier01", null),
+ "::NoSchemeIdentifier01",
+ "%3A%3ANoSchemeIdentifier01",
+ "::NoSchemeIdentifier01",
+ false},
+ {"No Scheme Identifier with no scheme and ::",
+ new DocumentIdentifier("NoSchemeIdentifier01::test", null),
+ "::NoSchemeIdentifier01::test",
+ "%3A%3ANoSchemeIdentifier01%3A%3Atest",
+ "::NoSchemeIdentifier01::test",
+ false},
+ {"Example with ## and double colon",
+ new DocumentIdentifier("urn::epsos##services:extended:epsos::51", "ehealth-resid-qns"),
+ "ehealth-resid-qns::urn::epsos##services:extended:epsos::51",
+ "ehealth-resid-qns%3A%3Aurn%3A%3Aepsos%23%23services%3Aextended%3Aepsos%3A%3A51",
+ "ehealth-resid-qns::urn::epsos##services:extended:epsos::51",
+ false},
+ {"Identifier with spaces - formatted to uri with '%20",
+ new DocumentIdentifier("urn ncpb test", "ehealth-actorid-qns"),
+ "ehealth-actorid-qns::urn ncpb test",
+ "ehealth-actorid-qns%3A%3Aurn%20ncpb%20test",
+ "ehealth-actorid-qns::urn ncpb test",
+ false},
+ {"Example 01 (parse spaces)",new DocumentIdentifier("urn:ehealth:pt:ncpb-idp","scheme"),
+ "scheme::urn:ehealth:pt:ncpb-idp",
+ "scheme%3A%3Aurn%3Aehealth%3Apt%3Ancpb-idp",
+ " scheme::urn:ehealth:pt:ncpb-idp",
+ false},
+ {"Example 02 (parse spaces)",new DocumentIdentifier("urn:ehealth:be:ncpb-idp","otherscheme"),
+ "otherscheme::urn:ehealth:be:ncpb-idp",
+ "otherscheme%3A%3Aurn%3Aehealth%3Abe%3Ancpb-idp" ,
+ "otherscheme::urn:ehealth:be:ncpb-idp ",
+ false},
+ {"Example 03 (parse spaces in argument)",new DocumentIdentifier("urn:ehealth:IdentityService::XCPD::CrossGatewayPatientDiscovery##ITI-55","ehealth-resid-qns"),
+ "ehealth-resid-qns::urn:ehealth:IdentityService::XCPD::CrossGatewayPatientDiscovery##ITI-55",
+ "ehealth-resid-qns%3A%3Aurn%3Aehealth%3AIdentityService%3A%3AXCPD%3A%3ACrossGatewayPatientDiscovery%23%23ITI-55",
+ "ehealth-resid-qns:: urn:ehealth:IdentityService::XCPD::CrossGatewayPatientDiscovery##ITI-55 ",
+ false},
+ {"Example 04",new DocumentIdentifier( "urn:XCPD::CrossGatewayPatientDiscovery", "ehealth-resid-qns"),
+ "ehealth-resid-qns::urn:XCPD::CrossGatewayPatientDiscovery",
+ "ehealth-resid-qns%3A%3Aurn%3AXCPD%3A%3ACrossGatewayPatientDiscovery",
+ "ehealth-resid-qns::urn:XCPD::CrossGatewayPatientDiscovery",
+ false},
+ {"Example 05",new DocumentIdentifier("urn:ehealth:PatientService::XCA::CrossGatewayQuery##ITI-38","ehealth-resid-qns"),
+ "ehealth-resid-qns::urn:ehealth:PatientService::XCA::CrossGatewayQuery##ITI-38",
+ "ehealth-resid-qns%3A%3Aurn%3Aehealth%3APatientService%3A%3AXCA%3A%3ACrossGatewayQuery%23%23ITI-38",
+ "ehealth-resid-qns::urn:ehealth:PatientService::XCA::CrossGatewayQuery##ITI-38",
+ false},
+ {"Example 06",new DocumentIdentifier("urn:XCA::CrossGatewayQuery", "ehealth-resid-qns"),
+ "ehealth-resid-qns::urn:XCA::CrossGatewayQuery",
+ "ehealth-resid-qns%3A%3Aurn%3AXCA%3A%3ACrossGatewayQuery",
+ "ehealth-resid-qns::urn:XCA::CrossGatewayQuery",
+ false},
+ {"Example 07",new DocumentIdentifier("urn:ehealth:OrderService::XCA::CrossGatewayQuery##ITI-38","ehealth-resid-qns"),
+ "ehealth-resid-qns::urn:ehealth:OrderService::XCA::CrossGatewayQuery##ITI-38",
+ "ehealth-resid-qns%3A%3Aurn%3Aehealth%3AOrderService%3A%3AXCA%3A%3ACrossGatewayQuery%23%23ITI-38",
+ "ehealth-resid-qns::urn:ehealth:OrderService::XCA::CrossGatewayQuery##ITI-38",
+ false},
+ {"Example 08",new DocumentIdentifier("urn:ehealth:DispensationService:Initialize::XDR::ProvideandRegisterDocumentSet-b##ITI-41","ehealth-resid-qns"),
+ "ehealth-resid-qns::urn:ehealth:DispensationService:Initialize::XDR::ProvideandRegisterDocumentSet-b##ITI-41",
+ "ehealth-resid-qns%3A%3Aurn%3Aehealth%3ADispensationService%3AInitialize%3A%3AXDR%3A%3AProvideandRegisterDocumentSet-b%23%23ITI-41",
+ "ehealth-resid-qns::urn:ehealth:DispensationService:Initialize::XDR::ProvideandRegisterDocumentSet-b##ITI-41",
+ false},
+ {"Example 09",new DocumentIdentifier("urn:XDR::ProvideandRegisterDocumentSet-b","ehealth-resid-qns"),
+ "ehealth-resid-qns::urn:XDR::ProvideandRegisterDocumentSet-b",
+ "ehealth-resid-qns%3A%3Aurn%3AXDR%3A%3AProvideandRegisterDocumentSet-b",
+ "ehealth-resid-qns::urn:XDR::ProvideandRegisterDocumentSet-b",
+ false},
+ {"Example 10",new DocumentIdentifier("urn:ehealth:DispensationService:Discard::XDR::ProvideandRegisterDocumentSet-b##ITI-41","ehealth-resid-qns"),
+ "ehealth-resid-qns::urn:ehealth:DispensationService:Discard::XDR::ProvideandRegisterDocumentSet-b##ITI-41",
+ "ehealth-resid-qns%3A%3Aurn%3Aehealth%3ADispensationService%3ADiscard%3A%3AXDR%3A%3AProvideandRegisterDocumentSet-b%23%23ITI-41",
+ "ehealth-resid-qns::urn:ehealth:DispensationService:Discard::XDR::ProvideandRegisterDocumentSet-b##ITI-41",
+ false},
+
+ });
+ }
+
+ // input parameters
+ @Parameterized.Parameter
+ public String name;
+ @Parameterized.Parameter(1)
+ public DocumentIdentifier identifierType;
+ @Parameterized.Parameter(2)
+ public String formattedIdentifier;
+ @Parameterized.Parameter(3)
+ public String uriFormattedIdentifier;
+ @Parameterized.Parameter(4)
+ public String identifierToParse;
+ @Parameterized.Parameter(5)
+ public boolean throwParseError;
+
+ DocumentIdentifierFormatter testInstance = new DocumentIdentifierFormatter();
+
+ @Test
+ public void testFormat() {
+
+ String result = testInstance.format(identifierType);
+ String uriResult = testInstance.urlEncodedFormat(identifierType);
+
+ Assert.assertEquals(formattedIdentifier, result);
+ Assert.assertEquals(uriFormattedIdentifier, uriResult);
+ }
+
+ @Test
+ public void testParse() {
+ IllegalArgumentException exception = null;
+ DocumentIdentifier result = null;
+ if (throwParseError) {
+ exception = Assert.assertThrows(IllegalArgumentException.class, () -> testInstance.parse(identifierToParse));
+ } else {
+ result = testInstance.parse(identifierToParse);
+ }
+
+ Assert.assertNotNull(throwParseError ? exception : result);
+ if (!throwParseError) {
+ Assert.assertEquals(identifierType.getScheme(), result.getScheme());
+ Assert.assertEquals(identifierType.getValue(), result.getValue());
+ }
+ }
+}
\ No newline at end of file
diff --git a/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/ParticipantIdentifierFormatterFormatTests.java b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/ParticipantIdentifierFormatterFormatTests.java
new file mode 100644
index 0000000000000000000000000000000000000000..30cb8056d93f27ce7c0cc36a32c0ec5babcb0716
--- /dev/null
+++ b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/ParticipantIdentifierFormatterFormatTests.java
@@ -0,0 +1,74 @@
+package eu.europa.ec.smp.api.identifiers;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+@RunWith(Parameterized.class)
+public class ParticipantIdentifierFormatterFormatTests {
+
+ @Parameterized.Parameters(name = "{index}: {0}")
+ public static Collection participantIdentifierCases() {
+ return Arrays.asList(new Object[][]{
+ {"ebCore unregistered",
+ new ParticipantIdentifierType( "ec.europa.eu","urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain" ),
+ "urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain:ec.europa.eu",
+ "urn%3Aoasis%3Anames%3Atc%3Aebcore%3Apartyid-type%3Aunregistered%3Adomain%3Aec.europa.eu"},
+ {"ebCore iso6523",
+ new ParticipantIdentifierType( "123456789","urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088" ),
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789",
+ "urn%3Aoasis%3Anames%3Atc%3Aebcore%3Apartyid-type%3Aiso6523%3A0088%3A123456789"},
+ {"Double colon basic",
+ new ParticipantIdentifierType( "b","a" ),
+ "a::b",
+ "a%3A%3Ab"},
+ {"Double colon twice", new ParticipantIdentifierType( "b::c","a" ),
+ "a::b::c",
+ "a%3A%3Ab%3A%3Ac"},
+ {"Double colon iso6523",
+ new ParticipantIdentifierType( "0002:12345","iso6523-actorid-upis" ),
+ "iso6523-actorid-upis::0002:12345",
+ "iso6523-actorid-upis%3A%3A0002%3A12345"},
+ {"Double colon eHealth",
+ new ParticipantIdentifierType( "urn:poland:ncpb","ehealth-actorid-qns" ),
+ "ehealth-actorid-qns::urn:poland:ncpb",
+ "ehealth-actorid-qns%3A%3Aurn%3Apoland%3Ancpb"},
+ {"Identifier with spaces - formatted to uri with '%20",
+ new ParticipantIdentifierType( "urn ncpb test","ehealth-actorid-qns" ),
+ "ehealth-actorid-qns::urn ncpb test",
+ "ehealth-actorid-qns%3A%3Aurn%20ncpb%20test"},
+ });
+ }
+
+ // input parameters
+ @Parameterized.Parameter
+ public String name;
+ @Parameterized.Parameter(1)
+ public ParticipantIdentifierType participantIdentifierType;
+ @Parameterized.Parameter(2)
+ public String formattedIdentifier;
+ @Parameterized.Parameter(3)
+ public String uriFormattedIdentifier;
+
+ ParticipantIdentifierFormatter testInstance = new ParticipantIdentifierFormatter();
+
+ @Test
+ public void testFormat() {
+
+ String result = testInstance.format(participantIdentifierType);
+ String uriResult = testInstance.urlEncodedFormat(participantIdentifierType);
+
+ Assert.assertEquals(formattedIdentifier,result);
+ Assert.assertEquals(uriFormattedIdentifier, uriResult);
+ }
+}
diff --git a/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/ParticipantIdentifierFormatterParseTests.java b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/ParticipantIdentifierFormatterParseTests.java
new file mode 100644
index 0000000000000000000000000000000000000000..9cc97af9295e8480b86f7f43d190874a3812c25c
--- /dev/null
+++ b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/ParticipantIdentifierFormatterParseTests.java
@@ -0,0 +1,82 @@
+package eu.europa.ec.smp.api.identifiers;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+@RunWith(Parameterized.class)
+public class ParticipantIdentifierFormatterParseTests {
+
+
+ @Parameterized.Parameters(name = "{index}: {0}")
+ public static Collection participantIdentifierPositiveCases() {
+ return Arrays.asList(new Object[][]{
+ {"ebCore unregistered", false, "urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain:ec.europa.eu", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain", "ec.europa.eu"},
+ {"ebCore iso6523", false, "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
+ {"ebCore with space 1", false, " urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
+ {"ebCore with space 2", false, "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789 ", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
+ {"ebCore with space 3", false, "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088::123456789 ", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
+ {"ebCore unregistered with urn and colons", false, "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth:urn:ehealth:pl:ncp-idp", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth", "urn:ehealth:pl:ncp-idp"},
+ {"ebCore unregistered with dash", false, "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth:pl:ncp-idp", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ehealth", "pl:ncp-idp"},
+ {"ebCore unregistered example double colon", false, "urn:oasis:names:tc:ebcore:partyid-type:unregistered::blue-gw", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "blue-gw"},
+ {"ebCore unregistered example", false, "urn:oasis:names:tc:ebcore:partyid-type:unregistered:blue-gw", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "blue-gw"},
+ {"ebCore unregistered domain example", false, "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ec.europa.eu", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "ec.europa.eu"},
+ {"ebCore unregistered email scheme example", false, "urn:oasis:names:tc:ebcore:partyid-type:unregistered:email:test@my.mail.com", "urn:oasis:names:tc:ebcore:partyid-type:unregistered:email", "test@my.mail.com"},
+ {"ebCore unregistered email example", false, "urn:oasis:names:tc:ebcore:partyid-type:unregistered:test@my.mail.com", "urn:oasis:names:tc:ebcore:partyid-type:unregistered", "test@my.mail.com"},
+ {"ebCore with double colon", false, " urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088::123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
+ {"ebCore with double colon start", false, " ::urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789"},
+ {"Double colon basic", false, "a::b", "a", "b"},
+ {"Double colon twice", false, "a::b::c", "a", "b::c"},
+ {"Double colon iso6523", false, "iso6523-actorid-upis::0002:gutek", "iso6523-actorid-upis", "0002:gutek"},
+ {"Double colon ehealth", false, "ehealth-actorid-qns::urn:poland:ncpb", "ehealth-actorid-qns", "urn:poland:ncpb"},
+ {"Double colon ehealth 2", false, "ehealth-actorid-qns::urn:ehealth:hr:ncpb-idp", "ehealth-actorid-qns", "urn:ehealth:hr:ncpb-idp"},
+ {"Double colon ehealth 3", false, "scheme::urn:ehealth:pt:ncpb-idp", "scheme", "urn:ehealth:pt:ncpb-idp"},
+ {"Double colon custom scheme", false, "otherscheme::urn:ehealth:be:ncpb-idp", "otherscheme", "urn:ehealth:be:ncpb-idp"},
+
+ {"ebCore iso6523", true, "urn:oasis:names:tc:ebcore:partyid-type:iso6523:Illegal-value-without-scheme", null, null},
+ {"ebCore with no catalog", true, " urn:oasis:names:tc:ebcore:partyid-type:0088123456789", null, null},
+ });
+ }
+ // input parameters
+ @Parameterized.Parameter
+ public String name;
+ @Parameterized.Parameter(1)
+ public boolean throwError;
+ @Parameterized.Parameter(2)
+ public String identifier;
+ @Parameterized.Parameter(3)
+ public String schemaPart;
+ @Parameterized.Parameter(4)
+ public String idPart;
+
+ ParticipantIdentifierFormatter testInstance = new ParticipantIdentifierFormatter();
+
+ @Test
+ public void testPartyIdentifierParse() {
+ IllegalArgumentException exception = null;
+ ParticipantIdentifierType result = null;
+ if (throwError) {
+ exception = Assert.assertThrows(IllegalArgumentException.class, () -> testInstance.parse(identifier));
+ } else {
+ result = testInstance.parse(identifier);
+ }
+
+ Assert.assertNotNull(throwError ? exception : result);
+ if (!throwError) {
+ Assert.assertEquals(schemaPart, result.getScheme());
+ Assert.assertEquals(idPart, result.getValue());
+ }
+ }
+
+
+}
diff --git a/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/types/EBCorePartyIdFormatterTypeTest.java b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/types/EBCorePartyIdFormatterTypeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6daa95e417075647720a69b715f52ced234b111
--- /dev/null
+++ b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/types/EBCorePartyIdFormatterTypeTest.java
@@ -0,0 +1,171 @@
+package eu.europa.ec.smp.api.identifiers.types;
+
+import eu.europa.ec.smp.api.exceptions.MalformedIdentifierException;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.apache.commons.lang3.StringUtils.*;
+import static org.junit.Assert.*;
+
+/**
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+@RunWith(Parameterized.class)
+public class EBCorePartyIdFormatterTypeTest {
+
+
+ @Parameterized.Parameters(name = "{index}: {0}")
+ public static Collection participantIdentifierPositiveCases() {
+ return Arrays.asList(new Object[][]{
+ {
+ "unregistered with <scheme-in-catalog",
+ true,
+ "urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain:ec.europa.eu",
+ "urn:oasis:names:tc:ebcore:partyid-type:unregistered:domain",
+ "ec.europa.eu",
+ null, null
+ },
+ {
+ "Case insensitive schema",
+ true,
+ "urn:OASIS:names:tC:eBcore:partyId-type:unregistered:domain:ec.europa.eu",
+ "urn:OASIS:names:tC:eBcore:partyId-type:unregistered:domain",
+ "ec.europa.eu",
+ null, null
+ },
+ {
+ "unregistered without <scheme-in-catalog",
+ true,
+ "urn:oasis:names:tc:ebcore:partyid-type:unregistered:ec.europa.eu",
+ "urn:oasis:names:tc:ebcore:partyid-type:unregistered",
+ "ec.europa.eu",
+ null, null},
+ {
+ "iso6523",
+ true,
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789",
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088",
+ "123456789",
+ null, null},
+ {"with spaces",
+ true,
+ " urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789 ",
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789",
+ null, null},
+ {"with spaces in the identifier",
+ true,
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088: 123456789 ",
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789",
+ null, null},
+ {"Parse eDelivery URN format",
+ true,
+ "::urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456789",
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789",
+ null, null},
+ {"Parse peppol URN format 1",
+ true,
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088::123456789",
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789",
+ null, null},
+ {"Parse peppol URN format 2",
+ true,
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523::0088:123456789",
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456789",
+ null, null},
+ {
+ "invalid catalog identifier",
+ true,
+ "urn:oasis:names:tc:ebcore:partyid-type:invalid-catalog:ec.europa.eu",
+ "urn:oasis:names:tc:ebcore:partyid-type:invalid-catalog",
+ "ec.europa.eu",
+ IllegalArgumentException.class, "Invalid ebCore id "},
+ {
+ "Not ebcore party id",
+ false,
+ "urn:ehealth:invalid-catalog:ec.europa.eu",
+ "urn:ehealth:invalid-catalog:ec.europa.eu",
+ null,
+ MalformedIdentifierException.class, "Malformed identifier"},
+ {
+ "Not ebcore party id iso6523",
+ true,
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523::0088",
+ "urn:oasis:names:tc:ebcore:partyid-type:iso6523::0088",
+ null,
+ IllegalArgumentException.class, "Invalid ebCore id"},
+ });
+ }
+
+ EBCorePartyIdFormatterType testInstance = new EBCorePartyIdFormatterType();
+
+ // input parameters
+ @Parameterized.Parameter
+ public String testName;
+ @Parameterized.Parameter(1)
+ public boolean isEBCorePartyId;
+ @Parameterized.Parameter(2)
+ public String toParseIdentifier;
+ @Parameterized.Parameter(3)
+ public String schemaPart;
+ @Parameterized.Parameter(4)
+ public String idPart;
+ @Parameterized.Parameter(5)
+ public Class errorClass;
+ @Parameterized.Parameter(6)
+ public String containsErrorMessage;
+
+
+ @Test
+ public void isTypeByScheme() {
+
+ boolean result = testInstance.isTypeByScheme(schemaPart);
+ assertEquals(isEBCorePartyId, result);
+ }
+
+ @Test
+ public void isType() {
+
+ boolean result = testInstance.isType(toParseIdentifier);
+ assertEquals(isEBCorePartyId, result);
+ }
+
+ @Test
+ public void format() {
+ // skip format for not ebcore party ids
+ if (!isEBCorePartyId) {
+ return;
+ }
+
+ String result = testInstance.format(schemaPart, idPart);
+
+ String schema = trimToEmpty(schemaPart);
+ assertEquals(schema + ":" + trimToEmpty(idPart), result);
+ }
+
+ @Test
+ public void parse() {
+ // skip parse not ebcore party ids
+ if (!isEBCorePartyId) {
+ IllegalArgumentException result = assertThrows(IllegalArgumentException.class, () -> testInstance.parse(toParseIdentifier));
+ MatcherAssert.assertThat(result.getMessage(), CoreMatchers.containsString(containsErrorMessage));
+ }
+ if (errorClass != null) {
+ Throwable result = assertThrows(errorClass, () -> testInstance.parse(toParseIdentifier));
+ MatcherAssert.assertThat(result.getMessage(), CoreMatchers.containsString(containsErrorMessage));
+ } else {
+
+ String[] result = testInstance.parse(toParseIdentifier);
+ assertNotNull(result);
+ assertEquals(2, result.length);
+ assertEquals(schemaPart, result[0]);
+ assertEquals(idPart, result[1]);
+ }
+ }
+}
\ No newline at end of file
diff --git a/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/types/OasisSMPFormatterTypeTest.java b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/types/OasisSMPFormatterTypeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7deac8c8ed2aebac5231e4e209706f16afb50c85
--- /dev/null
+++ b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/types/OasisSMPFormatterTypeTest.java
@@ -0,0 +1,122 @@
+package eu.europa.ec.smp.api.identifiers.types;
+
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.regex.Pattern;
+
+import static org.apache.commons.lang3.StringUtils.*;
+import static org.junit.Assert.*;
+
+/**
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+@RunWith(Parameterized.class)
+public class OasisSMPFormatterTypeTest {
+
+
+ @Parameterized.Parameters(name = "{index}: {0}")
+ public static Collection<Object> participantIdentifierPositiveCases() {
+ return Arrays.asList(new Object[][]{
+ {
+ "Valid peppol party identifier",
+ true,
+ "iso6523-actorid-upis::0002:12345",
+ "iso6523-actorid-upis",
+ "0002:12345",
+ null, null
+ },
+ {
+ "no schema",
+ true,
+ "::0002:12345",
+ null,
+ "0002:12345",
+ null, null
+ },
+ {
+ "test URN example ",
+ true, // allways true - default parser
+ "urn:justice:si:1123445",
+ null,
+ "urn:justice:si:1123445",
+ null, null}
+ });
+ }
+
+ OasisSMPFormatterType testInstance = new OasisSMPFormatterType();
+
+
+ // input parameters
+ @Parameterized.Parameter
+ public String testName;
+ @Parameterized.Parameter(1)
+ public boolean isValidPartyId;
+ @Parameterized.Parameter(2)
+ public String toParseIdentifier;
+ @Parameterized.Parameter(3)
+ public String schemaPart;
+ @Parameterized.Parameter(4)
+ public String idPart;
+ @Parameterized.Parameter(5)
+ public Class errorClass;
+ @Parameterized.Parameter(6)
+ public String containsErrorMessage;
+
+
+ @Test
+ public void isTypeByScheme() {
+
+ boolean result = testInstance.isTypeByScheme(schemaPart);
+ assertEquals(isValidPartyId, result);
+ }
+
+ @Test
+ public void isType() {
+
+ boolean result = testInstance.isType(toParseIdentifier);
+ assertEquals(isValidPartyId, result);
+ }
+
+ @Test
+ public void format() {
+ // skip format for not ebcore party ids
+ if (!isValidPartyId) {
+ return;
+ }
+
+ String result = testInstance.format(schemaPart, idPart);
+ String resultNoDelimiterForNullSchema = testInstance.format(schemaPart, idPart, true);
+
+ String schema = trimToEmpty(schemaPart);
+ assertEquals(schema + "::" + trim(idPart), result);
+
+ assertEquals((isEmpty(schema)?"":schema + "::") + trim(idPart), resultNoDelimiterForNullSchema);
+ }
+
+ @Test
+ public void parse() {
+ // skip parse not ebcore party ids
+ if (!isValidPartyId) {
+ IllegalArgumentException result = assertThrows(IllegalArgumentException.class, () -> testInstance.parse(toParseIdentifier));
+ MatcherAssert.assertThat(result.getMessage(), CoreMatchers.containsString(containsErrorMessage));
+ }
+ if (errorClass != null) {
+ Throwable result = assertThrows(errorClass, () -> testInstance.parse(toParseIdentifier));
+ MatcherAssert.assertThat(result.getMessage(), CoreMatchers.containsString(containsErrorMessage));
+ } else {
+
+ String[] result = testInstance.parse(toParseIdentifier);
+ assertNotNull(result);
+ assertEquals(2, result.length);
+ assertEquals(schemaPart, result[0]);
+ assertEquals(idPart, result[1]);
+ }
+ }
+}
\ No newline at end of file
diff --git a/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/types/TemplateFormatterTypeTest.java b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/types/TemplateFormatterTypeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..20fc7b32014fe043b100c9bffbb324687d881c4e
--- /dev/null
+++ b/smp-api/src/test/java/eu/europa/ec/smp/api/identifiers/types/TemplateFormatterTypeTest.java
@@ -0,0 +1,121 @@
+package eu.europa.ec.smp.api.identifiers.types;
+
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.regex.Pattern;
+
+import static org.apache.commons.lang3.StringUtils.trim;
+import static org.junit.Assert.*;
+
+/**
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+@RunWith(Parameterized.class)
+public class TemplateFormatterTypeTest {
+
+
+ @Parameterized.Parameters(name = "{index}: {0}")
+ public static Collection participantIdentifierPositiveCases() {
+ return Arrays.asList(new Object[][]{
+ {
+ "Email example ",
+ true,
+ "mailto:test@ec.europa.eu",
+ "mailto",
+ "test@ec.europa.eu",
+ null, null
+ },
+ {
+ "test URN example ",
+ true,
+ "urn:ehealth:si:1123445",
+ "urn:ehealth:si",
+ "1123445",
+ null, null
+ },
+ {
+ "test URN example ",
+ false,
+ "urn:justice:si:1123445",
+ "urn:justice:si",
+ "1123445",
+ IllegalArgumentException.class, "does not match regular expression"}
+ });
+ }
+
+ TemplateFormatterType testInstance
+ = new TemplateFormatterType(Pattern.compile("^(?i)\\s*(::)?((urn:ehealth:[a-zA-Z]{2})|mailto).*$"),
+ "${scheme}::${identifier}",
+ Pattern.compile("^(?i)\\s*(::)?(?<scheme>(urn:ehealth:[a-zA-Z]{2})|mailto):?(?<identifier>.+)?\\s*$")
+ );
+
+
+ // input parameters
+ @Parameterized.Parameter
+ public String testName;
+ @Parameterized.Parameter(1)
+ public boolean isValidPartyId;
+ @Parameterized.Parameter(2)
+ public String toParseIdentifier;
+ @Parameterized.Parameter(3)
+ public String schemaPart;
+ @Parameterized.Parameter(4)
+ public String idPart;
+ @Parameterized.Parameter(5)
+ public Class errorClass;
+ @Parameterized.Parameter(6)
+ public String containsErrorMessage;
+
+
+ @Test
+ public void isTypeByScheme() {
+
+ boolean result = testInstance.isTypeByScheme(schemaPart);
+ assertEquals(isValidPartyId, result);
+ }
+
+ @Test
+ public void isType() {
+
+ boolean result = testInstance.isType(toParseIdentifier);
+ assertEquals(isValidPartyId, result);
+ }
+
+ @Test
+ public void format() {
+ // skip format for not ebcore party ids
+ if (!isValidPartyId) {
+ return;
+ }
+
+ String result = testInstance.format(idPart, schemaPart);
+ assertEquals(trim(idPart) + "::" + trim(schemaPart), result);
+ }
+
+ @Test
+ public void parse() {
+ // skip parse not ebcore party ids
+ if (!isValidPartyId) {
+ IllegalArgumentException result = assertThrows(IllegalArgumentException.class, () -> testInstance.parse(toParseIdentifier));
+ MatcherAssert.assertThat(result.getMessage(), CoreMatchers.containsString(containsErrorMessage));
+ }
+ if (errorClass != null) {
+ Throwable result = assertThrows(errorClass, () -> testInstance.parse(toParseIdentifier));
+ MatcherAssert.assertThat(result.getMessage(), CoreMatchers.containsString(containsErrorMessage));
+ } else {
+
+ String[] result = testInstance.parse(toParseIdentifier);
+ assertNotNull(result);
+ assertEquals(2, result.length);
+ assertEquals(schemaPart, result[0]);
+ assertEquals(idPart, result[1]);
+ }
+ }
+}
\ No newline at end of file
diff --git a/smp-api/src/test/java/eu/europa/ec/smp/api/validators/BdxSmpOasisValidatorTest.java b/smp-api/src/test/java/eu/europa/ec/smp/api/validators/BdxSmpOasisValidatorTest.java
index 8f76ee95c7dad2e3ede98e48d9d1f884b06f5f60..91289e2265feff7e8113a3651e3a6e835308f173 100644
--- a/smp-api/src/test/java/eu/europa/ec/smp/api/validators/BdxSmpOasisValidatorTest.java
+++ b/smp-api/src/test/java/eu/europa/ec/smp/api/validators/BdxSmpOasisValidatorTest.java
@@ -14,68 +14,63 @@
package eu.europa.ec.smp.api.validators;
import eu.europa.ec.smp.api.exceptions.XmlInvalidAgainstSchemaException;
-import junitparams.JUnitParamsRunner;
-import junitparams.Parameters;
import org.apache.commons.io.IOUtils;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
import java.io.IOException;
import java.net.URL;
+import java.util.Arrays;
+import java.util.Collection;
+
import static org.junit.Assert.*;
/**
- * Created by migueti on 20/01/2017.
+ * @author migueti
+ * @since 3.0.0
*/
-@RunWith(JUnitParamsRunner.class)
+@RunWith(Parameterized.class)
public class BdxSmpOasisValidatorTest {
private static final String UTF_8 = "UTF-8";
- @Test
- @Parameters({"ServiceMetadata_OK.xml", "ServiceGroup_OK.xml"})
- public void testValidatePositive(String xmlFilename) throws IOException, XmlInvalidAgainstSchemaException {
- // given
- byte[] xmlBody = loadXMLFileAsByteArray(xmlFilename);
-
- // when
- BdxSmpOasisValidator.validateXSD(xmlBody);
-
- // then
- // no exception occur
+ @Parameterized.Parameters(name = "{index}: {0}")
+ public static Collection testCases() {
+ return Arrays.asList(new Object[][]{
+ {"ServiceMetadata_OK.xml",false, null},
+ {"ServiceGroup_OK.xml", false, null},
+ {"ServiceMetadata_ElementAdded.xml", true, "cvc-complex-type.2.4.a: Invalid content was found starting with element \\'\\{?(\\\"http://docs.oasis-open.org/bdxr/ns/SMP/2016/05\\\")?:?ElementAdded\\}?\\'.*Redirect.* is expected."},
+ {"ServiceMetadata_ElementMissing.xml", true, "cvc-complex-type.2.4.b: The content of element 'Redirect' is not complete. One of \\'\\{?(\"http://docs.oasis-open.org/bdxr/ns/SMP/2016/05\")?:?CertificateUID\\}?\\' is expected."},
+ {"ServiceGroup_MissingAssignment.xml", true, "Attribute name \"missingAssignment\" associated with an element type \"ServiceMetadataReferenceCollection\" must be followed by the ' = ' character."},
+ {"ServiceGroup_UnexpectedAttribute.xml", true, "cvc-complex-type.3.2.2: Attribute 'unexpectedAttribute' is not allowed to appear in element 'ServiceMetadataReferenceCollection'."},
+ {"ServiceGroup_externalDTD.xml", true, "External DTD: Failed to read external DTD 'any_external_file_address.dtd', because 'file' access is not allowed due to restriction set by the accessExternalDTD property."}
+ });
}
- private static Object[] negativeCases() {
- return new Object[][]{
- {"ServiceMetadata_ElementAdded.xml", "cvc-complex-type.2.4.a: Invalid content was found starting with element \\'\\{?(\\\"http://docs.oasis-open.org/bdxr/ns/SMP/2016/05\\\")?:?ElementAdded\\}?\\'.*Redirect.* is expected."},
- {"ServiceMetadata_ElementMissing.xml", "cvc-complex-type.2.4.b: The content of element 'Redirect' is not complete. One of \\'\\{?(\"http://docs.oasis-open.org/bdxr/ns/SMP/2016/05\")?:?CertificateUID\\}?\\' is expected."},
- {"ServiceGroup_MissingAssignment.xml", "Attribute name \"missingAssignment\" associated with an element type \"ServiceMetadataReferenceCollection\" must be followed by the ' = ' character."},
- {"ServiceGroup_UnexpectedAttribute.xml", "cvc-complex-type.3.2.2: Attribute 'unexpectedAttribute' is not allowed to appear in element 'ServiceMetadataReferenceCollection'."},
- {"ServiceGroup_externalDTD.xml", "External DTD: Failed to read external DTD 'any_external_file_address.dtd', because 'file' access is not allowed due to restriction set by the accessExternalDTD property."}
- };
- }
+ @Parameterized.Parameter
+ public String xmlFilename;
+ @Parameterized.Parameter(1)
+ public boolean throwsError;
+ @Parameterized.Parameter(2)
+ public String errorMessage;
@Test
- @Parameters(method = "negativeCases")
- public void testValidateNegative(String xmlFilename, String output) throws IOException {
+ public void testValidate() throws IOException, XmlInvalidAgainstSchemaException {
// given
byte[] xmlBody = loadXMLFileAsByteArray(xmlFilename);
+ XmlInvalidAgainstSchemaException result=null;
// when
- try {
+ if (throwsError){
+ result = assertThrows(XmlInvalidAgainstSchemaException.class, () -> BdxSmpOasisValidator.validateXSD(xmlBody));
+ } else {
BdxSmpOasisValidator.validateXSD(xmlBody);
- } catch (XmlInvalidAgainstSchemaException e) {
- // then
- assertThat(e.getMessage(), org.hamcrest.Matchers.matchesPattern(output));
- return;
}
- fail();
- }
-
- public String loadXMLFile(String path) throws IOException {
- URL fileUrl = BdxSmpOasisValidatorTest.class.getResource("/XMLValidation/" + path);
- return IOUtils.toString(fileUrl.openStream(), UTF_8);
+ assertEquals(throwsError, result!=null);
}
public byte[] loadXMLFileAsByteArray(String path) throws IOException {
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/CaseSensitivityNormalizer.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/CaseSensitivityNormalizer.java
deleted file mode 100644
index 08bcf190808066b8818310fcb90e81da36daacf7..0000000000000000000000000000000000000000
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/CaseSensitivityNormalizer.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright 2017 European Commission | CEF eDelivery
- *
- * Licensed under the EUPL, Version 1.2 or – as soon they will be approved by the European Commission - subsequent versions of the EUPL (the "Licence");
- * You may not use this work except in compliance with the Licence.
- *
- * You may obtain a copy of the Licence attached in file: LICENCE-EUPL-v1.2.pdf
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the Licence is distributed on an "AS IS" basis,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the Licence for the specific language governing permissions and limitations under the Licence.
- */
-
-package eu.europa.ec.edelivery.smp.conversion;
-
-import eu.europa.ec.edelivery.smp.services.ConfigurationService;
-import org.apache.commons.lang3.StringUtils;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.DocumentIdentifier;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
-import org.springframework.stereotype.Component;
-
-import java.util.List;
-
-import static eu.europa.ec.smp.api.Identifiers.asParticipantId;
-import static eu.europa.ec.smp.api.Identifiers.asString;
-
-/**
- * Created by gutowpa on 23/02/2017.
- */
-@Component
-public class CaseSensitivityNormalizer {
-
- protected static ConfigurationService configurationService;
-
- public CaseSensitivityNormalizer(ConfigurationService configurationService) {
- this.configurationService = configurationService;
- }
-
- public ParticipantIdentifierType normalizeParticipantIdentifier(String scheme, String value) {
- List<String> caseSensitiveParticipantSchemes = configurationService.getCaseSensitiveParticipantScheme();
- if (scheme==null || caseSensitiveParticipantSchemes == null || !caseSensitiveParticipantSchemes.stream().anyMatch(scheme::equalsIgnoreCase)) {
- scheme = StringUtils.lowerCase(scheme);
- value = StringUtils.lowerCase(value);
- }
- return new ParticipantIdentifierType(value, scheme);
- }
-
- public ParticipantIdentifierType normalize(final ParticipantIdentifierType participantIdentifier, boolean schemeMandatory) {
- ParticipantIdentifierType prtId = asParticipantId(asString(participantIdentifier),
- schemeMandatory);
- String scheme = prtId.getScheme();
- String value = prtId.getValue();
- return normalizeParticipantIdentifier(scheme, value);
- }
-
- public ParticipantIdentifierType normalize(final ParticipantIdentifierType participantIdentifier) {
- return normalize(participantIdentifier, configurationService.getParticipantSchemeMandatory());
- }
-
- public DocumentIdentifier normalize(final DocumentIdentifier documentIdentifier) {
- String scheme = documentIdentifier.getScheme();
- String value = documentIdentifier.getValue();
- return normalizeDocumentIdentifier(scheme, value);
- }
-
- public DocumentIdentifier normalizeDocumentIdentifier(String scheme, String value) {
- List<String> caseSensitiveDocumentSchemes = configurationService.getCaseSensitiveDocumentScheme();
- if (scheme==null || caseSensitiveDocumentSchemes == null || !caseSensitiveDocumentSchemes.stream().anyMatch(scheme::equalsIgnoreCase)) {
- scheme = StringUtils.lowerCase(scheme);
- value = StringUtils.lowerCase(value);
- }
- return new DocumentIdentifier(value, scheme);
- }
-
- public String normalizeParticipantId(String participantId) {
- return asString(normalizeParticipant(participantId));
- }
-
- public ParticipantIdentifierType normalizeParticipant(String participantId) {
- return normalize(asParticipantId(participantId, configurationService.getParticipantSchemeMandatory()));
- }
-}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/IdentifierService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/IdentifierService.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ccfd1527d33d61bb0f5b0cfbcf2ac1e1195173f
--- /dev/null
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/IdentifierService.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2017 European Commission | CEF eDelivery
+ *
+ * Licensed under the EUPL, Version 1.2 or – as soon they will be approved by the European Commission - subsequent versions of the EUPL (the "Licence");
+ * You may not use this work except in compliance with the Licence.
+ *
+ * You may obtain a copy of the Licence attached in file: LICENCE-EUPL-v1.2.pdf
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the Licence is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing permissions and limitations under the Licence.
+ */
+
+package eu.europa.ec.edelivery.smp.conversion;
+
+import eu.europa.ec.edelivery.smp.logging.SMPLogger;
+import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
+import eu.europa.ec.edelivery.smp.services.ConfigurationService;
+import eu.europa.ec.smp.api.identifiers.DocumentIdentifierFormatter;
+import eu.europa.ec.smp.api.identifiers.ParticipantIdentifierFormatter;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.DocumentIdentifier;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.regex.Pattern;
+
+
+/**
+ * Class provides tools to parse, format and normalize Document and Participant identifiers.
+ *
+ * @author gutowpa
+ * @since 3.0.0
+ */
+@Component
+public class IdentifierService {
+ private static final SMPLogger LOG = SMPLoggerFactory.getLogger(IdentifierService.class);
+
+ ParticipantIdentifierFormatter participantIdentifierFormatter = new ParticipantIdentifierFormatter();
+ DocumentIdentifierFormatter documentIdentifierFormatter = new DocumentIdentifierFormatter();
+
+ ConfigurationService configurationService;
+
+ public IdentifierService(ConfigurationService configurationService) {
+ this.configurationService = configurationService;
+
+ configureParticipantIdentifierFormatter(configurationService.getCaseSensitiveParticipantScheme(),
+ configurationService.getParticipantSchemeMandatory(),
+ configurationService.getParticipantIdentifierSchemeRexExp());
+ configureDocumentIdentifierFormatter(configurationService.getCaseSensitiveDocumentScheme());
+ }
+
+ /**
+ * Update ParticipantIdentifierFormatter for non null values. Null values are ignored
+ *
+ * @param caseInsensitiveSchemas
+ * @param mandatoryScheme
+ */
+ public void configureParticipantIdentifierFormatter(List<String> caseInsensitiveSchemas, Boolean mandatoryScheme, Pattern allowedSchemeRegExp) {
+ if (caseInsensitiveSchemas != null) {
+ participantIdentifierFormatter.setCaseSensitiveSchemas(caseInsensitiveSchemas);
+ } else {
+ LOG.debug("Skip configure ParticipantIdentifierFormatter.caseInsensitiveSchemas for null value");
+ }
+
+ if (mandatoryScheme != null) {
+ participantIdentifierFormatter.setSchemeMandatory(mandatoryScheme.booleanValue());
+ } else {
+ LOG.debug("Skip configure ParticipantIdentifierFormatter.mandatoryScheme for null value");
+ }
+
+ if (allowedSchemeRegExp != null) {
+ participantIdentifierFormatter.setSchemeValidationPattern(allowedSchemeRegExp);
+ } else {
+ LOG.debug("Skip configure ParticipantIdentifierFormatter.allowedSchemeRegExp for null value");
+ }
+ }
+
+ public void configureDocumentIdentifierFormatter(List<String> caseInsensitiveSchemas) {
+ if (caseInsensitiveSchemas != null) {
+ documentIdentifierFormatter.setCaseSensitiveSchemas(caseInsensitiveSchemas);
+ } else {
+ LOG.debug("Skip configure DocumentIdentifierFormatter.caseInsensitiveSchemas for null value");
+ }
+ }
+
+ public DocumentIdentifier normalizeDocument(final DocumentIdentifier documentIdentifier) {
+ return documentIdentifierFormatter.normalize(documentIdentifier);
+ }
+
+ public DocumentIdentifier normalizeDocument(final String scheme, final String identifier) {
+ return documentIdentifierFormatter.normalize(scheme, identifier);
+ }
+
+ public DocumentIdentifier normalizeDocumentIdentifier(String value) {
+ return documentIdentifierFormatter.normalizeIdentifier(value);
+ }
+
+ public ParticipantIdentifierType normalizeParticipant(final String scheme, final String identifier) {
+ return participantIdentifierFormatter.normalize(scheme, identifier);
+ }
+
+ public ParticipantIdentifierType normalizeParticipant(final ParticipantIdentifierType participantIdentifier) {
+ return participantIdentifierFormatter.normalize(participantIdentifier);
+ }
+
+ public ParticipantIdentifierType normalizeParticipantIdentifier(final String participantId) {
+ return participantIdentifierFormatter.normalizeIdentifier(participantId);
+ }
+
+ public String formatParticipant(final ParticipantIdentifierType participantIdentifier) {
+ return participantIdentifierFormatter.format(participantIdentifier);
+ }
+
+ public String urlEncodedFormatParticipant(final ParticipantIdentifierType participantIdentifier) {
+ return participantIdentifierFormatter.urlEncodedFormat(participantIdentifier);
+ }
+
+ public String formatParticipant(final String scheme, final String identifier) {
+ return participantIdentifierFormatter.format(scheme, identifier);
+ }
+
+ public String formatDocument(final DocumentIdentifier documentIdentifier) {
+ return documentIdentifierFormatter.format(documentIdentifier);
+ }
+
+ public String urlEncodedFormatDocument(final DocumentIdentifier documentIdentifier) {
+ return documentIdentifierFormatter.urlEncodedFormat(documentIdentifier);
+ }
+
+ public String formatDocument(final String scheme, final String identifier) {
+ return documentIdentifierFormatter.format(scheme, identifier);
+ }
+}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/ServiceGroupConverter.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/ServiceGroupConverter.java
index b4b8dde29a5513a4e38116f12783f954335c1821..7a0199100fb20775b1678e0efcc7768179710e3f 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/ServiceGroupConverter.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/ServiceGroupConverter.java
@@ -13,17 +13,12 @@
package eu.europa.ec.edelivery.smp.conversion;
-import eu.europa.ec.edelivery.smp.data.model.DBServiceGroup;
import eu.europa.ec.edelivery.smp.exceptions.ErrorCode;
import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
-import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ExtensionType;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ServiceGroup;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ServiceMetadataReferenceCollectionType;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
@@ -37,15 +32,15 @@ import javax.xml.stream.XMLStreamException;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.List;
import static eu.europa.ec.edelivery.smp.exceptions.ErrorCode.INVALID_EXTENSION_FOR_SG;
-import static eu.europa.ec.smp.api.Identifiers.EBCORE_IDENTIFIER_PREFIX;
import static java.nio.charset.StandardCharsets.UTF_8;
/**
- * Created by migueti on 26/01/2017.
+ * Purpose of class is to test ServiceGroupService base methods
+ *
+ * @author migueti
+ * @since 3.0.0
*/
public class ServiceGroupConverter {
@@ -75,10 +70,10 @@ public class ServiceGroupConverter {
}
/**
- * Method umarshal ServiceGroup from xml string
+ * Method unmarshal ServiceGroup from xml string
*
- * @param serviceGroupXml
- * @return
+ * @param serviceGroupXml service group xml
+ * @return java object Object
*/
public static ServiceGroup unmarshal(String serviceGroupXml) {
try {
@@ -90,7 +85,7 @@ public class ServiceGroupConverter {
}
/**
- * Method umarshal ServiceGroup from xml bytearraz
+ * Method unmarshal ServiceGroup from xml bytearray
*
* @param serviceGroupXml
* @return
@@ -98,68 +93,19 @@ public class ServiceGroupConverter {
public static ServiceGroup unmarshal(byte[] serviceGroupXml) {
try {
- System.out.println("UNMARSHAL SERVICE GROUP " + new String(serviceGroupXml));
Document serviceGroupDoc = parse(serviceGroupXml);
ServiceGroup serviceGroup = getUnmarshaller().unmarshal(serviceGroupDoc, ServiceGroup.class).getValue();
- /*
- if (serviceGroup!=null && serviceGroup.getParticipantIdentifier()!=null
- && StringUtils.isBlank(serviceGroup.getParticipantIdentifier().getScheme())
- && StringUtils.startsWithAny(serviceGroup.getParticipantIdentifier().getValue(),
- EBCORE_IDENTIFIER_PREFIX,
- "::"+ EBCORE_IDENTIFIER_PREFIX)){
- // normalize participant identifier
- LOG.info("Normalize ebCore identifier: " + serviceGroup.getParticipantIdentifier().getValue());
- ParticipantIdentifierType participantIdentifierType = Identifiers.asParticipantId(serviceGroup.getParticipantIdentifier().getValue(), allowNullPartcScheme);
- serviceGroup.setParticipantIdentifier(participantIdentifierType);
- }*/
return serviceGroup;
} catch (ParserConfigurationException | IOException | SAXException | JAXBException ex) {
throw new SMPRuntimeException(ErrorCode.XML_PARSE_EXCEPTION, ex, ServiceGroup.class.getName(), ExceptionUtils.getRootCauseMessage(ex));
}
}
- /**
- * Method returns Oasis ServiceGroup entity with extension and
- * empty ServiceMetadataReferenceCollectionType. If extension can not be converted to jaxb object than
- * ConversionException is thrown.
- *
- * @param dsg - database service group entity
- * @return Oasis ServiceGroup entity or null if parameter is null
- */
- public static ServiceGroup toServiceGroup(DBServiceGroup dsg, boolean concatenateEBCoreID) {
-
- if (dsg == null) {
- return null;
- }
-
- ServiceGroup serviceGroup = new ServiceGroup();
- String schema = dsg.getParticipantScheme();
- String value = dsg.getParticipantIdentifier();
- if (concatenateEBCoreID && StringUtils.startsWithIgnoreCase(schema, EBCORE_IDENTIFIER_PREFIX)) {
- value = schema + ":" + value;
- schema = null;
- }
- ParticipantIdentifierType identifier = new ParticipantIdentifierType(value, schema);
- serviceGroup.setParticipantIdentifier(identifier);
- if (dsg.getExtension() != null) {
- try {
- List<ExtensionType> extensions = ExtensionConverter.unmarshalExtensions(dsg.getExtension());
- serviceGroup.getExtensions().addAll(extensions);
- } catch (JAXBException e) {
- throw new SMPRuntimeException(INVALID_EXTENSION_FOR_SG, e, dsg.getParticipantIdentifier(),
- dsg.getParticipantScheme(), ExceptionUtils.getRootCauseMessage(e));
- }
- }
- serviceGroup.setServiceMetadataReferenceCollection(new ServiceMetadataReferenceCollectionType(new ArrayList()));
- return serviceGroup;
- }
-
private static Document parse(String serviceGroupXml) throws ParserConfigurationException, IOException, SAXException {
InputStream inputStream = new ByteArrayInputStream(serviceGroupXml.getBytes(UTF_8));
return getDocumentBuilder().parse(inputStream);
}
-
private static Document parse(byte[] serviceGroupXml) throws ParserConfigurationException, IOException, SAXException {
InputStream inputStream = new ByteArrayInputStream(serviceGroupXml);
return getDocumentBuilder().parse(inputStream);
@@ -181,5 +127,4 @@ public class ServiceGroupConverter {
ExceptionUtils.getRootCauseMessage(e));
}
}
-
}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/ServiceMetadataConverter.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/ServiceMetadataConverter.java
index fc40483895d58faef37c613d41a0bf301b04227a..b90ed5c23c88a9067e17f1d2d9984e716a519f12 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/ServiceMetadataConverter.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/ServiceMetadataConverter.java
@@ -16,10 +16,7 @@ package eu.europa.ec.edelivery.smp.conversion;
import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
-import eu.europa.ec.smp.api.Identifiers;
-import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ServiceMetadata;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
@@ -42,36 +39,35 @@ import java.io.*;
import static eu.europa.ec.edelivery.smp.exceptions.ErrorCode.INVALID_SMD_XML;
-;
-
/**
- * Created by gutowpa on 05/01/2017.
+ * @author gutowpa
+ * @since 3.0.0
*/
public class ServiceMetadataConverter {
/**
- * Class has only static members. Is not ment to create instances - also SONAR warning.
+ * Class has only static members. Is not meant to create instances - also SONAR warning.
*/
- private ServiceMetadataConverter() {
+ private ServiceMetadataConverter() {
}
private static final String NS = "http://docs.oasis-open.org/bdxr/ns/SMP/2016/05";
- private static final String DOC_SIGNED_SERVICE_METADATA_EMPTY = "<SignedServiceMetadata xmlns=\""+NS+"\"/>";
+ private static final String DOC_SIGNED_SERVICE_METADATA_EMPTY = "<SignedServiceMetadata xmlns=\"" + NS + "\"/>";
private static final String PARSER_DISALLOW_DTD_PARSING_FEATURE = "http://apache.org/xml/features/disallow-doctype-decl";
private static final SMPLogger LOG = SMPLoggerFactory.getLogger(ServiceMetadataConverter.class);
- private static final ThreadLocal<Unmarshaller> jaxbUnmarshaller = ThreadLocal.withInitial( () -> {
+ private static final ThreadLocal<Unmarshaller> jaxbUnmarshaller = ThreadLocal.withInitial(() -> {
try {
JAXBContext jaxbContext = JAXBContext.newInstance(ServiceMetadata.class);
return jaxbContext.createUnmarshaller();
- }catch(JAXBException ex) {
+ } catch (JAXBException ex) {
LOG.error("Error occurred while initializing JAXBContext for ServiceMetadata. Root Error:" +
ExceptionUtils.getRootCauseMessage(ex), ex);
}
return null;
- } );
+ });
private static Unmarshaller getUnmarshaller() {
return jaxbUnmarshaller.get();
@@ -79,23 +75,24 @@ public class ServiceMetadataConverter {
/**
* Method parses serviceMetadata XML and envelopes it to SignedServiceMetadata.
+ *
* @param serviceMetadataXml
* @return w3d dom element
*/
- public static Document toSignedServiceMetadataDocument(byte[] serviceMetadataXml) {
+ public static Document toSignedServiceMetadataDocument(byte[] serviceMetadataXml) {
try {
Document docServiceMetadata = parse(serviceMetadataXml);
Document root = parse(DOC_SIGNED_SERVICE_METADATA_EMPTY.getBytes());
Node imported = root.importNode(docServiceMetadata.getDocumentElement(), true);
root.getDocumentElement().appendChild(imported);
return root;
- }catch(ParserConfigurationException | SAXException | IOException ex){
+ } catch (ParserConfigurationException | SAXException | IOException ex) {
throw new SMPRuntimeException(INVALID_SMD_XML, ex, ExceptionUtils.getRootCauseMessage(ex));
}
}
- public static ServiceMetadata unmarshal(byte[] serviceMetadataXml){
+ public static ServiceMetadata unmarshal(byte[] serviceMetadataXml) {
try {
Document serviceMetadataDoc = parse(serviceMetadataXml);
ServiceMetadata serviceMetadata = getUnmarshaller().unmarshal(serviceMetadataDoc, ServiceMetadata.class).getValue();
@@ -110,14 +107,14 @@ public class ServiceMetadataConverter {
return getDocumentBuilder().parse(inputStream);
}
- public static String toString(Document doc) throws TransformerException, UnsupportedEncodingException {
+ public static String toString(Document doc) throws TransformerException {
Transformer transformer = createNewSecureTransformer();
StringWriter writer = new StringWriter();
transformer.transform(new DOMSource(doc), new StreamResult(writer));
return writer.toString();
}
- public static byte[] toByteArray(Document doc) throws TransformerException, UnsupportedEncodingException {
+ public static byte[] toByteArray(Document doc) throws TransformerException {
Transformer transformer = createNewSecureTransformer();
ByteArrayOutputStream stream = new ByteArrayOutputStream();
transformer.transform(new DOMSource(doc), new StreamResult(stream));
@@ -137,8 +134,4 @@ public class ServiceMetadataConverter {
return factory.newTransformer();
}
-
-
-
-
}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/SMPRevisionListener.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/SMPRevisionListener.java
index e1ef341a5f1197e263ae66e4b8f01546fcd3ad7b..24c0136f7dcccbfdfacaa62f867eaaf2b75c3e5e 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/SMPRevisionListener.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/SMPRevisionListener.java
@@ -1,7 +1,6 @@
package eu.europa.ec.edelivery.smp.data.dao;
import eu.europa.ec.edelivery.smp.data.model.DBRevisionLog;
-import eu.europa.ec.edelivery.smp.services.ServiceGroupService;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.envers.RevisionListener;
import org.slf4j.Logger;
@@ -13,7 +12,7 @@ import java.time.OffsetDateTime;
public class SMPRevisionListener implements RevisionListener {
- private static final Logger LOG = LoggerFactory.getLogger(ServiceGroupService.class);
+ private static final Logger LOG = LoggerFactory.getLogger(SMPRevisionListener.class);
@Override
public void newRevision(Object revisionEntity) {
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/ui/enums/SMPPropertyEnum.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/ui/enums/SMPPropertyEnum.java
index d2070c6575fe4c06ba0a4167401f8dd1219aea36..8c504ca2edf80aacc2155dfef10debff71226df7 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/ui/enums/SMPPropertyEnum.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/ui/enums/SMPPropertyEnum.java
@@ -36,23 +36,28 @@ public enum SMPPropertyEnum {
HTTP_PROXY_USER("smp.proxy.user", "", "The proxy user",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, STRING),
- PARTC_SCH_REGEXP("identifiersBehaviour.ParticipantIdentifierScheme.validationRegex", "^$|^(?!^.{26})([a-z0-9]+-[a-z0-9]+-[a-z0-9]+)$|^urn:oasis:names:tc:ebcore:partyid-type:(iso6523|unregistered)(:.+)?$", "Participant Identifier Schema of each PUT ServiceGroup request is validated against this schema.",
+ PARTC_SCH_VALIDATION_REGEXP("identifiersBehaviour.ParticipantIdentifierScheme.validationRegex", "^$|^(?!^.{26})([a-z0-9]+-[a-z0-9]+-[a-z0-9]+)$|^urn:oasis:names:tc:ebcore:partyid-type:(iso6523|unregistered)(:.+)?$",
+ "Regular expression for validating the participant schema!",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, REGEXP),
PARTC_SCH_REGEXP_MSG("identifiersBehaviour.ParticipantIdentifierScheme.validationRegexMessage",
"Participant scheme must start with:urn:oasis:names:tc:ebcore:partyid-type:(iso6523:|unregistered:) OR must be up to 25 characters long with form [domain]-[identifierArea]-[identifierType] (ex.: 'busdox-actorid-upis') and may only contain the following characters: [a-z0-9].", "Error message for UI",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, STRING),
PARTC_SCH_MANDATORY("identifiersBehaviour.scheme.mandatory", "true", "Scheme for participant identifier is mandatory",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, BOOLEAN),
-
- PARTC_EBCOREPARTYID_CONCATENATE("identifiersBehaviour.ParticipantIdentifierScheme.ebCoreId.concatenate", "false",
- "Concatenate ebCore party id in XML responses <ParticipantIdentifier>urn:oasis:names:tc:ebcore:partyid-type:unregistered:test-ebcore-id</ParticipantIdentifier>",
- OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, BOOLEAN),
+ PARTC_SCH_SPLIT_REGEXP("identifiersBehaviour.splitPattern", "^(?i)\\s*?(?<scheme>urn:oasis:names:tc:ebcore:partyid-type:(iso6523:[0-9]{4}|unregistered(:[^:]+)?))::?(?<identifier>.+)?\\s*$",
+ "Regular expression with groups <scheme> and <identifier> for splitting the identifiers to scheme and identifier part!", OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, REGEXP),
+ PARTC_SCH_URN_REGEXP("identifiersBehaviour.ParticipantIdentifierScheme.urn.concatenate",
+ "", "Regular expression to detect URN party identifiers. If the party identifier schema matches the regexp, then the party identifier is concatenated with a single colon in XML responses. Else it is handled as OASIS SMP party identifier. Example: ^(?i)(urn:)|(mailto:).*$",
+ OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, REGEXP),
CS_PARTICIPANTS("identifiersBehaviour.caseSensitive.ParticipantIdentifierSchemes", "sensitive-participant-sc1|sensitive-participant-sc2", "Specifies schemes of participant identifiers that must be considered CASE-SENSITIVE.",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, LIST_STRING),
CS_DOCUMENTS("identifiersBehaviour.caseSensitive.DocumentIdentifierSchemes", "casesensitive-doc-scheme1|casesensitive-doc-scheme2", "Specifies schemes of document identifiers that must be considered CASE-SENSITIVE.",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, LIST_STRING),
+ DOCUMENT_RESTRICTION_CERT_TYPES("document.restriction.allowed.certificate.types", "", "Allowed certificate types registered when composing service metadata. Empty value means no restrictions, for other values see the java KeyFactory Algorithms for example RSA|EC|Ed25519|Ed448",
+ OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, LIST_STRING),
+
// SML integration!
SML_ENABLED("bdmsl.integration.enabled", "false", "BDMSL (SML) integration ON/OFF switch",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, BOOLEAN),
@@ -357,13 +362,17 @@ public enum SMPPropertyEnum {
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, INTEGER),
SMP_ALERT_MAIL_FROM("smp.alert.mail.from", "test@alert-send-mail.eu", "Alert send mail",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, EMAIL),
-
+ // deprecated properties
CLIENT_CERT_HEADER_ENABLED_DEPRECATED("authentication.blueCoat.enabled", "false", "Property was replaced by property: smp.automation.authentication.external.tls.clientCert.enabled",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, BOOLEAN),
- DOCUMENT_RESTRICTION_CERT_TYPES("document.restriction.allowed.certificate.types", "", "Allowed certificate types registered when composing service metadata. Empty value means no restrictions, for other values see the java KeyFactory Algorithms for examples: RSA|EC|Ed25519|Ed448",
- OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, LIST_STRING),
+
+ PARTC_EBCOREPARTYID_CONCATENATE("identifiersBehaviour.ParticipantIdentifierScheme.ebCoreId.concatenate", "false",
+ "Concatenate ebCore party id in XML responses <ParticipantIdentifier>urn:oasis:names:tc:ebcore:partyid-type:unregistered:test-ebcore-id</ParticipantIdentifier>",
+ OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, BOOLEAN),
+
;
+
String property;
String defValue;
String desc;
@@ -426,11 +435,11 @@ public enum SMPPropertyEnum {
if (keyTrim == null) {
return Optional.empty();
}
- return Arrays.asList(values()).stream().filter(val -> val.getProperty().equalsIgnoreCase(keyTrim)).findAny();
+ return Arrays.stream(values()).filter(val -> val.getProperty().equalsIgnoreCase(keyTrim)).findAny();
}
public static List<SMPPropertyEnum> getRestartOnChangeProperties() {
- return Arrays.asList(values()).stream().filter(val -> val.isRestartNeeded()).collect(Collectors.toList());
+ return Arrays.stream(values()).filter(SMPPropertyEnum::isRestartNeeded).collect(Collectors.toList());
}
public Pattern getValuePattern() {
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ConfigurationService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ConfigurationService.java
index 1a6dad50b2d331e6341ec364d4e5975854b2e526..29207f38c64c33c1b036edb3cf35941ba3394b5d 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ConfigurationService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ConfigurationService.java
@@ -36,23 +36,17 @@ public class ConfigurationService {
public Pattern getParticipantIdentifierSchemeRexExp() {
- return configurationDAO.getCachedPropertyValue(PARTC_SCH_REGEXP);
+ return configurationDAO.getCachedPropertyValue(PARTC_SCH_VALIDATION_REGEXP);
}
public String getParticipantIdentifierSchemeRexExpPattern() {
- return configurationDAO.getCachedProperty(PARTC_SCH_REGEXP);
+ return configurationDAO.getCachedProperty(PARTC_SCH_VALIDATION_REGEXP);
}
public String getParticipantIdentifierSchemeRexExpMessage() {
return configurationDAO.getCachedPropertyValue(PARTC_SCH_REGEXP_MSG);
}
- public Boolean getForceConcatenateEBCorePartyId() {
- Boolean value = configurationDAO.getCachedPropertyValue(PARTC_EBCOREPARTYID_CONCATENATE);
- // true by default
- return value == null || value;
- }
-
public Pattern getPasswordPolicyRexExp() {
return configurationDAO.getCachedPropertyValue(PASSWORD_POLICY_REGULAR_EXPRESSION);
}
@@ -158,6 +152,14 @@ public class ConfigurationService {
return value != null && value;
}
+ public Pattern getParticipantIdentifierSplitRexExp() {
+ return configurationDAO.getCachedPropertyValue(PARTC_SCH_SPLIT_REGEXP);
+ }
+
+ public Pattern getParticipantIdentifierUrnValidationRexExp() {
+ return configurationDAO.getCachedPropertyValue(PARTC_SCH_URN_REGEXP);
+ }
+
public boolean isProxyEnabled() {
String proxyHost = configurationDAO.getCachedProperty(HTTP_PROXY_HOST);
return !StringUtils.isBlank(proxyHost);
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/DomainService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/DomainService.java
index 952eb5346373619ec4bb502116e588fb7f99fd24..26684ac935b38da134b4e43228426546b92706da 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/DomainService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/DomainService.java
@@ -1,22 +1,17 @@
package eu.europa.ec.edelivery.smp.services;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
import eu.europa.ec.edelivery.smp.data.dao.DomainDao;
import eu.europa.ec.edelivery.smp.data.dao.ServiceGroupDao;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
import eu.europa.ec.edelivery.smp.data.model.DBServiceGroup;
-import eu.europa.ec.edelivery.smp.data.model.DBServiceGroupDomain;
import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
import eu.europa.ec.edelivery.smp.services.ui.filters.ServiceGroupFilter;
-import eu.europa.ec.edelivery.smp.sml.SmlConnector;
import org.apache.commons.lang3.StringUtils;
-import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
import javax.validation.constraints.NotNull;
import java.util.List;
@@ -24,9 +19,6 @@ import java.util.Optional;
import java.util.regex.Pattern;
import static eu.europa.ec.edelivery.smp.exceptions.ErrorCode.*;
-import static eu.europa.ec.edelivery.smp.logging.SMPMessageCode.BUS_SML_REGISTER_SERVICE_GROUP;
-import static eu.europa.ec.edelivery.smp.logging.SMPMessageCode.BUS_SML_REGISTER_SERVICE_GROUP_ALREADY_REGISTERED;
-import static eu.europa.ec.edelivery.smp.logging.SMPMessageCode.BUS_SML_REGISTER_SERVICE_GROUP_FAILED;
/**
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationService.java
index b1bfc97818ac3c77bd5c7cde96cb4a346bc8724c..3c64d129c09aa72bea48da149e8ca6e80becaaa0 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationService.java
@@ -1,7 +1,7 @@
package eu.europa.ec.edelivery.smp.services;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.data.dao.DomainDao;
import eu.europa.ec.edelivery.smp.data.dao.ServiceGroupDao;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
@@ -34,6 +34,7 @@ import static eu.europa.ec.edelivery.smp.logging.SMPMessageCode.*;
public class SMLIntegrationService {
private static final SMPLogger LOG = SMPLoggerFactory.getLogger(SMLIntegrationService.class);
+ private static final String ERROR_MESSAGE_DNS_NOT_ENABLED = "SML integration is not enabled!";
@Autowired
private ConfigurationService configurationService;
@@ -48,7 +49,7 @@ public class SMLIntegrationService {
private DomainDao domainDao;
@Autowired
- private CaseSensitivityNormalizer caseSensitivityNormalizer;
+ private IdentifierService identifierService;
/**
@@ -60,7 +61,7 @@ public class SMLIntegrationService {
@Transactional
public void registerDomain(DBDomain domain) {
if (!isSMLIntegrationEnabled()) {
- throw new SMPRuntimeException(CONFIGURATION_ERROR, "SML integration is not enabled!");
+ throw new SMPRuntimeException(CONFIGURATION_ERROR, ERROR_MESSAGE_DNS_NOT_ENABLED);
}
domain.setSmlRegistered(true);
domainDao.update(domain);
@@ -77,7 +78,7 @@ public class SMLIntegrationService {
@Transactional
public void unRegisterDomain(DBDomain domain) {
if (!isSMLIntegrationEnabled()) {
- throw new SMPRuntimeException(CONFIGURATION_ERROR, "SML integration is not enabled!");
+ throw new SMPRuntimeException(CONFIGURATION_ERROR, ERROR_MESSAGE_DNS_NOT_ENABLED);
}
domain.setSmlRegistered(false);
@@ -106,9 +107,8 @@ public class SMLIntegrationService {
DBServiceGroupDomain serviceGroupDomain = getAndValidateServiceGroupDomain(participantId,
participantSchema, domainCode, BUS_SML_REGISTER_SERVICE_GROUP_FAILED);
- ParticipantIdentifierType normalizedParticipantId = caseSensitivityNormalizer
- .normalizeParticipantIdentifier(participantSchema,
- participantId);
+ ParticipantIdentifierType normalizedParticipantId = identifierService
+ .normalizeParticipant(participantSchema, participantId);
// register only not registered services
@@ -171,9 +171,8 @@ public class SMLIntegrationService {
public boolean unregisterParticipantFromSML(String participantId, String participantSchema, DBDomain domain) {
LOG.businessDebug(BUS_SML_UNREGISTER_SERVICE_GROUP, participantId, participantSchema, domain.getDomainCode());
- ParticipantIdentifierType normalizedParticipantId = caseSensitivityNormalizer
- .normalizeParticipantIdentifier(participantSchema,
- participantId);
+ ParticipantIdentifierType normalizedParticipantId = identifierService
+ .normalizeParticipant(participantSchema, participantId);
// unregister only registered participants
return smlConnector.unregisterFromDns(normalizedParticipantId, domain);
@@ -191,9 +190,8 @@ public class SMLIntegrationService {
public boolean registerParticipantToSML(String participantId, String participantSchema, DBDomain domain) {
LOG.businessDebug(BUS_SML_UNREGISTER_SERVICE_GROUP, participantId, participantSchema, domain.getDomainCode());
- ParticipantIdentifierType normalizedParticipantId = caseSensitivityNormalizer
- .normalizeParticipantIdentifier(participantSchema,
- participantId);
+ ParticipantIdentifierType normalizedParticipantId = identifierService
+ .normalizeParticipant(participantSchema, participantId);
// unregister only registered participants
return smlConnector.registerInDns(normalizedParticipantId, domain);
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ServiceGroupService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ServiceGroupService.java
index 8a8bfe61d39581417f54e39553e4a5f296ddb89b..a180872cba8b9fb345c56fdabc5a1d4fbe2ad07c 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ServiceGroupService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ServiceGroupService.java
@@ -13,7 +13,8 @@
package eu.europa.ec.edelivery.smp.services;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
+import eu.europa.ec.edelivery.smp.conversion.ExtensionConverter;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.conversion.ServiceGroupConverter;
import eu.europa.ec.edelivery.smp.data.dao.ServiceGroupDao;
import eu.europa.ec.edelivery.smp.data.dao.UserDao;
@@ -28,32 +29,42 @@ import eu.europa.ec.edelivery.smp.logging.SMPMessageCode;
import eu.europa.ec.edelivery.smp.sml.SmlConnector;
import eu.europa.ec.edelivery.text.DistinguishedNamesCodingUtil;
import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.ExtensionType;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ServiceGroup;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.ServiceMetadataReferenceCollectionType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
+import javax.xml.bind.JAXBException;
import java.io.UnsupportedEncodingException;
+import java.util.List;
import java.util.Optional;
+import java.util.regex.Pattern;
import static eu.europa.ec.edelivery.smp.exceptions.ErrorCode.*;
import static java.net.URLDecoder.decode;
import static org.apache.commons.lang3.StringUtils.isNotBlank;
/**
- * Created by gutowpa on 14/11/2017.
+ * Purpose of class is to test ServiceGroupService base methods
+ *
+ * @author gutowpa
+ * @since 3.0.0
*/
@Service
public class ServiceGroupService {
+
private static final String UTF_8 = "UTF-8";
private static final SMPLogger LOG = SMPLoggerFactory.getLogger(ServiceGroupService.class);
@Autowired
- private CaseSensitivityNormalizer caseSensitivityNormalizer;
+ private IdentifierService identifierService;
@Autowired
private ServiceGroupDao serviceGroupDao;
@@ -80,14 +91,14 @@ public class ServiceGroupService {
*/
public ServiceGroup getServiceGroup(ParticipantIdentifierType participantId) {
// normalize participant identifier
- ParticipantIdentifierType normalizedServiceGroupId = caseSensitivityNormalizer.normalize(participantId);
+ ParticipantIdentifierType normalizedServiceGroupId = identifierService.normalizeParticipant(participantId);
Optional<DBServiceGroup> sg = serviceGroupDao.findServiceGroup(normalizedServiceGroupId.getValue(),
normalizedServiceGroupId.getScheme());
if (!sg.isPresent()) {
throw new SMPRuntimeException(SG_NOT_EXISTS, normalizedServiceGroupId.getValue(),
normalizedServiceGroupId.getScheme());
}
- return ServiceGroupConverter.toServiceGroup(sg.get(), configurationService.getForceConcatenateEBCorePartyId());
+ return toServiceGroup(sg.get(), configurationService.getParticipantIdentifierUrnValidationRexExp());
}
/**
@@ -103,7 +114,7 @@ public class ServiceGroupService {
public boolean saveServiceGroup(ServiceGroup serviceGroup, String domain, String serviceGroupOwner, String authenticatedUser) {
// normalize participant identifier
- ParticipantIdentifierType normalizedParticipantId = caseSensitivityNormalizer.normalize(serviceGroup.getParticipantIdentifier());
+ ParticipantIdentifierType normalizedParticipantId = identifierService.normalizeParticipant(serviceGroup.getParticipantIdentifier());
LOG.businessDebug(SMPMessageCode.BUS_SAVE_SERVICE_GROUP, domain, normalizedParticipantId.getValue(), normalizedParticipantId.getScheme());
// normalize service group owner
@@ -243,7 +254,7 @@ public class ServiceGroupService {
*/
@Transactional
public boolean isServiceGroupOwner(String ownerIdentifier, String serviceGroupIdentifier) {
- ParticipantIdentifierType pt = caseSensitivityNormalizer.normalizeParticipant(serviceGroupIdentifier);
+ ParticipantIdentifierType pt = identifierService.normalizeParticipantIdentifier(serviceGroupIdentifier);
Optional<DBServiceGroup> osg = serviceGroupDao.findServiceGroup(pt.getValue(), pt.getScheme());
Optional<DBUser> own = userDao.findUserByIdentifier(ownerIdentifier);
return osg.isPresent() && own.isPresent() && osg.get().getUsers().contains(own.get());
@@ -252,7 +263,7 @@ public class ServiceGroupService {
@Transactional
public void deleteServiceGroup(ParticipantIdentifierType serviceGroupId) {
- final ParticipantIdentifierType normalizedServiceGroupId = caseSensitivityNormalizer.normalize(serviceGroupId);
+ final ParticipantIdentifierType normalizedServiceGroupId = identifierService.normalizeParticipant(serviceGroupId);
Optional<DBServiceGroup> dbServiceGroup = serviceGroupDao.findServiceGroup(normalizedServiceGroupId.getValue(),
normalizedServiceGroupId.getScheme());
@@ -272,4 +283,42 @@ public class ServiceGroupService {
serviceGroupDao.removeServiceGroup(dsg);
}
+
+ /**
+ * Method returns Oasis ServiceGroup entity with extension and
+ * empty ServiceMetadataReferenceCollectionType. If extension can not be converted to jaxb object than
+ * ConversionException is thrown.
+ *
+ * @param dsg - database service group entity
+ * @param concatenatePartyId - regular expression if servicegroup in party identifier must be concatenate and returned in string value.
+ * @return Oasis ServiceGroup entity or null if parameter is null
+ */
+ public ServiceGroup toServiceGroup(DBServiceGroup dsg, Pattern concatenatePartyId) {
+
+ if (dsg == null) {
+ return null;
+ }
+
+ ServiceGroup serviceGroup = new ServiceGroup();
+ String schema = dsg.getParticipantScheme();
+ String value = dsg.getParticipantIdentifier();
+
+ if (StringUtils.isNotBlank(schema) && concatenatePartyId != null && concatenatePartyId.matcher(schema).matches()) {
+ value = identifierService.formatParticipant(schema, value);
+ schema = null;
+ }
+ ParticipantIdentifierType identifier = new ParticipantIdentifierType(value, schema);
+ serviceGroup.setParticipantIdentifier(identifier);
+ if (dsg.getExtension() != null) {
+ try {
+ List<ExtensionType> extensions = ExtensionConverter.unmarshalExtensions(dsg.getExtension());
+ serviceGroup.getExtensions().addAll(extensions);
+ } catch (JAXBException e) {
+ throw new SMPRuntimeException(INVALID_EXTENSION_FOR_SG, e, dsg.getParticipantIdentifier(),
+ dsg.getParticipantScheme(), ExceptionUtils.getRootCauseMessage(e));
+ }
+ }
+ serviceGroup.setServiceMetadataReferenceCollection(new ServiceMetadataReferenceCollectionType());
+ return serviceGroup;
+ }
}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ServiceMetadataService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ServiceMetadataService.java
index a8e3910937c6555062d706c2a3a9ca0654889017..579e285f116ca860fac9e9d55dcd7721029c3b34 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ServiceMetadataService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ServiceMetadataService.java
@@ -13,7 +13,7 @@
package eu.europa.ec.edelivery.smp.services;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.data.dao.ServiceGroupDao;
import eu.europa.ec.edelivery.smp.data.dao.ServiceMetadataDao;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
@@ -44,7 +44,7 @@ import static eu.europa.ec.edelivery.smp.exceptions.ErrorCode.SG_NOT_EXISTS;
public class ServiceMetadataService {
@Autowired
- private CaseSensitivityNormalizer caseSensitivityNormalizer;
+ private IdentifierService identifierService;
@Autowired
private ServiceMetadataDao serviceMetadataDao;
@@ -62,8 +62,8 @@ public class ServiceMetadataService {
@Transactional
public Document getServiceMetadataDocument(ParticipantIdentifierType serviceGroupId, DocumentIdentifier documentId) {
- ParticipantIdentifierType normalizedServiceGroupId = caseSensitivityNormalizer.normalize(serviceGroupId);
- DocumentIdentifier normalizedDocId = caseSensitivityNormalizer.normalize(documentId);
+ ParticipantIdentifierType normalizedServiceGroupId = identifierService.normalizeParticipant(serviceGroupId);
+ DocumentIdentifier normalizedDocId = identifierService.normalizeDocument(documentId);
Optional<DBServiceMetadata> osmd = serviceMetadataDao.findServiceMetadata(normalizedServiceGroupId.getValue(),
normalizedServiceGroupId.getScheme(),normalizedDocId.getValue(),normalizedDocId.getScheme());
@@ -90,8 +90,8 @@ public class ServiceMetadataService {
@Transactional
public boolean saveServiceMetadata(String domain, ParticipantIdentifierType serviceGroupId, DocumentIdentifier documentId, byte[] xmlContent) {
- ParticipantIdentifierType normalizedServiceGroupId = caseSensitivityNormalizer.normalize(serviceGroupId);
- DocumentIdentifier normalizedDocId = caseSensitivityNormalizer.normalize(documentId);
+ ParticipantIdentifierType normalizedServiceGroupId = identifierService.normalizeParticipant(serviceGroupId);
+ DocumentIdentifier normalizedDocId = identifierService.normalizeDocument(documentId);
Optional<DBServiceGroup> serviceGroup = serviceGroupDao.findServiceGroup(normalizedServiceGroupId.getValue(),
normalizedServiceGroupId.getScheme());
@@ -105,10 +105,7 @@ public class ServiceMetadataService {
Optional<DBServiceMetadata> doc = serviceMetadataDao.findServiceMetadata(normalizedServiceGroupId.getValue(),
normalizedServiceGroupId.getScheme(), normalizedDocId.getValue(), normalizedDocId.getScheme());
- //TODO: domain for servicegroup!!
- //DBDomain dbDomain = serviceDomain.getDomain(domain);
-
- boolean alreadyExisted = false;
+ boolean alreadyExisted;
if (doc.isPresent()){
DBServiceMetadata smd = doc.get();
smd.setXmlContent(xmlContent);
@@ -133,8 +130,8 @@ public class ServiceMetadataService {
@Transactional
public void deleteServiceMetadata(String domain, ParticipantIdentifierType serviceGroupId, DocumentIdentifier documentId) {
- ParticipantIdentifierType normalizedServiceGroupId = caseSensitivityNormalizer.normalize(serviceGroupId);
- DocumentIdentifier normalizedDocId = caseSensitivityNormalizer.normalize(documentId);
+ ParticipantIdentifierType normalizedServiceGroupId = identifierService.normalizeParticipant(serviceGroupId);
+ DocumentIdentifier normalizedDocId = identifierService.normalizeDocument(documentId);
Optional<DBServiceMetadata> oDoc = serviceMetadataDao.findServiceMetadata(normalizedServiceGroupId.getValue(),
@@ -151,12 +148,12 @@ public class ServiceMetadataService {
public List<DocumentIdentifier> findServiceMetadataIdentifiers(ParticipantIdentifierType participantId) {
- ParticipantIdentifierType normalizedServiceGroupId = caseSensitivityNormalizer.normalize(participantId);
+ ParticipantIdentifierType normalizedServiceGroupId = identifierService.normalizeParticipant(participantId);
List<DBServiceMetadata> metadata = serviceMetadataDao.getAllMetadataForServiceGroup(
normalizedServiceGroupId.getValue(),
normalizedServiceGroupId.getScheme());
- List<DocumentIdentifier> documentIds = new ArrayList();
+ List<DocumentIdentifier> documentIds = new ArrayList<>();
for (DBServiceMetadata md : metadata) {
DocumentIdentifier documentIdentifier = new DocumentIdentifier(md.getDocumentIdentifier(),
md.getDocumentIdentifierScheme());
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupService.java
index 8956298b164bacea5980700974fc2b7c30026def..e6ac0e25860fbe2bf9f9a8681b02f9f3efadaac2 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupService.java
@@ -1,7 +1,7 @@
package eu.europa.ec.edelivery.smp.services.ui;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
import eu.europa.ec.edelivery.smp.conversion.ExtensionConverter;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.conversion.ServiceMetadataConverter;
import eu.europa.ec.edelivery.smp.data.dao.BaseDao;
import eu.europa.ec.edelivery.smp.data.dao.DomainDao;
@@ -41,20 +41,20 @@ public class UIServiceGroupService extends UIServiceBase<DBServiceGroup, Service
protected final DomainDao domainDao;
protected final ServiceGroupDao serviceGroupDao;
protected final UserDao userDao;
- protected final CaseSensitivityNormalizer caseSensitivityNormalizer;
+ protected final IdentifierService identifierService;
protected final SMLIntegrationService smlIntegrationService;
protected final ConfigurationService configurationService;
public UIServiceGroupService(DomainDao domainDao,
ServiceGroupDao serviceGroupDao,
UserDao userDao,
- CaseSensitivityNormalizer caseSensitivityNormalizer,
+ IdentifierService identifierService,
SMLIntegrationService smlIntegrationService,
ConfigurationService configurationService) {
this.domainDao = domainDao;
this.serviceGroupDao = serviceGroupDao;
this.userDao = userDao;
- this.caseSensitivityNormalizer = caseSensitivityNormalizer;
+ this.identifierService = identifierService;
this.smlIntegrationService = smlIntegrationService;
this.configurationService = configurationService;
}
@@ -115,7 +115,7 @@ public class UIServiceGroupService extends UIServiceBase<DBServiceGroup, Service
@Transactional
public ServiceGroupRO getOwnedServiceGroupById(Long userId, Long serviceGroupId) {
DBServiceGroup dbServiceGroup = getDatabaseDao().find(serviceGroupId);
- if (isServiceGroupOwner(userId,dbServiceGroup )){
+ if (isServiceGroupOwner(userId, dbServiceGroup)) {
convertToRo(dbServiceGroup);
}
return null;
@@ -123,13 +123,14 @@ public class UIServiceGroupService extends UIServiceBase<DBServiceGroup, Service
/**
* Method validates if any of the service group users contains userID
+ *
* @param userId
* @param dbServiceGroup
* @return
*/
- protected boolean isServiceGroupOwner(Long userId, DBServiceGroup dbServiceGroup){
- return dbServiceGroup!=null &&
- dbServiceGroup.getUsers().stream().filter(user ->user.getId().equals(userId)).findAny().isPresent();
+ protected boolean isServiceGroupOwner(Long userId, DBServiceGroup dbServiceGroup) {
+ return dbServiceGroup != null &&
+ dbServiceGroup.getUsers().stream().filter(user -> user.getId().equals(userId)).findAny().isPresent();
}
@Transactional
@@ -283,11 +284,13 @@ public class UIServiceGroupService extends UIServiceBase<DBServiceGroup, Service
}
private void normalizeIdentifiers(ServiceGroupRO sgo) {
- ParticipantIdentifierType pti = caseSensitivityNormalizer.normalizeParticipant(sgo.getParticipantScheme() + "::" + sgo.getParticipantIdentifier());
+ ParticipantIdentifierType pti = identifierService.normalizeParticipant(sgo.getParticipantScheme(),
+ sgo.getParticipantIdentifier());
sgo.setParticipantScheme(pti.getScheme());
sgo.setParticipantIdentifier(pti.getValue());
sgo.getServiceMetadata().forEach(smd -> {
- DocumentIdentifier dit = caseSensitivityNormalizer.normalizeDocumentIdentifier(smd.getDocumentIdentifierScheme(), smd.getDocumentIdentifier());
+ DocumentIdentifier dit = identifierService.normalizeDocument(smd.getDocumentIdentifierScheme(),
+ smd.getDocumentIdentifier());
smd.setDocumentIdentifierScheme(dit.getScheme());
smd.setDocumentIdentifier(dit.getValue());
@@ -555,7 +558,7 @@ public class UIServiceGroupService extends UIServiceBase<DBServiceGroup, Service
ServiceMetadata smd = ServiceMetadataConverter.unmarshal(buff);
if (smd.getServiceInformation() != null) {
- DocumentIdentifier di = caseSensitivityNormalizer.normalize(smd.getServiceInformation().getDocumentIdentifier());
+ DocumentIdentifier di = identifierService.normalizeDocument(smd.getServiceInformation().getDocumentIdentifier());
if (Objects.equals(di.getScheme(), serviceMetadataRO.getDocumentIdentifierScheme())
&& Objects.equals(di.getValue(), serviceMetadataRO.getDocumentIdentifier())) {
@@ -634,7 +637,8 @@ public class UIServiceGroupService extends UIServiceBase<DBServiceGroup, Service
byte[] buff = validateServiceMetadata(serviceMetadataRO);
DBServiceMetadata dbServiceMetadata = new DBServiceMetadata();
- DocumentIdentifier docIdent = caseSensitivityNormalizer.normalizeDocumentIdentifier(serviceMetadataRO.getDocumentIdentifierScheme(), serviceMetadataRO.getDocumentIdentifier());
+ DocumentIdentifier docIdent = identifierService.normalizeDocument(serviceMetadataRO.getDocumentIdentifierScheme(),
+ serviceMetadataRO.getDocumentIdentifier());
dbServiceMetadata.setDocumentIdentifier(docIdent.getValue());
dbServiceMetadata.setDocumentIdentifierScheme(docIdent.getScheme());
dbServiceMetadata.setXmlContent(buff);
@@ -677,9 +681,10 @@ public class UIServiceGroupService extends UIServiceBase<DBServiceGroup, Service
} // if new check if service group already exist
if (serviceGroup.getStatusAction() == EntityROStatus.NEW.getStatusNumber()) {
- ParticipantIdentifierType normalizedParticipant = caseSensitivityNormalizer.normalizeParticipantIdentifier(
- serviceGroup.getParticipantScheme(),
- serviceGroup.getParticipantIdentifier());
+ ParticipantIdentifierType normalizedParticipant = identifierService
+ .normalizeParticipant(
+ serviceGroup.getParticipantScheme(),
+ serviceGroup.getParticipantIdentifier());
Optional<DBServiceGroup> sg = serviceGroupDao.findServiceGroup(normalizedParticipant.getValue(),
normalizedParticipant.getScheme());
if (sg.isPresent()) {
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataService.java
index 8a43d193a53127f7d8714a454499c274542f56cc..8a0aea1af38389970163f2b0d181f6d0685eaf0b 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataService.java
@@ -1,7 +1,7 @@
package eu.europa.ec.edelivery.smp.services.ui;
import eu.europa.ec.edelivery.security.utils.X509CertificateUtils;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.conversion.ServiceMetadataConverter;
import eu.europa.ec.edelivery.smp.data.dao.BaseDao;
import eu.europa.ec.edelivery.smp.data.dao.DomainDao;
@@ -46,14 +46,14 @@ public class UIServiceMetadataService extends UIServiceBase<DBServiceMetadata, S
protected final DomainDao domainDao;
protected final ServiceMetadataDao serviceMetadataDao;
protected final UserDao userDao;
- protected final CaseSensitivityNormalizer caseSensitivityNormalizer;
+ protected final IdentifierService caseSensitivityNormalizer;
protected final ConfigurationService configurationService;
public UIServiceMetadataService(DomainDao domainDao,
ServiceMetadataDao serviceMetadataDao,
UserDao userDao,
- CaseSensitivityNormalizer caseSensitivityNormalizer,
+ IdentifierService caseSensitivityNormalizer,
ConfigurationService configurationService) {
this.domainDao = domainDao;
this.serviceMetadataDao = serviceMetadataDao;
@@ -119,10 +119,10 @@ public class UIServiceMetadataService extends UIServiceBase<DBServiceMetadata, S
}
- DocumentIdentifier headerDI = caseSensitivityNormalizer.normalizeDocumentIdentifier(
+ DocumentIdentifier headerDI = caseSensitivityNormalizer.normalizeDocument(
serviceMetadataRO.getDocumentIdentifierScheme(),
serviceMetadataRO.getDocumentIdentifier());
- ParticipantIdentifierType headerPI = caseSensitivityNormalizer.normalizeParticipantIdentifier(
+ ParticipantIdentifierType headerPI = caseSensitivityNormalizer.normalizeParticipant(
serviceMetadataRO.getParticipantScheme(),
serviceMetadataRO.getParticipantIdentifier());
@@ -145,8 +145,8 @@ public class UIServiceMetadataService extends UIServiceBase<DBServiceMetadata, S
}
if (smd.getServiceInformation() != null) {
- DocumentIdentifier xmlDI = caseSensitivityNormalizer.normalize(smd.getServiceInformation().getDocumentIdentifier());
- ParticipantIdentifierType xmlPI = caseSensitivityNormalizer.normalize(smd.getServiceInformation().getParticipantIdentifier());
+ DocumentIdentifier xmlDI = caseSensitivityNormalizer.normalizeDocument(smd.getServiceInformation().getDocumentIdentifier());
+ ParticipantIdentifierType xmlPI = caseSensitivityNormalizer.normalizeParticipant(smd.getServiceInformation().getParticipantIdentifier());
if (!xmlDI.equals(headerDI)) {
serviceMetadataRO.setErrorMessage("Document identifier and scheme do not match!");
return serviceMetadataRO;
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UITruststoreService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UITruststoreService.java
index 53f20f7f87694359160174bd986759f04c57f9fa..d28271257a263db49d37d8e831c2f07dfb5a2b65 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UITruststoreService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UITruststoreService.java
@@ -276,6 +276,7 @@ public class UITruststoreService {
LOG.debug("No certificate key types configured. Skip certificate key validation.");
return;
}
+
PublicKey certKey = x509Certificate.getPublicKey();
if (!StringUtils.equalsAnyIgnoreCase(certKey.getAlgorithm(), allowedCertificateKeyTypes.toArray(new String[]{}))) {
throw new CertificateException("Certificate does not have allowed key algorithm type! Key type ["
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlConnector.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlConnector.java
index 6c5083061610ff0395c3009d8d1ed2fc0af02a07..f6cb2c301a6ed00d5c9402da6b54fccaa984a19f 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlConnector.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlConnector.java
@@ -17,6 +17,7 @@ import eu.europa.ec.bdmsl.ws.soap.BadRequestFault;
import eu.europa.ec.bdmsl.ws.soap.IManageParticipantIdentifierWS;
import eu.europa.ec.bdmsl.ws.soap.IManageServiceMetadataWS;
import eu.europa.ec.bdmsl.ws.soap.NotFoundFault;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
import eu.europa.ec.edelivery.smp.data.ui.CertificateRO;
import eu.europa.ec.edelivery.smp.data.ui.enums.SMPPropertyEnum;
@@ -58,7 +59,6 @@ import java.util.*;
import static eu.europa.ec.edelivery.smp.conversion.SmlIdentifierConverter.toBusdoxParticipantId;
import static eu.europa.ec.edelivery.smp.exceptions.SMLErrorMessages.*;
-import static eu.europa.ec.smp.api.Identifiers.asString;
/**
* Component responsible for building SOAP request and calling BDMSL.
@@ -85,15 +85,19 @@ public class SmlConnector implements ApplicationContextAware {
@Autowired
UITruststoreService truststoreService;
+ @Autowired
+ IdentifierService identifierService;
+
private ApplicationContext ctx;
+
public boolean registerInDns(ParticipantIdentifierType normalizedParticipantId, DBDomain domain) {
if (!configurationService.isSMLIntegrationEnabled()) {
return false;
}
- String normalizedParticipantString = asString(normalizedParticipantId);
+ String normalizedParticipantString = identifierService.formatParticipant(normalizedParticipantId);
if (!domain.isSmlRegistered()) {
LOG.info("Participant {} is not registered to SML because domain {} is not registered!",
normalizedParticipantString, domain.getDomainCode());
@@ -170,31 +174,30 @@ public class SmlConnector implements ApplicationContextAware {
smlSmpRequest.getPublisherEndpoint().setPhysicalAddress(smpPhysicalAddress);
smlSmpRequest.setServiceMetadataPublisherID(domain.getSmlSmpId());
getSMPManagerWSClient(domain).create(smlSmpRequest);
- return true;
} catch (BadRequestFault e) {
- return processSMLErrorMessage(e, domain);
+ processSMLErrorMessage(e, domain);
} catch (Exception e) {
LOG.error(e.getClass().getName() + "" + e.getMessage(), e);
throw new SMPRuntimeException(ErrorCode.SML_INTEGRATION_EXCEPTION, e, ExceptionUtils.getRootCauseMessage(e));
}
+ // if not error is thrown - the registration is done OK.
+ return true;
}
- private boolean processSMLErrorMessage(BadRequestFault e, DBDomain domain) {
+ private void processSMLErrorMessage(BadRequestFault e, DBDomain domain) {
if (!isOkMessage(domain, e.getMessage())) {
LOG.error(e.getMessage(), e);
throw new SMPRuntimeException(ErrorCode.SML_INTEGRATION_EXCEPTION, e, ExceptionUtils.getRootCauseMessage(e));
}
LOG.warn(e.getMessage(), e);
- return true;
}
- private boolean processSMLErrorMessage(NotFoundFault e, DBDomain domain) {
+ private void processSMLErrorMessage(NotFoundFault e, DBDomain domain) {
if (!isOkMessage(domain, e.getMessage())) {
LOG.error(e.getMessage(), e);
throw new SMPRuntimeException(ErrorCode.SML_INTEGRATION_EXCEPTION, e, ExceptionUtils.getRootCauseMessage(e));
}
LOG.warn(e.getMessage(), e);
- return true;
}
/**
@@ -219,7 +222,7 @@ public class SmlConnector implements ApplicationContextAware {
if (!configurationService.isSMLIntegrationEnabled()) {
return false;
}
- String normalizedParticipantString = asString(normalizedParticipantId);
+ String normalizedParticipantString = identifierService.formatParticipant(normalizedParticipantId);
if (!domain.isSmlRegistered()) {
LOG.info("Participant {} is not unregistered from SML because domain {} is not registered!",
normalizedParticipantString, domain.getDomainCode());
@@ -242,18 +245,17 @@ public class SmlConnector implements ApplicationContextAware {
}
}
- public boolean unregisterDomain(DBDomain domain) {
+ public void unregisterDomain(DBDomain domain) {
if (!configurationService.isSMLIntegrationEnabled()) {
- return true;
+ return;
}
LOG.info("Removing SMP id (Domain) from BDMSL: {} ", domain.getDomainCode());
try {
getSMPManagerWSClient(domain).delete(domain.getSmlSmpId());
- return true;
} catch (BadRequestFault e) {
- return processSMLErrorMessage(e, domain);
+ processSMLErrorMessage(e, domain);
} catch (NotFoundFault e) {
- return processSMLErrorMessage(e, domain);
+ processSMLErrorMessage(e, domain);
} catch (Exception e) {
LOG.error(e.getClass().getName() + "" + e.getMessage(), e);
throw new SMPRuntimeException(ErrorCode.SML_INTEGRATION_EXCEPTION, e, ExceptionUtils.getRootCauseMessage(e));
@@ -336,7 +338,7 @@ public class SmlConnector implements ApplicationContextAware {
}
if (!clientCertAuthentication && !useTLS) {
- LOG.warn("SML integration is wrongly configured. Uses 2-way-SSL HTTPS but URL is not HTTPS! Url: {}.", urlSMPManagment.toString());
+ LOG.warn("SML integration is wrongly configured. Uses 2-way-SSL HTTPS but URL is not HTTPS! Url: [{}].", urlSMPManagment);
}
HTTPConduit httpConduit = (HTTPConduit) client.getConduit();
@@ -362,7 +364,7 @@ public class SmlConnector implements ApplicationContextAware {
tlsParams.setUseHttpsURLConnectionDefaultHostnameVerifier(false);
tlsParams.setCertConstraints(createCertConstraint(configurationService.getSMLIntegrationServerCertSubjectRegExpPattern()));
tlsParams.setDisableCNCheck(configurationService.smlDisableCNCheck());
- if(!configurationService.useSystemTruststoreForTLS()){
+ if (!configurationService.useSystemTruststoreForTLS()) {
/**
* Sets the TrustManagers associated with this endpoint.
* This parameter may be set to null for system default behavior.
@@ -378,7 +380,7 @@ public class SmlConnector implements ApplicationContextAware {
} else {
LOG.debug("User Client cert header to authenticate to SML {}.", smlClientAuthentication);
Map<String, List<String>> customHeaders = new HashMap<>();
- customHeaders.put(CLIENT_CERT_HEADER_KEY, Arrays.asList(smlClientAuthentication));
+ customHeaders.put(CLIENT_CERT_HEADER_KEY, Collections.singletonList(smlClientAuthentication));
requestContext.put(MessageContext.HTTP_REQUEST_HEADERS, customHeaders);
}
if (useTLS) {
@@ -410,7 +412,7 @@ public class SmlConnector implements ApplicationContextAware {
}
private void configurePayloadLogging(Client client) {
- client.getBus().setFeatures(Arrays.asList(new LoggingFeature()));
+ client.getBus().setFeatures(Collections.singletonList(new LoggingFeature()));
}
private void configureProxy(HTTPConduit httpConduit, URL targetUrl) {
@@ -433,9 +435,7 @@ public class SmlConnector implements ApplicationContextAware {
LOG.info("Configuring proxy for BDMSL integration client: {}:{}@{}:{}", proxyUser, "******", proxyServer, proxyPort.isPresent() ? proxyPort.get() : "");
httpConduit.getClient().setProxyServerType(ProxyServerType.HTTP);
httpConduit.getClient().setProxyServer(proxyServer);
- if (proxyPort.isPresent()) {
- httpConduit.getClient().setProxyServerPort(proxyPort.get());
- }
+ proxyPort.ifPresent(port -> httpConduit.getClient().setProxyServerPort(port));
if (!StringUtils.isBlank(proxyUser)) {
ProxyAuthorizationPolicy proxyAuth = new ProxyAuthorizationPolicy();
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/CaseSensitivityNormalizerTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/IdentifierServiceTests.java
similarity index 64%
rename from smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/CaseSensitivityNormalizerTest.java
rename to smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/IdentifierServiceTests.java
index 65ac2052f913ef0d15c48f50a748f4cd57781067..3e49e60dd8b84cf5752da3370e343f7f96a718e6 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/CaseSensitivityNormalizerTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/IdentifierServiceTests.java
@@ -14,41 +14,29 @@
package eu.europa.ec.edelivery.smp.conversion;
import eu.europa.ec.edelivery.smp.services.ConfigurationService;
-import junitparams.JUnitParamsRunner;
-import junitparams.Parameters;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
import org.mockito.Mockito;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.DocumentIdentifier;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
-import org.springframework.test.util.ReflectionTestUtils;
+
+import java.util.Arrays;
+import java.util.Collection;
import static java.util.Arrays.asList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.*;
/**
* Created by gutowpa on 06/03/2017.
*/
-@RunWith(JUnitParamsRunner.class)
-public class CaseSensitivityNormalizerTest {
-
- private CaseSensitivityNormalizer normalizer;
-
- @Before
- public void init() {
- ConfigurationService configurationService = Mockito.mock(ConfigurationService.class);
- normalizer = new CaseSensitivityNormalizer(configurationService);
-
- Mockito.doReturn(asList(new String[]{"case-SENSITIVE-scheme-1", "Case-SENSITIVE-Scheme-2"})).when(configurationService).getCaseSensitiveDocumentScheme();
- Mockito.doReturn(asList(new String[]{"case-sensitive-scheme-1", "Case-SENSITIVE-Scheme-2"})).when(configurationService).getCaseSensitiveParticipantScheme();
-
- }
+@RunWith(Parameterized.class)
+public class IdentifierServiceTests {
- @SuppressWarnings("unused")
- private static Object[] testCases() {
- return new Object[][]{
+ @Parameterized.Parameters(name = "{index}: {0}")
+ public static Collection testCases() {
+ return Arrays.asList(new Object[][]{
{"scheme", "value", "scheme", "value"},
{"SCHEME", "VALUE", "scheme", "value"},
{"SchemE", "ValuE", "scheme", "value"},
@@ -56,43 +44,60 @@ public class CaseSensitivityNormalizerTest {
{"CASE-SENSITIVE-SCHEME-1", "Case-Sensitive-Value", "CASE-SENSITIVE-SCHEME-1", "Case-Sensitive-Value"}, //scheme itself checked case-insensitively if should be case-sensitive or not
{"case-sensitive-scheme-2", "Case-Sensitive-Value", "case-sensitive-scheme-2", "Case-Sensitive-Value"},
{"CASE-SENSITIVE-SCHEME-2", "Case-Sensitive-Value", "CASE-SENSITIVE-SCHEME-2", "Case-Sensitive-Value"}, //scheme itself checked case-insensitively if should be case-sensitive or not
- };
+ });
}
+ // input parameters
+ @Parameterized.Parameter
+ public String inputScheme;
+ @Parameterized.Parameter(1)
+ public String inputValue;
+ @Parameterized.Parameter(2)
+ public String expectedScheme;
+ @Parameterized.Parameter(3)
+ public String expectedValue;
+
+ private IdentifierService testInstance = new IdentifierService(Mockito.mock(ConfigurationService.class));
+
+ @Before
+ public void init() {
+ testInstance.configureDocumentIdentifierFormatter(asList(new String[]{"case-SENSITIVE-scheme-1", "Case-SENSITIVE-Scheme-2"}));
+ testInstance.configureParticipantIdentifierFormatter(asList(new String[]{"case-sensitive-scheme-1", "Case-SENSITIVE-Scheme-2"}), false, null);
+ }
+
+
@Test
- @Parameters(method = "testCases")
- public void testParticipantIdsCaseNormalization(String inputScheme, String inputValue, String expectedScheme, String expectedValue) {
+ public void testParticipantIdsCaseNormalization() {
//given
ParticipantIdentifierType inputParticpantId = new ParticipantIdentifierType(inputValue, inputScheme);
//when
- ParticipantIdentifierType outputParticipantId = normalizer.normalize(inputParticpantId);
+ ParticipantIdentifierType outputParticipantId = testInstance.normalizeParticipant(inputParticpantId);
//then
assertEquals(expectedScheme, outputParticipantId.getScheme());
assertEquals(expectedValue, outputParticipantId.getValue());
//input stays untouched
- assertFalse(inputParticpantId == outputParticipantId);
+ assertNotSame(inputParticpantId, outputParticipantId);
assertEquals(inputScheme, inputParticpantId.getScheme());
assertEquals(inputValue, inputParticpantId.getValue());
}
@Test
- @Parameters(method = "testCases")
- public void testDocumentIdsCaseNormalization(String inputScheme, String inputValue, String expectedScheme, String expectedValue) {
+ public void testDocumentIdsCaseNormalization() {
//given
DocumentIdentifier inputDocId = new DocumentIdentifier(inputValue, inputScheme);
//when
- DocumentIdentifier outputDocId = normalizer.normalize(inputDocId);
+ DocumentIdentifier outputDocId = testInstance.normalizeDocument(inputDocId);
//then
assertEquals(expectedScheme, outputDocId.getScheme());
assertEquals(expectedValue, outputDocId.getValue());
//input stays untouched
- assertFalse(inputDocId == outputDocId);
+ assertNotSame(inputDocId, outputDocId);
assertEquals(inputScheme, inputDocId.getScheme());
assertEquals(inputValue, inputDocId.getValue());
}
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/ServiceGroupConverterTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/ServiceGroupConverterTest.java
index 361c5ace34483da121d6d98753ae416367776989..5fb6ed80979f79e5c02b5019676e13d074cc7734 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/ServiceGroupConverterTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/conversion/ServiceGroupConverterTest.java
@@ -13,9 +13,7 @@
package eu.europa.ec.edelivery.smp.conversion;
-import eu.europa.ec.edelivery.smp.data.model.DBServiceGroup;
import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
-import eu.europa.ec.edelivery.smp.testutil.TestDBUtils;
import eu.europa.ec.edelivery.smp.testutil.XmlTestUtils;
import org.hamcrest.Matchers;
import org.junit.Rule;
@@ -25,10 +23,7 @@ import org.oasis_open.docs.bdxr.ns.smp._2016._05.ServiceGroup;
import org.xml.sax.SAXParseException;
import javax.xml.bind.JAXBException;
-import javax.xml.bind.UnmarshalException;
-import javax.xml.stream.XMLStreamException;
import java.io.IOException;
-import java.io.UnsupportedEncodingException;
import static org.junit.Assert.*;
@@ -42,81 +37,6 @@ public class ServiceGroupConverterTest {
@Rule
public ExpectedException expectedExeption = ExpectedException.none();
- @Test
- public void toServiceGroupTest() {
- // set
- DBServiceGroup sg = TestDBUtils.createDBServiceGroup();
-
- //when
- ServiceGroup serviceGroup = ServiceGroupConverter.toServiceGroup(sg, false);
- assertNotNull(serviceGroup);
- assertEquals(sg.getParticipantIdentifier(), serviceGroup.getParticipantIdentifier().getValue());
- assertEquals(sg.getParticipantScheme(), serviceGroup.getParticipantIdentifier().getScheme());
- assertEquals(1, serviceGroup.getExtensions().size());
- }
-
- @Test
- public void toServiceGroupTestEBCorePartyIDNotContact() {
- // set
-
- DBServiceGroup sg = TestDBUtils.createDBServiceGroup("0088:123456789","urn:oasis:names:tc:ebcore:partyid-type:iso6523");
-
- //when
- ServiceGroup serviceGroup = ServiceGroupConverter.toServiceGroup(sg, false);
- assertNotNull(serviceGroup);
- assertEquals(sg.getParticipantIdentifier(), serviceGroup.getParticipantIdentifier().getValue());
- assertEquals(sg.getParticipantScheme(), serviceGroup.getParticipantIdentifier().getScheme());
- assertEquals(1, serviceGroup.getExtensions().size());
- }
-
- @Test
- public void toServiceGroupTestEBCorePartyIDContact() {
- // set
- DBServiceGroup sg = TestDBUtils.createDBServiceGroup("0088:123456789","urn:oasis:names:tc:ebcore:partyid-type:iso6523");
- //when
- ServiceGroup serviceGroup = ServiceGroupConverter.toServiceGroup(sg, true);
- assertNotNull(serviceGroup);
- assertEquals(sg.getParticipantScheme() +":" + sg.getParticipantIdentifier(), serviceGroup.getParticipantIdentifier().getValue());
- assertNull(serviceGroup.getParticipantIdentifier().getScheme());
- assertEquals(1, serviceGroup.getExtensions().size());
- }
-
- @Test
- public void toServiceGroupTestMultiExtensions() throws UnsupportedEncodingException, JAXBException, XMLStreamException {
- // set
- DBServiceGroup sg = TestDBUtils.createDBServiceGroup();
- sg.setExtension(ExtensionConverter.concatByteArrays(TestDBUtils.generateExtension(), TestDBUtils.generateExtension()));
-
- //when-then
- ServiceGroup serviceGroup = ServiceGroupConverter.toServiceGroup(sg, false);
- assertNotNull(serviceGroup);
- assertEquals(sg.getParticipantIdentifier(), serviceGroup.getParticipantIdentifier().getValue());
- assertEquals(sg.getParticipantScheme(), serviceGroup.getParticipantIdentifier().getScheme());
- assertEquals(2, serviceGroup.getExtensions().size());
- }
-
- @Test
- public void toServiceGroupTestIsEmpty() {
- // set
- //when
- ServiceGroup serviceGroup = ServiceGroupConverter.toServiceGroup(null, false);
- assertNull(serviceGroup);
- }
-
- @Test
- public void testInvalidExtension() {
- //given
- DBServiceGroup sg = TestDBUtils.createDBServiceGroup();
- sg.setExtension("<This > is invalid extensions".getBytes());
- expectedExeption.expect(SMPRuntimeException.class);
- expectedExeption.expectCause(Matchers.isA(UnmarshalException.class));
- expectedExeption.expectMessage(Matchers.startsWith("Invalid extension for service group"));
-
- //when-then
- ServiceGroup serviceGroup = ServiceGroupConverter.toServiceGroup(sg, false);
- }
-
-
@Test
public void testUnmashallingServiceGroup() throws IOException {
//given
@@ -140,11 +60,11 @@ public class ServiceGroupConverterTest {
ServiceGroup serviceGroup = ServiceGroupConverter.unmarshal(inputDoc);
//when
- byte[] val = ServiceGroupConverter.extractExtensionsPayload(serviceGroup);
+ byte[] val = ServiceGroupConverter.extractExtensionsPayload(serviceGroup);
//then
assertNotNull(val);
- assertEquals(expectedExt, new String(val,"UTF-8"));
+ assertEquals(expectedExt, new String(val, "UTF-8"));
}
@Test
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/AbstractServiceIntegrationTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/AbstractServiceIntegrationTest.java
index ca5d6ebe8133e78a9a4dd9e4c49770148de755f8..52dff2dde0ee74fbfe8b4722032a4f9bee1402a0 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/AbstractServiceIntegrationTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/AbstractServiceIntegrationTest.java
@@ -4,7 +4,7 @@ package eu.europa.ec.edelivery.smp.services;
import eu.europa.ec.edelivery.smp.config.ConversionTestConfig;
import eu.europa.ec.edelivery.smp.config.H2JPATestConfig;
import eu.europa.ec.edelivery.smp.config.ServicesBeansConfiguration;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.cron.CronTriggerConfig;
import eu.europa.ec.edelivery.smp.data.dao.*;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
@@ -43,7 +43,7 @@ import static eu.europa.ec.edelivery.smp.testutil.TestConstants.*;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {H2JPATestConfig.class,
- CaseSensitivityNormalizer.class,SmlConnector.class,ServiceMetadataSigner.class, MailService.class,
+ IdentifierService.class,SmlConnector.class,ServiceMetadataSigner.class, MailService.class,
ServiceGroupService.class, DomainService.class, ServiceMetadataService.class,
ServiceGroupDao.class,ServiceMetadataDao.class, DomainDao.class, UserDao.class,DBAssertion.class, ConfigurationDao.class, AlertDao.class,
UITruststoreService.class, UIKeystoreService.class, ConversionTestConfig.class, SMLIntegrationService.class,
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ConfigurationServiceAllGetMethodsTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ConfigurationServiceAllGetMethodsTest.java
index a7e0f320bdee8842ef5e04876f803ad811333882..95e932cd87f477d42f7be2fa4cbe8614b9d63345 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ConfigurationServiceAllGetMethodsTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ConfigurationServiceAllGetMethodsTest.java
@@ -52,10 +52,11 @@ public class ConfigurationServiceAllGetMethodsTest {
{HTTP_PROXY_PASSWORD, TEST_STRING, "getProxyCredentialToken", true},
{HTTP_PROXY_PORT, 8800, "getHttpProxyPort", true},
{HTTP_PROXY_USER, TEST_STRING, "getProxyUsername", true},
- {PARTC_SCH_REGEXP, TEST_REXEXP,"getParticipantIdentifierSchemeRexExp", true},
- {PARTC_SCH_REGEXP, TEST_STRING, "getParticipantIdentifierSchemeRexExpPattern", false},
+ {PARTC_SCH_VALIDATION_REGEXP, TEST_REXEXP,"getParticipantIdentifierSchemeRexExp", true},
+ {PARTC_SCH_VALIDATION_REGEXP, TEST_STRING, "getParticipantIdentifierSchemeRexExpPattern", false},
{PARTC_SCH_REGEXP_MSG, TEST_STRING, "getParticipantIdentifierSchemeRexExpMessage", true},
- {PARTC_EBCOREPARTYID_CONCATENATE, Boolean.FALSE, "getForceConcatenateEBCorePartyId", true},
+ //{PARTC_EBCOREPARTYID_CONCATENATE, Boolean.FALSE, "getForceConcatenateEBCorePartyId", true},
+ {PARTC_SCH_MANDATORY, Boolean.FALSE, "getParticipantSchemeMandatory", true},
{CS_PARTICIPANTS, TEST_STRING_LIST, "getCaseSensitiveParticipantScheme", true},
{CS_DOCUMENTS, TEST_STRING_LIST, "getCaseSensitiveDocumentScheme", true},
{SML_ENABLED, Boolean.FALSE, "isSMLIntegrationEnabled", true},
@@ -105,8 +106,6 @@ public class ConfigurationServiceAllGetMethodsTest {
{SSO_CAS_TOKEN_VALIDATION_URL_PATH, TEST_STRING, "getCasURLTokenValidation", true},
{SSO_CAS_TOKEN_VALIDATION_PARAMS, TEST_MAP, "getCasTokenValidationParams", true},
{SSO_CAS_TOKEN_VALIDATION_GROUPS, TEST_STRING_LIST, "getCasURLTokenValidationGroups", true},
- {PARTC_EBCOREPARTYID_CONCATENATE, Boolean.FALSE, "getForceConcatenateEBCorePartyId", true},
- {PARTC_SCH_MANDATORY, Boolean.FALSE, "getParticipantSchemeMandatory", true},
{SMP_CLUSTER_ENABLED, Boolean.FALSE, "isClusterEnabled", true},
{ENCODED_SLASHES_ALLOWED_IN_URL, Boolean.FALSE, "encodedSlashesAllowedInUrl", true},
{SMP_ALERT_CREDENTIALS_SERVER, TEST_STRING, "getTargetServerForCredentialValidation", true},
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/DomainServiceSMLTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/DomainServiceSMLTest.java
index 24bab3dac6eedc09cb83a2b916426768e1c86e5c..594d3c2a4ea8f7b8dfa13fa4833b9103b5b880e5 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/DomainServiceSMLTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/DomainServiceSMLTest.java
@@ -18,6 +18,7 @@ import eu.europa.ec.bdmsl.ws.soap.InternalErrorFault;
import eu.europa.ec.bdmsl.ws.soap.NotFoundFault;
import eu.europa.ec.bdmsl.ws.soap.UnauthorizedFault;
import eu.europa.ec.edelivery.smp.config.SmlIntegrationConfiguration;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
import eu.europa.ec.edelivery.smp.data.model.DBServiceGroupDomain;
import eu.europa.ec.edelivery.smp.data.ui.enums.SMPPropertyEnum;
@@ -41,6 +42,7 @@ import org.springframework.transaction.annotation.Transactional;
import javax.xml.ws.http.HTTPException;
import java.io.IOException;
+import java.util.regex.Pattern;
import static eu.europa.ec.edelivery.smp.testutil.TestConstants.*;
import static org.junit.Assert.*;
@@ -61,12 +63,12 @@ public class DomainServiceSMLTest extends AbstractServiceIntegrationTest {
@Rule
public ExpectedException expectedExeption = ExpectedException.none();
+ @Autowired
+ IdentifierService identifierService;
@Autowired
SmlIntegrationConfiguration integrationMock;
-
@Autowired
SmlConnector smlConnector;
-
@Autowired
private SMLIntegrationService smlIntegrationService;
@@ -83,6 +85,9 @@ public class DomainServiceSMLTest extends AbstractServiceIntegrationTest {
ReflectionTestUtils.setField(smlIntegrationService,"smlConnector",smlConnector);
ReflectionTestUtils.setField(testInstance,"smlIntegrationService",smlIntegrationService);
+ ReflectionTestUtils.setField(smlIntegrationService,"identifierService",identifierService);
+ identifierService.configureParticipantIdentifierFormatter(null,false, Pattern.compile(".*"));
+
resetKeystore();
setDatabaseProperty(SMPPropertyEnum.SML_PHYSICAL_ADDRESS, "0.0.0.0");
setDatabaseProperty(SMPPropertyEnum.SML_LOGICAL_ADDRESS, "http://localhost/smp");
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationServiceTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationServiceTest.java
index 763004d0bc1e1bbb3d78205fc55cfa7bb74da8f2..f2e86fba32d7856cfa13af4955f5d0cfe2b1da0f 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationServiceTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationServiceTest.java
@@ -18,6 +18,7 @@ import eu.europa.ec.bdmsl.ws.soap.InternalErrorFault;
import eu.europa.ec.bdmsl.ws.soap.NotFoundFault;
import eu.europa.ec.bdmsl.ws.soap.UnauthorizedFault;
import eu.europa.ec.edelivery.smp.config.SmlIntegrationConfiguration;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
import eu.europa.ec.edelivery.smp.sml.SmlConnector;
@@ -33,50 +34,53 @@ import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.transaction.annotation.Transactional;
+import java.util.regex.Pattern;
+
import static eu.europa.ec.edelivery.smp.testutil.TestConstants.*;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
/**
- * Purpose of class is to test ServiceGroupService base methods
+ * Purpose of class is to test ServiceGroupService base methods
*
* @author Joze Rihtarsic
* @since 4.1
*/
@RunWith(SpringRunner.class)
-@ContextConfiguration(classes= {SmlIntegrationConfiguration.class,
- SMLIntegrationService.class} )
+@ContextConfiguration(classes = {SmlIntegrationConfiguration.class,
+ SMLIntegrationService.class})
public class SMLIntegrationServiceTest extends AbstractServiceIntegrationTest {
@Rule
public ExpectedException expectedExeption = ExpectedException.none();
+ @Autowired
+ IdentifierService identifierService;
@Autowired
SmlIntegrationConfiguration integrationMock;
-
@Autowired
protected SmlConnector smlConnector;
-
@Autowired
protected SMLIntegrationService testInstance;
-
@Autowired
ConfigurationService configurationService;
@Before
@Transactional
public void prepareDatabase() {
+ ReflectionTestUtils.setField(testInstance, "identifierService", identifierService);
+
+ identifierService.configureParticipantIdentifierFormatter(null, false, Pattern.compile(".*"));
configurationService = Mockito.spy(configurationService);
smlConnector = Mockito.spy(smlConnector);
Mockito.doNothing().when(smlConnector).configureClient(any(), any(), any());
- ReflectionTestUtils.setField(testInstance,"configurationService",configurationService);
- ReflectionTestUtils.setField(smlConnector,"configurationService",configurationService);
- ReflectionTestUtils.setField(testInstance,"smlConnector",smlConnector);
+ ReflectionTestUtils.setField(testInstance, "configurationService", configurationService);
+ ReflectionTestUtils.setField(smlConnector, "configurationService", configurationService);
+ ReflectionTestUtils.setField(testInstance, "smlConnector", smlConnector);
Mockito.doReturn(true).when(configurationService).isSMLIntegrationEnabled();
@@ -87,7 +91,7 @@ public class SMLIntegrationServiceTest extends AbstractServiceIntegrationTest {
@Test
public void registerDomainToSml() throws UnauthorizedFault, InternalErrorFault, BadRequestFault {
- // given
+ // given
DBDomain testDomain01 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
testDomain01.setSmlRegistered(false);
domainDao.update(testDomain01);
@@ -128,9 +132,9 @@ public class SMLIntegrationServiceTest extends AbstractServiceIntegrationTest {
* Users: USERNAME_1, USER_CERT_2
* ServiceGroup1: TEST_SG_ID_1, TEST_SG_SCHEMA_1
* - Domain: TEST_DOMAIN_CODE_1
- */
+ */
// when
- testInstance.registerParticipant(TEST_SG_ID_1,TEST_SG_SCHEMA_1,TEST_DOMAIN_CODE_1 );
+ testInstance.registerParticipant(TEST_SG_ID_1, TEST_SG_SCHEMA_1, TEST_DOMAIN_CODE_1);
//then -- expect on call
assertEquals(1, integrationMock.getParticipantManagmentClientMocks().size());
@@ -148,7 +152,7 @@ public class SMLIntegrationServiceTest extends AbstractServiceIntegrationTest {
* - Domain: TEST_DOMAIN_CODE_1
*/
// when
- testInstance.registerParticipant(TEST_SG_ID_NO_SCHEME,null,TEST_DOMAIN_CODE_1 );
+ testInstance.registerParticipant(TEST_SG_ID_NO_SCHEME, null, TEST_DOMAIN_CODE_1);
//then -- expect on call
assertEquals(1, integrationMock.getParticipantManagmentClientMocks().size());
@@ -166,7 +170,7 @@ public class SMLIntegrationServiceTest extends AbstractServiceIntegrationTest {
* - Domain: TEST_DOMAIN_CODE_1
*/
// when
- testInstance.registerParticipant(TEST_SG_ID_1,TEST_SG_SCHEMA_1,TEST_DOMAIN_CODE_1 );
+ testInstance.registerParticipant(TEST_SG_ID_1, TEST_SG_SCHEMA_1, TEST_DOMAIN_CODE_1);
//then -- expect on call
assertEquals(1, integrationMock.getParticipantManagmentClientMocks().size());
@@ -176,31 +180,30 @@ public class SMLIntegrationServiceTest extends AbstractServiceIntegrationTest {
}
@Test
- public void registerParticipant_NotExists(){
+ public void registerParticipant_NotExists() {
expectedExeption.expect(SMPRuntimeException.class);
- String notExistsId = TEST_SG_ID_1+"NotExists";
- expectedExeption.expectMessage("ServiceGroup not found (part. id: '"+TEST_SG_ID_1+"NotExists', part. sch.: '"+TEST_SG_SCHEMA_1+"')!");
+ String notExistsId = TEST_SG_ID_1 + "NotExists";
+ expectedExeption.expectMessage("ServiceGroup not found (part. id: '" + TEST_SG_ID_1 + "NotExists', part. sch.: '" + TEST_SG_SCHEMA_1 + "')!");
// when
- testInstance.registerParticipant(notExistsId,TEST_SG_SCHEMA_1,TEST_DOMAIN_CODE_1 );
+ testInstance.registerParticipant(notExistsId, TEST_SG_SCHEMA_1, TEST_DOMAIN_CODE_1);
}
@Test
- public void registerParticipant_NotOnDomain(){
+ public void registerParticipant_NotOnDomain() {
expectedExeption.expect(SMPRuntimeException.class);
- expectedExeption.expectMessage("Service group not registered for domain (domain: "+TEST_DOMAIN_CODE_2+", part. id: '"+TEST_SG_ID_1+"', part. sch.: '"+TEST_SG_SCHEMA_1+"')!");
+ expectedExeption.expectMessage("Service group not registered for domain (domain: " + TEST_DOMAIN_CODE_2 + ", part. id: '" + TEST_SG_ID_1 + "', part. sch.: '" + TEST_SG_SCHEMA_1 + "')!");
// when
- testInstance.registerParticipant(TEST_SG_ID_1,TEST_SG_SCHEMA_1,TEST_DOMAIN_CODE_2 );
+ testInstance.registerParticipant(TEST_SG_ID_1, TEST_SG_SCHEMA_1, TEST_DOMAIN_CODE_2);
}
-
@Test
public void registerParticipantToSML() throws NotFoundFault, UnauthorizedFault, InternalErrorFault, BadRequestFault {
DBDomain testDomain01 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
// when
- testInstance.registerParticipantToSML(TEST_SG_ID_1,TEST_SG_SCHEMA_1,testDomain01 );
+ testInstance.registerParticipantToSML(TEST_SG_ID_1, TEST_SG_SCHEMA_1, testDomain01);
//then -- expect on call
assertEquals(1, integrationMock.getParticipantManagmentClientMocks().size());
@@ -213,14 +216,11 @@ public class SMLIntegrationServiceTest extends AbstractServiceIntegrationTest {
DBDomain testDomain01 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
testDomain01.setSmlRegistered(true);
// when
- testInstance.unregisterParticipantFromSML(TEST_SG_ID_1,TEST_SG_SCHEMA_1,testDomain01 );
+ testInstance.unregisterParticipantFromSML(TEST_SG_ID_1, TEST_SG_SCHEMA_1, testDomain01);
//then -- expect on call
assertEquals(1, integrationMock.getParticipantManagmentClientMocks().size());
verify(integrationMock.getParticipantManagmentClientMocks().get(0)).delete(any());
Mockito.verifyNoMoreInteractions(integrationMock.getParticipantManagmentClientMocks().toArray());
}
-
-
-
}
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceGroupServiceIntegrationTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceGroupServiceIntegrationTest.java
index 9bc7ae95238fd5462f511bad5ac6b966440a5365..aa8d2516c88d9f05b0cec01dc890794fc7a12088 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceGroupServiceIntegrationTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceGroupServiceIntegrationTest.java
@@ -13,23 +13,33 @@
package eu.europa.ec.edelivery.smp.services;
+import eu.europa.ec.edelivery.smp.conversion.ExtensionConverter;
+import eu.europa.ec.edelivery.smp.conversion.ServiceGroupConverter;
import eu.europa.ec.edelivery.smp.data.model.DBServiceGroup;
import eu.europa.ec.edelivery.smp.data.model.DBUser;
import eu.europa.ec.edelivery.smp.exceptions.ErrorCode;
import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
import eu.europa.ec.edelivery.smp.testutil.TestConstants;
import eu.europa.ec.edelivery.smp.testutil.TestDBUtils;
+import org.hamcrest.MatcherAssert;
+import org.hamcrest.Matchers;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.ServiceGroup;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.UnmarshalException;
+import javax.xml.stream.XMLStreamException;
+import java.io.UnsupportedEncodingException;
import java.util.Optional;
+import java.util.regex.Pattern;
import static eu.europa.ec.edelivery.smp.testutil.TestConstants.*;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
/**
* Purpose of class is to test ServiceGroupService base methods
@@ -38,9 +48,7 @@ import static org.junit.Assert.assertTrue;
* @since 4.1
*/
public class ServiceGroupServiceIntegrationTest extends AbstractServiceIntegrationTest {
-
- @Rule
- public ExpectedException expectedExeption = ExpectedException.none();
+ public static Pattern DEFAULT_URN_PATTERN = Pattern.compile("^(?i)((urn:)|(mailto:)).*$");
@Autowired
ServiceGroupService testInstance;
@@ -54,11 +62,9 @@ public class ServiceGroupServiceIntegrationTest extends AbstractServiceIntegrati
public void validateOwnershipUserNotExists(){
Optional<DBServiceGroup> dbsg = serviceGroupDao.findServiceGroup( TEST_SG_ID_2, TEST_SG_SCHEMA_2);
assertTrue(dbsg.isPresent()); // test if exists
-
- expectedExeption.expect(SMPRuntimeException.class);
- expectedExeption.expectMessage(ErrorCode.USER_NOT_EXISTS.getMessage());
//test
- testInstance.validateOwnership("UserNotExist", dbsg.get());
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class, () -> testInstance.validateOwnership("UserNotExist", dbsg.get()));
+ assertEquals(ErrorCode.USER_NOT_EXISTS.getMessage(), result.getMessage());
}
@Test
@@ -69,12 +75,82 @@ public class ServiceGroupServiceIntegrationTest extends AbstractServiceIntegrati
DBUser u3= TestDBUtils.createDBUserByCertificate(TestConstants.USER_CERT_3);
userDao.persistFlushDetach(u3);
-
- expectedExeption.expect(SMPRuntimeException.class);
- expectedExeption.expectMessage(ErrorCode.USER_IS_NOT_OWNER.getMessage(USER_CERT_3,
- TEST_SG_ID_2, TEST_SG_SCHEMA_2));
//test
- testInstance.validateOwnership(USER_CERT_3, dbsg.get());
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class, () -> testInstance.validateOwnership(USER_CERT_3, dbsg.get()) );
+ assertEquals(ErrorCode.USER_IS_NOT_OWNER.getMessage(USER_CERT_3,
+ TEST_SG_ID_2, TEST_SG_SCHEMA_2), result.getMessage());
+
+ }
+
+ @Test
+ public void toServiceGroupTest() {
+ // set
+ DBServiceGroup sg = TestDBUtils.createDBServiceGroup();
+
+ //when
+ ServiceGroup serviceGroup = testInstance.toServiceGroup(sg, DEFAULT_URN_PATTERN);
+ assertNotNull(serviceGroup);
+ assertEquals(sg.getParticipantIdentifier(), serviceGroup.getParticipantIdentifier().getValue());
+ assertEquals(sg.getParticipantScheme(), serviceGroup.getParticipantIdentifier().getScheme());
+ assertEquals(1, serviceGroup.getExtensions().size());
+ }
+
+ @Test
+ public void toServiceGroupTestEBCorePartyIDNotContact() {
+ // set
+
+ DBServiceGroup sg = TestDBUtils.createDBServiceGroup("0088:123456789","urn:oasis:names:tc:ebcore:partyid-type:iso6523");
+
+ //when
+ ServiceGroup serviceGroup = testInstance.toServiceGroup(sg, null);
+ assertNotNull(serviceGroup);
+ assertEquals(sg.getParticipantIdentifier(), serviceGroup.getParticipantIdentifier().getValue());
+ assertEquals(sg.getParticipantScheme(), serviceGroup.getParticipantIdentifier().getScheme());
+ assertEquals(1, serviceGroup.getExtensions().size());
+ }
+
+ @Test
+ public void toServiceGroupTestEBCorePartyIDContact() {
+ // set
+ DBServiceGroup sg = TestDBUtils.createDBServiceGroup("0088:123456789","urn:oasis:names:tc:ebcore:partyid-type:iso6523");
+ //when
+ ServiceGroup serviceGroup = testInstance.toServiceGroup(sg, DEFAULT_URN_PATTERN);
+ assertNotNull(serviceGroup);
+ assertEquals(sg.getParticipantScheme() +":" + sg.getParticipantIdentifier(), serviceGroup.getParticipantIdentifier().getValue());
+ assertNull(serviceGroup.getParticipantIdentifier().getScheme());
+ assertEquals(1, serviceGroup.getExtensions().size());
+ }
+
+ @Test
+ public void toServiceGroupTestMultiExtensions() {
+ // set
+ DBServiceGroup sg = TestDBUtils.createDBServiceGroup();
+ sg.setExtension(ExtensionConverter.concatByteArrays(TestDBUtils.generateExtension(), TestDBUtils.generateExtension()));
+
+ //when-then
+ ServiceGroup serviceGroup = testInstance.toServiceGroup(sg, null);
+ assertNotNull(serviceGroup);
+ assertEquals(sg.getParticipantIdentifier(), serviceGroup.getParticipantIdentifier().getValue());
+ assertEquals(sg.getParticipantScheme(), serviceGroup.getParticipantIdentifier().getScheme());
+ assertEquals(2, serviceGroup.getExtensions().size());
+ }
+
+ @Test
+ public void toServiceGroupTestIsEmpty() {
+ // set
+ //when
+ ServiceGroup serviceGroup = testInstance.toServiceGroup(null, null);
+ assertNull(serviceGroup);
+ }
+
+ @Test
+ public void testInvalidExtension() {
+ //given
+ DBServiceGroup sg = TestDBUtils.createDBServiceGroup();
+ sg.setExtension("<This > is invalid extensions".getBytes());
+ //when-then
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class, () -> testInstance.toServiceGroup(sg, null));
+ MatcherAssert.assertThat( result.getMessage(), Matchers.startsWith("Invalid extension for service group"));
}
}
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceGroupServiceSingleDomainIntegrationTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceGroupServiceSingleDomainIntegrationTest.java
index 77a6810679d18fdbb8cc122f9f29c7345a71a345..1ac34ae81d52afb94eb1c208ae5ea329e601288b 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceGroupServiceSingleDomainIntegrationTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceGroupServiceSingleDomainIntegrationTest.java
@@ -19,6 +19,8 @@ import eu.europa.ec.edelivery.smp.data.model.*;
import eu.europa.ec.edelivery.smp.data.ui.enums.SMPPropertyEnum;
import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
import eu.europa.ec.edelivery.smp.testutil.TestConstants;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
import org.hamcrest.core.StringStartsWith;
import org.junit.Before;
import org.junit.Rule;
@@ -43,7 +45,6 @@ import static eu.europa.ec.edelivery.smp.conversion.ServiceGroupConverter.unmars
import static eu.europa.ec.edelivery.smp.exceptions.ErrorCode.*;
import static eu.europa.ec.edelivery.smp.testutil.TestConstants.*;
import static eu.europa.ec.edelivery.smp.testutil.XmlTestUtils.loadDocumentAsString;
-import static eu.europa.ec.smp.api.Identifiers.asParticipantId;
import static org.junit.Assert.*;
/**
@@ -55,9 +56,6 @@ public class ServiceGroupServiceSingleDomainIntegrationTest extends AbstractServ
@Autowired
protected ServiceGroupService testInstance;
- @Rule
- public ExpectedException expectedExeption = ExpectedException.none();
-
@Before
@Transactional
public void prepareDatabase() {
@@ -163,11 +161,11 @@ public class ServiceGroupServiceSingleDomainIntegrationTest extends AbstractServ
@Test
public void serviceGroupNotExistsWhenRetrievingSG() {
- // given
- expectedExeption.expect(SMPRuntimeException.class);
- expectedExeption.expectMessage(SG_NOT_EXISTS.getMessage("service-group", "not-existing"));
// when-then
- testInstance.getServiceGroup(asParticipantId("not-existing::service-group", false) );
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class,
+ ()->testInstance.getServiceGroup(new ParticipantIdentifierType("not-existing", "bad-srv-grp") ));
+
+ assertEquals(SG_NOT_EXISTS.getMessage("not-existing", "bad-srv-grp"), result.getMessage());
}
@Test
@@ -183,13 +181,10 @@ public class ServiceGroupServiceSingleDomainIntegrationTest extends AbstractServ
testInstance.deleteServiceGroup(inServiceGroup.getParticipantIdentifier());
serviceGroupDao.clearPersistenceContext();
- //then
- expectedExeption.expect(SMPRuntimeException.class);
- // get by null domain so: (all registered domains)
- expectedExeption.expectMessage(SG_NOT_EXISTS.getMessage( inServiceGroup.getParticipantIdentifier().getValue(),
- inServiceGroup.getParticipantIdentifier().getScheme()));
-
- ServiceGroup sg = testInstance.getServiceGroup(inServiceGroup.getParticipantIdentifier());
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class,
+ ()->testInstance.getServiceGroup(inServiceGroup.getParticipantIdentifier()));
+ assertEquals(SG_NOT_EXISTS.getMessage( inServiceGroup.getParticipantIdentifier().getValue(), inServiceGroup.getParticipantIdentifier().getScheme())
+ , result.getMessage());
}
@@ -223,16 +218,13 @@ public class ServiceGroupServiceSingleDomainIntegrationTest extends AbstractServ
assertTrue(dbUser.isPresent()); // test if exists
assertFalse(dbsg.get().getUsers().contains(dbUser.get())); // test not owner
- //then
- expectedExeption.expect(SMPRuntimeException.class);
- // get by null domain so: (all registered domains)
- expectedExeption.expectMessage(USER_IS_NOT_OWNER.getMessage(TestConstants.USER_CERT_2,
-
- dbsg.get().getParticipantIdentifier(), dbsg.get().getParticipantScheme()));
-
// when
- testInstance.saveServiceGroup(inServiceGroup,null,
- TestConstants.USER_CERT_2, TestConstants.USER_CERT_2);
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class,
+ ()->testInstance.saveServiceGroup(inServiceGroup,null,
+ TestConstants.USER_CERT_2, TestConstants.USER_CERT_2));
+
+ assertEquals(USER_IS_NOT_OWNER.getMessage(TestConstants.USER_CERT_2,
+ dbsg.get().getParticipantIdentifier(), dbsg.get().getParticipantScheme()), result.getMessage());
}
@Test
@@ -244,15 +236,12 @@ public class ServiceGroupServiceSingleDomainIntegrationTest extends AbstractServ
Optional<DBUser> dbUser = userDao.findUserByIdentifier(TestConstants.USER_CERT_3);
assertTrue(dbsg.isPresent()); // test if note exists
assertFalse(dbUser.isPresent()); // test if exists
-
- //then
- expectedExeption.expect(SMPRuntimeException.class);
- // get by null domain so: (all registered domains)
- expectedExeption.expectMessage(INVALID_OWNER.getMessage(TestConstants.USER_CERT_3));
-
// when
- testInstance.saveServiceGroup(inServiceGroup, null,
- TestConstants.USER_CERT_3, TestConstants.USER_CERT_3);
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class,
+ ()->testInstance.saveServiceGroup(inServiceGroup, null,
+ TestConstants.USER_CERT_3, TestConstants.USER_CERT_3));
+
+ assertEquals(INVALID_OWNER.getMessage(TestConstants.USER_CERT_3), result.getMessage());
}
@Test
@@ -260,12 +249,12 @@ public class ServiceGroupServiceSingleDomainIntegrationTest extends AbstractServ
String username = "test::20%atest";
//given
ServiceGroup inServiceGroup = unmarshal(loadDocumentAsString(TestConstants.SERVICE_GROUP_TEST2_XML_PATH));
- expectedExeption.expect(SMPRuntimeException.class);
- expectedExeption.expectMessage(StringStartsWith.startsWith("Unsupported or invalid encoding"));
//when
- testInstance.saveServiceGroup(inServiceGroup, null, username, username);
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class,
+ ()->testInstance.saveServiceGroup(inServiceGroup, null, username, username));
+ MatcherAssert.assertThat(result.getMessage(), CoreMatchers.startsWith("Unsupported or invalid encoding"));
}
@Test
@@ -273,11 +262,12 @@ public class ServiceGroupServiceSingleDomainIntegrationTest extends AbstractServ
//given
String domain="NOTEXISTINGDOMAIN";
ServiceGroup inServiceGroup = unmarshal(loadDocumentAsString(TestConstants.SERVICE_GROUP_POLAND_XML_PATH));
- expectedExeption.expect(SMPRuntimeException.class);
- expectedExeption.expectMessage(DOMAIN_NOT_EXISTS.getMessage(domain));
//execute
- testInstance.saveServiceGroup(inServiceGroup, domain, USERNAME_TOKEN_1, USERNAME_TOKEN_1);
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class,
+ ()->testInstance.saveServiceGroup(inServiceGroup, domain, USERNAME_TOKEN_1, USERNAME_TOKEN_1));
+
+ assertEquals(DOMAIN_NOT_EXISTS.getMessage(domain), result.getMessage());
}
@Test
@@ -285,12 +275,13 @@ public class ServiceGroupServiceSingleDomainIntegrationTest extends AbstractServ
//given
String domain="notAllowedChars:-_;#$";
ServiceGroup inServiceGroup = unmarshal(loadDocumentAsString(TestConstants.SERVICE_GROUP_POLAND_XML_PATH));
- expectedExeption.expect(SMPRuntimeException.class);
- expectedExeption.expectMessage(INVALID_DOMAIN_CODE.getMessage(domain,
- DomainService.DOMAIN_ID_PATTERN.pattern()));
//execute
- testInstance.saveServiceGroup(inServiceGroup, domain, USERNAME_TOKEN_1, USERNAME_TOKEN_1);
+ SMPRuntimeException result = assertThrows(SMPRuntimeException.class,
+ ()->testInstance.saveServiceGroup(inServiceGroup, domain, USERNAME_TOKEN_1, USERNAME_TOKEN_1));
+
+ assertEquals(INVALID_DOMAIN_CODE.getMessage(domain,
+ DomainService.DOMAIN_ID_PATTERN.pattern()), result.getMessage());
}
@Test
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceMetadataIntegrationTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceMetadataIntegrationTest.java
index 3cde33a4fa109b14ca897764be1bcbad1d03a9a2..949239a9c4515b6c29da037cd665b14f70df9389 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceMetadataIntegrationTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ServiceMetadataIntegrationTest.java
@@ -13,7 +13,7 @@
package eu.europa.ec.edelivery.smp.services;
-import eu.europa.ec.edelivery.smp.conversion.ServiceMetadataConverter;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
import eu.europa.ec.edelivery.smp.data.model.DBServiceGroup;
import eu.europa.ec.edelivery.smp.data.model.DBServiceMetadata;
@@ -21,7 +21,6 @@ import eu.europa.ec.edelivery.smp.exceptions.ErrorCode;
import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
import eu.europa.ec.edelivery.smp.services.ui.UIKeystoreService;
import org.junit.Before;
-import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
@@ -40,23 +39,20 @@ import org.w3c.dom.NodeList;
import javax.xml.bind.JAXBException;
import javax.xml.transform.TransformerException;
-import javax.xml.transform.TransformerFactory;
-import javax.xml.transform.dom.DOMSource;
-import javax.xml.transform.stream.StreamResult;
-import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
-import java.util.Arrays;
import java.util.List;
import java.util.Optional;
+import java.util.regex.Pattern;
import static eu.europa.ec.edelivery.smp.conversion.ServiceMetadataConverter.unmarshal;
import static eu.europa.ec.edelivery.smp.testutil.TestConstants.*;
import static eu.europa.ec.edelivery.smp.testutil.XmlTestUtils.loadDocumentAsByteArray;
import static eu.europa.ec.edelivery.smp.testutil.XmlTestUtils.marshallToByteArray;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
/**
* Created by gutowpa on 15/11/2017.
@@ -64,31 +60,30 @@ import static org.junit.Assert.*;
@RunWith(SpringJUnit4ClassRunner.class)
public class ServiceMetadataIntegrationTest extends AbstractServiceIntegrationTest {
- static ParticipantIdentifierType PT_ID =null;
- static DocumentIdentifier DOC_ID = null;
+ static ParticipantIdentifierType PT_ID = null;
+ static DocumentIdentifier DOC_ID = null;
+
static {
- PT_ID = new ParticipantIdentifierType();
+ PT_ID = new ParticipantIdentifierType();
PT_ID.setValue(TEST_SG_ID_PL2);
PT_ID.setScheme(TEST_SG_SCHEMA_PL2);
- DOC_ID = new DocumentIdentifier();
+ DOC_ID = new DocumentIdentifier();
DOC_ID.setValue(TEST_DOC_ID_PL2);
DOC_ID.setScheme(TEST_DOC_SCHEMA_PL2);
}
- @Autowired
- ServiceMetadataService testInstance;
-
- Path resourceDirectory = Paths.get("src", "test", "resources", "keystores");
+ Path resourceDirectory = Paths.get("src", "test", "resources", "keystores");
ConfigurationService configurationService = Mockito.mock(ConfigurationService.class);
+ @Autowired
+ IdentifierService identifierService;
+ @Autowired
+ ServiceMetadataService testInstance;
@Autowired
UIKeystoreService uiKeystoreService;
-
@Autowired
- private ServiceMetadataSigner signer;
-
-
+ ServiceMetadataSigner signer;
@Rule
public ExpectedException expectedExeption = ExpectedException.none();
@@ -97,14 +92,16 @@ public class ServiceMetadataIntegrationTest extends AbstractServiceIntegrationTe
@Transactional
public void prepareDatabase() {
configurationService = Mockito.spy(configurationService);
- ReflectionTestUtils.setField(uiKeystoreService,"configurationService",configurationService);
- ReflectionTestUtils.setField(signer,"uiKeystoreService",uiKeystoreService);
- ReflectionTestUtils.setField(testInstance,"signer",signer);
+ ReflectionTestUtils.setField(uiKeystoreService, "configurationService", configurationService);
+ ReflectionTestUtils.setField(signer, "uiKeystoreService", uiKeystoreService);
+ ReflectionTestUtils.setField(testInstance, "signer", signer);
+ ReflectionTestUtils.setField(testInstance, "identifierService", identifierService);
+ identifierService.configureParticipantIdentifierFormatter(null, null, Pattern.compile(".*"));
// set keystore properties
File keystoreFile = new File(resourceDirectory.toFile(), "smp-keystore.jks");
- Mockito.doReturn( keystoreFile).when(configurationService).getKeystoreFile();
- Mockito.doReturn( resourceDirectory.toFile()).when(configurationService).getConfigurationFolder();
+ Mockito.doReturn(keystoreFile).when(configurationService).getKeystoreFile();
+ Mockito.doReturn(resourceDirectory.toFile()).when(configurationService).getConfigurationFolder();
Mockito.doReturn("test123").when(configurationService).getKeystoreCredentialToken();
uiKeystoreService.refreshData();
@@ -120,8 +117,8 @@ public class ServiceMetadataIntegrationTest extends AbstractServiceIntegrationTe
@Test
public void saveAndReadPositiveScenario() throws IOException, TransformerException, JAXBException {
//given
- byte[] inServiceMetadataXml = loadDocumentAsByteArray(SERVICE_METADATA_XML_PATH);
- // byte[] expectedSignedServiceMetadataXml = loadDocumentAsByteArray(SIGNED_SERVICE_METADATA_XML_PATH);
+ byte[] inServiceMetadataXml = loadDocumentAsByteArray(SERVICE_METADATA_XML_PATH);
+ // byte[] expectedSignedServiceMetadataXml = loadDocumentAsByteArray(SIGNED_SERVICE_METADATA_XML_PATH);
List<DocumentIdentifier> docIdsBefore = testInstance.findServiceMetadataIdentifiers(PT_ID);
assertEquals(0, docIdsBefore.size());
@@ -136,11 +133,11 @@ public class ServiceMetadataIntegrationTest extends AbstractServiceIntegrationTe
assertEquals(DOC_ID.getScheme().toLowerCase(), docIdsAfter.get(0).getScheme()); // normalized
assertEquals("SignedServiceMetadata", outServiceMetadataDoc.getDocumentElement().getTagName());
// has signature
- assertEquals(1, outServiceMetadataDoc.getElementsByTagNameNS("http://www.w3.org/2000/09/xmldsig#","Signature").getLength());
+ assertEquals(1, outServiceMetadataDoc.getElementsByTagNameNS("http://www.w3.org/2000/09/xmldsig#", "Signature").getLength());
// has service metadata
- NodeList serviceMetadata = outServiceMetadataDoc.getElementsByTagNameNS("http://docs.oasis-open.org/bdxr/ns/SMP/2016/05","ServiceMetadata");
+ NodeList serviceMetadata = outServiceMetadataDoc.getElementsByTagNameNS("http://docs.oasis-open.org/bdxr/ns/SMP/2016/05", "ServiceMetadata");
assertEquals(1, serviceMetadata.getLength());
- // assertArrayEquals(expectedSignedServiceMetadataXml, ServiceMetadataConverter.toByteArray(outServiceMetadataDoc));
+ // assertArrayEquals(expectedSignedServiceMetadataXml, ServiceMetadataConverter.toByteArray(outServiceMetadataDoc));
}
@Test
@@ -148,7 +145,7 @@ public class ServiceMetadataIntegrationTest extends AbstractServiceIntegrationTe
expectedExeption.expect(SMPRuntimeException.class);
expectedExeption.expectMessage(ErrorCode.METADATA_NOT_EXISTS.getMessage(SERVICE_GROUP_ID.getValue().toLowerCase(),
- SERVICE_GROUP_ID.getScheme().toLowerCase(),DOC_ID.getValue().toLowerCase(), DOC_ID.getScheme().toLowerCase()));
+ SERVICE_GROUP_ID.getScheme().toLowerCase(), DOC_ID.getValue().toLowerCase(), DOC_ID.getScheme().toLowerCase()));
testInstance.getServiceMetadataDocument(SERVICE_GROUP_ID, DOC_ID);
}
@@ -159,7 +156,7 @@ public class ServiceMetadataIntegrationTest extends AbstractServiceIntegrationTe
// given
expectedExeption.expect(SMPRuntimeException.class);
expectedExeption.expectMessage(ErrorCode.METADATA_NOT_EXISTS.getMessage(SERVICE_GROUP_ID.getValue().toLowerCase(),
- SERVICE_GROUP_ID.getScheme().toLowerCase(),DOC_ID.getValue().toLowerCase(), DOC_ID.getScheme().toLowerCase()));
+ SERVICE_GROUP_ID.getScheme().toLowerCase(), DOC_ID.getValue().toLowerCase(), DOC_ID.getScheme().toLowerCase()));
// when - then
testInstance.deleteServiceMetadata(null, SERVICE_GROUP_ID, DOC_ID);
}
@@ -167,13 +164,13 @@ public class ServiceMetadataIntegrationTest extends AbstractServiceIntegrationTe
@Test
public void saveAndDeletePositiveScenario() throws IOException {
//given
- byte[] inServiceMetadataXml = loadDocumentAsByteArray(SERVICE_METADATA_XML_PATH);
+ byte[] inServiceMetadataXml = loadDocumentAsByteArray(SERVICE_METADATA_XML_PATH);
testInstance.saveServiceMetadata(null, PT_ID, DOC_ID, inServiceMetadataXml);
List<DocumentIdentifier> docIdsBefore = testInstance.findServiceMetadataIdentifiers(PT_ID);
assertEquals(1, docIdsBefore.size());
Optional<DBServiceMetadata> dbServiceMetadata = serviceMetadataDao.findServiceMetadata(
PT_ID.getValue().toLowerCase(), PT_ID.getScheme().toLowerCase(),
- DOC_ID.getValue().toLowerCase(), DOC_ID.getScheme().toLowerCase());;
+ DOC_ID.getValue().toLowerCase(), DOC_ID.getScheme().toLowerCase());
assertTrue(dbServiceMetadata.isPresent());
//when
@@ -185,7 +182,7 @@ public class ServiceMetadataIntegrationTest extends AbstractServiceIntegrationTe
expectedExeption.expect(SMPRuntimeException.class);
expectedExeption.expectMessage(ErrorCode.METADATA_NOT_EXISTS.getMessage(SERVICE_GROUP_ID.getValue().toLowerCase(),
- SERVICE_GROUP_ID.getScheme().toLowerCase(),DOC_ID.getValue().toLowerCase(), DOC_ID.getScheme().toLowerCase()));
+ SERVICE_GROUP_ID.getScheme().toLowerCase(), DOC_ID.getValue().toLowerCase(), DOC_ID.getScheme().toLowerCase()));
testInstance.getServiceMetadataDocument(SERVICE_GROUP_ID, DOC_ID);
}
@@ -193,7 +190,7 @@ public class ServiceMetadataIntegrationTest extends AbstractServiceIntegrationTe
@Test
public void updatePositiveScenario() throws IOException, JAXBException, TransformerException {
//given
- byte[] oldServiceMetadataXml = loadDocumentAsByteArray(SERVICE_METADATA_XML_PATH);
+ byte[] oldServiceMetadataXml = loadDocumentAsByteArray(SERVICE_METADATA_XML_PATH);
testInstance.saveServiceMetadata(null, PT_ID, DOC_ID, oldServiceMetadataXml);
ServiceMetadata newServiceMetadata = unmarshal(loadDocumentAsByteArray(SERVICE_METADATA_XML_PATH));
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupServiceUpdateListIntegrationTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupServiceUpdateListIntegrationTest.java
index 61a8c583adf45e8393aba9aab04ae4944f9ba49f..b8b2a7f782b171230f4fad8126a0e8aa198b4838 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupServiceUpdateListIntegrationTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupServiceUpdateListIntegrationTest.java
@@ -27,8 +27,7 @@ import java.io.IOException;
import java.util.List;
import java.util.UUID;
-import static eu.europa.ec.edelivery.smp.testutil.TestConstants.TEST_DOMAIN_CODE_1;
-import static eu.europa.ec.edelivery.smp.testutil.TestConstants.TEST_DOMAIN_CODE_2;
+import static eu.europa.ec.edelivery.smp.testutil.TestConstants.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
@@ -91,7 +90,7 @@ public class UIServiceGroupServiceUpdateListIntegrationTest extends AbstractServ
// given
DBDomain dbDomain1 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
DBDomain dbDomain2 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_2).get();
- ServiceGroupRO serviceGroupRO = TestROUtils.createROServiceGroupForDomains(UUID.randomUUID().toString(), UUID.randomUUID().toString(),
+ ServiceGroupRO serviceGroupRO = TestROUtils.createROServiceGroupForDomains(UUID.randomUUID().toString(), TEST_SG_SCHEMA_1,
dbDomain1, dbDomain2);
// When
List<ParticipantSMLRecord> lst = testInstance.addNewServiceGroup(serviceGroupRO);
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataServiceTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataServiceTest.java
index e8341afead0bc11e0cb89c73648f5ef5d37ea941..d17f81ae8645a9b3377e5a02b296138fa2dda745 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataServiceTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataServiceTest.java
@@ -1,10 +1,6 @@
package eu.europa.ec.edelivery.smp.services.ui;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
import eu.europa.ec.edelivery.smp.conversion.ServiceMetadataConverter;
-import eu.europa.ec.edelivery.smp.data.dao.DomainDao;
-import eu.europa.ec.edelivery.smp.data.dao.ServiceMetadataDao;
-import eu.europa.ec.edelivery.smp.data.dao.UserDao;
import eu.europa.ec.edelivery.smp.data.model.DBServiceMetadata;
import eu.europa.ec.edelivery.smp.data.ui.ServiceMetadataRO;
import eu.europa.ec.edelivery.smp.data.ui.ServiceMetadataValidationRO;
@@ -61,13 +57,13 @@ public class UIServiceMetadataServiceTest extends AbstractServiceIntegrationTest
@Test
public void validateServiceMetadataValid() {
- DBServiceMetadata md = TestDBUtils.createDBServiceMetadata("partId", "partSch");
+ DBServiceMetadata md = TestDBUtils.createDBServiceMetadata("partId", TEST_SG_SCHEMA_1);
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getDocumentIdentifier());
smv.setDocumentIdentifierScheme(md.getDocumentIdentifierScheme());
smv.setParticipantIdentifier("partId");
- smv.setParticipantScheme("partSch");
+ smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
@@ -82,7 +78,7 @@ public class UIServiceMetadataServiceTest extends AbstractServiceIntegrationTest
smv.setDocumentIdentifier(md.getDocumentIdentifier());
smv.setDocumentIdentifierScheme(md.getDocumentIdentifierScheme());
smv.setParticipantIdentifier("partId");
- smv.setParticipantScheme("partSch");
+ smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
@@ -97,7 +93,7 @@ public class UIServiceMetadataServiceTest extends AbstractServiceIntegrationTest
smv.setDocumentIdentifier(md.getDocumentIdentifier());
smv.setDocumentIdentifierScheme(md.getDocumentIdentifierScheme());
smv.setParticipantIdentifier("partId");
- smv.setParticipantScheme("partSch");
+ smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
@@ -108,13 +104,14 @@ public class UIServiceMetadataServiceTest extends AbstractServiceIntegrationTest
@Test
public void validateServiceMetadataParticipantNotMatch() {
- DBServiceMetadata md = TestDBUtils.createDBServiceMetadata("partId", "partSch");
+
+ DBServiceMetadata md = TestDBUtils.createDBServiceMetadata("partId", TEST_SG_SCHEMA_1);
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getDocumentIdentifier());
smv.setDocumentIdentifierScheme(md.getDocumentIdentifierScheme());
smv.setParticipantIdentifier("partIdNotMatch");
- smv.setParticipantScheme("partSch");
+ smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
@@ -123,13 +120,13 @@ public class UIServiceMetadataServiceTest extends AbstractServiceIntegrationTest
@Test
public void validateServiceMetadataDocumentNotMatch() {
- DBServiceMetadata md = TestDBUtils.createDBServiceMetadata("partId", "partSch");
+ DBServiceMetadata md = TestDBUtils.createDBServiceMetadata("partId", TEST_SG_SCHEMA_1);
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getDocumentIdentifierScheme());
smv.setDocumentIdentifierScheme(md.getDocumentIdentifier());
smv.setParticipantIdentifier("partId");
- smv.setParticipantScheme("partSch");
+ smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
@@ -138,13 +135,13 @@ public class UIServiceMetadataServiceTest extends AbstractServiceIntegrationTest
@Test
public void validateServiceMetadataInvalidXML() {
- DBServiceMetadata md = TestDBUtils.createDBServiceMetadata("partId", "partSch");
+ DBServiceMetadata md = TestDBUtils.createDBServiceMetadata("partId", TEST_SG_SCHEMA_1);
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getDocumentIdentifierScheme());
smv.setDocumentIdentifierScheme(md.getDocumentIdentifier());
smv.setParticipantIdentifier("partId");
- smv.setParticipantScheme("partSch");
+ smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()) + "Something to invalidate xml");
smv = testInstance.validateServiceMetadata(smv);
@@ -199,7 +196,7 @@ public class UIServiceMetadataServiceTest extends AbstractServiceIntegrationTest
}
@Test
- public void testValidateServiceMetadataCertificatesNotAllowed() throws IOException, CertificateException {
+ public void testValidateServiceMetadataCertificatesNotAllowed() throws IOException{
ConfigurationService configurationService = Mockito.mock(ConfigurationService.class);
UIServiceMetadataService testInstance = new UIServiceMetadataService(null, null,
null, null,
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/sml/SmlConnectorDomainTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/sml/SmlConnectorDomainTest.java
index 0e99e9a65b20e23f8191e2857f1a5ee6e36e6258..840dafb8491dd39d555c24ef62a765620ac311b5 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/sml/SmlConnectorDomainTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/sml/SmlConnectorDomainTest.java
@@ -14,32 +14,33 @@
package eu.europa.ec.edelivery.smp.sml;
- import eu.europa.ec.bdmsl.ws.soap.BadRequestFault;
- import eu.europa.ec.bdmsl.ws.soap.InternalErrorFault;
- import eu.europa.ec.bdmsl.ws.soap.NotFoundFault;
- import eu.europa.ec.bdmsl.ws.soap.UnauthorizedFault;
- import eu.europa.ec.edelivery.smp.config.SmlIntegrationConfiguration;
- import eu.europa.ec.edelivery.smp.data.model.DBDomain;
- import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
- import eu.europa.ec.edelivery.smp.services.AbstractServiceIntegrationTest;
- import eu.europa.ec.edelivery.smp.services.ConfigurationService;
- import org.junit.Before;
- import org.junit.Rule;
- import org.junit.Test;
- import org.junit.rules.ExpectedException;
- import org.junit.runner.RunWith;
- import org.mockito.Mockito;
- import org.springframework.beans.factory.annotation.Autowired;
- import org.springframework.test.context.ContextConfiguration;
- import org.springframework.test.context.junit4.SpringRunner;
- import org.springframework.test.util.ReflectionTestUtils;
-
- import java.util.UUID;
-
- import static eu.europa.ec.edelivery.smp.sml.SmlConnectorTestConstants.*;
- import static org.junit.Assert.*;
- import static org.mockito.ArgumentMatchers.any;
- import static org.mockito.Mockito.verify;
+import eu.europa.ec.bdmsl.ws.soap.BadRequestFault;
+import eu.europa.ec.bdmsl.ws.soap.InternalErrorFault;
+import eu.europa.ec.bdmsl.ws.soap.NotFoundFault;
+import eu.europa.ec.bdmsl.ws.soap.UnauthorizedFault;
+import eu.europa.ec.edelivery.smp.config.SmlIntegrationConfiguration;
+import eu.europa.ec.edelivery.smp.data.model.DBDomain;
+import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
+import eu.europa.ec.edelivery.smp.services.AbstractServiceIntegrationTest;
+import eu.europa.ec.edelivery.smp.services.ConfigurationService;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.util.UUID;
+
+import static eu.europa.ec.edelivery.smp.sml.SmlConnectorTestConstants.*;
+import static org.junit.Assert.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
/**
* Created by JRC
@@ -67,7 +68,7 @@ public class SmlConnectorDomainTest extends AbstractServiceIntegrationTest {
testInstance = Mockito.spy(testInstance);
// default behaviour
Mockito.doNothing().when(testInstance).configureClient(any(), any(), any());
- ReflectionTestUtils.setField(testInstance,"configurationService",configurationService);
+ ReflectionTestUtils.setField(testInstance, "configurationService", configurationService);
Mockito.doReturn(true).when(configurationService).isSMLIntegrationEnabled();
mockSml.reset();
}
@@ -127,10 +128,9 @@ public class SmlConnectorDomainTest extends AbstractServiceIntegrationTest {
@Test
public void testDomainUnregisterFromDns() throws UnauthorizedFault, NotFoundFault, InternalErrorFault, BadRequestFault {
//when
- boolean result = testInstance.unregisterDomain(DEFAULT_DOMAIN);
+ testInstance.unregisterDomain(DEFAULT_DOMAIN);
//then
- assertTrue(result);
assertEquals(1, mockSml.getSmpManagerClientMocks().size());
verify(mockSml.getSmpManagerClientMocks().get(0)).delete(any());
Mockito.verifyNoMoreInteractions(mockSml.getSmpManagerClientMocks().toArray());
@@ -177,9 +177,8 @@ public class SmlConnectorDomainTest extends AbstractServiceIntegrationTest {
//when
BadRequestFault ex = new BadRequestFault(ERROR_SMP_NOT_EXISTS);
mockSml.setThrowException(ex);
- boolean suc = testInstance.unregisterDomain(DEFAULT_DOMAIN);
- assertTrue(suc);
+ Assertions.assertDoesNotThrow(() -> testInstance.unregisterDomain(DEFAULT_DOMAIN););
}
@Test
@@ -200,7 +199,7 @@ public class SmlConnectorDomainTest extends AbstractServiceIntegrationTest {
@Test
public void testGetSmlClientKeyAliasForDomain() {
- DBDomain domain = new DBDomain();
+ DBDomain domain = new DBDomain();
domain.setSmlClientKeyAlias(UUID.randomUUID().toString());
domain.setSmlClientCertAuth(false);
@@ -212,7 +211,7 @@ public class SmlConnectorDomainTest extends AbstractServiceIntegrationTest {
@Test
public void testGetSmlClientKeyAliasForDomainNulForSingleKey() {
- DBDomain domain = new DBDomain();
+ DBDomain domain = new DBDomain();
domain.setSmlClientKeyAlias(null);
domain.setSmlClientCertAuth(false);
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestConstants.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestConstants.java
index 45cf76ac640e52a64b0cf86188931a02d822da76..4aa78f73e814ea7c4efd516cb20d620daf12c281 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestConstants.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestConstants.java
@@ -2,8 +2,6 @@ package eu.europa.ec.edelivery.smp.testutil;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
-import static eu.europa.ec.smp.api.Identifiers.asParticipantId;
-
public class TestConstants {
public static final String TEST_DOMAIN_CODE_1 = "utestPeppol01";
@@ -52,7 +50,7 @@ public class TestConstants {
public static final String SERVICE_METADATA_XML_PATH = "/examples/services/ServiceMetadataPoland.xml";
public static final String SIGNED_SERVICE_METADATA_XML_PATH = "/examples/services/SignedServiceMetadataPoland.xml";
- public static final ParticipantIdentifierType SERVICE_GROUP_ID = asParticipantId("participant-scheme-qns::urn:eu:ncpb", false);
+ public static final ParticipantIdentifierType SERVICE_GROUP_ID = new ParticipantIdentifierType("urn:eu:ncpb", "participant-scheme-qns");
public static final String ADMIN_USERNAME = "test_admin";
public static final String CERT_USER = "CN=common name,O=org,C=BE:0000000000000066";
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestDBUtils.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestDBUtils.java
index afb35fca9b2bed1bbf48e1da93e1470e4e256f79..bf09181589757fe81cffff4f673a765dc7a93829 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestDBUtils.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestDBUtils.java
@@ -95,7 +95,7 @@ public class TestDBUtils {
}
public static DBServiceGroup createDBServiceGroupRandom() {
- return createDBServiceGroup(UUID.randomUUID().toString(), UUID.randomUUID().toString(), true);
+ return createDBServiceGroup(UUID.randomUUID().toString(), TEST_SG_SCHEMA_1, true);
}
public static DBServiceGroup createDBServiceGroup(String id, String sch, boolean withExtension) {
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/utils/PropertyUtilsTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/utils/PropertyUtilsTest.java
index 8e800808121683a9a8fb73bffcdf00610a748e69..a94f18f2702f049b4bffa985e35530766713c5dd 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/utils/PropertyUtilsTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/utils/PropertyUtilsTest.java
@@ -61,7 +61,7 @@ public class PropertyUtilsTest {
{EXTERNAL_TLS_AUTHENTICATION_CLIENT_CERT_HEADER_ENABLED, "true", Boolean.class},
{EXTERNAL_TLS_AUTHENTICATION_CERTIFICATE_HEADER_ENABLED, "true", Boolean.class},
{OUTPUT_CONTEXT_PATH, "true", Boolean.class},
- {PARTC_SCH_REGEXP, ".*", Pattern.class},
+ {PARTC_SCH_VALIDATION_REGEXP, ".*", Pattern.class},
{CS_PARTICIPANTS, "casesensitive-participant-scheme1|casesensitive-participant-scheme2", List.class},
{CS_DOCUMENTS, "casesensitive-doc-scheme1|casesensitive-doc-scheme2", List.class},
{SML_ENABLED, "true", Boolean.class},
diff --git a/smp-soapui-tests/pom.xml b/smp-soapui-tests/pom.xml
index f98e4ab212ee480150cc646258e01e61230d1e33..f752d49d849887d05f76127bd06c2af30617ca03 100644
--- a/smp-soapui-tests/pom.xml
+++ b/smp-soapui-tests/pom.xml
@@ -32,7 +32,7 @@
<artifactId>soapui-pro-maven-plugin</artifactId>
<version>5.1.2</version>
<configuration>
- <outputFolder>${build.directory}/soapui-reports/</outputFolder>
+ <outputFolder>${project.build.directory}/soapui-reports/</outputFolder>
<junitReport>true</junitReport>
<printReport>true</printReport>
<settingsFile>${basedir}/soapui/soapui-settings.xml</settingsFile>
diff --git a/smp-soapui-tests/soapui/SMP4.0-Generic-soapui-project.xml b/smp-soapui-tests/soapui/SMP4.0-Generic-soapui-project.xml
index 72aebe5b269dd6794c0cf6dc6345f7d8042aacd4..0c1e0346eccfd4c5116de63aa0a8ca5f2573bff5 100644
--- a/smp-soapui-tests/soapui/SMP4.0-Generic-soapui-project.xml
+++ b/smp-soapui-tests/soapui/SMP4.0-Generic-soapui-project.xml
@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
-<con:soapui-project activeEnvironment="Default" name="SMP_TESTS" resourceRoot="" soapui-version="5.6.0" abortOnError="false" runType="SEQUENTIAL" id="8147b356-07e4-4ff9-ade6-4e92e0597a38" xmlns:con="http://eviware.com/soapui/config"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.actions.iface.tools.soapui.ProTestRunnerAction@values-local"><![CDATA[<xml-fragment xmlns:con="http://eviware.com/soapui/config">
+<con:soapui-project activeEnvironment="Default" name="SMP_TESTS" resourceRoot="" soapui-version="5.7.0" abortOnError="false" runType="SEQUENTIAL" id="8147b356-07e4-4ff9-ade6-4e92e0597a38" xmlns:con="http://eviware.com/soapui/config"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.actions.iface.tools.soapui.ProTestRunnerAction@values-local"><![CDATA[<xml-fragment xmlns:con="http://eviware.com/soapui/config">
<con:entry key="Environment" value="Default"/>
<con:entry key="Global Properties" value=""/>
<con:entry key="TestSuite" value="<all>"/>
@@ -116,7 +116,7 @@
</Process>
</ProcessList>
</ServiceInformation>
-</ServiceMetadata>]]></con:request><con:credentials><con:username>user</con:username><con:password>user</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/></con:request></con:method><con:method name="YYYZZZ-47-Delete" method="DELETE" id="cccbd073-0e3d-439b-a747-946a73f5b67c"><con:settings/><con:parameters/><con:representation type="FAULT"><con:mediaType>text/plain</con:mediaType><con:status>403 404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html;charset=utf-8</con:mediaType><con:status>404 500</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="REQUEST"><con:mediaType>application/xml</con:mediaType><con:params/></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=UTF-8</con:mediaType><con:status>500</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:request name="Delete" mediaType="application/xml" id="cfe391c2-9084-45a5-a637-fbbc25a25f27" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:credentials><con:username>user</con:username><con:password>user</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/></con:request></con:method></con:resource><con:resource name="ServiceGroupIDWrongFormat" path="/ehealth-actorid-qns:0088:7770010100777" id="2ff08415-f133-4c23-bf64-91204b94f5c1"><con:settings/><con:parameters/><con:method name="YYYZZZ-54-Get" method="GET" id="36ced4c8-0e92-4686-a5f4-e9c9870b721f"><con:settings/><con:parameters/><con:representation type="RESPONSE"><con:mediaType>application/xml</con:mediaType><con:status>200</con:status><con:params/><con:element xmlns:ns="http://busdox.org/serviceMetadata/publishing/1.0/">ns:ServiceGroup</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/plain</con:mediaType><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html;charset=utf-8</con:mediaType><con:status>404 500</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType>text/xml</con:mediaType><con:status>200</con:status><con:params/><con:element xmlns:ns="http://busdox.org/serviceMetadata/publishing/1.0/">ns:ServiceGroup</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=UTF-8</con:mediaType><con:status>401 500 404</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml</con:mediaType><con:status>404 400</con:status><con:params/></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=utf-8</con:mediaType><con:status>403</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml;charset=UTF-8</con:mediaType><con:status>400</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:request name="Get" mediaType="application/xml" id="a9f15369-89e3-4e53-a448-a9881605a8b0"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://130.206.118.4/cipa-smp-full-webapp/iso6523-actorid-upis::0088:5798000000003</con:originalUri><con:credentials><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/></con:request></con:method><con:method name="YYYZZZ-55-Put" method="PUT" id="951c948c-9ef6-494b-b569-389e1dd323ea"><con:settings/><con:parameters/><con:representation type="REQUEST"><con:mediaType>text/xml</con:mediaType><con:params/><con:element xmlns:ns="http://busdox.org/serviceMetadata/publishing/1.0/">ns:ServiceGroup</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html;charset=utf-8</con:mediaType><con:status>400 403</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/plain</con:mediaType><con:status>403</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=UTF-8</con:mediaType><con:status>401 403 500 400 404</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=utf-8</con:mediaType><con:status>407</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>500</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml</con:mediaType><con:status>500 400</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml;charset=UTF-8</con:mediaType><con:status>400</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:request name="Put" mediaType="text/xml" postQueryString="false" id="e50d78e0-763f-4bfd-aa1c-f4dcc7595a2a"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request><![CDATA[<ServiceGroup xmlns="http://docs.oasis-open.org/bdxr/ns/SMP/2016/05">
+</ServiceMetadata>]]></con:request><con:credentials><con:username>user</con:username><con:password>user</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/></con:request></con:method><con:method name="YYYZZZ-47-Delete" method="DELETE" id="cccbd073-0e3d-439b-a747-946a73f5b67c"><con:settings/><con:parameters/><con:representation type="FAULT"><con:mediaType>text/plain</con:mediaType><con:status>403 404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html;charset=utf-8</con:mediaType><con:status>404 500</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="REQUEST"><con:mediaType>application/xml</con:mediaType><con:params/></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=UTF-8</con:mediaType><con:status>500</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:request name="Delete" mediaType="application/xml" id="cfe391c2-9084-45a5-a637-fbbc25a25f27" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:credentials><con:username>user</con:username><con:password>user</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/></con:request></con:method></con:resource><con:resource name="ServiceGroupIDWrongFormat" path="/ehealth-actorid-qns:0088:7770010100777" id="2ff08415-f133-4c23-bf64-91204b94f5c1"><con:settings/><con:parameters/><con:method name="YYYZZZ-54-Get" method="GET" id="36ced4c8-0e92-4686-a5f4-e9c9870b721f"><con:settings/><con:parameters/><con:representation type="RESPONSE"><con:mediaType>application/xml</con:mediaType><con:status>200</con:status><con:params/><con:element xmlns:ns="http://busdox.org/serviceMetadata/publishing/1.0/">ns:ServiceGroup</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/plain</con:mediaType><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html;charset=utf-8</con:mediaType><con:status>404 500</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType>text/xml</con:mediaType><con:status>200</con:status><con:params/><con:element xmlns:ns="http://busdox.org/serviceMetadata/publishing/1.0/">ns:ServiceGroup</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=UTF-8</con:mediaType><con:status>401 500 404</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml</con:mediaType><con:status>404 400</con:status><con:params/></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=utf-8</con:mediaType><con:status>403</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml;charset=UTF-8</con:mediaType><con:status>400</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:request name="Get" mediaType="application/xml" id="a9f15369-89e3-4e53-a448-a9881605a8b0"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://130.206.118.4/cipa-smp-full-webapp/iso6523-actorid-upis::0088:5798000000003</con:originalUri><con:credentials><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/></con:request></con:method><con:method name="YYYZZZ-55-Put" method="PUT" id="951c948c-9ef6-494b-b569-389e1dd323ea"><con:settings/><con:parameters/><con:representation type="REQUEST"><con:mediaType>text/xml</con:mediaType><con:params/><con:element xmlns:ns="http://busdox.org/serviceMetadata/publishing/1.0/">ns:ServiceGroup</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html;charset=utf-8</con:mediaType><con:status>400 403</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/plain</con:mediaType><con:status>403</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=UTF-8</con:mediaType><con:status>401 403 500 400 404</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>404</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html; charset=utf-8</con:mediaType><con:status>407</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>400</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType xsi:nil="true"/><con:status>500</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml</con:mediaType><con:status>500 400</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml;charset=UTF-8</con:mediaType><con:status>400</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:request name="Put" mediaType="text/xml" postQueryString="false" id="e50d78e0-763f-4bfd-aa1c-f4dcc7595a2a"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request><![CDATA[<ServiceGroup xmlns="http://docs.oasis-open.org/bdxr/ns/SMP/2016/05">
<ParticipantIdentifier scheme="${=request.getProperty('ParticipantIdentifierScheme').getValue()}">${=request.getProperty('ParticipantIdentifier').getValue()}</ParticipantIdentifier>
<ServiceMetadataReferenceCollection/>
<Extension>
@@ -208,13 +208,7 @@
<ExtensionAgencyName>sample string</ExtensionAgencyName>
<ext:nextdummynode xmlns:ext="http://test2.eu">token1</ext:nextdummynode>
</Extension>
-</ServiceGroup>]]></con:request><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
- <con:entry key="ParticipantIdentifierScheme" value="${#Project#defaultParticipantIdentifierScheme}"/>
- <con:entry key="ParticipantIdentifier" value="${#Project#defaultParticipantIdentifier}"/>
-</con:parameters><con:parameterOrder><con:entry>ParticipantIdentifierScheme</con:entry><con:entry>ParticipantIdentifier</con:entry></con:parameterOrder></con:request></con:method><con:method name="DELETE ServiceGroup" id="57d76dab-afb8-4f0e-9a71-3c95150e3ceb" method="DELETE"><con:settings/><con:parameters/><con:representation type="FAULT"><con:mediaType>text/html</con:mediaType><con:status>401</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:representation type="REQUEST"><con:mediaType>text/xml</con:mediaType><con:params/></con:representation><con:representation type="REQUEST"><con:mediaType>application/xml</con:mediaType><con:params/></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml;charset=UTF-8</con:mediaType><con:status>404 401 400</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html;charset=utf-8</con:mediaType><con:status>403</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:request name="Simple Request" id="803032c1-cc3a-49c0-98d8-ac48dc1ebdc5" mediaType="text/xml" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://localhost/smp/ehealth-actorid-qns::0088%3A7770010100777%3Atest</con:originalUri><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
- <con:entry key="ParticipantIdentifierScheme" value="${#Project#defaultParticipantIdentifierScheme}"/>
- <con:entry key="ParticipantIdentifier" value="${#Project#defaultParticipantIdentifier}"/>
-</con:parameters><con:parameterOrder><con:entry>ParticipantIdentifierScheme</con:entry><con:entry>ParticipantIdentifier</con:entry></con:parameterOrder></con:request><con:request name="Simple Request with reference params" id="803032c1-cc3a-49c0-98d8-ac48dc1ebdc5" mediaType="text/xml" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://localhost/smp/ehealth-actorid-qns::0088%3A7770010100777%3Atest</con:originalUri><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
+</ServiceGroup>]]></con:request><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/><con:parameterOrder><con:entry>ParticipantIdentifierScheme</con:entry><con:entry>ParticipantIdentifier</con:entry></con:parameterOrder></con:request></con:method><con:method name="DELETE ServiceGroup" id="57d76dab-afb8-4f0e-9a71-3c95150e3ceb" method="DELETE"><con:settings/><con:parameters/><con:representation type="FAULT"><con:mediaType>text/html</con:mediaType><con:status>401</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:representation type="REQUEST"><con:mediaType>text/xml</con:mediaType><con:params/></con:representation><con:representation type="REQUEST"><con:mediaType>application/xml</con:mediaType><con:params/></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml;charset=UTF-8</con:mediaType><con:status>404 401 400</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/html;charset=utf-8</con:mediaType><con:status>403</con:status><con:params/><con:element>html</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>0</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:representation type="RESPONSE"><con:mediaType xsi:nil="true"/><con:status>200</con:status><con:params/><con:element>data</con:element></con:representation><con:request name="Simple Request" id="803032c1-cc3a-49c0-98d8-ac48dc1ebdc5" mediaType="text/xml" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://localhost/smp/ehealth-actorid-qns::0088%3A7770010100777%3Atest</con:originalUri><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/><con:parameterOrder><con:entry>ParticipantIdentifierScheme</con:entry><con:entry>ParticipantIdentifier</con:entry></con:parameterOrder></con:request><con:request name="Simple Request with reference params" id="803032c1-cc3a-49c0-98d8-ac48dc1ebdc5" mediaType="text/xml" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://localhost/smp/ehealth-actorid-qns::0088%3A7770010100777%3Atest</con:originalUri><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
<con:entry key="ParticipantIdentifierScheme" value="${Put ServiceGroup#ParticipantIdentifierScheme}"/>
<con:entry key="ParticipantIdentifier" value="${Put ServiceGroup#ParticipantIdentifier}"/>
</con:parameters><con:parameterOrder><con:entry>ParticipantIdentifierScheme</con:entry><con:entry>ParticipantIdentifier</con:entry></con:parameterOrder></con:request></con:method></con:resource><con:resource name="NServiceMetadata" path="/{ParticipantIdentifierScheme}::{ParticipantIdentifier}/services/{DocTypeIdentifierScheme}::{DocTypeIdentifier}" id="61682ae6-7d71-468d-ade1-cac863e89a1c"><con:settings/><con:parameters><con:parameter><con:name>ParticipantIdentifierScheme</con:name><con:value>${Put ServiceGroup#ParticipantIdentifierScheme}</con:value><con:style>TEMPLATE</con:style><con:default>${Put ServiceGroup#ParticipantIdentifierScheme}</con:default></con:parameter><con:parameter><con:name>ParticipantIdentifier</con:name><con:value>${Put ServiceGroup#ParticipantIdentifier}</con:value><con:style>TEMPLATE</con:style><con:default>${Put ServiceGroup#ParticipantIdentifier}</con:default></con:parameter><con:parameter><con:name>DocTypeIdentifierScheme</con:name><con:value>${#Project#defaultDocTypeIdentifierScheme}</con:value><con:style>TEMPLATE</con:style><con:default>${#Project#defaultDocTypeIdentifierScheme}</con:default></con:parameter><con:parameter><con:name>DocTypeIdentifier</con:name><con:value>${#Project#defaultDocTypeIdentifier}</con:value><con:style>TEMPLATE</con:style><con:default>${#Project#defaultDocTypeIdentifier}</con:default></con:parameter></con:parameters><con:method name="GET ServiceMetadata" id="57d76dab-afb8-4f0e-9a71-3c95150e3ceb" method="GET"><con:settings/><con:parameters/><con:representation type="RESPONSE"><con:mediaType>text/xml;charset=UTF-8</con:mediaType><con:status>200</con:status><con:params/><con:element xmlns:ns="http://docs.oasis-open.org/bdxr/ns/SMP/2016/05">ns:ServiceGroup</con:element></con:representation><con:representation type="FAULT"><con:mediaType>text/xml;charset=UTF-8</con:mediaType><con:status>404 400</con:status><con:params/><con:element xmlns:ec="ec:services:SMP:1.0">ec:ErrorResponse</con:element></con:representation><con:request name="Simple Request" id="803032c1-cc3a-49c0-98d8-ac48dc1ebdc5" mediaType="application/json"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:credentials><con:authType>No Authorization</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
@@ -1332,8 +1326,8 @@ testRunner.testCase.testSteps['Delete ServiceGroup'].run(testRunner, context);
<ex:Test xmlns:ex="http://test.eu">Test</ex:Test>
</Extension>
</ServiceGroup>]]></con:request><con:originalUri>http://wltdgt02.cc.cec.eu.int/cipa-smp-full-webapp/ehealth-actorid-qns::0088:7770010100777</con:originalUri><con:assertion type="Valid HTTP Status Codes" id="2c5c11d9-018c-4b57-854c-8ae30dab1088" name="Valid HTTP Status Codes"><con:configuration><codes>201</codes></con:configuration></con:assertion><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters><entry key="ParticipantIdentifier" value="${#Project#defaultParticipantIdentifier}:smp017" xmlns="http://eviware.com/soapui/config"/></con:parameters></con:restRequest></con:config></con:testStep><con:testStep type="restrequest" name="TEST1 Delete ServiceGroup" id="7f6b7d43-c490-4cc9-a0cc-1ae359dfa792"><con:settings/><con:config service="SMP" resourcePath="/{ParticipantIdentifierScheme}::{ParticipantIdentifier}" methodName="DELETE ServiceGroup" xsi:type="con:RestRequestStep" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><con:restRequest name="TEST1 Delete ServiceGroup" mediaType="application/xml" id="a97cde56-8e9c-4d6f-b950-faf82b0268e9" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://wltdgt02.cc.cec.eu.int/cipa-smp-full-webapp/ehealth-actorid-notqns::0088:7770010100777</con:originalUri><con:assertion type="Valid HTTP Status Codes" id="4c4a216d-0466-4c22-8bfc-397a1a35182c" name="Valid HTTP Status Codes"><con:configuration><codes>404</codes></con:configuration></con:assertion><con:assertion type="Simple Contains" id="b950b451-c585-470c-ae3b-d0d519dae8d7" name="Contains"><con:configuration><token>NOT_FOUND</token><ignoreCase>false</ignoreCase><useRegEx>false</useRegEx></con:configuration></con:assertion><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
- <con:entry key="ParticipantIdentifierScheme" value="${Put ServiceGroup#ParticipantIdentifierScheme}:different"/>
- <con:entry key="ParticipantIdentifier" value="${Put ServiceGroup#ParticipantIdentifier}"/>
+ <con:entry key="ParticipantIdentifierScheme" value="${Put ServiceGroup#ParticipantIdentifierScheme}"/>
+ <con:entry key="ParticipantIdentifier" value="${Put ServiceGroup#ParticipantIdentifier}:different"/>
</con:parameters></con:restRequest></con:config></con:testStep><con:testStep type="restrequest" name="Get ServiceGroup1" id="9f1fb1b5-e6e9-4734-864d-5a9baf8d9ab8"><con:settings/><con:config service="SMP" resourcePath="/{ParticipantIdentifierScheme}::{ParticipantIdentifier}" methodName="GET ServiceGroup" xsi:type="con:RestRequestStep" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><con:restRequest name="Get ServiceGroup1" mediaType="application/xml" id="a9f15369-89e3-4e53-a448-a9881605a8b0"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://130.206.118.4/cipa-smp-full-webapp/iso6523-actorid-upis::0088:5798000000003</con:originalUri><con:assertion type="Valid HTTP Status Codes" id="bb579212-262c-4380-82df-c81be864bf71" name="Valid HTTP Status Codes"><con:configuration><codes>200</codes></con:configuration></con:assertion><con:credentials><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
<con:entry key="ParticipantIdentifierScheme" value="${Put ServiceGroup#ParticipantIdentifierScheme}"/>
<con:entry key="ParticipantIdentifier" value="${Put ServiceGroup#ParticipantIdentifier}"/>
@@ -3437,7 +3431,7 @@ testRunner.testCase.testSteps['Delete ServiceGroup'].run(testRunner, context);
</ServiceMetadata>]]></con:request><con:originalUri>http://wltdgt02.cc.cec.eu.int/cipa-smp-full-webapp/ehealth-actorid-qns%3A%3A0088%3A7770010100777/services/busdox-docid-qns%3A%3Aurn%3Aoasis%3Anames%3Aspecification%3Aubl%3Aschema%3Axsd%3AInvoice-001%3A%3AInvoice%23%23UBL-2.0</con:originalUri><con:assertion type="Valid HTTP Status Codes" id="9e0a9400-9bb6-42a7-9104-ef7c169997b9" name="Valid HTTP Status Codes"><con:configuration><codes>201</codes></con:configuration></con:assertion><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
<con:entry key="ParticipantIdentifierScheme" value="${Put ServiceGroup#ParticipantIdentifierScheme}"/>
<con:entry key="ParticipantIdentifier" value="${Put ServiceGroup#ParticipantIdentifier}"/>
-</con:parameters></con:restRequest></con:config></con:testStep><con:testStep type="restrequest" name="TEST Delete ServiceMetadata FORMAT_ERROR" id="ee2f4c33-8d90-4b08-8c8c-2a9ed564057b"><con:settings/><con:config service="SMP" resourcePath="/{ParticipantIdentifierScheme}%3A{ParticipantIdentifier}/services/busdox-docid-qns%3Aurn%3Aoasis%3Anames%3Aspecification%3Aubl%3Aschema%3Axsd%3AInvoice-001%3AInvoice%23%23UBL-2.0" methodName="YYYZZZ-59-Delete" xsi:type="con:RestRequestStep" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><con:restRequest name="TEST Delete ServiceMetadata FORMAT_ERROR" mediaType="application/xml" id="cfe391c2-9084-45a5-a637-fbbc25a25f27" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://wltdgt02.cc.cec.eu.int/cipa-smp-full-webapp/ehealth-actorid-qns%3A%3A0088%3A7770010100777/services/busdox-docid-qns%3Aurn%3Aoasis%3Anames%3Aspecification%3Aubl%3Aschema%3Axsd%3AInvoice-001%3AInvoice%23%23UBL-2.0</con:originalUri><con:assertion type="Valid HTTP Status Codes" id="c4033a08-4d2f-4db5-b7d2-dce1419c0401" name="Valid HTTP Status Codes"><con:configuration><codes>400</codes></con:configuration></con:assertion><con:assertion type="Simple Contains" id="abe0bedb-b702-4d19-8624-f62104ed3299" name="Contains"><con:configuration><token>FORMAT_ERROR</token><ignoreCase>false</ignoreCase><useRegEx>false</useRegEx></con:configuration></con:assertion><con:assertion type="Simple Contains" id="48703dfe-9df9-4ae9-854b-96b0dcb6be5e" name="Contains 2"><con:configuration><token>Malformed identifier, scheme and id should be delimited by double colon</token><ignoreCase>false</ignoreCase><useRegEx>false</useRegEx></con:configuration></con:assertion><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
+</con:parameters></con:restRequest></con:config></con:testStep><con:testStep type="restrequest" name="TEST Delete ServiceMetadata FORMAT_ERROR" id="ee2f4c33-8d90-4b08-8c8c-2a9ed564057b"><con:settings/><con:config service="SMP" resourcePath="/{ParticipantIdentifierScheme}%3A{ParticipantIdentifier}/services/busdox-docid-qns%3Aurn%3Aoasis%3Anames%3Aspecification%3Aubl%3Aschema%3Axsd%3AInvoice-001%3AInvoice%23%23UBL-2.0" methodName="YYYZZZ-59-Delete" xsi:type="con:RestRequestStep" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><con:restRequest name="TEST Delete ServiceMetadata FORMAT_ERROR" mediaType="application/xml" id="cfe391c2-9084-45a5-a637-fbbc25a25f27" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://wltdgt02.cc.cec.eu.int/cipa-smp-full-webapp/ehealth-actorid-qns%3A%3A0088%3A7770010100777/services/busdox-docid-qns%3Aurn%3Aoasis%3Anames%3Aspecification%3Aubl%3Aschema%3Axsd%3AInvoice-001%3AInvoice%23%23UBL-2.0</con:originalUri><con:assertion type="Valid HTTP Status Codes" id="c4033a08-4d2f-4db5-b7d2-dce1419c0401" name="Valid HTTP Status Codes"><con:configuration><codes>400</codes></con:configuration></con:assertion><con:assertion type="Simple Contains" id="abe0bedb-b702-4d19-8624-f62104ed3299" name="Contains"><con:configuration><token>FORMAT_ERROR</token><ignoreCase>false</ignoreCase><useRegEx>false</useRegEx></con:configuration></con:assertion><con:assertion type="Simple Contains" id="48703dfe-9df9-4ae9-854b-96b0dcb6be5e" name="Contains 2"><con:configuration><token>Invalid Identifier:</token><ignoreCase>false</ignoreCase><useRegEx>false</useRegEx></con:configuration></con:assertion><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
<con:entry key="ParticipantIdentifierScheme" value=""/>
<con:entry key="ParticipantIdentifier" value=""/>
</con:parameters><con:parameterOrder><con:entry>ParticipantIdentifierScheme</con:entry><con:entry>ParticipantIdentifier</con:entry></con:parameterOrder></con:restRequest></con:config></con:testStep><con:testStep type="restrequest" name="Get ServiceMetadata FORMAT_ERROR" id="5b1270fb-7209-478e-a9ac-d08c51c230d2"><con:settings/><con:config service="SMP" resourcePath="/{ParticipantIdentifierScheme}::{ParticipantIdentifier}/services/{DocTypeIdentifierScheme}::{DocTypeIdentifier}" methodName="GET ServiceMetadata" xsi:type="con:RestRequestStep" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><con:restRequest name="Get ServiceMetadata FORMAT_ERROR" mediaType="application/xml" id="798e6729-3cf8-44b5-8fc7-f19165c82521"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://wltdgt02.cc.cec.eu.int/cipa-smp-full-webapp/ehealth-actorid-qns%3A%3A0088%3A7770010100777/services/busdox-docid-qns%3A%3Aurn%3Aoasis%3Anames%3Aspecification%3Aubl%3Aschema%3Axsd%3AInvoice-001%3A%3AInvoice%23%23UBL-2.0</con:originalUri><con:assertion type="Valid HTTP Status Codes" id="108aac0b-5f2d-4000-8678-31afca1f6816" name="Valid HTTP Status Codes"><con:configuration><codes>200</codes></con:configuration></con:assertion><con:credentials><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/></con:restRequest></con:config></con:testStep><con:testStep type="restrequest" name="Delete ServiceMetadata" id="03fa933f-9f7d-4302-86fc-edb188e88373" disabled="true"><con:settings/><con:config service="SMP" resourcePath="/{ParticipantIdentifierScheme}::{ParticipantIdentifier}/services/{DocTypeIdentifierScheme}::{DocTypeIdentifier}" methodName="DELETE ServiceMetadata" xsi:type="con:RestRequestStep" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><con:restRequest name="Delete ServiceMetadata" mediaType="application/xml" id="cfe391c2-9084-45a5-a637-fbbc25a25f27" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://wltdgt02.cc.cec.eu.int/cipa-smp-full-webapp/ehealth-actorid-qns%3A%3A0088%3A7770010100777/services/busdox-docid-qns%3A%3Aurn%3Aoasis%3Anames%3Aspecification%3Aubl%3Aschema%3Axsd%3AInvoice-001%3A%3AInvoice%23%23UBL-2.0</con:originalUri><con:assertion type="Valid HTTP Status Codes" id="7e8b1492-e2f8-45aa-b293-f460e1662715" name="Valid HTTP Status Codes"><con:configuration><codes>200</codes></con:configuration></con:assertion><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters/></con:restRequest></con:config></con:testStep><con:testStep type="restrequest" name="Delete ServiceGroup" id="dda84879-7c1e-4019-a75b-a1428c5d8a9c" disabled="true"><con:settings/><con:config service="SMP" resourcePath="/{ParticipantIdentifierScheme}::{ParticipantIdentifier}" methodName="DELETE ServiceGroup" xsi:type="con:RestRequestStep" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><con:restRequest name="Delete ServiceGroup" mediaType="application/xml" id="a97cde56-8e9c-4d6f-b950-faf82b0268e9" postQueryString="false"><con:settings><con:setting id="com.eviware.soapui.impl.wsdl.WsdlRequest@request-headers"><xml-fragment/></con:setting></con:settings><con:endpoint>${#Project#url}</con:endpoint><con:request/><con:originalUri>http://wltdgt02.cc.cec.eu.int/cipa-smp-full-webapp/ehealth-actorid-qns::0088:7770010100777</con:originalUri><con:assertion type="Valid HTTP Status Codes" id="030a58c2-0ac3-4d98-9575-e70e57cec7ec" name="Valid HTTP Status Codes"><con:configuration><codes>200</codes></con:configuration></con:assertion><con:credentials><con:username>${#Project#adminSmp1Test}</con:username><con:password>${#Project#adminSmp1TestPassword}</con:password><con:selectedAuthProfile>Basic</con:selectedAuthProfile><con:addedBasicAuthenticationTypes>Basic</con:addedBasicAuthenticationTypes><con:preemptive>true</con:preemptive><con:authType>Preemptive</con:authType></con:credentials><con:jmsConfig JMSDeliveryMode="PERSISTENT"/><con:jmsPropertyConfig/><con:parameters>
diff --git a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/config/properties/SMPIdentifierServicePropertyUpdateListener.java b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/config/properties/SMPIdentifierServicePropertyUpdateListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..19cf498e273df6d33e092464287efdc3e062ff0a
--- /dev/null
+++ b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/config/properties/SMPIdentifierServicePropertyUpdateListener.java
@@ -0,0 +1,58 @@
+package eu.europa.ec.edelivery.smp.config.properties;
+
+import eu.europa.ec.edelivery.smp.config.PropertyUpdateListener;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
+import eu.europa.ec.edelivery.smp.data.ui.enums.SMPPropertyEnum;
+import eu.europa.ec.edelivery.smp.logging.SMPLogger;
+import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+import static eu.europa.ec.edelivery.smp.data.ui.enums.SMPPropertyEnum.*;
+
+/**
+ * Class update mail sender configuration on property update event
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+@Component
+public class SMPIdentifierServicePropertyUpdateListener implements PropertyUpdateListener {
+ private static final SMPLogger LOG = SMPLoggerFactory.getLogger(SMPIdentifierServicePropertyUpdateListener.class);
+
+ IdentifierService identifierService;
+
+ public SMPIdentifierServicePropertyUpdateListener(IdentifierService identifierService) {
+ this.identifierService = identifierService;
+ }
+
+ @Override
+ public void updateProperties(Map<SMPPropertyEnum, Object> properties) {
+ if (identifierService == null) {
+ LOG.warn("No IdentifierService found, Skip IdentifierService configuration!");
+ return;
+ }
+ Boolean partcSchemeMandatory = (Boolean) properties.get(PARTC_SCH_MANDATORY);
+ Pattern partcSchemePattern = (Pattern) properties.get(PARTC_SCH_VALIDATION_REGEXP);
+ List<String> partcCaseSensitiveSchemes = (List<String>) properties.get(CS_PARTICIPANTS);
+ List<String> docCaseSensitiveSchemes = (List<String>) properties.get(CS_DOCUMENTS);
+
+ identifierService.configureParticipantIdentifierFormatter(partcCaseSensitiveSchemes, partcSchemeMandatory, partcSchemePattern);
+ identifierService.configureDocumentIdentifierFormatter(docCaseSensitiveSchemes);
+ }
+
+ @Override
+ public List<SMPPropertyEnum> handledProperties() {
+ return Arrays.asList(
+ PARTC_SCH_SPLIT_REGEXP,
+ PARTC_SCH_VALIDATION_REGEXP,
+ PARTC_SCH_MANDATORY,
+ CS_PARTICIPANTS,
+ CS_DOCUMENTS
+ );
+ }
+}
diff --git a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/ServiceGroupController.java b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/ServiceGroupController.java
index aa924b40453866777d737ae84a892b627f3c893e..e04f62e95e38c1b2361e13b2892877f4bbb3efe0 100644
--- a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/ServiceGroupController.java
+++ b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/ServiceGroupController.java
@@ -13,7 +13,7 @@
package eu.europa.ec.edelivery.smp.controllers;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.conversion.ServiceGroupConverter;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
@@ -59,14 +59,14 @@ public class ServiceGroupController {
protected final SmpUrlBuilder pathBuilder;
protected final ServiceGroupService serviceGroupService;
protected final ServiceMetadataService serviceMetadataService;
- protected final CaseSensitivityNormalizer caseSensitivityNormalizer;
+ protected final IdentifierService caseSensitivityNormalizer;
protected final PayloadValidatorService payloadValidatorService;
public ServiceGroupController(ServiceGroupValidator serviceGroupValidator,
SmpUrlBuilder pathBuilder,
ServiceGroupService serviceGroupService,
ServiceMetadataService serviceMetadataService,
- CaseSensitivityNormalizer caseSensitivityNormalizer,
+ IdentifierService caseSensitivityNormalizer,
PayloadValidatorService payloadValidatorService) {
this.serviceGroupValidator = serviceGroupValidator;
this.pathBuilder = pathBuilder;
@@ -83,7 +83,7 @@ public class ServiceGroupController {
String host = httpReq.getRemoteHost();
LOG.businessInfo(SMPMessageCode.BUS_HTTP_GET_SERVICE_GROUP, host, serviceGroupId);
- ParticipantIdentifierType participantIdentifierType = caseSensitivityNormalizer.normalizeParticipant(serviceGroupId);
+ ParticipantIdentifierType participantIdentifierType = caseSensitivityNormalizer.normalizeParticipantIdentifier(serviceGroupId);
ServiceGroup serviceGroup = serviceGroupService.getServiceGroup(participantIdentifierType);
addReferences(serviceGroup);
@@ -124,7 +124,7 @@ public class ServiceGroupController {
String host = getRemoteHost(httpReq);
LOG.businessInfo(SMPMessageCode.BUS_HTTP_DELETE_SERVICE_GROUP, authentUser, host, serviceGroupId);
- ParticipantIdentifierType participantIdentifierType = caseSensitivityNormalizer.normalizeParticipant(serviceGroupId);
+ ParticipantIdentifierType participantIdentifierType = caseSensitivityNormalizer.normalizeParticipantIdentifier(serviceGroupId);
serviceGroupService.deleteServiceGroup(participantIdentifierType);
LOG.businessInfo(SMPMessageCode.BUS_HTTP_DELETE_END_SERVICE_GROUP, authentUser, host, serviceGroupId);
diff --git a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/ServiceMetadataController.java b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/ServiceMetadataController.java
index e8823d80852b30f5187f3f57c445bca5b5d8b8af..868d368615afc71500d50e19b91d275fa98994f5 100644
--- a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/ServiceMetadataController.java
+++ b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/ServiceMetadataController.java
@@ -13,7 +13,7 @@
package eu.europa.ec.edelivery.smp.controllers;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.conversion.ServiceMetadataConverter;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
@@ -23,6 +23,7 @@ import eu.europa.ec.edelivery.smp.services.ServiceMetadataService;
import eu.europa.ec.edelivery.smp.validation.ServiceMetadataValidator;
import eu.europa.ec.smp.api.exceptions.XmlInvalidAgainstSchemaException;
import org.apache.commons.lang3.StringUtils;
+import org.oasis_open.docs.bdxr.ns.smp._2016._05.DocumentIdentifier;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
@@ -34,56 +35,56 @@ import org.w3c.dom.Document;
import javax.servlet.http.HttpServletRequest;
import javax.xml.transform.TransformerException;
import java.io.ByteArrayInputStream;
-import java.io.UnsupportedEncodingException;
import static eu.europa.ec.edelivery.smp.controllers.WebConstants.HTTP_PARAM_DOMAIN;
-import static eu.europa.ec.smp.api.Identifiers.asDocumentId;
import static org.springframework.http.ResponseEntity.created;
import static org.springframework.http.ResponseEntity.ok;
/**
- * Created by gutowpa on 11/09/2017.
+ * @author gutowpa
+ * @since 3.0.0
*/
@RestController
@RequestMapping("/{serviceGroupId}/services/{serviceMetadataId}")
public class ServiceMetadataController {
- private static final SMPLogger LOG = SMPLoggerFactory.getLogger(ServiceGroupController.class);
+ private static final SMPLogger LOG = SMPLoggerFactory.getLogger(ServiceMetadataController.class);
protected final ServiceMetadataValidator serviceMetadataValidator;
protected final ServiceMetadataService serviceMetadataService;
protected final SmpUrlBuilder pathBuilder;
- protected final CaseSensitivityNormalizer caseSensitivityNormalizer;
+ protected final IdentifierService identifierService;
protected final PayloadValidatorService payloadValidatorService;
public ServiceMetadataController(ServiceMetadataValidator serviceMetadataValidator,
ServiceMetadataService serviceMetadataService,
SmpUrlBuilder pathBuilder,
- CaseSensitivityNormalizer caseSensitivityNormalizer,
+ IdentifierService identifierService,
PayloadValidatorService payloadValidatorService) {
this.serviceMetadataValidator = serviceMetadataValidator;
this.serviceMetadataService = serviceMetadataService;
this.pathBuilder = pathBuilder;
- this.caseSensitivityNormalizer = caseSensitivityNormalizer;
+ this.identifierService = identifierService;
this.payloadValidatorService = payloadValidatorService;
}
@GetMapping(produces = "text/xml; charset=UTF-8")
public String getServiceMetadata(HttpServletRequest httpReq,
@PathVariable String serviceGroupId,
- @PathVariable String serviceMetadataId) throws TransformerException, UnsupportedEncodingException {
+ @PathVariable String serviceMetadataId) throws TransformerException {
String host = httpReq.getRemoteHost();
LOG.businessInfo(SMPMessageCode.BUS_HTTP_GET_SERVICE_METADATA, host, serviceGroupId, serviceMetadataId);
- ParticipantIdentifierType participantIdentifierType = caseSensitivityNormalizer.normalizeParticipant(serviceGroupId);
- Document serviceMetadata = serviceMetadataService.getServiceMetadataDocument(participantIdentifierType, asDocumentId(serviceMetadataId));
+ ParticipantIdentifierType participantIdentifierType = identifierService.normalizeParticipantIdentifier(serviceGroupId);
+ DocumentIdentifier documentIdentifier = identifierService.normalizeDocumentIdentifier(serviceMetadataId);
+
+ Document serviceMetadata = serviceMetadataService.getServiceMetadataDocument(participantIdentifierType, documentIdentifier);
LOG.businessInfo(SMPMessageCode.BUS_HTTP_GET_END_SERVICE_METADATA, host, serviceGroupId, serviceMetadataId);
return ServiceMetadataConverter.toString(serviceMetadata);
}
@PutMapping
- /// @PreAuthorize("hasAnyAuthority(T(eu.europa.ec.edelivery.smp.data.ui.auth.SMPAuthority).S_AUTHORITY_TOKEN_SMP_ADMIN) OR @serviceGroupService.isServiceGroupOwner(authentication.name, #serviceGroupId)")
@PreAuthorize("hasAnyAuthority(T(eu.europa.ec.edelivery.smp.data.ui.auth.SMPAuthority).S_AUTHORITY_TOKEN_SMP_ADMIN, " +
" T(eu.europa.ec.edelivery.smp.data.ui.auth.SMPAuthority).S_AUTHORITY_TOKEN_WS_SMP_ADMIN) " +
" OR @serviceGroupService.isServiceGroupOwner(authentication.name, #serviceGroupId)")
@@ -100,8 +101,10 @@ public class ServiceMetadataController {
payloadValidatorService.validateUploadedContent(new ByteArrayInputStream(body), MimeTypeUtils.APPLICATION_XML_VALUE);
serviceMetadataValidator.validate(serviceGroupId, serviceMetadataId, body);
- ParticipantIdentifierType participantIdentifierType = caseSensitivityNormalizer.normalizeParticipant(serviceGroupId);
- boolean newServiceMetadataCreated = serviceMetadataService.saveServiceMetadata(domain, participantIdentifierType, asDocumentId(serviceMetadataId), body);
+ ParticipantIdentifierType participantIdentifierType = identifierService.normalizeParticipantIdentifier(serviceGroupId);
+ DocumentIdentifier documentIdentifier = identifierService.normalizeDocumentIdentifier(serviceMetadataId);
+
+ boolean newServiceMetadataCreated = serviceMetadataService.saveServiceMetadata(domain, participantIdentifierType, documentIdentifier, body);
LOG.businessInfo(SMPMessageCode.BUS_HTTP_PUT_END_SERVICE_METADATA, authentUser, host, domain, serviceGroupId, serviceMetadataId, newServiceMetadataCreated);
@@ -121,8 +124,9 @@ public class ServiceMetadataController {
String authentUser = SecurityContextHolder.getContext().getAuthentication().getName();
String host = getRemoteHost(httpReq);
LOG.businessInfo(SMPMessageCode.BUS_HTTP_DELETE_SERVICE_METADATA, authentUser, host, domain, serviceGroupId, serviceMetadataId);
- ParticipantIdentifierType participantIdentifierType = caseSensitivityNormalizer.normalizeParticipant(serviceGroupId);
- serviceMetadataService.deleteServiceMetadata(domain, participantIdentifierType, asDocumentId(serviceMetadataId));
+ ParticipantIdentifierType participantIdentifierType = identifierService.normalizeParticipantIdentifier(serviceGroupId);
+ DocumentIdentifier documentIdentifier = identifierService.normalizeDocumentIdentifier(serviceMetadataId);
+ serviceMetadataService.deleteServiceMetadata(domain, participantIdentifierType, documentIdentifier);
LOG.businessInfo(SMPMessageCode.BUS_HTTP_DELETE_END_SERVICE_METADATA, authentUser, host, domain, serviceGroupId, serviceMetadataId);
return ok().build();
diff --git a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/SmpUrlBuilder.java b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/SmpUrlBuilder.java
index 7ea947e29c81143ac949d4a3923f48f7352772b7..a50ca5c107c54cc7fbf44e75a6743cfb1d1cf9c9 100644
--- a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/SmpUrlBuilder.java
+++ b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/controllers/SmpUrlBuilder.java
@@ -13,6 +13,7 @@
package eu.europa.ec.edelivery.smp.controllers;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
import eu.europa.ec.edelivery.smp.services.ConfigurationService;
@@ -20,13 +21,11 @@ import eu.europa.ec.edelivery.smp.utils.HttpForwardedHeaders;
import org.apache.commons.lang3.StringUtils;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.DocumentIdentifier;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
-import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
-import org.springframework.web.server.adapter.ForwardedHeaderTransformer;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
import org.springframework.web.util.UriComponentsBuilder;
import org.springframework.web.util.UrlPathHelper;
@@ -34,8 +33,6 @@ import org.springframework.web.util.UrlPathHelper;
import javax.servlet.http.HttpServletRequest;
import java.net.URI;
-import static eu.europa.ec.smp.api.Identifiers.asUrlEncodedString;
-
/**
* This class provides tools to generate SMP's URL in responses. The client can use provided URL for another call to the SMP.
* Because SMP can run behind the reverse proxy, the X-Forwarded-* headers from the request are used for generating the URL.
@@ -58,12 +55,14 @@ public class SmpUrlBuilder {
private static final String SMP_DOCUMENT_RESOURCE_TEMPLATE = "/{participantId}/services/{docId}";
- @Autowired
- ConfigurationService configurationService;
- @Autowired
- ForwardedHeaderTransformer forwardedHeaderTransformer;
+ private ConfigurationService configurationService;
+ private IdentifierService identifierService;
+ public SmpUrlBuilder(ConfigurationService configurationService, IdentifierService identifierService) {
+ this.configurationService = configurationService;
+ this.identifierService = identifierService;
+ }
public URI getCurrentUri() {
return ServletUriComponentsBuilder.fromCurrentRequestUri().build().toUri();
@@ -73,29 +72,29 @@ public class SmpUrlBuilder {
LOG.debug("Build SMP url for participant identifier: [{}] and document identifier [{}].", participantId, docId);
HttpServletRequest req = getCurrentRequest();
HttpForwardedHeaders fh = new HttpForwardedHeaders(req);
- LOG.debug("Generate response uri with headers data: [{}]" + fh.toString());
+ LOG.debug("Generate response uri with headers data: [{}]", fh);
UriComponentsBuilder uriBuilder = getSMPUrlBuilder();//
- if (fh.getHost()!=null) {
- LOG.debug("Set response uri for forwarded headers: [{}]", fh.toString());
+ if (fh.getHost() != null) {
+ LOG.debug("Set response uri for forwarded headers: [{}]", fh);
uriBuilder = uriBuilder.host(fh.getHost());
String port = fh.getNonDefaultPort();
if (!StringUtils.isBlank(port)) {
uriBuilder = uriBuilder.port(port);
- } else if (!StringUtils.isBlank(fh.getPort())){
- LOG.debug("Set port to null because it is default port: [{}]", fh.toString());
+ } else if (!StringUtils.isBlank(fh.getPort())) {
+ LOG.debug("Set port to null because it is default port: [{}]", fh);
uriBuilder = uriBuilder.port(null);
}
uriBuilder = uriBuilder.scheme(fh.getProto());
} else {
LOG.debug("Ignore settings header because host is null!");
}
+ String urlEncodedFormatParticipant = identifierService.urlEncodedFormatParticipant(participantId);
+ String urlEncodedFormatDocument = identifierService.urlEncodedFormatDocument(docId);
- String path = uriBuilder
+ return uriBuilder
.path(SMP_DOCUMENT_RESOURCE_TEMPLATE)
- .buildAndExpand(asUrlEncodedString(participantId), asUrlEncodedString(docId))
+ .buildAndExpand(urlEncodedFormatParticipant, urlEncodedFormatDocument)
.toUriString();
-
- return path;
}
public String buildSMPUrlForPath(String path) {
diff --git a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/error/ServiceErrorControllerAdvice.java b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/error/ServiceErrorControllerAdvice.java
index a8391b5a7c9ad677cca172ccf4364631e09ebfc7..682130bc3151eccfc1514e3d25eaafff7fa39ab6 100644
--- a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/error/ServiceErrorControllerAdvice.java
+++ b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/error/ServiceErrorControllerAdvice.java
@@ -56,6 +56,11 @@ public class ServiceErrorControllerAdvice extends AbstractErrorControllerAdvice
return buildAndLog(BAD_REQUEST, FORMAT_ERROR, ex.getMessage(), ex);
}
+ @ExceptionHandler(IllegalArgumentException.class)
+ public ResponseEntity handleMalformedIdentifierException(IllegalArgumentException ex) {
+ return buildAndLog(BAD_REQUEST, FORMAT_ERROR, ex.getMessage(), ex);
+ }
+
@ExceptionHandler(WrongInputFieldException.class)
public ResponseEntity handleWrongInputFieldException(WrongInputFieldException ex) {
return buildAndLog(BAD_REQUEST, WRONG_FIELD, ex.getMessage(), ex);
diff --git a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/ui/external/ApplicationResource.java b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/ui/external/ApplicationResource.java
index f4b17af39678478adcfab6e67965722436cd059c..bc01387dfeccb8023015efc881f0b90ef041ddef 100644
--- a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/ui/external/ApplicationResource.java
+++ b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/ui/external/ApplicationResource.java
@@ -69,14 +69,12 @@ public class ApplicationResource {
}
protected String getDisplayVersion() {
- StringBuilder display = new StringBuilder();
- display.append(artifactName);
- display.append(" Version [");
- display.append(artifactVersion);
- display.append("] Build-Time [");
- display.append(buildTime + "|" + TimeZone.getDefault().getDisplayName());
- display.append("]");
- return display.toString();
+ return artifactName +
+ " Version [" +
+ artifactVersion +
+ "] Build-Time [" +
+ buildTime + "|" + TimeZone.getDefault().getDisplayName() +
+ "]";
}
@Secured({SMPAuthority.S_AUTHORITY_TOKEN_SYSTEM_ADMIN, SMPAuthority.S_AUTHORITY_TOKEN_SMP_ADMIN,
@@ -88,7 +86,7 @@ public class ApplicationResource {
info.setSmlParticipantMultiDomainOn(configurationService.isSMLMultiDomainEnabled());
info.setParticipantSchemaRegExp(configurationService.getParticipantIdentifierSchemeRexExpPattern());
info.setParticipantSchemaRegExpMessage(configurationService.getParticipantIdentifierSchemeRexExpMessage());
- info.setConcatEBCorePartyId(configurationService.getForceConcatenateEBCorePartyId());
+ info.setConcatEBCorePartyId(false);
info.setPartyIDSchemeMandatory(configurationService.getParticipantSchemeMandatory());
info.setPasswordValidationRegExp(configurationService.getPasswordPolicyRexExpPattern());
diff --git a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/validation/ServiceGroupValidator.java b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/validation/ServiceGroupValidator.java
index bbde9c3f173614308c2f8e6281a01e49f09e4a41..5eaddb8cfc250a3704715a9a873191ab05037408 100644
--- a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/validation/ServiceGroupValidator.java
+++ b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/validation/ServiceGroupValidator.java
@@ -13,57 +13,48 @@
package eu.europa.ec.edelivery.smp.validation;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.error.exceptions.BadRequestException;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
import eu.europa.ec.edelivery.smp.services.ConfigurationService;
-import eu.europa.ec.smp.api.Identifiers;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ParticipantIdentifierType;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ServiceGroup;
import org.oasis_open.docs.bdxr.ns.smp._2016._05.ServiceMetadataReferenceCollectionType;
import org.springframework.stereotype.Component;
-import java.util.regex.Pattern;
-
import static eu.europa.ec.edelivery.smp.exceptions.ErrorBusinessCode.WRONG_FIELD;
import static org.springframework.util.CollectionUtils.isEmpty;
/**
- * Created by gutowpa on 02/08/2017.
+ * Class provides tools to parse, format and normalize Document and Participant identifiers.
+ *
+ * @author gutowpa
+ * @since 3.0.0
*/
@Component
public class ServiceGroupValidator {
private static final SMPLogger LOG = SMPLoggerFactory.getLogger(ServiceGroupValidator.class);
protected final ConfigurationService configurationService;
- protected final CaseSensitivityNormalizer caseSensitivityNormalizer;
+ protected final IdentifierService identifierService;
public ServiceGroupValidator(ConfigurationService configurationService,
- CaseSensitivityNormalizer caseSensitivityNormalizer) {
+ IdentifierService identifierService) {
this.configurationService = configurationService;
- this.caseSensitivityNormalizer = caseSensitivityNormalizer;
+ this.identifierService = identifierService;
}
public void validate(String serviceGroupId, ServiceGroup serviceGroup) {
- boolean schemeMandatory = configurationService.getParticipantSchemeMandatory();
- LOG.debug("Parse service group [{}] with [{}] scheme", serviceGroupId, (schemeMandatory?"mandatory":"optional"));
+ LOG.debug("Validate URL participant identifier [{}] and XML serviceGroup", serviceGroupId);
- final ParticipantIdentifierType participantId = caseSensitivityNormalizer.normalize(Identifiers.asParticipantId(serviceGroupId, schemeMandatory), schemeMandatory);
- final ParticipantIdentifierType serviceGroupParticipantId = caseSensitivityNormalizer.normalize(
- serviceGroup.getParticipantIdentifier(), schemeMandatory);
+ final ParticipantIdentifierType participantId = identifierService.normalizeParticipantIdentifier(serviceGroupId);
+ final ParticipantIdentifierType serviceGroupParticipantId = identifierService.normalizeParticipant(serviceGroup.getParticipantIdentifier());
if (!participantId.equals(serviceGroupParticipantId)) {
// Business identifier must equal path
- throw new BadRequestException(WRONG_FIELD, "Service Group Ids don't match between URL parameter and XML body");
- }
-
- String scheme = serviceGroupParticipantId.getScheme();
- Pattern schemaPattern = configurationService.getParticipantIdentifierSchemeRexExp();
-
- if (!schemaPattern.matcher(scheme==null?"":scheme).matches()) {
- throw new BadRequestException(WRONG_FIELD, "Service Group scheme does not match allowed pattern: " + schemaPattern.pattern());
+ throw new BadRequestException(WRONG_FIELD, "Participant identifiers don't match between URL parameter [" + serviceGroupId + "] and XML body: [ scheme: '" + serviceGroupParticipantId.getScheme() + "', value: '" + serviceGroupParticipantId.getValue() + "']");
}
ServiceMetadataReferenceCollectionType references = serviceGroup.getServiceMetadataReferenceCollection();
@@ -71,5 +62,4 @@ public class ServiceGroupValidator {
throw new BadRequestException(WRONG_FIELD, "ServiceMetadataReferenceCollection must be empty");
}
}
-
}
diff --git a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/validation/ServiceMetadataValidator.java b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/validation/ServiceMetadataValidator.java
index 8ffd5d076c21ef1963f391dedf4f02ffa2243185..60d6cbd689c8a3b93d4c50f12cf0432da7f0de11 100644
--- a/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/validation/ServiceMetadataValidator.java
+++ b/smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/validation/ServiceMetadataValidator.java
@@ -13,7 +13,7 @@
package eu.europa.ec.edelivery.smp.validation;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.conversion.ServiceMetadataConverter;
import eu.europa.ec.edelivery.smp.error.exceptions.BadRequestException;
import eu.europa.ec.edelivery.smp.services.ConfigurationService;
@@ -28,82 +28,88 @@ import java.util.Date;
import java.util.HashSet;
import java.util.Set;
-import static eu.europa.ec.edelivery.smp.exceptions.ErrorBusinessCode.OUT_OF_RANGE;
-import static eu.europa.ec.edelivery.smp.exceptions.ErrorBusinessCode.WRONG_FIELD;
-import static eu.europa.ec.smp.api.Identifiers.asDocumentId;
-import static eu.europa.ec.smp.api.Identifiers.asString;
+import static eu.europa.ec.edelivery.smp.exceptions.ErrorBusinessCode.*;
/**
- * Created by gutowpa on 11/09/2017.
+ * Simple Service metadata validator
+ *
+ * @author gutowpa
+ * @since 3.0.0.
*/
@Component
public class ServiceMetadataValidator {
- private static final Logger log = LoggerFactory.getLogger(ServiceMetadataValidator.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ServiceMetadataValidator.class);
protected final ConfigurationService configurationService;
- protected final CaseSensitivityNormalizer caseSensitivityNormalizer;
+ protected final IdentifierService identifierService;
public ServiceMetadataValidator(ConfigurationService configurationService,
- CaseSensitivityNormalizer caseSensitivityNormalizer) {
+ IdentifierService caseSensitivityNormalizer) {
this.configurationService = configurationService;
- this.caseSensitivityNormalizer = caseSensitivityNormalizer;
+ this.identifierService = caseSensitivityNormalizer;
}
- public void validate(String serviceGroupIdStr,
- String serviceMetadataIdStr,
+ public void validate(String participantIdentifierFromUrl,
+ String documentIdentifierFromUrl,
byte[] serviceMetadataBody
) throws XmlInvalidAgainstSchemaException {
- ServiceInformationType serviceInformation = validate(serviceGroupIdStr, serviceMetadataBody);
- DocumentIdentifier serviceMetadataId = asDocumentId(serviceMetadataIdStr);
-
- if (serviceInformation != null && !serviceMetadataId.equals(serviceInformation.getDocumentIdentifier())) {
- String errorMessage = String.format("Save service metadata was called with bad Document ID parameters. Message body param: %s URL param: %s",
- asString(serviceInformation.getDocumentIdentifier()),
- asString(serviceMetadataId));
- log.info(errorMessage);
- throw new BadRequestException(WRONG_FIELD, errorMessage);
- }
- }
-
- public ServiceInformationType validate(String serviceGroupIdStr,
- byte[] serviceMetadataBody
- ) throws XmlInvalidAgainstSchemaException {
+ // validate XML serviceMetadata xml against schema
BdxSmpOasisValidator.validateXSD(serviceMetadataBody);
- final ParticipantIdentifierType serviceGroupId = caseSensitivityNormalizer.normalizeParticipant(serviceGroupIdStr);
+ // parse serviceMetadataBody
ServiceMetadata serviceMetadata = ServiceMetadataConverter.unmarshal(serviceMetadataBody);
ServiceInformationType serviceInformation = serviceMetadata.getServiceInformation();
-
if (serviceInformation == null && serviceMetadata.getRedirect() != null) {
- return null;
+ LOG.debug("Redirect serviceMetadata, skip document/participant identifier validation");
+ return;
}
if (serviceInformation == null) {
- String errorMessage = "Missing service information";
- throw new BadRequestException(WRONG_FIELD, errorMessage);
+ throw new BadRequestException(WRONG_FIELD, "Missing service information or redirect");
}
- final ParticipantIdentifierType serviceGroupParticipantId = caseSensitivityNormalizer.normalize(
- serviceInformation.getParticipantIdentifier());
+ ParticipantIdentifierType serviceGroupId = identifierService.normalizeParticipantIdentifier(participantIdentifierFromUrl);
+ DocumentIdentifier documentId = identifierService.normalizeDocumentIdentifier(documentIdentifierFromUrl);
+ validateServiceInformation(serviceGroupId, documentId, serviceInformation);
+ }
- if (!serviceGroupId.equals(serviceGroupParticipantId)) {
- String errorMessage = String.format("Save service metadata was called with bad Participant ID parameters. Message body param: %s URL param: %s",
- asString(serviceInformation.getParticipantIdentifier()),
- asString(serviceGroupId));
- log.info(errorMessage);
+ /**
+ * Validate participant identifier in the serviceMetadata
+ *
+ * @param urlParticipantId
+ * @param urlDocumentId
+ * @param serviceInformation
+ * @return
+ */
+ public ServiceInformationType validateServiceInformation(final ParticipantIdentifierType urlParticipantId,
+ final DocumentIdentifier urlDocumentId,
+ final ServiceInformationType serviceInformation) {
+
+ final ParticipantIdentifierType xmlParticipantId = identifierService.normalizeParticipant(
+ serviceInformation.getParticipantIdentifier());
+ final DocumentIdentifier xmlDocumentId = identifierService.normalizeDocument
+ (serviceInformation.getDocumentIdentifier());
+
+ if (!urlParticipantId.equals(xmlParticipantId)) {
+ String errorMessage = "Save service metadata was called with bad Participant ID parameters. Message body param: ["
+ + identifierToString(xmlParticipantId) + "] URL param: [" + identifierToString(urlParticipantId) + "]";
throw new BadRequestException(WRONG_FIELD, errorMessage);
}
- if (serviceInformation != null) {
- validateServiceInformation(serviceInformation);
+
+ if (!urlDocumentId.equals(xmlDocumentId)) {
+ String errorMessage = "Save service metadata was called with bad Document ID parameters. Message body param: ["
+ + identifierToString(xmlDocumentId) + "] URL param: [" + identifierToString(urlDocumentId) + "]";
+ throw new BadRequestException(WRONG_FIELD, errorMessage);
}
+ validateProcesses(serviceInformation);
return serviceInformation;
}
- private void validateServiceInformation(ServiceInformationType serviceInformation) {
+ private void validateProcesses(ServiceInformationType serviceInformation) {
ProcessListType processList = serviceInformation.getProcessList();
if (processList == null) {
return;
@@ -114,6 +120,18 @@ public class ServiceMetadataValidator {
}
}
+ private String identifierToString(ParticipantIdentifierType identifierType) {
+ return "ParticipantIdentifier: " + (identifierType == null ? "NULL" : identifierToString(identifierType.getScheme(), identifierType.getValue()));
+ }
+
+ private String identifierToString(DocumentIdentifier identifierType) {
+ return "DocumentIdentifier: " + (identifierType == null ? "NULL" : identifierToString(identifierType.getScheme(), identifierType.getValue()));
+ }
+
+ private String identifierToString(String scheme, String value) {
+ return "scheme: '" + scheme + "', value: '" + value + "'";
+ }
+
private void validateProcess(ProcessType process) {
ServiceEndpointList serviceEndpoints = process.getServiceEndpointList();
if (serviceEndpoints == null) {
diff --git a/smp-webapp/src/test/java/eu/europa/ec/edelivery/smp/error/ServiceErrorControllerAdviceTest.java b/smp-webapp/src/test/java/eu/europa/ec/edelivery/smp/error/ServiceErrorControllerAdviceTest.java
index a97d1a6480e188a6cf6475583ae04fa0dec6c7ed..200e3414f50ac3894effa6f4147f5b5ca1329499 100644
--- a/smp-webapp/src/test/java/eu/europa/ec/edelivery/smp/error/ServiceErrorControllerAdviceTest.java
+++ b/smp-webapp/src/test/java/eu/europa/ec/edelivery/smp/error/ServiceErrorControllerAdviceTest.java
@@ -39,7 +39,7 @@ public class ServiceErrorControllerAdviceTest {
@Test
public void handleMalformedIdentifierException() {
- ResponseEntity re = testIntance.handleMalformedIdentifierException(new MalformedIdentifierException("MalformedIdentifierExceptionMessage", null));
+ ResponseEntity re = testIntance.handleMalformedIdentifierException(new MalformedIdentifierException("MalformedIdentifierExceptionMessage", null));
assertEquals(BAD_REQUEST, re.getStatusCode());
assertEquals(ErrorBusinessCode.FORMAT_ERROR.toString(), ((ErrorResponse)re.getBody()).getBusinessCode());
diff --git a/smp-webapp/src/test/java/eu/europa/ec/edelivery/smp/validation/ServiceGroupValidatorTest.java b/smp-webapp/src/test/java/eu/europa/ec/edelivery/smp/validation/ServiceGroupValidatorTest.java
index 109c6aa0b0157aa6f73b5f025e308637b3889262..2ef64a036d34644fe017d899428b6ac0f746a41f 100644
--- a/smp-webapp/src/test/java/eu/europa/ec/edelivery/smp/validation/ServiceGroupValidatorTest.java
+++ b/smp-webapp/src/test/java/eu/europa/ec/edelivery/smp/validation/ServiceGroupValidatorTest.java
@@ -13,8 +13,7 @@
package eu.europa.ec.edelivery.smp.validation;
-import eu.europa.ec.edelivery.smp.conversion.CaseSensitivityNormalizer;
-import eu.europa.ec.edelivery.smp.error.exceptions.BadRequestException;
+import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.services.ConfigurationService;
import eu.europa.ec.smp.api.exceptions.MalformedIdentifierException;
import org.hamcrest.CoreMatchers;
@@ -32,38 +31,35 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.regex.Pattern;
-import static eu.europa.ec.smp.api.Identifiers.asString;
-
/**
* Created by gutowpa on 02/08/2017.
*/
@RunWith(Parameterized.class)
public class ServiceGroupValidatorTest {
- private static final String ALLOWED_SCHEME_REGEXP = "^$|^(?!^.{26})([a-z0-9]+-[a-z0-9]+-[a-z0-9]+)$|^urn:oasis:names:tc:ebcore:partyid-type:(iso6523|unregistered)(:.+)?$";
+ private static final Pattern ALLOWED_SCHEME_PATTERN = Pattern.compile("^$|^(?!^.{26})([a-z0-9]+-[a-z0-9]+-[a-z0-9]+)$|^urn:oasis:names:tc:ebcore:partyid-type:(iso6523|unregistered)(:.+)?$");
private ServiceGroupValidator validator;
ConfigurationService configurationService = Mockito.mock(ConfigurationService.class);
- CaseSensitivityNormalizer normalizer = new CaseSensitivityNormalizer(configurationService);
+ IdentifierService normalizer = new IdentifierService(configurationService);
@Parameterized.Parameters(name = "{index}: {0}")
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][]{
- {"Good peppol schema", "good6-scheme4-ok", "urn:poland:ncpb", false, true, null, null},
- {"Allowed null schema", null, "urn:poland:ncpb", false, false, null, null},
- {"Length exceeded", "ength-exceeeeeedsTheCharacters-25chars", "urn:poland:ncpb", true, true, BadRequestException.class, "Service Group scheme does not match allowed pattern:"},
- {"Too many parts", "too-many-segments-inside", "urn:poland:ncpb", true, true, BadRequestException.class, "Service Group scheme does not match allowed pattern:"},
- {"Missing parts", "only-two", "urn:poland:ncpb", true, true, BadRequestException.class, "Service Group scheme does not match allowed pattern:"},
- {"Null not allowed", null, "urn:poland:ncpb", true, true, MalformedIdentifierException.class, "Malformed identifier, scheme and id should be delimited by double colon"},
- {"EBCorePartyId Oasis", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456", false, true, null, null},
- {"EBCorePartyId eDelivery", null, "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456", false, true, null, null},
+ {"Good peppol schema", "good6-scheme4-ok", "urn:poland:ncpb", false, true, ALLOWED_SCHEME_PATTERN, null, null},
+ {"Allowed null schema", null, "urn:poland:ncpb", false, false, ALLOWED_SCHEME_PATTERN, null, null},
+ {"Length exceeded", "ength-exceeeeeedsTheCharacters-25chars", "urn:poland:ncpb", true, true, ALLOWED_SCHEME_PATTERN, MalformedIdentifierException.class, "Scheme does not match pattern:"},
+ {"Too many parts", "too-many-segments-inside", "urn:poland:ncpb", true, true, ALLOWED_SCHEME_PATTERN, MalformedIdentifierException.class, "Scheme does not match pattern:"},
+ {"Missing parts", "only-two", "urn:poland:ncpb", true, true, ALLOWED_SCHEME_PATTERN, MalformedIdentifierException.class, "Scheme does not match pattern: "},
+ {"Null not allowed", null, "urn:poland:ncpb", true, true, ALLOWED_SCHEME_PATTERN, IllegalArgumentException.class, "Invalid Identifier: "},
+ {"EBCorePartyId Oasis", "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088", "123456", false, true, ALLOWED_SCHEME_PATTERN, null, null},
+ {"EBCorePartyId eDelivery", null, "urn:oasis:names:tc:ebcore:partyid-type:iso6523:0088:123456", false, true, ALLOWED_SCHEME_PATTERN, null, null},
});
}
@Before
public void init() {
- Mockito.doReturn(Pattern.compile(ALLOWED_SCHEME_REGEXP)).when(configurationService).getParticipantIdentifierSchemeRexExp();
validator = new ServiceGroupValidator(configurationService, normalizer);
}
@@ -78,14 +74,16 @@ public class ServiceGroupValidatorTest {
@Parameterized.Parameter(4)
public boolean mandatoryScheme;
@Parameterized.Parameter(5)
- public Class errorClass;
+ public Pattern schemePattern;
@Parameterized.Parameter(6)
+ public Class errorClass;
+ @Parameterized.Parameter(7)
public String errorMessage;
@Test
public void testServiceGroupIdentifier() {
- Mockito.doReturn(mandatoryScheme).when(configurationService).getParticipantSchemeMandatory();
+ normalizer.configureParticipantIdentifierFormatter(null, mandatoryScheme, schemePattern);
validateScheme(schema, value);
}
@@ -95,17 +93,11 @@ public class ServiceGroupValidatorTest {
ParticipantIdentifierType id = new ParticipantIdentifierType(value, scheme);
sg.setParticipantIdentifier(id);
- try {
- validator.validate(asString(id), sg);
- if (expectedThrowError) {
- Assert.fail();
- }
- } catch (RuntimeException exc) {
- if (!expectedThrowError) {
- Assert.fail();
- }
- Assert.assertEquals(errorClass, exc.getClass());
- MatcherAssert.assertThat(exc.getMessage(), CoreMatchers.startsWith(errorMessage));
+ if (expectedThrowError) {
+ Throwable throwable = Assert.assertThrows(errorClass, () -> validator.validate(normalizer.formatParticipant(id), sg));
+ MatcherAssert.assertThat(throwable.getMessage(), CoreMatchers.containsString(errorMessage));
+ } else {
+ validator.validate(normalizer.formatParticipant(id), sg);
}
}