diff --git a/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/DspNegotiationTransformExtension.java b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/DspNegotiationTransformExtension.java new file mode 100644 index 00000000000..dbbb9abf9f6 --- /dev/null +++ b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/DspNegotiationTransformExtension.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2023 Fraunhofer Institute for Software and Systems Engineering + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Fraunhofer Institute for Software and Systems Engineering - initial API and implementation + * + */ + +package org.eclipse.edc.protocol.dsp.negotiation.transform; + +import jakarta.json.Json; +import org.eclipse.edc.jsonld.JsonLdExtension; +import org.eclipse.edc.jsonld.transformer.JsonLdTransformerRegistry; +import org.eclipse.edc.protocol.dsp.negotiation.transform.from.JsonObjectFromContractAgreementRequestTransformer; +import org.eclipse.edc.protocol.dsp.negotiation.transform.from.JsonObjectFromContractNegotiationErrorTransformer; +import org.eclipse.edc.protocol.dsp.negotiation.transform.from.JsonObjectFromContractNegotiationTransformer; +import org.eclipse.edc.protocol.dsp.negotiation.transform.from.JsonObjectFromContractRequestTransformer; +import org.eclipse.edc.runtime.metamodel.annotation.Extension; +import org.eclipse.edc.runtime.metamodel.annotation.Inject; +import org.eclipse.edc.runtime.metamodel.annotation.Provides; +import org.eclipse.edc.spi.system.ServiceExtension; +import org.eclipse.edc.spi.system.ServiceExtensionContext; +import org.eclipse.edc.spi.types.TypeManager; + +import java.util.Map; + +@Extension(value = JsonLdExtension.NAME) +@Provides({JsonLdTransformerRegistry.class}) +public class DspNegotiationTransformExtension implements ServiceExtension { + + public static final String NAME = "Dataspace Protocol Negotiation Transform Extension"; + + @Inject + private TypeManager typeManager; + + @Inject + private JsonLdTransformerRegistry registry; + + @Override + public String name() { + return NAME; + } + + @Override + public void initialize(ServiceExtensionContext context) { + var builderFactory = Json.createBuilderFactory(Map.of()); + + var mapper = typeManager.getMapper("json-ld"); + + registry.register(new JsonObjectFromContractAgreementRequestTransformer(builderFactory)); + registry.register(new JsonObjectFromContractNegotiationTransformer(builderFactory)); + registry.register(new JsonObjectFromContractRequestTransformer(builderFactory, mapper)); + registry.register(new JsonObjectFromContractNegotiationErrorTransformer(builderFactory, mapper)); + } +} diff --git a/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractAgreementRequestTransformer.java b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractAgreementRequestTransformer.java new file mode 100644 index 00000000000..85d0288fd92 --- /dev/null +++ b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractAgreementRequestTransformer.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2023 Fraunhofer Institute for Software and Systems Engineering + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Fraunhofer Institute for Software and Systems Engineering - initial API and implementation + * + */ + +package org.eclipse.edc.protocol.dsp.negotiation.transform.from; + +import jakarta.json.JsonBuilderFactory; +import jakarta.json.JsonObject; +import org.eclipse.edc.connector.contract.spi.types.agreement.ContractAgreement; +import org.eclipse.edc.connector.contract.spi.types.agreement.ContractAgreementRequest; +import org.eclipse.edc.jsonld.JsonLdKeywords; +import org.eclipse.edc.jsonld.transformer.AbstractJsonLdTransformer; +import org.eclipse.edc.transform.spi.TransformerContext; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.UUID; + +import static org.eclipse.edc.protocol.dsp.transform.transformer.Namespaces.DSPACE_SCHEMA; + +/** + * Creates a dspace:ContractAgreementMessage as {@link JsonObject} from {@link ContractAgreementRequest}. + */ +public class JsonObjectFromContractAgreementRequestTransformer extends AbstractJsonLdTransformer { + + private final JsonBuilderFactory jsonFactory; + + public JsonObjectFromContractAgreementRequestTransformer(JsonBuilderFactory jsonFactory) { + super(ContractAgreementRequest.class, JsonObject.class); + this.jsonFactory = jsonFactory; + } + + @Override + public @Nullable JsonObject transform(@Nullable ContractAgreementRequest message, @NotNull TransformerContext context) { + if (message == null) { + return null; + } + + var builder = jsonFactory.createObjectBuilder(); + builder.add(JsonLdKeywords.ID, String.valueOf(UUID.randomUUID())); + builder.add(JsonLdKeywords.TYPE, DSPACE_SCHEMA + "ContractAgreementMessage"); + + builder.add(DSPACE_SCHEMA + "processId", message.getCorrelationId()); + builder.add(DSPACE_SCHEMA + "agreement", transformContractAgreement(message.getContractAgreement(), context)); + + return builder.build(); + } + + private @Nullable JsonObject transformContractAgreement(ContractAgreement agreement, TransformerContext context) { + return context.transform(agreement.getPolicy(), JsonObject.class); + } + +} diff --git a/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractNegotiationErrorTransformer.java b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractNegotiationErrorTransformer.java new file mode 100644 index 00000000000..2d4c9c3fb7f --- /dev/null +++ b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractNegotiationErrorTransformer.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2023 Fraunhofer Institute for Software and Systems Engineering + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Fraunhofer Institute for Software and Systems Engineering - initial API and implementation + * + */ + +package org.eclipse.edc.protocol.dsp.negotiation.transform.from; + +import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.json.JsonArrayBuilder; +import jakarta.json.JsonBuilderFactory; +import jakarta.json.JsonObject; +import org.eclipse.edc.jsonld.JsonLdKeywords; +import org.eclipse.edc.jsonld.transformer.AbstractJsonLdTransformer; +import org.eclipse.edc.protocol.dsp.negotiation.spi.types.NegotiationError; +import org.eclipse.edc.transform.spi.TransformerContext; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.UUID; + +import static org.eclipse.edc.protocol.dsp.transform.transformer.Namespaces.DSPACE_SCHEMA; + +/** + * Creates a {@link JsonObject} from a {@link NegotiationError}. + */ +public class JsonObjectFromContractNegotiationErrorTransformer extends AbstractJsonLdTransformer { + + private final JsonBuilderFactory jsonFactory; + private final ObjectMapper mapper; + + public JsonObjectFromContractNegotiationErrorTransformer(JsonBuilderFactory jsonFactory, ObjectMapper mapper) { + super(NegotiationError.class, JsonObject.class); + this.jsonFactory = jsonFactory; + this.mapper = mapper; + } + + @Override + public @Nullable JsonObject transform(@Nullable NegotiationError error, @NotNull TransformerContext context) { + if (error == null) { + return null; + } + + var builder = jsonFactory.createObjectBuilder(); + builder.add(JsonLdKeywords.ID, String.valueOf(UUID.randomUUID())); + builder.add(JsonLdKeywords.TYPE, DSPACE_SCHEMA + "ContractNegotiationError"); + + var reasons = error.getReasons().stream() + .collect(jsonFactory::createArrayBuilder, JsonArrayBuilder::add, JsonArrayBuilder::add) + .build(); + + builder.add(DSPACE_SCHEMA + "processId", error.getProcessId()); + builder.add(DSPACE_SCHEMA + "code", error.getCode()); + builder.add(DSPACE_SCHEMA + "reason", reasons); + + return builder.build(); + } + +} diff --git a/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractNegotiationTransformer.java b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractNegotiationTransformer.java new file mode 100644 index 00000000000..7dd665644b7 --- /dev/null +++ b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractNegotiationTransformer.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2023 Fraunhofer Institute for Software and Systems Engineering + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Fraunhofer Institute for Software and Systems Engineering - initial API and implementation + * + */ + +package org.eclipse.edc.protocol.dsp.negotiation.transform.from; + +import jakarta.json.JsonBuilderFactory; +import jakarta.json.JsonObject; +import org.eclipse.edc.connector.contract.spi.types.negotiation.ContractNegotiation; +import org.eclipse.edc.connector.contract.spi.types.negotiation.ContractNegotiationStates; +import org.eclipse.edc.jsonld.JsonLdKeywords; +import org.eclipse.edc.jsonld.transformer.AbstractJsonLdTransformer; +import org.eclipse.edc.transform.spi.TransformerContext; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import static org.eclipse.edc.protocol.dsp.transform.transformer.Namespaces.DSPACE_SCHEMA; + +/** + * Creates a {@link JsonObject} from a {@link ContractNegotiation}. + */ +public class JsonObjectFromContractNegotiationTransformer extends AbstractJsonLdTransformer { + + private final JsonBuilderFactory jsonFactory; + + public JsonObjectFromContractNegotiationTransformer(JsonBuilderFactory jsonFactory) { + super(ContractNegotiation.class, JsonObject.class); + this.jsonFactory = jsonFactory; + } + + @Override + public @Nullable JsonObject transform(@Nullable ContractNegotiation negotiation, @NotNull TransformerContext context) { + if (negotiation == null) { + return null; + } + + var builder = jsonFactory.createObjectBuilder(); + builder.add(JsonLdKeywords.ID, negotiation.getId()); + builder.add(JsonLdKeywords.TYPE, DSPACE_SCHEMA + "ContractNegotiation"); + + builder.add(DSPACE_SCHEMA + "correlationId", negotiation.getCorrelationId()); + builder.add(DSPACE_SCHEMA + "state", ContractNegotiationStates.from(negotiation.getState()).name()); + //builder.add(DSPACE_PREFIX + "checksum", negotiation.getChecksum()); TODO + + return builder.build(); + } + +} diff --git a/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractRejectionTransformer.java b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractRejectionTransformer.java new file mode 100644 index 00000000000..73854d9e261 --- /dev/null +++ b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractRejectionTransformer.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2023 Fraunhofer Institute for Software and Systems Engineering + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Fraunhofer Institute for Software and Systems Engineering - initial API and implementation + * + */ + +package org.eclipse.edc.protocol.dsp.negotiation.transform.from; + +import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.json.JsonBuilderFactory; +import jakarta.json.JsonObject; +import org.eclipse.edc.connector.contract.spi.types.negotiation.ContractOfferRequest; +import org.eclipse.edc.connector.contract.spi.types.negotiation.ContractRejection; +import org.eclipse.edc.connector.contract.spi.types.offer.ContractOffer; +import org.eclipse.edc.jsonld.JsonLdKeywords; +import org.eclipse.edc.jsonld.transformer.AbstractJsonLdTransformer; +import org.eclipse.edc.transform.spi.TransformerContext; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.UUID; + +import static org.eclipse.edc.protocol.dsp.transform.transformer.Namespaces.DSPACE_SCHEMA; + +/** + * Creates a {@link JsonObject} from a {@link ContractOfferRequest}. + */ +public class JsonObjectFromContractRejectionTransformer extends AbstractJsonLdTransformer { + + private final JsonBuilderFactory jsonFactory; + private final ObjectMapper mapper; + + public JsonObjectFromContractRejectionTransformer(JsonBuilderFactory jsonFactory, ObjectMapper mapper) { + super(ContractRejection.class, JsonObject.class); + this.jsonFactory = jsonFactory; + this.mapper = mapper; + } + + @Override + public @Nullable JsonObject transform(@Nullable ContractRejection message, @NotNull TransformerContext context) { + if (message == null) { + return null; + } + + var builder = jsonFactory.createObjectBuilder(); + builder.add(JsonLdKeywords.ID, String.valueOf(UUID.randomUUID())); + builder.add(JsonLdKeywords.TYPE, DSPACE_SCHEMA + "ContractRequestMessage"); + + //builder.add(DSPACE_SCHEMA + "dataSet", message.getContractOffer().getAsset().getId()); + builder.add(DSPACE_SCHEMA + "processId", message.getCorrelationId()); + //builder.add(DSPACE_SCHEMA + "offer", transformContractOffer(message.getContractOffer(), context)); + + return builder.build(); + } + + private @Nullable JsonObject transformContractOffer(ContractOffer offer, TransformerContext context) { + return context.transform(offer.getPolicy(), JsonObject.class); + } + +} diff --git a/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractRequestTransformer.java b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractRequestTransformer.java new file mode 100644 index 00000000000..99e896eb72f --- /dev/null +++ b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/from/JsonObjectFromContractRequestTransformer.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2023 Fraunhofer Institute for Software and Systems Engineering + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Fraunhofer Institute for Software and Systems Engineering - initial API and implementation + * + */ + +package org.eclipse.edc.protocol.dsp.negotiation.transform.from; + +import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.json.JsonBuilderFactory; +import jakarta.json.JsonObject; +import org.eclipse.edc.connector.contract.spi.types.negotiation.ContractOfferRequest; +import org.eclipse.edc.connector.contract.spi.types.offer.ContractOffer; +import org.eclipse.edc.jsonld.JsonLdKeywords; +import org.eclipse.edc.jsonld.transformer.AbstractJsonLdTransformer; +import org.eclipse.edc.transform.spi.TransformerContext; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.UUID; + +import static org.eclipse.edc.protocol.dsp.transform.transformer.Namespaces.DSPACE_SCHEMA; + +/** + * Creates a {@link JsonObject} from a {@link ContractOfferRequest}. + */ +public class JsonObjectFromContractRequestTransformer extends AbstractJsonLdTransformer { + + private final JsonBuilderFactory jsonFactory; + private final ObjectMapper mapper; + + public JsonObjectFromContractRequestTransformer(JsonBuilderFactory jsonFactory, ObjectMapper mapper) { + super(ContractOfferRequest.class, JsonObject.class); + this.jsonFactory = jsonFactory; + this.mapper = mapper; + } + + @Override + public @Nullable JsonObject transform(@Nullable ContractOfferRequest message, @NotNull TransformerContext context) { + if (message == null) { + return null; + } + + var builder = jsonFactory.createObjectBuilder(); + builder.add(JsonLdKeywords.ID, String.valueOf(UUID.randomUUID())); + builder.add(JsonLdKeywords.TYPE, DSPACE_SCHEMA + "ContractRequestMessage"); + + builder.add(DSPACE_SCHEMA + "dataSet", message.getContractOffer().getAsset().getId()); + builder.add(DSPACE_SCHEMA + "processId", message.getCorrelationId()); + builder.add(DSPACE_SCHEMA + "offer", transformContractOffer(message.getContractOffer(), context)); + + return builder.build(); + } + + private @Nullable JsonObject transformContractOffer(ContractOffer offer, TransformerContext context) { + return context.transform(offer.getPolicy(), JsonObject.class); + } + +} diff --git a/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/to/JsonObjectToContractNegotiationTransformer.java b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/to/JsonObjectToContractNegotiationTransformer.java new file mode 100644 index 00000000000..1fe0c162055 --- /dev/null +++ b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/to/JsonObjectToContractNegotiationTransformer.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2023 Fraunhofer Institute for Software and Systems Engineering + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Fraunhofer Institute for Software and Systems Engineering - initial API and implementation + * + */ + +package org.eclipse.edc.protocol.dsp.negotiation.transform.to; + +import jakarta.json.JsonObject; +import org.eclipse.edc.connector.contract.spi.types.negotiation.ContractNegotiation; +import org.eclipse.edc.jsonld.transformer.AbstractJsonLdTransformer; +import org.eclipse.edc.transform.spi.TransformerContext; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * Creates a {@link ContractNegotiation} from a {@link JsonObject}. + */ +public class JsonObjectToContractNegotiationTransformer extends AbstractJsonLdTransformer { + + public JsonObjectToContractNegotiationTransformer() { + super(JsonObject.class, ContractNegotiation.class); + } + + @Override + public @Nullable ContractNegotiation transform(@Nullable JsonObject input, @NotNull TransformerContext context) { + if (input == null) { + return null; + } + + return ContractNegotiation.Builder.newInstance().build(); + } + +} diff --git a/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/to/JsonObjectToContractRequestTransformer.java b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/to/JsonObjectToContractRequestTransformer.java new file mode 100644 index 00000000000..078a07aeceb --- /dev/null +++ b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/java/org.eclipse.edc.protocol.dsp.negotiation.transform/to/JsonObjectToContractRequestTransformer.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2023 Fraunhofer Institute for Software and Systems Engineering + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Fraunhofer Institute for Software and Systems Engineering - initial API and implementation + * + */ + +package org.eclipse.edc.protocol.dsp.negotiation.transform.to; + +import jakarta.json.JsonObject; +import org.eclipse.edc.connector.contract.spi.types.negotiation.ContractOfferRequest; +import org.eclipse.edc.jsonld.transformer.AbstractJsonLdTransformer; +import org.eclipse.edc.transform.spi.TransformerContext; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * Creates a {@link ContractOfferRequest} from a {@link JsonObject}. + */ +public class JsonObjectToContractRequestTransformer extends AbstractJsonLdTransformer { + + public JsonObjectToContractRequestTransformer() { + super(JsonObject.class, ContractOfferRequest.class); + } + + @Override + public @Nullable ContractOfferRequest transform(@Nullable JsonObject input, @NotNull TransformerContext context) { + if (input == null) { + return null; + } + + return ContractOfferRequest.Builder.newInstance().build(); + } + +} diff --git a/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/resources/META-INF/services/org.eclipse.edc.spi.system.ServiceExtension b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/resources/META-INF/services/org.eclipse.edc.spi.system.ServiceExtension new file mode 100644 index 00000000000..23d0653ece4 --- /dev/null +++ b/data-protocols/dsp/dsp-negotiation/dsp-negotiation-transform/src/main/resources/META-INF/services/org.eclipse.edc.spi.system.ServiceExtension @@ -0,0 +1,15 @@ +# +# Copyright (c) 2023 Fraunhofer Institute for Software and Systems Engineering +# +# This program and the accompanying materials are made available under the +# terms of the Apache License, Version 2.0 which is available at +# https://www.apache.org/licenses/LICENSE-2.0 +# +# SPDX-License-Identifier: Apache-2.0 +# +# Contributors: +# Fraunhofer Institute for Software and Systems Engineering - Initial API and Implementation +# +# + +org.eclipse.edc.protocol.dsp.negotiation.transform.DspNegotiationTransformExtension \ No newline at end of file