repo stringclasses 1k values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 6 values | commit_sha stringclasses 1k values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/ExampleJavaOneFunction.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/ExampleJavaOneFunction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class ExampleJavaOneFunction implements ODataFunction {
public ExampleJavaOneFunction() {
super();
}
@EdmFunction(name = "", returnType = @ReturnType, hasFunctionImport = true)
public Integer sum(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testaction/Actions.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testaction/Actions.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testaction;
import java.math.BigDecimal;
import jakarta.persistence.EntityManager;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmVisibleFor;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
public class Actions implements ODataAction {
public Actions(final EntityManager em) {
super();
}
@EdmAction(name = "BoundNoImport", isBound = true)
public void boundNoImport(
@EdmParameter(name = "Person") final Person person,
@EdmParameter(name = "A", precision = 34, scale = 10) final BigDecimal a) {
// Do nothing
}
@EdmAction(name = "WithImport", isBound = false)
public void withImport(
@EdmParameter(name = "Person") final Person person,
@EdmParameter(name = "A", precision = 34, scale = 10) final BigDecimal a) {
// Do nothing
}
@EdmAction(name = "ProtectedAction", isBound = false, visibleFor = @EdmVisibleFor("Person"))
public void protectedAction(
@EdmParameter(name = "Person") final Person person,
@EdmParameter(name = "A", precision = 34, scale = 10) final BigDecimal a) {
// Do nothing
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testaction/ActionWithOverload.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testaction/ActionWithOverload.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testaction;
import jakarta.persistence.EntityManager;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.api.JPARequestParameterMap;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.processor.core.testmodel.AdministrativeDivision;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartner;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
public class ActionWithOverload implements ODataAction {
public ActionWithOverload(final EntityManager em, final JPAHttpHeaderMap header,
final JPARequestParameterMap parameter) {
super();
}
@EdmAction(name = "DoSometingFunny", isBound = true)
public void baseAction(@EdmParameter(name = "Binding") final BusinessPartner partner) {
// Not needed
}
@EdmAction(name = "DoSometingFunny", isBound = true)
public void overloadedAction(@EdmParameter(name = "Binding") final Person partner) {
// Not needed
}
@EdmAction(name = "DoSometingFunny", isBound = true)
public void overloadedAction(@EdmParameter(name = "Binding") final AdministrativeDivision partner) {
// Not needed
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testaction/function/Function.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testaction/function/Function.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testaction.function;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
public class Function implements ODataFunction {
@EdmFunction(name = "", returnType = @ReturnType)
public Integer sum(
@EdmParameter(name = "A") short a, @EdmParameter(name = "B") int b) {
return a + b;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaTwoFunctions.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaTwoFunctions.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class ExampleJavaTwoFunctions implements ODataFunction {
public ExampleJavaTwoFunctions() {
super();
}
@EdmFunction(name = "", returnType = @ReturnType)
public Integer multi(@EdmParameter(name = "A") final int a, @EdmParameter(name = "B") final int b) {
return a * b;
}
@EdmFunction(name = "", returnType = @ReturnType)
public Integer divide(@EdmParameter(name = "A") final int a, @EdmParameter(name = "B") final int b) {
return a / b;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ConverterWithConstructorError.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ConverterWithConstructorError.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import jakarta.persistence.AttributeConverter;
public class ConverterWithConstructorError implements AttributeConverter<Enum<?>[], Integer> {
private final int counter;
public ConverterWithConstructorError(final int counter) {
super();
this.counter = counter;
}
@Override
public Integer convertToDatabaseColumn(final Enum<?>[] attribute) {
return null;
}
@Override
public Enum<?>[] convertToEntityAttribute(final Integer dbData) {
return null;
}
public int getCounter() {
return counter;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/EnumWithConverterError.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/EnumWithConverterError.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEnumeration;
@EdmEnumeration(converter = ConverterWithConstructorError.class)
public enum EnumWithConverterError {
TEST, DUMMY;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/TestCollectionInterface.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/TestCollectionInterface.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.io.Serializable;
import java.util.Collection;
public interface TestCollectionInterface extends Serializable, Collection<String> {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongMember.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongMember.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEnumeration;
@EdmEnumeration(isFlags = true, converter = WrongMemberConverter.class)
public enum WrongMember {
Right(1), Wrong(-2);
private final int value;
private WrongMember(final int value) {
this.value = value;
}
public int getValue() {
return value;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaPrivateConstructor.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaPrivateConstructor.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import jakarta.persistence.EntityManager;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class ExampleJavaPrivateConstructor implements ODataFunction, ODataAction {
private ExampleJavaPrivateConstructor(final EntityManager em) {
super();
}
@EdmFunction(name = "", returnType = @ReturnType)
public Integer sum(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
@EdmAction(name = "")
public void mul(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaEmConstructor.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaEmConstructor.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import jakarta.persistence.EntityManager;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class ExampleJavaEmConstructor implements ODataFunction, ODataAction {
public ExampleJavaEmConstructor(final EntityManager em) {
super();
}
@EdmFunction(name = "", returnType = @ReturnType)
public Integer sum(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
@EdmAction(name = "")
public void mul(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaOneAction.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaOneAction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.math.BigDecimal;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
public class ExampleJavaOneAction implements ODataAction {
@EdmAction(isBound = false)
public void unbound(
@EdmParameter(name = "Person") Person person,
@EdmParameter(name = "A", precision = 34, scale = 10) BigDecimal a) {
// Do nothing
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongTypeConverter.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongTypeConverter.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.math.BigDecimal;
import jakarta.persistence.AttributeConverter;
public class WrongTypeConverter implements AttributeConverter<WrongType[], BigDecimal> {
@Override
public BigDecimal convertToDatabaseColumn(final WrongType[] attribute) {
return WrongType.TEST.getValue();
}
@Override
public WrongType[] convertToEntityAttribute(final BigDecimal dbData) {
return new WrongType[] { WrongType.TEST };
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaActions.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaActions.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.olingo.commons.api.edm.geo.Geospatial.Dimension;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmGeospatial;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.processor.core.testmodel.ABCClassification;
import com.sap.olingo.jpa.processor.core.testmodel.AccessRights;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartnerRole;
import com.sap.olingo.jpa.processor.core.testmodel.ChangeInformation;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
import com.sap.olingo.jpa.processor.core.testmodel.PostalAddressData;
public class ExampleJavaActions implements ODataAction {
@EdmAction(name = "")
public Integer unboundWithImport(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
@EdmAction(name = "BoundNoImport", isBound = true)
public void boundNoImport(
@EdmParameter(name = "Person") final Person person,
@EdmParameter(name = "A", precision = 34, scale = 10) final BigDecimal a) {
// Do nothing
}
@EdmAction(name = "", returnType = @ReturnType(isNullable = false, precision = 20, scale = 5))
public BigDecimal unboundReturnFacet(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return new BigDecimal(a).add(new BigDecimal(b));
}
@EdmAction(name = "", isBound = true, entitySetPath = "Person/Roles")
public BusinessPartnerRole boundWithEntitySetPath(
@EdmParameter(name = "Person") final Person person) {
return null;
}
@EdmAction(name = "")
public ChangeInformation returnEmbeddable() {
return new ChangeInformation();
}
@EdmAction(name = "")
public Person returnEntity() {
return new Person();
}
@EdmAction
public ABCClassification returnEnumeration(@EdmParameter(name = "Rights") final AccessRights rights) {
return ABCClassification.B;
}
@EdmAction(name = "", returnType = @ReturnType(type = String.class))
public List<String> returnCollection() {
return new ArrayList<>();
}
@EdmAction(name = "", returnType = @ReturnType(type = ChangeInformation.class))
public List<ChangeInformation> returnEmbeddableCollection() {
return Arrays.asList(new ChangeInformation());
}
@EdmAction(name = "")
public List<String> returnCollectionWithoutReturnType() {
return new ArrayList<>();
}
@EdmAction(name = "",
returnType = @ReturnType(maxLength = 60,
srid = @EdmGeospatial(dimension = Dimension.GEOGRAPHY, srid = "4326")))
public String calculateLocation(
@EdmParameter(name = "String", maxLength = 100,
srid = @EdmGeospatial(dimension = Dimension.GEOGRAPHY, srid = "4326")) final String a) {
return "";
}
@EdmAction(name = "")
public Integer errorNonPrimitiveParameter(
@EdmParameter(name = "A") final PostalAddressData a) {
return 1;
}
@EdmAction(name = "", isBound = true)
public void boundWithOutBindingParameter(
@EdmParameter(name = "A", precision = 34, scale = 10) final BigDecimal a) {
// Do nothing
}
@EdmAction(name = "", isBound = true)
public void boundWithOutParameter() {
// Do nothing
}
@EdmAction(name = "", isBound = true)
public void boundBindingParameterSecondParameter(
@EdmParameter(name = "A", precision = 34, scale = 10) final BigDecimal a,
@EdmParameter(name = "Person") final Person person) {
// Do nothing
}
@EdmAction(name = "", isBound = false, entitySetPath = "Person/Address")
public PostalAddressData errorUnboundWithEntitySetPath(
@EdmParameter(name = "Person") final Person person) {
return null;
}
@EdmAction(name = "", isBound = true, entitySetPath = "Person/Address")
public Integer errorPrimitiveTypeWithEntitySetPath(
@EdmParameter(name = "Person") final Person person) {
return null;
}
@EdmAction(name = "", returnType = @ReturnType())
public void nameEmpty(@EdmParameter(name = "") final AccessRights rights) {
// Do nothing
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/DayOfWeek.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/DayOfWeek.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEnumeration;
@EdmEnumeration
public enum DayOfWeek {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaTwoActions.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaTwoActions.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.math.BigDecimal;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
public class ExampleJavaTwoActions implements ODataAction {
@EdmAction(name = "Test", isBound = false)
public void unbound(
@EdmParameter(name = "Person") Person person,
@EdmParameter(name = "A", precision = 34, scale = 10) BigDecimal a) {
// Do nothing
}
@EdmAction(isBound = true)
public void bound(
@EdmParameter(name = "Person") Person person,
@EdmParameter(name = "A", precision = 34, scale = 10) BigDecimal a) {
// Do nothing
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/FileAccess.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/FileAccess.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEnumeration;
@EdmEnumeration(isFlags = true, converter = FileAccessConverter.class)
public enum FileAccess {
Read((short) 1), Write((short) 2), Create((short) 4), Delete((short) 8);
private short value;
private FileAccess(short value) {
this.setValue(value);
}
public short getValue() {
return value;
}
private void setValue(short value) {
this.value = value;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongFunctionConstructor.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongFunctionConstructor.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import jakarta.persistence.EntityManager;
import com.sap.olingo.jpa.metadata.api.JPAODataQueryContext;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class WrongFunctionConstructor implements ODataFunction {
public WrongFunctionConstructor(final JPAODataQueryContext stmt, final EntityManager em) {
super();
}
@EdmFunction(name = "", returnType = @ReturnType)
public Integer sum(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/FileAccessConverter.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/FileAccessConverter.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import jakarta.persistence.AttributeConverter;
public class FileAccessConverter implements AttributeConverter<FileAccess[], Short> {
@Override
public Short convertToDatabaseColumn(final FileAccess[] attributes) {
return attributes[0].getValue();
}
@Override
public FileAccess[] convertToEntityAttribute(final Short dbData) {
if (dbData == null)
return null;
final List<FileAccess> accesses = new ArrayList<>();
for (final FileAccess e : Arrays.asList(FileAccess.values())) {
if (e.getValue() == dbData)
accesses.add(e);
}
return accesses.toArray(new FileAccess[] {});
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaFunctions.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaFunctions.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.olingo.commons.api.edm.geo.Geospatial.Dimension;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.api.JPARequestParameterMap;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmGeospatial;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmVisibleFor;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
import com.sap.olingo.jpa.processor.core.testmodel.ABCClassification;
import com.sap.olingo.jpa.processor.core.testmodel.AccessRights;
import com.sap.olingo.jpa.processor.core.testmodel.BusinessPartnerRole;
import com.sap.olingo.jpa.processor.core.testmodel.ChangeInformation;
import com.sap.olingo.jpa.processor.core.testmodel.Person;
import com.sap.olingo.jpa.processor.core.testmodel.PostalAddressData;
public class ExampleJavaFunctions implements ODataFunction {
public ExampleJavaFunctions(final JPARequestParameterMap parameterMap, final JPAHttpHeaderMap header) {
super();
}
@EdmFunction(name = "Add", isBound = true, hasFunctionImport = true, returnType = @ReturnType,
visibleFor = @EdmVisibleFor({ "Person", "Company" }))
public Integer sum(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
@EdmFunction(name = "", returnType = @ReturnType,
parameter = {
@EdmParameter(name = "Dummy", parameterName = "A",
type = String.class, maxLength = 10) })
public Integer div(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a / b;
}
@EdmFunction(name = "", returnType = @ReturnType(type = Double.class))
public Integer errorReturnType(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
@EdmFunction(name = "", returnType = @ReturnType(isNullable = false, precision = 9, scale = 3))
public Timestamp now() {
return Timestamp.valueOf(LocalDateTime.now(ZoneId.of("UTC")));
}
@EdmFunction(name = "", returnType = @ReturnType(maxLength = 60, srid = @EdmGeospatial(
dimension = Dimension.GEOGRAPHY, srid = "4326")))
public String determineLocation() {
return "";
}
@EdmFunction(name = "", returnType = @ReturnType(type = String.class))
public List<String> returnCollection() {
return new ArrayList<>();
}
@EdmFunction(name = "", returnType = @ReturnType())
public List<String> returnCollectionWithoutReturnType() {
return new ArrayList<>();
}
@EdmFunction(name = "", returnType = @ReturnType())
public ChangeInformation returnEmbeddable() {
return new ChangeInformation();
}
@EdmFunction(name = "", returnType = @ReturnType(type = ChangeInformation.class))
public List<ChangeInformation> returnEmbeddableCollection() {
return Arrays.asList(new ChangeInformation());
}
@EdmFunction(name = "", returnType = @ReturnType())
public Person returnEntity() {
return new Person();
}
@EdmFunction(name = "", returnType = @ReturnType())
public ExampleJavaOneFunction wrongReturnType() {
return new ExampleJavaOneFunction();
}
@EdmFunction(name = "", returnType = @ReturnType())
public Integer errorNonPrimitiveParameter(
@EdmParameter(name = "A") final PostalAddressData a) {
return 1;
}
@EdmFunction(name = "", returnType = @ReturnType())
public ABCClassification returnEnumerationType(@EdmParameter(name = "Rights") final AccessRights rights) {
return ABCClassification.A;
}
@EdmFunction(name = "", returnType = @ReturnType(type = ABCClassification.class))
public List<ABCClassification> returnEnumerationCollection() {
return new ArrayList<>();
}
@EdmFunction(name = "", isBound = true, entitySetPath = "Person/Roles", returnType = @ReturnType())
public BusinessPartnerRole boundWithEntitySetPath(
@EdmParameter(name = "Person") final Person person) {
return null;
}
@EdmFunction(name = "", returnType = @ReturnType())
public Integer nameEmpty(@EdmParameter(name = "") final AccessRights rights) {
return 0;
}
@EdmFunction(name = "", returnType = @ReturnType(type = Void.class))
public void returnsNothing(@EdmParameter(name = "rights") final AccessRights rights) {
// Do nothing
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaTwoParameterConstructor.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaTwoParameterConstructor.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import jakarta.persistence.EntityManager;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class ExampleJavaTwoParameterConstructor implements ODataFunction, ODataAction {
public ExampleJavaTwoParameterConstructor(final EntityManager em, final Integer a) {
super();
}
@EdmFunction(name = "", returnType = @ReturnType)
public Integer sum(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
@EdmAction(name = "")
public void mul(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ComplexSubTypeError.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ComplexSubTypeError.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import org.apache.olingo.commons.api.edm.geo.Point;
import org.apache.olingo.commons.api.edm.geo.SRID;
public class ComplexSubTypeError extends Point {
public ComplexSubTypeError(final Dimension dimension, final SRID srid) {
super(dimension, srid);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ComplexSubTypeOfIgnore.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ComplexSubTypeOfIgnore.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import com.sap.olingo.jpa.processor.core.testmodel.DummyEmbeddedToIgnore;
public class ComplexSubTypeOfIgnore extends DummyEmbeddedToIgnore {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleFunctionForFilter.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleFunctionForFilter.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.time.LocalDate;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.From;
import com.sap.olingo.jpa.metadata.api.JPAODataQueryContext;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class ExampleFunctionForFilter implements ODataFunction {
private final JPAODataQueryContext stmt;
public ExampleFunctionForFilter(final JPAODataQueryContext stmt) {
super();
this.stmt = stmt;
}
@EdmFunction(returnType = @ReturnType(type = Boolean.class), hasFunctionImport = false, isBound = false)
public Object at(@EdmParameter(name = "date") final LocalDate date) {
final CriteriaBuilder cb = stmt.getCriteriaBuilder();
final From<?, ?> from = stmt.getFrom();
return cb.and(
cb.lessThanOrEqualTo(from.get("validityStartDate"), date),
cb.greaterThanOrEqualTo(from.get("validityEndDate"), date));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongType.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongType.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.math.BigDecimal;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEnumeration;
@EdmEnumeration(converter = WrongTypeConverter.class)
public enum WrongType {
TEST(BigDecimal.valueOf(2L));
private BigDecimal value;
private WrongType(BigDecimal value) {
this.value = value;
}
public BigDecimal getValue() {
return value;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongMemberConverter.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/WrongMemberConverter.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import jakarta.persistence.AttributeConverter;
public class WrongMemberConverter implements AttributeConverter<WrongMember[], Integer> {
@Override
public Integer convertToDatabaseColumn(final WrongMember[] attributes) {
return attributes[0].getValue();
}
@Override
public WrongMember[] convertToEntityAttribute(final Integer dbData) {
if (dbData == null)
return null;
final List<WrongMember> accesses = new ArrayList<>();
for (final WrongMember e : Arrays.asList(WrongMember.values())) {
if (e.getValue() == dbData)
accesses.add(e);
}
return accesses.toArray(new WrongMember[] {});
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/TestActionCollection.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/TestActionCollection.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAction;
public interface TestActionCollection extends TestCollectionInterface, JPAAction {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaOneFunction.java | jpa/odata-jpa-metadata/src/test/java/com/sap/olingo/jpa/metadata/core/edm/mapper/testobjects/ExampleJavaOneFunction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.testobjects;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
public class ExampleJavaOneFunction implements ODataFunction {
public ExampleJavaOneFunction() {
super();
}
@EdmFunction(returnType = @ReturnType, hasFunctionImport = true)
public Integer sum(
@EdmParameter(name = "A") final short a, @EdmParameter(name = "B") final int b) {
return a + b;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAHttpHeaderMap.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAHttpHeaderMap.java | package com.sap.olingo.jpa.metadata.api;
import java.util.List;
import java.util.Map;
/**
*
* @author Oliver Grande
* @since 1.0.3
* 20.05.2021
*/
public interface JPAHttpHeaderMap extends Map<String, List<String>> {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAJoinColumn.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAJoinColumn.java | /**
*
*/
package com.sap.olingo.jpa.metadata.api;
/**
* @author Oliver Grande
* Created: 02.02.2020
*
*/
public interface JPAJoinColumn {
/**
* Returns the name of the column of the target table. This can be different from the name given in the @JoinColumn
* annotation.
* @return
*/
String getReferencedColumnName();
/**
* Returns the name of the column of the source table. This can be different from the name given in the @JoinColumn
* annotation.
* @return
*/
String getName();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAEdmProvider.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAEdmProvider.java | package com.sap.olingo.jpa.metadata.api;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import javax.annotation.Nonnull;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.metamodel.Metamodel;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.provider.CsdlAbstractEdmProvider;
import org.apache.olingo.commons.api.edm.provider.CsdlAction;
import org.apache.olingo.commons.api.edm.provider.CsdlActionImport;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotations;
import org.apache.olingo.commons.api.edm.provider.CsdlComplexType;
import org.apache.olingo.commons.api.edm.provider.CsdlEntityContainer;
import org.apache.olingo.commons.api.edm.provider.CsdlEntityContainerInfo;
import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet;
import org.apache.olingo.commons.api.edm.provider.CsdlEntityType;
import org.apache.olingo.commons.api.edm.provider.CsdlEnumType;
import org.apache.olingo.commons.api.edm.provider.CsdlFunction;
import org.apache.olingo.commons.api.edm.provider.CsdlFunctionImport;
import org.apache.olingo.commons.api.edm.provider.CsdlSchema;
import org.apache.olingo.commons.api.edm.provider.CsdlSingleton;
import org.apache.olingo.commons.api.edm.provider.CsdlTerm;
import org.apache.olingo.commons.api.edm.provider.CsdlTypeDefinition;
import org.apache.olingo.commons.api.edmx.EdmxReference;
import org.apache.olingo.commons.api.ex.ODataException;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.AnnotationProvider;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPADefaultEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocumentFactory;
public class JPAEdmProvider extends CsdlAbstractEdmProvider {
private final JPAEdmNameBuilder nameBuilder;
private final JPAServiceDocument serviceDocument;
private final List<String> userGroups;
// http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406397930
public JPAEdmProvider(@Nonnull final String namespace, @Nonnull final EntityManagerFactory emf,
final JPAEdmMetadataPostProcessor postProcessor, final String[] packageName) throws ODataException {
this(namespace, Objects.requireNonNull(emf.getMetamodel()), postProcessor, packageName, Collections.emptyList());
}
public JPAEdmProvider(@Nonnull final String namespace, final EntityManagerFactory emf,
final JPAEdmMetadataPostProcessor postProcessor, final String[] packageName,
final List<AnnotationProvider> annotationProvider) throws ODataException {
this(namespace, Objects.requireNonNull(emf.getMetamodel()), postProcessor, packageName, annotationProvider);
}
public JPAEdmProvider(@Nonnull final String namespace, final Metamodel jpaMetamodel,
final JPAEdmMetadataPostProcessor postProcessor, final String[] packageName,
final List<AnnotationProvider> annotationProvider) throws ODataException {
this(jpaMetamodel, postProcessor, packageName, new JPADefaultEdmNameBuilder(namespace), annotationProvider);
}
public JPAEdmProvider(final Metamodel jpaMetamodel, final JPAEdmMetadataPostProcessor postProcessor,
final String[] packageName, final JPAEdmNameBuilder nameBuilder,
final List<AnnotationProvider> annotationProvider) throws ODataException {
super();
this.nameBuilder = nameBuilder;
// After this call either a schema exists or an exception has been thrown
this.serviceDocument = new JPAServiceDocumentFactory().getServiceDocument(nameBuilder, jpaMetamodel, postProcessor,
packageName, annotationProvider);
this.userGroups = List.of();
}
private JPAEdmProvider(JPAEdmProvider source, List<String> userGroups) throws ODataJPAModelException {
this.nameBuilder = source.nameBuilder;
this.serviceDocument = new JPAServiceDocumentFactory().asUserGroupRestricted(source.serviceDocument, userGroups);
this.userGroups = userGroups;
}
public JPAEdmProvider asUserGroupRestricted(List<String> userGroups) {
try {
return new JPAEdmProvider(this, userGroups);
} catch (ODataJPAModelException e) {
throw new ODataJPAModelCopyException("Could not create restricted metadata", e);
}
}
List<String> getUserGroups() {
return userGroups;
}
/**
* This method should return a {@link CsdlComplexType} or <b>null</b> if nothing is found.
*
* @param complexTypeName full qualified name of complex type
* @return for the given name
* @throws ODataException
*/
@Override
public CsdlComplexType getComplexType(final FullQualifiedName complexTypeName) throws ODataException {
for (final CsdlSchema schema : serviceDocument.getAllSchemas()) {
if (schema.getNamespace().equals(complexTypeName.getNamespace())
|| (schema.getAlias() != null && schema.getAlias().equals(complexTypeName.getNamespace()))) {
return schema.getComplexType(complexTypeName.getName());
}
}
return null;
}
/**
* Returns the entity container of this edm
* @return of this edm
* @throws ODataException
*/
@Override
public CsdlEntityContainer getEntityContainer() throws ODataException {
return serviceDocument.getEdmEntityContainer();
}
/**
* This method should return an {@link CsdlEntityContainerInfo} or <b>null</b> if nothing is found
*
* @param entityContainerName (null for default container)
* @return for the given name
* @throws ODataException
*/
@Override
public CsdlEntityContainerInfo getEntityContainerInfo(final FullQualifiedName entityContainerName)
throws ODataException {
// This method is invoked when displaying the Service Document at e.g.: .../DemoService.svc
if (entityContainerName == null
|| entityContainerName.equals(buildFQN(nameBuilder.buildContainerName()))) {
final CsdlEntityContainerInfo entityContainerInfo = new CsdlEntityContainerInfo();
entityContainerInfo.setContainerName(buildFQN(nameBuilder.buildContainerName()));
return entityContainerInfo;
}
return null;
}
/**
* This method should return an {@link CsdlEntitySet} or <b>null</b> if nothing is found
*
* @param entityContainer this EntitySet is contained in
* @param entitySetName name of entity set
* @return for the given container and entity set name
* @throws ODataException
*/
@Override
public CsdlEntitySet getEntitySet(final FullQualifiedName entityContainerFQN, final String entitySetName)
throws ODataException {
final CsdlEntityContainer container = serviceDocument.getEdmEntityContainer();
if (entityContainerFQN.equals(buildFQN(container.getName()))) {
return container.getEntitySet(entitySetName);
}
return null;
}
@Override
public CsdlSingleton getSingleton(final FullQualifiedName entityContainerFQN, final String singletonName)
throws ODataException {
final CsdlEntityContainer container = serviceDocument.getEdmEntityContainer();
if (entityContainerFQN.equals(buildFQN(container.getName()))) {
return container.getSingleton(singletonName);
}
return null;
}
/**
* This method should return an {@link CsdlEntityType} or <b>null</b> if nothing is found
*
* @param entityTypeName full qualified name of entity type
* @return for the given name
* @throws ODataException
*/
@Override
public CsdlEntityType getEntityType(final FullQualifiedName entityTypeName) throws ODataException {
for (final CsdlSchema schema : serviceDocument.getEdmSchemas()) {
if (schema.getNamespace().equals(entityTypeName.getNamespace())) {
return schema.getEntityType(entityTypeName.getName());
}
}
return null;
}
/**
* This method should return a {@link CsdlFunctionImport} or <b>null</b> if nothing is found
*
* @param entityContainer this FunctionImport is contained in
* @param functionImportName name of function import
* @return for the given container name and function import name
* @throws ODataException
*/
@Override
public CsdlFunctionImport getFunctionImport(final FullQualifiedName entityContainerFQN,
final String functionImportName) throws ODataException {
final CsdlEntityContainer container = serviceDocument.getEdmEntityContainer();
if (entityContainerFQN.equals(buildFQN(container.getName()))) {
return container.getFunctionImport(functionImportName);
}
return null;
}
/**
* This method should return a list of all {@link CsdlFunction} for the FullQualifiedName or <b>null</b> if nothing is
* found
*
* @param functionName full qualified name of function
* @return List of or null
* @throws ODataException
*/
@Override
public List<CsdlFunction> getFunctions(final FullQualifiedName functionName) throws ODataException {
for (final CsdlSchema schema : serviceDocument.getEdmSchemas()) {
if (schema.getNamespace().equals(functionName.getNamespace())) {
final List<CsdlFunction> functions = schema.getFunctions(functionName.getName());
return functions.isEmpty() ? null : functions;
}
}
return null; // NOSONAR see documentation
}
/**
* This method should return a list of all {@link CsdlAction} for the FullQualifiedName
* or <b>null</b> if nothing is found
*
* @param actionName full qualified name of action
* @return List of
* or null
* @throws ODataException
*/
@Override
public List<CsdlAction> getActions(final FullQualifiedName actionName) throws ODataException {
for (final CsdlSchema schema : serviceDocument.getEdmSchemas()) {
if (schema.getNamespace().equals(actionName.getNamespace())) {
return schema.getActions(actionName.getName());
}
}
return null; // NOSONAR see documentation
}
/**
* This method should return an {@link CsdlActionImport} or <b>null</b> if nothing is found
*
* @param entityContainer this ActionImport is contained in
* @param actionImportName name of action import
* @return for the given container and ActionImport name
* @throws ODataException
*/
@Override
public CsdlActionImport getActionImport(final FullQualifiedName entityContainerFQN, final String actionImportName)
throws ODataException {
final CsdlEntityContainer container = serviceDocument.getEdmEntityContainer();
if (entityContainerFQN.equals(buildFQN(container.getName()))) {
return container.getActionImport(actionImportName);
}
return null;
}
/**
* This method should return an {@link CsdlEnumType} or <b>null</b> if nothing is found
*
* @param enumTypeName full qualified name of enum type
* @return for given name
* @throws ODataException
*/
@Override
public CsdlEnumType getEnumType(final FullQualifiedName enumTypeNameFQN) throws ODataException {
for (final CsdlSchema schema : serviceDocument.getEdmSchemas()) {
if (schema.getNamespace().equals(enumTypeNameFQN.getNamespace())) {
return schema.getEnumType(enumTypeNameFQN.getName());
}
}
return null;
}
/**
* Gets annotations group.
*
* @param targetName full qualified name of target
* @param qualifier for the given target. Might be null.
* @return group for the given Target
* @throws ODataException
*/
@Override
public CsdlAnnotations getAnnotationsGroup(final FullQualifiedName targetName, final String qualifier)
throws ODataException {
return null;
}
/**
* This method should return a {@link CsdlTerm} for the FullQualifiedName or <b>null</b> if nothing is found.
* @param termName the name of the Term
* @return or null
* @throws ODataException
*/
@Override
public CsdlTerm getTerm(final FullQualifiedName termName) throws ODataException {
return serviceDocument.getTerm(termName);
}
/**
* This method should return an {@link CsdlTypeDefinition} or <b>null</b> if nothing is found
*
* @param typeDefinitionName full qualified name of type definition
* @return for given name
* @throws ODataException
*/
@Override
public CsdlTypeDefinition getTypeDefinition(final FullQualifiedName typeDefinitionName) throws ODataException {
for (final CsdlSchema schema : serviceDocument.getAllSchemas()) {
if (schema.getNamespace().equals(typeDefinitionName.getNamespace())) {
return schema.getTypeDefinition(typeDefinitionName.getName());
}
}
return null;
}
/**
* This method should return a collection of all {@link CsdlSchema}
*
* @return List of
* @throws ODataException
*/
@Override
public List<CsdlSchema> getSchemas() throws ODataException {
return serviceDocument.getEdmSchemas();
}
public @Nonnull JPAServiceDocument getServiceDocument() {
return serviceDocument;
}
public void setRequestLocales(final Enumeration<Locale> locales) {
ODataJPAException.setLocales(locales);
}
public List<EdmxReference> getReferences() {
return serviceDocument.getReferences();
}
public JPAEdmNameBuilder getEdmNameBuilder() {
return nameBuilder;
}
protected final FullQualifiedName buildFQN(final String name) {
return new FullQualifiedName(nameBuilder.getNamespace(), name);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAEdmMetadataPostProcessor.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAEdmMetadataPostProcessor.java | package com.sap.olingo.jpa.metadata.api;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateEntityContainerAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateEntitySetAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateEntityTypeAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateNavigationPropertyAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediatePropertyAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateReferenceList;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateSingletonAccess;
public interface JPAEdmMetadataPostProcessor {
public default void processEntityContainer(final IntermediateEntityContainerAccess container) {}
public default void processEntityType(final IntermediateEntityTypeAccess entityType) {}
public default void processEntitySet(final IntermediateEntitySetAccess entitySet) {}
public default void processSingleton(final IntermediateSingletonAccess singleton) {}
public default void processNavigationProperty(final IntermediateNavigationPropertyAccess property,
final String jpaManagedTypeClassName) {}
/**
*
* @param property
* @param jpaManagedTypeClassName
* @return
*/
public default void processProperty(final IntermediatePropertyAccess property,
final String jpaManagedTypeClassName) {}
/**
* Option to provide references to external CSDL documents. The document must be an XML document
* @param references List of references to external CSDL documents.
* @throws ODataJPAModelException
*/
public default void provideReferences(final IntermediateReferenceList references) throws ODataJPAModelException {}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAApiVersionBuilder.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAApiVersionBuilder.java | package com.sap.olingo.jpa.metadata.api;
import javax.annotation.Nonnull;
import jakarta.persistence.EntityManagerFactory;
import com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAApiVersionProvider.Builder;
public interface JPAApiVersionBuilder {
public Builder setId(@Nonnull final String id);
/**
* Set an externally created entity manager factory.<br>
* This is necessary e.g. in case a spring based service shall run without a <code>persistance.xml</code>.
* @param emf
* @return
*/
public Builder setEntityManagerFactory(@Nonnull final EntityManagerFactory emf);
/**
* Name of the top level package to look for
* <ul>
* <li>Enumeration Types
* <li>Java class based Functions
* </ul>
* @param packageName
*/
public Builder setTypePackage(final String... rootPackages);
public Builder setRequestMappingPath(final String mappingPath);
public Builder setMetadataPostProcessor(final JPAEdmMetadataPostProcessor metadataPostProcessor);
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/ODataJPAModelCopyException.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/ODataJPAModelCopyException.java | package com.sap.olingo.jpa.metadata.api;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
public class ODataJPAModelCopyException extends RuntimeException {
private static final long serialVersionUID = -1695284009828517502L;
public ODataJPAModelCopyException(final String message, final ODataJPAModelException exception) {
super(message, exception);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAODataQueryContext.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAODataQueryContext.java | package com.sap.olingo.jpa.metadata.api;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.From;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
public interface JPAODataQueryContext {
CriteriaBuilder getCriteriaBuilder();
<X, Y> From<X, Y> getFrom();
JPAEntityType getEntityType();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPARequestParameterMap.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPARequestParameterMap.java | package com.sap.olingo.jpa.metadata.api;
import java.util.Map;
/**
*
* @author Oliver Grande
* @since 1.0.3
* 20.05.2021
*/
public interface JPARequestParameterMap extends Map<String, Object> {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAEntityManagerFactory.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAEntityManagerFactory.java | package com.sap.olingo.jpa.metadata.api;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;
public class JPAEntityManagerFactory {
private static final String ENTITY_MANAGER_DATA_SOURCE = "jakarta.persistence.nonJtaDataSource";
private static Map<String, Map<Integer, EntityManagerFactory>> emfMap;
private JPAEntityManagerFactory() {
throw new IllegalStateException("JPAEntityManagerFactory class");
}
public static EntityManagerFactory getEntityManagerFactory(final String pUnit, final Map<String, Object> ds) {
if (pUnit == null) {
return null;
}
if (emfMap == null) {
emfMap = new HashMap<>();
}
final Integer dsKey = ds.hashCode();
if (emfMap.containsKey(pUnit)) {
final Map<Integer, EntityManagerFactory> dsMap = emfMap.get(pUnit);
EntityManagerFactory emf = dsMap.get(dsKey);
if (emf != null) {
return emf;
}
emf = Persistence.createEntityManagerFactory(pUnit, ds);
dsMap.put(dsKey, emf);
return emf;
} else {
final Map<Integer, EntityManagerFactory> dsMap = new HashMap<>();
emfMap.put(pUnit, dsMap);
final EntityManagerFactory emf = Persistence.createEntityManagerFactory(pUnit, ds);
dsMap.put(dsKey, emf);
return emf;
}
}
public static EntityManagerFactory getEntityManagerFactory(final String pUnit, final DataSource ds) {
final Map<String, Object> properties = new HashMap<>();
properties.put(ENTITY_MANAGER_DATA_SOURCE, ds);
return getEntityManagerFactory(pUnit, properties);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAApiVersion.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/api/JPAApiVersion.java | package com.sap.olingo.jpa.metadata.api;
import javax.annotation.Nonnull;
import jakarta.persistence.EntityManagerFactory;
import com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAApiVersionProvider.Builder;
public interface JPAApiVersion {
public static JPAApiVersionBuilder with() {
return new Builder();
}
public String getId();
public EntityManagerFactory getEntityManagerFactory();
public @Nonnull String[] getPackageNames();
public String getRequestMappingPath();
public JPAEdmMetadataPostProcessor getMetadataPostProcessor();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateReferenceList.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateReferenceList.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
import java.net.URI;
import java.nio.charset.Charset;
import javax.annotation.Nonnull;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ReferenceAccess;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ReferenceList;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
/**
* A IntermediateReferenceList collects all references to external CSDL documents. The document must be an XML
* document.<br>
* See also: <a
* href=
* "https://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752504">Common
* Schema Definition Language (CSDL) 3.3 Element edmx:Reference</a>
* @author Oliver Grande
*/
public interface IntermediateReferenceList extends ReferenceList {
/**
* Loads a referenced external CSDL document from the provided uri. The document has to be a XML document.<br>
* The method is mainly for prototyping and testing, move of content as it is usually not wanted in productive code
* that the used
* content changes during runtime or on a restart.
* @param uri A uniquely identifier of a referenced document, so two references MUST NOT specify the same URI. E.g.
* "http://docs.oasis-open.org/odata/odata/v4.0/os/vocabularies/Org.OData.Core.V1.xml"
* @return
* @throws ODataJPAModelException
*/
public IntermediateReferenceAccess addReference(@Nonnull final String uri) throws ODataJPAModelException;
/**
* Loads a referenced external CSDL document from the file system. The document has to be a XML document. The document
* is loaded assuming it has been stored using the system default character set.
* @param uri A uniquely identifier of a referenced document, so two references MUST NOT specify the same URI.
* @param path Path to the CSDL document
* @return
* @throws ODataJPAModelException
*/
public IntermediateReferenceAccess addReference(@Nonnull final String uri, @Nonnull final String path)
throws ODataJPAModelException;
/**
* Loads a referenced external CSDL document from the file system. The document has to be a XML document.
* @param uri A uniquely identifier of a referenced document, so two references MUST NOT specify the same URI.
* @param path Path to the CSDL document
* @param charSet Character set to be used when loading the document.
* @return
* @throws ODataJPAModelException
*/
public IntermediateReferenceAccess addReference(@Nonnull final String uri, @Nonnull final String path,
@Nonnull final Charset charSet) throws ODataJPAModelException;
public interface IntermediateReferenceAccess extends ReferenceAccess {
public URI getURI();
public String getPath();
/**
* See: <a
* href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752506">3.4
* Element edmx:Include</a>
* @param namespace Namespace of a schema defined in the referenced CSDL document to be included. The same namespace
* MUST NOT be included more than once.
* @param alias Alias for the given namespace. The alias must be unique.
*/
@Override
public void addInclude(@Nonnull final String namespace, final String alias);
/**
* See: <a
* href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752506">3.4
* Element edmx:Include</a>
* @param namespace Namespace of a schema defined in the referenced CSDL document to be included. The same namespace
* MUST NOT be included more than once.
*/
public void addInclude(@Nonnull final String namespace);
/**
* See: <a
* href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752509">3.5
* Element edmx:IncludeAnnotations</a>
* @param termNamespace
* @throws ODataJPAModelException
*/
public void addIncludeAnnotation(@Nonnull final String termNamespace) throws ODataJPAModelException;
/**
* See: <a
* href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752509">3.5
* Element edmx:IncludeAnnotations</a>
* @param termNamespace
* @param qualifier
* @param targetNamespace
* @throws ODataJPAModelException
*/
public void addIncludeAnnotation(@Nonnull final String termNamespace, final String qualifier,
final String targetNamespace) throws ODataJPAModelException;
}
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/ODataFunction.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/ODataFunction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
/**
* Tag Interface to indicate that a java class represents an OData <a href =
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398010">
* Function.</a>
* <p>
* An instance of the converter is created once per OData request. That is, it could be created multiple times per http
* request in case of $batch requests.
* <p>
* An implementing class may provide <b>one</b> constructor having no parameter or a combination of the following:
* <ul>
* <li>An Entity Manager: jakarta.persistence.EntityManager</li>
* <li>All header: com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap</li>
* <li>Access to own request parameter: com.sap.olingo.jpa.metadata.api.JPARequestParameterMap</li>
* <li></li>
* </ul>
*
* @author Oliver Grande
*
*/
public interface ODataFunction extends ODataOperation {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateEntitySetAccess.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateEntitySetAccess.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
import java.util.List;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAElement;
public interface IntermediateEntitySetAccess extends JPAElement {
/**
* Enables to add or overwrite annotations to an entity set, e.g. because the type of annotation is not enabled via
* {@link com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAnnotation EdmAnnotation} or they should be changed
* during runtime.
* @param annotations
*/
public void addAnnotations(final List<CsdlAnnotation> annotations);
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/ODataOperation.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/ODataOperation.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
/**
* Tag interface as super type for Function and Action
* @author Oliver Grande
*
*/
public interface ODataOperation {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/ODataEnumerationType.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/ODataEnumerationType.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
/**
*
* @author Oliver Grande
*
*/
public interface ODataEnumerationType {
public Integer getValue();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/ODataAction.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/ODataAction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
/**
* Tag Interface to indicate that a java class represents an OData <a href =
* "https://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398005">
* Action.</a>
* <p>
* An implementing class may provide <b>one</b> constructor having no parameter or a combination of the following:
* <ul>
* <li>An Entity Manager: jakarta.persistence.EntityManager</li>
* <li>All header: com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap</li>
* <li>Access to own request parameter: com.sap.olingo.jpa.metadata.api.JPARequestParameterMap</li>
* </ul>
* @author Oliver Grande
*
*/
public interface ODataAction extends ODataOperation {
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediatePropertyAccess.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediatePropertyAccess.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
import java.util.List;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
/**
* Override generated metadata for a property.
* @author Oliver Grande
*
*/
public interface IntermediatePropertyAccess extends IntermediateModelItemAccess {
public boolean isEtag();
/**
* Enables to add annotations to a property, e.g. because the type of annotation is not enabled via
* {@link com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAnnotation EdmAnnotation} or should changed be during
* runtime
* @param annotations
*/
public void addAnnotations(final List<CsdlAnnotation> annotations);
public boolean hasProtection();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateNavigationPropertyAccess.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateNavigationPropertyAccess.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
import java.util.List;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
import org.apache.olingo.commons.api.edm.provider.CsdlOnDelete;
public interface IntermediateNavigationPropertyAccess extends IntermediateModelItemAccess {
public void setOnDelete(CsdlOnDelete onDelete);
/**
* Enables to add annotations to a navigation property, e.g. because the type of annotation is not enabled via
* {@link com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAnnotation EdmAnnotation} or should be changed during
* runtime
* @param annotations
*/
public void addAnnotations(final List<CsdlAnnotation> annotations);
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateEntityTypeAccess.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateEntityTypeAccess.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
import java.util.List;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
public interface IntermediateEntityTypeAccess extends IntermediateModelItemAccess {
/**
* Enables to add annotations to the entity container
* @param annotations
*/
public void addAnnotations(final List<CsdlAnnotation> annotations);
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateEntityContainerAccess.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateEntityContainerAccess.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
import java.util.List;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
public interface IntermediateEntityContainerAccess {
/**
* Enables to add annotations to the entity container
*/
public void addAnnotations(final List<CsdlAnnotation> annotations);
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateSingletonAccess.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateSingletonAccess.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
import java.util.List;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAElement;
/**
*
* @author Oliver Grande
* @since 1.0.3
*/
public interface IntermediateSingletonAccess extends JPAElement {
/**
* Enables to add or change annotations of a singleton, e.g. because the type of annotation is not enabled via
* {@link com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAnnotation EdmAnnotation} or they should be changed
* during runtime.
* @param annotations
*/
public void addAnnotations(final List<CsdlAnnotation> annotations);
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateModelItemAccess.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/extension/IntermediateModelItemAccess.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.extension;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAElement;
/**
* @author Oliver Grande
*
*/
public interface IntermediateModelItemAccess extends JPAElement {
/**
* Element shall be ignored for metadata generation.
* @return
*/
boolean ignore();
/**
* Enables to switch if a model item shall be ignored during runtime.
* @param ignore
*/
void setIgnore(boolean ignore);
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/MapCache.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/MapCache.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.cache;
import java.util.Map;
import javax.annotation.Nonnull;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
public interface MapCache<K, V> {
@Nonnull
Map<K, V> get() throws ODataJPAModelException;
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/InstanceCacheFunction.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/InstanceCacheFunction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.cache;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiFunction;
import javax.annotation.Nonnull;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
public class InstanceCacheFunction<T, I, B> implements InstanceCache<T> {
private Optional<Optional<T>> value = Optional.empty();
private final BiFunction<B, I, T> mappingFunction;
private B first;
private I second;
public InstanceCacheFunction(@Nonnull BiFunction<B, I, T> mappingFunction, B first, I second) {
this.mappingFunction = Objects.requireNonNull(mappingFunction);
this.first = first;
this.second = second;
}
@Override
public Optional<T> get() throws ODataJPAModelException {
if (value.isEmpty()) {
try {
final T newValue = mappingFunction.apply(first, second);
value = Optional.of(Optional.ofNullable(newValue));
} catch (ODataJPAModelInternalException e) {
throw (ODataJPAModelException) e.getCause();
}
}
return value.get();
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/MapCacheFunction.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/MapCacheFunction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.cache;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
public class MapCacheFunction<K, V, F, S> implements MapCache<K, V> {
private Optional<Map<K, V>> value = Optional.empty();
private final BiFunction<F, S, Map<K, V>> mappingFunction;
private F first;
private S second;
public MapCacheFunction(BiFunction<F, S, Map<K, V>> mappingFunction, F first, S second) {
super();
this.mappingFunction = mappingFunction;
this.first = first;
this.second = second;
}
@Override
public Map<K, V> get() throws ODataJPAModelException {
if (value.isEmpty()) {
try {
final Map<K, V> newValue = Objects.requireNonNull(mappingFunction.apply(first, second));
value = Optional.of(newValue);
} catch (ODataJPAModelInternalException e) {
throw (ODataJPAModelException) e.getCause();
}
}
return value.orElse(Map.of());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/ListCacheSupplier.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/ListCacheSupplier.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.cache;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
public class ListCacheSupplier<T> implements ListCache<T> {
private Optional<List<T>> value = Optional.empty();
private final Supplier<List<T>> mappingFunction;
public ListCacheSupplier(@Nonnull Supplier<List<T>> mappingFunction) {
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
public List<T> get() throws ODataJPAModelException {
if (value.isEmpty()) {
try {
final List<T> newValue = Objects.requireNonNull(mappingFunction.get());
value = Optional.of(newValue);
} catch (ODataJPAModelInternalException e) {
throw (ODataJPAModelException) e.getCause();
}
}
return value.orElse(List.of());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/ListCache.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/ListCache.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.cache;
import java.util.List;
import javax.annotation.Nonnull;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
public interface ListCache<T> {
@Nonnull
List<T> get() throws ODataJPAModelException;
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/InstanceCacheSupplier.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/InstanceCacheSupplier.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.cache;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
public class InstanceCacheSupplier<T> implements InstanceCache<T> {
private Optional<Optional<T>> value = Optional.empty();
private final Supplier<T> mappingFunction;
public InstanceCacheSupplier(@Nonnull Supplier<T> mappingFunction) {
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
public Optional<T> get() throws ODataJPAModelException {
if (value.isEmpty()) {
try {
final T newValue = mappingFunction.get();
value = Optional.of(Optional.ofNullable(newValue));
} catch (ODataJPAModelInternalException e) {
throw (ODataJPAModelException) e.getCause();
}
}
return value.get();
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/InstanceCache.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/InstanceCache.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.cache;
import java.util.Optional;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
public interface InstanceCache<T> {
Optional<T> get() throws ODataJPAModelException;
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/MapCacheSupplier.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/cache/MapCacheSupplier.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.cache;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Supplier;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
public class MapCacheSupplier<K, V> implements MapCache<K, V> {
private Optional<Map<K, V>> value = Optional.empty();
private final Supplier<Map<K, V>> mappingFunction;
public MapCacheSupplier(Supplier<Map<K, V>> mappingFunction) {
super();
this.mappingFunction = mappingFunction;
}
@Override
public Map<K, V> get() throws ODataJPAModelException {
if (value.isEmpty()) {
try {
final Map<K, V> newValue = Objects.requireNonNull(mappingFunction.get());
value = Optional.of(newValue);
} catch (ODataJPAModelInternalException e) {
throw (ODataJPAModelException) e.getCause();
}
}
return value.orElse(Map.of());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAMessageKey.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAMessageKey.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.exception;
public interface ODataJPAMessageKey {
public String getKey();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAModelIgnoreException.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAModelIgnoreException.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.exception;
public class ODataJPAModelIgnoreException extends Exception {
private static final long serialVersionUID = -5527636158836324228L;
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAModelException.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAModelException.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.exception;
/*
* Copied from org.apache.olingo.odata2.jpa.processor.api.exception.ODataJPAModelException
* See also org.apache.olingo.odata2.jpa.processor.core.exception.ODataJPAMessageServiceDefault
*/
public class ODataJPAModelException extends ODataJPAException {
/**
*
*/
private static final long serialVersionUID = -7188499882306858747L;
public enum MessageKeys implements ODataJPAMessageKey {
INVALID_DESCRIPTION_PROPERTY,
INVALID_COLLECTION_TYPE,
INVALID_TOP_LEVEL_SETTING,
INVALID_NAVIGATION_PROPERTY,
TYPE_NOT_SUPPORTED,
FUNC_UNBOUND_ENTITY_SET,
FUNC_RETURN_TYPE_ENTITY_SET,
FUNC_RETURN_TYPE_EXP,
FUNC_RETURN_TYPE_UNKNOWN,
FUNC_RETURN_TYPE_INVALID,
FUNC_RETURN_NOT_SUPPORTED,
FUNC_PARAM_ANNOTATION_MISSING,
FUNC_PARAM_ONLY_PRIMITIVE,
FUNC_PARAM_NAME_REQUIRED,
FUNC_CONV_ERROR,
FUNC_CONSTRUCTOR_MISSING,
ACTION_RETURN_TYPE_EXP,
ACTION_PARAM_ANNOTATION_MISSING,
ACTION_PARAM_ONLY_PRIMITIVE,
ACTION_PARAM_BINDING_NOT_FOUND,
ACTION_PARAM_NAME_REQUIRED,
ACTION_UNBOUND_ENTITY_SET,
OPERATION_CONSTRUCTOR_WRONG_PARAMETER,
OPERATION_CONSTRUCTOR_WRONG_PARAMETER_COMBINATION,
ENUMERATION_ANNOTATION_MISSING,
ENUMERATION_UNSUPPORTED_TYPE,
ENUMERATION_NO_NEGATIVE_VALUE,
ENUMERATION_UNKNOWN,
TYPE_MAPPER_COULD_NOT_INSTANTIATED,
JOIN_TABLE_NOT_FOUND,
NOT_SUPPORTED_ATTRIBUTE_TYPE,
NOT_SUPPORTED_NO_IMPLICIT_COLUMNS,
NOT_SUPPORTED_NO_IMPLICIT_COLUMNS_COMPLEX,
NOT_SUPPORTED_EMBEDDED_STREAM,
NOT_SUPPORTED_PROTECTED_COLLECTION,
NOT_SUPPORTED_PROTECTED_NAVIGATION,
NOT_SUPPORTED_NAVIGATION_PART_OF_GROUP,
NOT_SUPPORTED_MANDATORY_PART_OF_GROUP,
NOT_SUPPORTED_KEY_PART_OF_GROUP,
NOT_SUPPORTED_MIXED_PART_OF_GROUP,
DESCRIPTION_LOCALE_FIELD_MISSING,
DESCRIPTION_ANNOTATION_MISSING,
DESCRIPTION_FIELD_WRONG_TYPE,
PROPERTY_DEFAULT_ERROR,
PROPERTY_MISSING_PRECISION,
PROPERTY_PRECISION_NOT_IN_RANGE,
PROPERTY_REQUIRED_UNKNOWN,
COMPLEX_PROPERTY_MISSING_PROTECTION_PATH,
COMPLEX_PROPERTY_WRONG_PROTECTION_PATH,
REFERENCED_PROPERTY_NOT_FOUND,
TRANSIENT_CALCULATOR_TOO_MANY_CONSTRUCTORS,
TRANSIENT_CALCULATOR_WRONG_PARAMETER,
TRANSIENT_KEY_NOT_SUPPORTED,
EXTENSION_PROVIDER_TOO_MANY_CONSTRUCTORS,
EXTENSION_PROVIDER_WRONG_PARAMETER,
INHERITANCE_NOT_ALLOWED,
TO_MANY_STREAMS,
MISSING_TERM_NAMESPACE,
ANNOTATION_STREAM_INCOMPLETE,
ANNOTATION_PARSE_ERROR,
ANNOTATION_PATH_NOT_FOUND,
VARIABLE_NOT_SUPPORTED,
ODATA_ANNOTATION_TWO_EXPRESSIONS,
NAVI_PROPERTY_NOT_FOUND,
ON_LEFT_ATTRIBUTE_NULL,
ON_RIGHT_ATTRIBUTE_NULL,
NO_JOIN_TABLE_TYPE,
PATH_ELEMENT_NOT_FOUND,
PATH_ELEMENT_NOT_EMBEDDABLE,
PATH_NOT_FOUND,
DB_TYPE_NOT_DETERMINED,
FILE_NOT_FOUND,
MISSING_ONE_TO_ONE_ANNOTATION,
ENTITY_TYPE_NOT_FOUND,
VERSION_ID_MISSING,
VERSION_EMF_MISSING;
@Override
public String getKey() {
return name();
}
}
private static final String BUNDLE_NAME = "metadata-exceptions-i18n";
public ODataJPAModelException(final Throwable e) {
super(e);
}
public ODataJPAModelException(final MessageKeys messageKey, final Throwable e, final String... params) {
super(messageKey.name(), e, params);
}
public ODataJPAModelException(final MessageKeys messageKey) {
super(messageKey.getKey());
}
public ODataJPAModelException(final MessageKeys messageKey, final String... params) {
super(messageKey.getKey(), params);
}
public ODataJPAModelException(final MessageKeys messageKey, final Throwable e) {
super(messageKey.getKey(), e);
}
@Override
protected String getBundleName() {
return BUNDLE_NAME;
}
public String getId() {
return id;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAException.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAException.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.exception;
import java.util.Enumeration;
import java.util.Locale;
import org.apache.olingo.commons.api.ex.ODataException;
public abstract class ODataJPAException extends ODataException {
private static final long serialVersionUID = 1148357369597923853L;
private static final String UNKNOWN_MESSAGE = "No message text found";
private static Enumeration<Locale> locales;
public static Enumeration<Locale> getLocales() {
return locales;
}
public static void setLocales(final Enumeration<Locale> locales) {
ODataJPAException.locales = locales;
}
protected final String id;
protected final transient ODataJPAMessageTextBuffer messageBuffer;
protected final String[] parameter;
protected ODataJPAException(final String id) {
super("");
this.id = id;
this.messageBuffer = new ODataJPAMessageTextBuffer(getBundleName(), locales);
this.parameter = null;
}
protected ODataJPAException(final String id, final String... params) {
super("");
this.id = id;
this.messageBuffer = new ODataJPAMessageTextBuffer(getBundleName(), locales);
this.parameter = params;
}
protected ODataJPAException(final String id, final Throwable cause, final String... params) {
super("", cause);
this.id = id;
this.messageBuffer = new ODataJPAMessageTextBuffer(getBundleName(), locales);
this.parameter = params;
}
protected ODataJPAException(final String id, final Throwable cause) {
super("", cause);
this.id = id;
this.messageBuffer = new ODataJPAMessageTextBuffer(getBundleName(), locales);
this.parameter = null;
}
protected ODataJPAException(final Throwable cause) {
super(cause);
id = null;
messageBuffer = null;
this.parameter = null;
}
@Override
public String getLocalizedMessage() {
return getMessage();
}
@Override
public String getMessage() {
if (id != null && !id.isEmpty() && messageBuffer != null) {
return messageBuffer.getText(this, id, parameter);
} else if (getCause() != null) {
return getCause().getLocalizedMessage();
} else
return UNKNOWN_MESSAGE;
}
protected abstract String getBundleName();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAMessageTextBuffer.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAMessageTextBuffer.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.exception;
import java.util.Enumeration;
import java.util.Formatter;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.ResourceBundle.Control;
public class ODataJPAMessageTextBuffer implements ODataJPAMessageBufferRead {
private static final String PATH_SEPARATOR = ".";
public static final Locale DEFAULT_LOCALE = Locale.ENGLISH;
protected final String bundleName;
protected final ResourceBundle bundle;
protected final Locale locale;
public ODataJPAMessageTextBuffer(final String bundleName) {
super();
this.bundleName = bundleName;
this.locale = DEFAULT_LOCALE;
this.bundle = getResourceBundle(locale);
}
public ODataJPAMessageTextBuffer(final String bundleName, final Enumeration<Locale> locales) {
super();
this.bundleName = bundleName;
this.locale = setLocales(locales);
this.bundle = getResourceBundle(locale);
}
public ODataJPAMessageTextBuffer(final String bundleName, final Locale locale) {
this.bundleName = bundleName;
this.locale = locale;
this.bundle = getResourceBundle(locale);
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAMessageBufferRead#getText(java.lang.Object,
* java.lang.String)
*/
@Override
public String getText(final Object execution, final String id) {
return bundle.getString(execution.getClass().getSimpleName() + PATH_SEPARATOR + id);
}
@Override
public String getText(final Object execution, final String ID, final String... parameters) {
final String message = getText(execution, ID);
final StringBuilder builder = new StringBuilder();
final Formatter f = new Formatter(builder, locale);
f.format(message, (Object[]) parameters);
f.close();
return builder.toString();
}
private Locale setLocales(final Enumeration<Locale> locales) {
ResourceBundle resourceBundle;
Locale resourceLocale = DEFAULT_LOCALE;
if (locales != null && locales.hasMoreElements()) {
while (locales.hasMoreElements()) {
resourceLocale = locales.nextElement();
resourceBundle = getResourceBundle(resourceLocale);
if (resourceBundle.getLocale().getLanguage().equals(resourceLocale.getLanguage())
&& resourceBundle.getLocale().getCountry().equals(resourceLocale.getCountry()))
break;
}
}
return resourceLocale;
}
String getBundleName() {
return bundleName;
}
Locale getLocale() {
return locale;
}
private ResourceBundle getResourceBundle(final Locale resourceLocale) throws MissingResourceException {
return ResourceBundle.getBundle(bundleName, resourceLocale, Control.getNoFallbackControl(
Control.FORMAT_PROPERTIES));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAModelInternalException.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAModelInternalException.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.exception;
public class ODataJPAModelInternalException extends RuntimeException {
private static final long serialVersionUID = 1L;
public ODataJPAModelInternalException(final ODataJPAModelException rootCause) {
super(rootCause);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAMessageBufferRead.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/exception/ODataJPAMessageBufferRead.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.exception;
public interface ODataJPAMessageBufferRead {
String getText(Object execution, String iD);
String getText(Object execution, String iD, String... parameters);
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPAApiVersionProvider.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPAApiVersionProvider.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.Objects;
import javax.annotation.Nonnull;
import jakarta.persistence.EntityManagerFactory;
import com.sap.olingo.jpa.metadata.api.JPAApiVersion;
import com.sap.olingo.jpa.metadata.api.JPAApiVersionBuilder;
import com.sap.olingo.jpa.metadata.api.JPAEdmMetadataPostProcessor;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
public class JPAApiVersionProvider implements JPAApiVersion {
private final String id;
private final EntityManagerFactory emf;
private final String[] packageNames;
private final String requestMappingPath;
private final JPAEdmMetadataPostProcessor metadataPostProcessor;
private JPAApiVersionProvider(final Builder builder) {
id = builder.id;
emf = builder.emf;
packageNames = builder.packageNames;
requestMappingPath = builder.mappingPath;
metadataPostProcessor = builder.metadataPostProcessor;
}
public static Builder with() {
return new Builder();
}
public static class Builder implements JPAApiVersionBuilder {
private String id;
private EntityManagerFactory emf;
private String[] packageNames;
private String mappingPath;
private JPAEdmMetadataPostProcessor metadataPostProcessor;
/**
*
* @param id Used to identify the version. Value is required.
* @return
*/
@Override
public Builder setId(@Nonnull final String id) {
Objects.requireNonNull(id);
this.id = id;
return this;
}
/**
* Set an externally created entity manager factory.<br>
* This is necessary e.g. in case a spring based service shall run without a <code>persistance.xml</code>.
* @param emf
* @return
*/
@Override
public Builder setEntityManagerFactory(@Nonnull final EntityManagerFactory emf) {
Objects.requireNonNull(emf);
this.emf = emf;
return this;
}
/**
* Name of the top level package to look for
* <ul>
* <li>Enumeration Types
* <li>Java class based Functions
* </ul>
* @param packageName
*/
@Override
public Builder setTypePackage(final String... rootPackages) {
this.packageNames = rootPackages;
return this;
}
@Override
public Builder setRequestMappingPath(final String mappingPath) {
this.mappingPath = mappingPath;
return this;
}
@Override
public Builder setMetadataPostProcessor(final JPAEdmMetadataPostProcessor metadataPostProcessor) {
this.metadataPostProcessor = metadataPostProcessor;
return this;
}
public JPAApiVersion build() throws ODataJPAModelException {
if (id == null || id.isBlank())
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.VERSION_ID_MISSING);
if (emf == null)
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.VERSION_EMF_MISSING);
if (packageNames == null)
packageNames = new String[0];
if (metadataPostProcessor == null)
metadataPostProcessor = new DefaultEdmPostProcessor();
return new JPAApiVersionProvider(this);
}
}
@Override
public String getId() {
return id;
}
@Override
public EntityManagerFactory getEntityManagerFactory() {
return emf;
}
@Override
public String[] getPackageNames() {
return packageNames;
}
@Override
public String getRequestMappingPath() {
return requestMappingPath;
}
@Override
public JPAEdmMetadataPostProcessor getMetadataPostProcessor() {
return metadataPostProcessor;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateFunction.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateFunction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.FUNC_RETURN_TYPE_ENTITY_SET;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.FUNC_UNBOUND_ENTITY_SET;
import java.util.List;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.provider.CsdlFunction;
import org.apache.olingo.commons.api.edm.provider.CsdlParameter;
import org.apache.olingo.commons.api.edm.provider.CsdlReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
/**
* Mapper that is able to convert different metadata resources into a edm function metadata. It is important to know
* that:
* <cite>Functions MUST NOT have observable side effects and MUST return a single instance or a collection of instances
* of any type.</cite>
* <p>
* For details about Function metadata see:
* <a href=
* "https://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398010"
* >OData Version 4.0 Part 3 - 12.2 Element edm:Function</a>
* @author Oliver Grande
*
*/
abstract class IntermediateFunction extends IntermediateOperation implements JPAFunction {
protected CsdlFunction edmFunction;
protected final EdmFunction jpaFunction;
protected final IntermediateSchema schema;
IntermediateFunction(final JPAEdmNameBuilder nameBuilder, final EdmFunction jpaFunction,
final IntermediateSchema schema, final String internalName) {
super(nameBuilder, internalName, schema.getAnnotationInformation());
this.jpaFunction = jpaFunction;
this.schema = schema;
}
@Override
protected synchronized void lazyBuildEdmItem() throws ODataJPAModelException {
if (edmFunction == null) {
edmFunction = new CsdlFunction();
edmFunction.setName(getExternalName());
edmFunction.setParameters(returnNullIfEmpty(determineEdmInputParameter()));
edmFunction.setReturnType(determineEdmResultType(jpaFunction.returnType()));
edmFunction.setBound(jpaFunction.isBound());
// TODO edmFunction.setComposable(isComposable)
edmFunction.setComposable(false);
determineUserGroups(this.jpaFunction.visibleFor());
/*
* Bound actions and functions that return an entity or a collection of entities MAY specify an entity set path if
* the entity set of the returned entities depends on the entity set of the binding parameter value.
* The entity set path consists of a series of segments joined together with forward slashes.
* The first segment of the entity set path MUST be the name of the binding parameter. The remaining segments of
* the entity set path MUST represent navigation segments or type casts.
* A navigation segment names the simple identifier of the navigation property to be traversed. A type-cast
* segment names the qualified name of the entity type that should be returned from the type cast.
*/
edmFunction.setEntitySetPath(setEntitySetPath());
}
}
private String setEntitySetPath() throws ODataJPAModelException {
final String path = jpaFunction.entitySetPath();
if (path == null || path.isEmpty())
return null;
if (!jpaFunction.isBound())
// Entity Set Path shall only provided for bound functions. Function '%1$s' is unbound.
throw new ODataJPAModelException(FUNC_UNBOUND_ENTITY_SET, jpaFunction.functionName());
if (schema.getEntityType(jpaFunction.returnType().type()) == null)
// Entity Set Path shall only if a function returns an entity or collection of entities. Function '%1$s' has a
// wrong return type.
throw new ODataJPAModelException(FUNC_RETURN_TYPE_ENTITY_SET, jpaFunction.functionName());
return path;
}
@Override
CsdlFunction getEdmItem() throws ODataJPAModelException {
if (edmFunction == null) {
lazyBuildEdmItem();
}
return edmFunction;
}
String getUserDefinedFunction() {
return jpaFunction.functionName();
}
@Override
boolean hasImport() {
return jpaFunction.hasFunctionImport();
}
@Override
public boolean isBound() throws ODataJPAModelException {
return getEdmItem().isBound();
}
protected abstract List<CsdlParameter> determineEdmInputParameter() throws ODataJPAModelException;
protected abstract CsdlReturnType determineEdmResultType(final ReturnType returnType) throws ODataJPAModelException;
protected abstract FullQualifiedName determineParameterType(final Class<?> type,
final EdmParameter definedParameter) throws ODataJPAModelException;
protected class IntermediateFunctionParameter extends IntermediateOperationParameter {
private final EdmParameter jpaParameter;
IntermediateFunctionParameter(final JPAEdmNameBuilder nameBuilder, final EdmParameter jpaParameter,
final IntermediateAnnotationInformation annotationInfo) {
super(nameBuilder, jpaParameter, jpaParameter.name(), jpaParameter.parameterName(), jpaParameter.type(),
annotationInfo);
this.jpaParameter = jpaParameter;
}
IntermediateFunctionParameter(final JPAEdmNameBuilder nameBuilder, final EdmParameter jpaParameter,
final String externalName, final String internalName, final Class<?> type,
final IntermediateAnnotationInformation annotationInfo) {
super(nameBuilder, jpaParameter, externalName, internalName, type, annotationInfo);
this.jpaParameter = jpaParameter;
}
@Override
public FullQualifiedName getTypeFQN() throws ODataJPAModelException {
return determineParameterType(getType(), jpaParameter);
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateJoinTable.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateJoinTable.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.NO_JOIN_TABLE_TYPE;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.JoinTable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.sap.olingo.jpa.metadata.api.JPAJoinColumn;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAJoinTable;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOnConditionItem;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
class IntermediateJoinTable implements JPAJoinTable {
private static final Log LOGGER = LogFactory.getLog(IntermediateJoinTable.class);
private final IntermediateNavigationProperty<?> intermediateProperty;
private final JoinTable jpaJoinTable;
private final IntermediateStructuredType<?> sourceType;
private List<IntermediateJoinColumn> joinColumns = null;
private List<IntermediateJoinColumn> inverseJoinColumns = null;
private final Optional<JPAEntityType> jpaEntityType;
IntermediateJoinTable(final IntermediateNavigationProperty<?> intermediateProperty, final JoinTable jpaJoinTable,
final IntermediateSchema schema) {
super();
this.intermediateProperty = intermediateProperty;
this.jpaJoinTable = jpaJoinTable;
this.sourceType = intermediateProperty.getSourceType();
this.jpaEntityType = Optional.ofNullable(schema.getEntityType(jpaJoinTable.catalog(), jpaJoinTable.schema(),
jpaJoinTable.name()));
LOGGER.trace("Determined entity type of join table: "
+ jpaEntityType.map(JPAEntityType::getInternalName).orElse("null"));
}
private IntermediateJoinTable(final IntermediateJoinTable intermediateJoinTable,
final IntermediateNavigationProperty<?> mappedBy) throws ODataJPAModelException {
this.jpaJoinTable = intermediateJoinTable.jpaJoinTable;
this.sourceType = intermediateJoinTable.getTargetType();
this.jpaEntityType = intermediateJoinTable.jpaEntityType;
this.intermediateProperty = mappedBy;
this.joinColumns = intermediateJoinTable.buildInverseJoinColumns();
this.inverseJoinColumns = intermediateJoinTable.buildJoinColumns();
}
private IntermediateJoinTable(final IntermediateJoinTable intermediateJoinTable,
final IntermediateStructuredType<?> sourceType) throws ODataJPAModelException {
this.jpaJoinTable = intermediateJoinTable.jpaJoinTable;
this.sourceType = sourceType;
this.jpaEntityType = intermediateJoinTable.jpaEntityType;
this.intermediateProperty = intermediateJoinTable.intermediateProperty;
this.inverseJoinColumns = intermediateJoinTable.buildInverseJoinColumns();
buildJoinColumns();
}
@Override
public JPAEntityType getEntityType() {
return jpaEntityType.orElse(null);
}
@Override
public List<JPAOnConditionItem> getInverseJoinColumns() throws ODataJPAModelException {
buildInverseJoinColumns();
final IntermediateStructuredType<?> targetType = (IntermediateStructuredType<?>) intermediateProperty
.getTargetEntity();
final List<JPAOnConditionItem> result = new ArrayList<>();
for (final IntermediateJoinColumn column : inverseJoinColumns) {
result.add(new JPAOnConditionItemImpl(
((IntermediateEntityType<?>) jpaEntityType
.orElseThrow(() -> new ODataJPAModelException(NO_JOIN_TABLE_TYPE)))
.getPathByDBField(column.getReferencedColumnName()),
targetType.getPathByDBField(column.getName())));
}
return result;
}
@Override
public List<JPAOnConditionItem> getJoinColumns() throws ODataJPAModelException {
final List<JPAOnConditionItem> result = new ArrayList<>();
for (final IntermediateJoinColumn column : buildJoinColumns()) {
result.add(new JPAOnConditionItemImpl(
sourceType.getPathByDBField(column.getName()),
((IntermediateEntityType<?>) jpaEntityType
.orElseThrow(() -> new ODataJPAModelException(NO_JOIN_TABLE_TYPE)))
.getPathByDBField(column.getReferencedColumnName())));
}
return result;
}
@Override
public List<JPAPath> getRightColumnsList() throws ODataJPAModelException {
return getInverseJoinColumns().stream()
.map(JPAOnConditionItem::getRightPath)
.toList();
}
@Override
public List<JPAPath> getLeftColumnsList() throws ODataJPAModelException {
return getJoinColumns().stream()
.map(JPAOnConditionItem::getLeftPath)
.toList();
}
@SuppressWarnings("unchecked")
@Override
public <T extends JPAJoinColumn> List<T> getRawInverseJoinInformation() throws ODataJPAModelException {
buildInverseJoinColumns();
// For criteria builder the columns get switched
final List<T> invertedColumns = new ArrayList<>(inverseJoinColumns.size());
for (final IntermediateJoinColumn column : inverseJoinColumns) {
invertedColumns.add((T) new IntermediateJoinColumn(column.getReferencedColumnName(), column.getName()));
}
return invertedColumns;
}
@SuppressWarnings("unchecked")
@Override
public <T extends JPAJoinColumn> List<T> getRawJoinInformation() {
return (List<T>) joinColumns;
}
/**
* Returns the name of database table
* @return
*/
@Override
public String getTableName() {
return buildFQTableName(jpaJoinTable.schema(), jpaJoinTable.name());
}
protected final String buildFQTableName(final String schema, final String table) {
final StringBuilder fqt = new StringBuilder();
if (schema != null && !schema.isEmpty()) {
fqt.append(schema);
fqt.append(".");
}
fqt.append(table);
return fqt.toString();
}
IntermediateJoinTable asMapped(final IntermediateNavigationProperty<?> mappedBy) throws ODataJPAModelException {
return new IntermediateJoinTable(this, mappedBy);
}
List<IntermediateJoinColumn> buildInverseJoinColumns() throws ODataJPAModelException {
if (inverseJoinColumns == null) {
inverseJoinColumns = new ArrayList<>(jpaJoinTable.inverseJoinColumns().length);
for (final JoinColumn column : jpaJoinTable.inverseJoinColumns()) {
buildInverseJoinColumn(column);
}
}
return inverseJoinColumns;
}
List<IntermediateJoinColumn> buildJoinColumns() throws ODataJPAModelException {
if (joinColumns == null) {
joinColumns = new ArrayList<>(jpaJoinTable.inverseJoinColumns().length);
for (final JoinColumn column : jpaJoinTable.joinColumns()) {
buildJoinColumn(column);
}
}
return joinColumns;
}
IntermediateJoinTable withSource(final IntermediateStructuredType<?> sourceType) throws ODataJPAModelException {
return new IntermediateJoinTable(this, sourceType);
}
private void buildInverseJoinColumn(final JoinColumn column) throws ODataJPAModelException {
if (column.referencedColumnName() == null || column.referencedColumnName().isEmpty()) {
if (jpaJoinTable.joinColumns().length > 1)
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.NOT_SUPPORTED_NO_IMPLICIT_COLUMNS,
intermediateProperty.getInternalName());
else
inverseJoinColumns.add(new IntermediateJoinColumn(
((IntermediateProperty) ((IntermediateEntityType<?>) getTargetType()).getKey().get(0)).getDBFieldName(),
column.name()));
} else {
inverseJoinColumns.add(new IntermediateJoinColumn(column.referencedColumnName(), column.name()));
}
}
private void buildJoinColumn(final JoinColumn column) throws ODataJPAModelException {
if (column.referencedColumnName() == null || column.referencedColumnName().isEmpty()) {
if (jpaJoinTable.joinColumns().length > 1)
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.NOT_SUPPORTED_NO_IMPLICIT_COLUMNS,
intermediateProperty.getInternalName());
else if (!(intermediateProperty.getSourceType() instanceof IntermediateEntityType))
throw new ODataJPAModelException(
ODataJPAModelException.MessageKeys.NOT_SUPPORTED_NO_IMPLICIT_COLUMNS_COMPLEX,
intermediateProperty.getInternalName());
else {
joinColumns.add(new IntermediateJoinColumn(
((IntermediateProperty) ((IntermediateEntityType<?>) intermediateProperty.getSourceType()).getKey().get(
0)).getDBFieldName(), column.name()));
}
} else {
joinColumns.add(new IntermediateJoinColumn(column.referencedColumnName(), column.name()));
}
}
private IntermediateStructuredType<?> getTargetType() throws ODataJPAModelException {
return (IntermediateStructuredType<?>) intermediateProperty.getTargetEntity();
}
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateEnumerationType.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateEnumerationType.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import jakarta.persistence.AttributeConverter;
import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.provider.CsdlEnumMember;
import org.apache.olingo.commons.api.edm.provider.CsdlEnumType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEnumeration;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEnumeration.DummyConverter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEnumerationAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys;
class IntermediateEnumerationType extends IntermediateModelElement implements JPAEnumerationAttribute {
private CsdlEnumType edmEnumType;
private final Class<?> javaEnum;
private EdmEnumeration annotation;
private List<?> javaMembers;
IntermediateEnumerationType(final JPAEdmNameBuilder nameBuilder, final Class<? extends Enum<?>> javaEnum,
final IntermediateAnnotationInformation annotationInfo) {
super(nameBuilder, javaEnum.getSimpleName(), annotationInfo);
this.setExternalName(nameBuilder.buildEnumerationTypeName(javaEnum));
this.javaEnum = javaEnum;
}
@Override
public Object convert(final List<String> values) throws ODataJPAModelException {
if (values == null || values.isEmpty())
return null;
if (annotation.converter() == EdmEnumeration.DummyConverter.class)
return enumOf(values.get(0));
else {
final Enum<?>[] array = getArray(javaEnum, values.size(), null);
for (int i = 0; i < values.size(); i++) {
array[i] = enumOf(values.get(i));
}
return array;
}
}
@SuppressWarnings("unchecked")
@Override
public <T extends Enum<?>> T enumOf(final String value) throws ODataJPAModelException {
if (edmEnumType == null) {
lazyBuildEdmItem();
}
for (final Object member : javaMembers)
if (((T) member).name().equals(value))
return (T) member;
return null;
}
@Override
@SuppressWarnings("unchecked")
public <T extends Number, E extends Enum<E>> E enumOf(final T value) throws ODataJPAModelException {
if (edmEnumType == null) {
lazyBuildEdmItem();
}
if (annotation.converter() != DummyConverter.class) {
return (E) (createConverter().convertToEntityAttribute(value)[0]);
} else {
for (final Object member : javaMembers)
if (((Enum<?>) member).ordinal() == (Integer) value)
return (E) member;
}
return null;
}
@SuppressWarnings("unchecked")
private <T extends Number> AttributeConverter<Enum<?>[], T> createConverter() throws ODataJPAModelException {
try {
return (AttributeConverter<Enum<?>[], T>) annotation.converter().getDeclaredConstructor().newInstance();
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
| NoSuchMethodException | SecurityException e) {
throw new ODataJPAModelException(e);
}
}
@Override
public boolean isFlags() throws ODataJPAModelException {
if (edmEnumType == null) {
lazyBuildEdmItem();
}
return edmEnumType.isFlags();
}
@SuppressWarnings("unchecked")
@Override
public <T extends Number> T valueOf(final String value) throws ODataJPAModelException {
final Enum<?>[] array = getArray(javaEnum, 1, enumOf(value));
return (T) createConverter().convertToDatabaseColumn(array);
}
@SuppressWarnings("unchecked")
@Override
public <T extends Number> T valueOf(final List<String> values) throws ODataJPAModelException {
if (values == null || values.isEmpty())
return null;
if (annotation.converter() == EdmEnumeration.DummyConverter.class)
return valueOf(values.get(0));
else {
return (T) createConverter().convertToDatabaseColumn((Enum<?>[]) convert(values));
}
}
@Override
protected synchronized void lazyBuildEdmItem() throws ODataJPAModelException {
if (edmEnumType == null) {
annotation = getAnnotation();
edmEnumType = new CsdlEnumType();
edmEnumType.setFlags(determineIsFlag());
edmEnumType.setMembers(buildMembers());
edmEnumType.setName(getExternalName());
edmEnumType.setUnderlyingType(determineUnderlyingType());
}
}
@Override
CsdlEnumType getEdmItem() throws ODataJPAModelException {
if (edmEnumType == null) {
lazyBuildEdmItem();
}
return edmEnumType;
}
private List<CsdlEnumMember> buildMembers() throws ODataJPAModelException {
final List<CsdlEnumMember> members = new ArrayList<>();
javaMembers = Arrays.asList(javaEnum.getEnumConstants());
for (final Object constants : javaMembers) {
if (constants instanceof Enum) {
final Enum<?> e = (Enum<?>) constants;
final CsdlEnumMember member = new CsdlEnumMember();
member.setName(e.name());
final Number value = valueOf(e.toString());
if (determineIsFlag() && value.longValue() < 0L)
// An Enumeration that is marked as Flag must not have a negative value: '%1$s - %2$s'.
throw new ODataJPAModelException(MessageKeys.ENUMERATION_NO_NEGATIVE_VALUE, e.name(), javaEnum
.getName());
member.setValue(String.valueOf(value));
members.add(member);
}
}
return members;
}
private boolean determineIsFlag() {
return annotation.isFlags();
}
private <T extends Number> FullQualifiedName determineUnderlyingType() throws ODataJPAModelException {
if (javaEnum.getEnumConstants().length == 0)
return EdmPrimitiveTypeKind.Int32.getFullQualifiedName();
final T value = valueOf(javaEnum.getEnumConstants()[0].toString());
final EdmPrimitiveTypeKind type = JPATypeConverter.convertToEdmSimpleType(value.getClass());
if (isValidType(type))
return type.getFullQualifiedName();
// Enumeration '%1$s' has the unsupported type '%2$s'.
throw new ODataJPAModelException(MessageKeys.ENUMERATION_UNSUPPORTED_TYPE, javaEnum.getName(), type
.getFullQualifiedName().getFullQualifiedNameAsString());
}
private EdmEnumeration getAnnotation() throws ODataJPAModelException {
final EdmEnumeration enumAnnotation = javaEnum.getAnnotation(EdmEnumeration.class);
if (enumAnnotation == null)
// Annotation EdmEnumeration is missing for Enum %1$s.
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.ENUMERATION_ANNOTATION_MISSING, javaEnum
.getName());
return enumAnnotation;
}
@SuppressWarnings("unchecked")
private <E extends Enum<?>> E[] getArray(final Class<?> javaEnum, final int size, final Enum<?> e) {
final E[] arr = (E[]) Array.newInstance(javaEnum, size);
arr[0] = (E) e;
return arr;
}
private boolean isValidType(final EdmPrimitiveTypeKind type) {
// "Edm.Byte, Edm.SByte, Edm.Int16, Edm.Int32, or Edm.Int64."
return type == EdmPrimitiveTypeKind.Byte
|| type == EdmPrimitiveTypeKind.Int16
|| type == EdmPrimitiveTypeKind.Int32
|| type == EdmPrimitiveTypeKind.Int64
|| type == EdmPrimitiveTypeKind.SByte;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateSchema.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateSchema.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
import jakarta.persistence.metamodel.Attribute;
import jakarta.persistence.metamodel.EmbeddableType;
import jakarta.persistence.metamodel.EntityType;
import jakarta.persistence.metamodel.Metamodel;
import jakarta.persistence.metamodel.PluralAttribute;
import org.apache.olingo.commons.api.edm.EdmEnumType;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.provider.CsdlSchema;
import org.reflections8.Reflections;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmEnumeration;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEnumerationAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAUserGroupRestrictable;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
/**
* <p>
* For details about Schema metadata see:
* <a href=
* "https://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406397946"
* >OData Version 4.0 Part 3 - 5 Schema </a>
* @author Oliver Grande
*
*/
final class IntermediateSchema extends IntermediateModelElement {
private final Metamodel jpaMetamodel;
private final Map<String, IntermediateComplexType<?>> complexTypeListInternalKey;
private final Map<String, IntermediateEntityType<?>> entityTypeListInternalKey;
private final Map<String, IntermediateFunction> functionListInternalKey;
private final Map<ODataActionKey, IntermediateJavaAction> actionListByKey;
private final Map<String, IntermediateEnumerationType> enumTypeListInternalKey;
private IntermediateEntityContainer container;
private final Reflections reflections;
private CsdlSchema edmSchema;
IntermediateSchema(final JPAEdmNameBuilder nameBuilder, final Metamodel jpaMetamodel, final Reflections reflections,
final IntermediateAnnotationInformation annotationInfo) throws ODataJPAModelException {
super(nameBuilder, nameBuilder.getNamespace(), annotationInfo);
this.jpaMetamodel = jpaMetamodel;
this.reflections = reflections;
this.enumTypeListInternalKey = buildEnumerationTypeList();
this.complexTypeListInternalKey = buildComplexTypeList();
this.entityTypeListInternalKey = buildEntityTypeList();
this.functionListInternalKey = buildFunctionList();
this.actionListByKey = buildActionList();
}
private IntermediateSchema(final IntermediateSchema source, final List<String> userGroups)
throws ODataJPAModelException {
super(source.nameBuilder, source.nameBuilder.getNamespace(), source.getAnnotationInformation());
jpaMetamodel = source.jpaMetamodel;
reflections = source.reflections;
complexTypeListInternalKey = copyRestricted(source.complexTypeListInternalKey, userGroups);
enumTypeListInternalKey = source.enumTypeListInternalKey;
entityTypeListInternalKey = copyRestricted(source.entityTypeListInternalKey, userGroups);
functionListInternalKey = copyRestricted(source.functionListInternalKey, userGroups);
actionListByKey = copyRestrictedActions(source.actionListByKey, userGroups);
}
private Map<ODataActionKey, IntermediateJavaAction> copyRestrictedActions(
final Map<ODataActionKey, IntermediateJavaAction> source, final List<String> userGroups)
throws ODataJPAModelException {
final Map<ODataActionKey, IntermediateJavaAction> result = new HashMap<>(source.size());
for (final var item : source.entrySet()) {
if (item.getValue().isAccessibleFor(userGroups)) {
result.put(item.getKey(), item.getValue().asUserGroupRestricted(userGroups));
}
}
return result;
}
private <T extends IntermediateModelElement> Map<String, T> copyRestricted(final Map<String, T> source,
final List<String> userGroups) throws ODataJPAModelException {
final Map<String, T> result = new HashMap<>(source.size());
for (final var item : source.entrySet()) {
if (item.getValue() instanceof final JPAUserGroupRestrictable restrictable) {
if (restrictable.isAccessibleFor(userGroups)) {
result.put(item.getKey(), item.getValue().asUserGroupRestricted(userGroups));
}
} else {
result.put(item.getKey(), item.getValue().asUserGroupRestricted(userGroups));
}
}
return result;
}
IntermediateEnumerationType getEnumerationType(final Class<?> enumType) {
if (enumType.isArray())
return this.enumTypeListInternalKey.get(enumType.getComponentType().getSimpleName());
return this.enumTypeListInternalKey.get(enumType.getSimpleName());
}
JPAEnumerationAttribute getEnumerationType(final EdmEnumType type) {
for (final Entry<String, IntermediateEnumerationType> enumeration : this.enumTypeListInternalKey.entrySet()) {
if (enumeration.getValue().getExternalFQN().equals(type.getFullQualifiedName()))
return enumeration.getValue();
}
return null;
}
IntermediateEnumerationType getEnumerationType(final String externalName) {
for (final Entry<String, IntermediateEnumerationType> enumeration : this.enumTypeListInternalKey.entrySet()) {
if (enumeration.getValue().getExternalName().equals(externalName))
return enumeration.getValue();
}
return null;
}
@SuppressWarnings("unchecked")
@Override
protected <T extends IntermediateModelElement> T asUserGroupRestricted(final List<String> userGroups)
throws ODataJPAModelException {
return (T) new IntermediateSchema(this, userGroups);
}
@Override
protected synchronized void lazyBuildEdmItem() throws ODataJPAModelException {
try {
edmSchema = new CsdlSchema();
edmSchema.setNamespace(nameBuilder.getNamespace());
edmSchema.setEnumTypes(extractEdmModelElements(enumTypeListInternalKey));
edmSchema.setComplexTypes(extractEdmModelElements(complexTypeListInternalKey));
edmSchema.setEntityTypes(extractEdmModelElements(entityTypeListInternalKey));
edmSchema.setFunctions(extractEdmModelElements(functionListInternalKey));
edmSchema.setActions(extractEdmModelElements(actionListByKey));
// edm:Annotations
// edm:Annotation
// edm:Term
// edm:TypeDefinition
// MUST be the last thing that is done !!!!
if (container != null)
edmSchema.setEntityContainer(container.getEdmItem());
} catch (final ODataJPAModelException e) {
throw e;
} catch (final Exception e) {
throw new ODataJPAModelException(e);
}
}
@CheckForNull
JPAAction getAction(final String externalName, final FullQualifiedName actionFqn) {
return actionListByKey.get(new ODataActionKey(externalName, actionFqn));
}
@SuppressWarnings("unchecked")
@Nonnull
<S extends JPAAction> List<S> getActions() {
return Collections.unmodifiableList(new ArrayList<>((Collection<S>) actionListByKey.values()));
}
@SuppressWarnings("unchecked")
<T> IntermediateStructuredType<T> getComplexType(final Class<T> targetClass) {
return (IntermediateStructuredType<T>) complexTypeListInternalKey.get(InternalNameBuilder.buildStructuredTypeName(
targetClass));
}
JPAStructuredType getComplexType(final String externalName) {
for (final Map.Entry<String, IntermediateComplexType<?>> complexType : complexTypeListInternalKey.entrySet()) {
if (complexType.getValue().getExternalName().equals(externalName))
return complexType.getValue();
}
return null;
}
@Override
CsdlSchema getEdmItem() throws ODataJPAModelException {
if (edmSchema == null)
lazyBuildEdmItem();
return edmSchema;
}
@SuppressWarnings("unchecked")
@CheckForNull
<T> IntermediateStructuredType<T> getEntityType(final Class<T> targetClass) {
return (IntermediateStructuredType<T>) entityTypeListInternalKey.get(InternalNameBuilder.buildStructuredTypeName(
targetClass));
}
JPAEntityType getEntityType(final String externalName) {
for (final Entry<String, IntermediateEntityType<?>> et : entityTypeListInternalKey.entrySet()) {
if (et.getValue().getExternalName().equals(externalName))
return et.getValue();
}
return null;
}
JPAEntityType getEntityType(final String dbCatalog, final String dbSchema, final String dbTableName) {
for (final Entry<String, IntermediateEntityType<?>> et : entityTypeListInternalKey.entrySet()) {
if (et.getValue().dbEquals(dbCatalog, dbSchema, dbTableName))
return et.getValue();
}
return null;
}
List<IntermediateEntityType<?>> getEntityTypes() {
final List<IntermediateEntityType<?>> entityTypes = new ArrayList<>();
for (final Entry<String, IntermediateEntityType<?>> et : entityTypeListInternalKey.entrySet()) {
entityTypes.add(et.getValue());
}
return entityTypes;
}
JPAFunction getFunction(final String externalName) {
for (final Entry<String, IntermediateFunction> func : functionListInternalKey.entrySet()) {
if (func.getValue().getExternalName().equals(externalName)
&& !func.getValue().ignore())
return func.getValue();
}
return null;
}
@Nonnull
List<JPAFunction> getFunctions() {
final ArrayList<JPAFunction> functions = new ArrayList<>();
for (final Entry<String, IntermediateFunction> func : functionListInternalKey.entrySet()) {
functions.add(func.getValue());
}
return functions;
}
@SuppressWarnings("unchecked")
<T> IntermediateStructuredType<T> getStructuredType(final PluralAttribute<?, ?, ?> jpaAttribute) {
IntermediateStructuredType<?> type = complexTypeListInternalKey.get(InternalNameBuilder.buildStructuredTypeName(
jpaAttribute.getElementType().getJavaType()));
if (type == null)
type = entityTypeListInternalKey.get(InternalNameBuilder.buildStructuredTypeName(jpaAttribute.getElementType()
.getJavaType()));
return (IntermediateStructuredType<T>) type;
}
@SuppressWarnings("unchecked")
<T> IntermediateStructuredType<T> getStructuredType(final Attribute<?, ?> jpaAttribute) {
IntermediateStructuredType<?> type = complexTypeListInternalKey.get(InternalNameBuilder.buildStructuredTypeName(
jpaAttribute.getJavaType()));
if (type == null)
type = entityTypeListInternalKey.get(InternalNameBuilder.buildStructuredTypeName(jpaAttribute.getJavaType()));
return (IntermediateStructuredType<T>) type;
}
@SuppressWarnings("unchecked")
<T> IntermediateStructuredType<T> getStructuredType(final Class<?> targetClass) {
IntermediateStructuredType<?> type = entityTypeListInternalKey
.get(InternalNameBuilder.buildStructuredTypeName(targetClass));
if (type == null)
type = complexTypeListInternalKey.get(InternalNameBuilder.buildStructuredTypeName(targetClass));
return (IntermediateStructuredType<T>) type;
}
void setContainer(final IntermediateEntityContainer container) {
this.container = container;
}
private Map<ODataActionKey, IntermediateJavaAction> buildActionList() throws ODataJPAModelException {
final HashMap<ODataActionKey, IntermediateJavaAction> actionList = new HashMap<>();
final IntermediateActionFactory factory = new IntermediateActionFactory();
actionList.putAll(factory.create(nameBuilder, reflections, this));
return actionList;
}
private Map<String, IntermediateComplexType<?>> buildComplexTypeList() {
final HashMap<String, IntermediateComplexType<?>> ctList = new HashMap<>();
for (final EmbeddableType<?> embeddable : this.jpaMetamodel.getEmbeddables()) {
final IntermediateComplexType<?> ct = new IntermediateComplexType<>(nameBuilder, embeddable, this);
ctList.put(ct.internalName, ct);
}
return ctList;
}
private Map<String, IntermediateEntityType<?>> buildEntityTypeList() {
final HashMap<String, IntermediateEntityType<?>> etList = new HashMap<>();
for (final EntityType<?> entity : this.jpaMetamodel.getEntities()) {
final IntermediateEntityType<?> et = new IntermediateEntityType<>(nameBuilder, entity, this);
etList.put(et.internalName, et);
}
return etList;
}
private <T extends Enum<?>> Map<String, IntermediateEnumerationType> buildEnumerationTypeList() {
final HashMap<String, IntermediateEnumerationType> enumList = new HashMap<>();
if (reflections != null) {
for (final Class<?> enumeration : reflections.getTypesAnnotatedWith(EdmEnumeration.class)) {
if (enumeration.isEnum()) {
@SuppressWarnings("unchecked")
final IntermediateEnumerationType type = new IntermediateEnumerationType(nameBuilder, (Class<T>) enumeration,
getAnnotationInformation());
enumList.put(type.getInternalName(), type);
}
}
}
return enumList;
}
private Map<String, IntermediateFunction> buildFunctionList() throws ODataJPAModelException {
final HashMap<String, IntermediateFunction> functionList = new HashMap<>();
// 1. Option: Create Function from Entity Annotations
final IntermediateFunctionFactory<?> factory = new IntermediateFunctionFactory<>();
for (final EntityType<?> entity : this.jpaMetamodel.getEntities()) {
functionList.putAll(factory.create(nameBuilder, entity, this));
}
// 2. Option: Create Function from Java Classes
functionList.putAll(factory.create(nameBuilder, reflections, this));
return functionList;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateSimpleProperty.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateSimpleProperty.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.NOT_SUPPORTED_KEY_PART_OF_GROUP;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.NOT_SUPPORTED_MANDATORY_PART_OF_GROUP;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.util.List;
import jakarta.persistence.Column;
import jakarta.persistence.Version;
import jakarta.persistence.metamodel.Attribute;
import jakarta.persistence.metamodel.Attribute.PersistentAttributeType;
import jakarta.persistence.metamodel.SingularAttribute;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmMediaStream;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
/**
* A Property is described on the one hand by its Name and Type and on the other
* hand by its Property Facets. The type is a qualified name of either a
* primitive type, a complex type or a enumeration type. Primitive types are
* mapped by {@link JPATypeConverter}.
*
* <p>
* For details about Property metadata see: <a href=
* "https://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406397954"
* >OData Version 4.0 Part 3 - 6 Structural Property </a>
*
*
* @author Oliver Grande
*
*/
class IntermediateSimpleProperty extends IntermediateProperty {
private static final Log LOGGER = LogFactory.getLog(IntermediateSimpleProperty.class);
private EdmMediaStream streamInfo;
private Boolean isKey;
IntermediateSimpleProperty(final JPAEdmNameBuilder nameBuilder, final Attribute<?, ?> jpaAttribute,
final IntermediateSchema schema) throws ODataJPAModelException {
super(nameBuilder, jpaAttribute, schema);
}
IntermediateSimpleProperty(final IntermediateSimpleProperty source, final List<String> userGroups)
throws ODataJPAModelException {
super(source, userGroups);
}
IntermediateSimpleProperty(final IntermediateSimpleProperty source, final String newDbFieldName)
throws ODataJPAModelException {
super(source, source.getUserGroups());
this.dbFieldName = newDbFieldName;
}
@Override
public boolean isAssociation() {
return false;
}
@Override
public boolean isCollection() {
return false;
}
@Override
public boolean isComplex() {
return jpaAttribute.getPersistentAttributeType() == PersistentAttributeType.EMBEDDED;
}
@Override
public boolean isKey() {
return isKey != null ? isKey : isIdAttribute();
}
@SuppressWarnings("unchecked")
@Override
protected <T extends IntermediateModelElement> T asUserGroupRestricted(final List<String> userGroups) // NOSONAR
throws ODataJPAModelException { // NOSONAR
if (this.isComplex())
return (T) new IntermediateSimpleProperty(this, userGroups);
else
return (T) this;
}
@Override
void checkConsistency() throws ODataJPAModelException {
final Column jpaColumn = ((AnnotatedElement) jpaAttribute.getJavaMember()).getAnnotation(Column.class);
if (jpaColumn != null && isPartOfGroup() && !jpaColumn.nullable())
throw new ODataJPAModelException(NOT_SUPPORTED_MANDATORY_PART_OF_GROUP, jpaAttribute.getDeclaringType()
.getJavaType().getCanonicalName(), jpaAttribute.getName());
if (isPartOfGroup() && isKey())
throw new ODataJPAModelException(NOT_SUPPORTED_KEY_PART_OF_GROUP, jpaAttribute.getDeclaringType()
.getJavaType().getCanonicalName(), jpaAttribute.getName());
}
@Override
Class<?> determinePropertyType() {
return jpaAttribute.getJavaType();
}
@Override
void determineIsVersion() {
final Version jpaVersion = ((AnnotatedElement) this.jpaAttribute.getJavaMember())
.getAnnotation(Version.class);
if (jpaVersion != null) {
isVersion = true;
}
}
@Override
void determineStreamInfo() throws ODataJPAModelException {
streamInfo = ((AnnotatedElement) jpaAttribute.getJavaMember()).getAnnotation(EdmMediaStream.class);
if (streamInfo != null
&& (streamInfo.contentType() == null || streamInfo.contentType().isEmpty())
&& (streamInfo.contentTypeAttribute() == null || streamInfo.contentTypeAttribute().isEmpty()))
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.ANNOTATION_STREAM_INCOMPLETE,
internalName);
}
@Override
void determineStructuredType() {
if (jpaAttribute.getPersistentAttributeType() == PersistentAttributeType.EMBEDDED)
type = schema.getStructuredType(jpaAttribute);
else
type = null;
}
@Override
FullQualifiedName determineType() throws ODataJPAModelException {
return determineTypeByPersistenceType(jpaAttribute.getPersistentAttributeType());
}
String getContentType() {
return streamInfo.contentType();
}
String getContentTypeProperty() {
return streamInfo.contentTypeAttribute();
}
@Override
String getDefaultValue() throws ODataJPAModelException {
String valueString = null;
final boolean isAbstract = Modifier.isAbstract(jpaAttribute.getDeclaringType().getJavaType().getModifiers());
if (!isAbstract
&& jpaAttribute.getJavaMember() instanceof Field
&& jpaAttribute.getPersistentAttributeType() == PersistentAttributeType.BASIC) {
// It is not possible to get the default value directly from the
// Field, only from an instance field.get(Object obj).toString(); //NOSONAR
try {
// Problem: In case of compound key, which is not referenced via @EmbeddedId Hibernate returns a field of the
// key class, whereas EclipseLink returns a field of the entity class; which can be checked via
// field.getDeclaringClass()
final Field field = (Field) jpaAttribute.getJavaMember();
Constructor<?> constructor;
if (!field.getDeclaringClass().equals(jpaAttribute.getDeclaringType().getJavaType()))
constructor = field.getDeclaringClass().getConstructor();
else
constructor = jpaAttribute.getDeclaringType().getJavaType().getConstructor();
final Object pojo = constructor.newInstance();
if (field.trySetAccessible()) {
final Object value = field.get(pojo);
if (value != null)
valueString = value.toString();
}
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.PROPERTY_DEFAULT_ERROR, e,
jpaAttribute.getName());
} catch (final InstantiationException | NoSuchMethodException e) {
// Class could not be instantiated e.g. abstract class like
// Business Partner or missing parameter free constructor
// => default could not be determined and will be ignored
LOGGER.debug("Default could not be determined: "
+ jpaAttribute.getDeclaringType().getJavaType().getName()
+ "#"
+ jpaAttribute.getJavaMember().getName(), e);
}
}
return valueString;
}
@Override
boolean isStream() {
return streamInfo != null && streamInfo.stream();
}
private Boolean isIdAttribute() {
isKey = jpaAttribute instanceof final SingularAttribute<?, ?> singular
&& singular.isId();
return isKey;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPATypeConverter.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPATypeConverter.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.lang.reflect.AnnotatedElement;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Timestamp;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.ZonedDateTime;
import java.util.Calendar;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import jakarta.persistence.Lob;
import jakarta.persistence.Temporal;
import jakarta.persistence.TemporalType;
import jakarta.persistence.metamodel.Attribute;
import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind;
import org.apache.olingo.commons.api.edm.geo.Geospatial.Dimension;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmGeospatial;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
/**
* This class holds utility methods for type conversions between JPA Java types and OData Types.
*
*/
public final class JPATypeConverter {
private static Set<Class<?>> olingoSupportedTypes = typesSupportedByOlingo();
private static Set<Class<?>> scalarTypes = typesScalar();
private JPATypeConverter() {}
private static Set<Class<?>> typesSupportedByOlingo() {
final Set<Class<?>> types = new HashSet<>(32);
types.add(Boolean.class);
types.add(Byte.class);
types.add(Byte[].class);
types.add(byte[].class);
types.add(Double.class);
types.add(Float.class);
types.add(Integer.class);
types.add(java.math.BigDecimal.class);
types.add(java.math.BigInteger.class);
types.add(java.sql.Date.class);
types.add(java.sql.Time.class);
types.add(java.sql.Timestamp.class);
types.add(java.util.Calendar.class);
types.add(java.time.LocalTime.class);
types.add(java.time.LocalDate.class);
types.add(java.time.ZonedDateTime.class);
types.add(java.time.Instant.class);
types.add(java.util.Date.class);
types.add(java.util.UUID.class);
types.add(Long.class);
types.add(Short.class);
types.add(String.class);
return types;
}
private static Set<Class<?>> typesScalar() {
final Set<Class<?>> types = new HashSet<>(32);
types.add(String.class);
types.add(Character.class);
types.add(Long.class);
types.add(Short.class);
types.add(Integer.class);
types.add(Double.class);
types.add(Float.class);
types.add(BigDecimal.class);
types.add(BigInteger.class);
types.add(Byte.class);
types.add(Boolean.class);
types.add(java.sql.Date.class);
types.add(java.sql.Time.class);
types.add(java.time.LocalTime.class);
types.add(java.time.Duration.class);
types.add(java.time.LocalDate.class);
types.add(java.time.OffsetDateTime.class);
types.add(java.time.ZonedDateTime.class);
types.add(java.time.Instant.class);
types.add(Calendar.class);
types.add(Timestamp.class);
types.add(java.util.Calendar.class);
types.add(java.util.Date.class);
types.add(UUID.class);
return types;
}
public static EdmPrimitiveTypeKind convertToEdmSimpleType(final Class<?> type) throws ODataJPAModelException {
return convertToEdmSimpleType(type, null);
}
/**
* This utility method converts a given jpa Type to equivalent EdmPrimitiveTypeKind for maintaining compatibility
* between Java and OData Types.
*
* @param jpaType
* The JPA Type input.
* @return The corresponding EdmPrimitiveTypeKind.
* @throws ODataJPAModelException
* @throws org.apache.olingo.odata2.jpa.processor.api.exception.ODataJPARuntimeException
*
* @see EdmPrimitiveTypeKind
*/
public static <T> EdmPrimitiveTypeKind convertToEdmSimpleType(final Class<T> jpaType, // NOSONAR
final Attribute<?, ?> currentAttribute) throws ODataJPAModelException {
if (jpaType.equals(String.class) || jpaType.equals(Character.class) || jpaType.equals(char.class) || jpaType.equals(
char[].class) || jpaType.equals(Character[].class))
return EdmPrimitiveTypeKind.String;
else if (jpaType.equals(Long.class) || jpaType.equals(long.class))
return EdmPrimitiveTypeKind.Int64;
else if (jpaType.equals(Short.class) || jpaType.equals(short.class))
return EdmPrimitiveTypeKind.Int16;
else if (jpaType.equals(Integer.class) || jpaType.equals(int.class))
return EdmPrimitiveTypeKind.Int32;
else if (jpaType.equals(Double.class) || jpaType.equals(double.class))
return EdmPrimitiveTypeKind.Double;
else if (jpaType.equals(Float.class) || jpaType.equals(float.class))
return EdmPrimitiveTypeKind.Single;
else if (jpaType.equals(BigDecimal.class) || jpaType.equals(BigInteger.class))
return EdmPrimitiveTypeKind.Decimal;
else if (jpaType.equals(byte[].class))
return EdmPrimitiveTypeKind.Binary;
else if (jpaType.equals(Byte.class) || jpaType.equals(byte.class))
return EdmPrimitiveTypeKind.SByte;
else if (jpaType.equals(Boolean.class) || jpaType.equals(boolean.class))
return EdmPrimitiveTypeKind.Boolean;
else if (jpaType.equals(java.time.LocalTime.class) || jpaType.equals(java.sql.Time.class))
return EdmPrimitiveTypeKind.TimeOfDay;
else if (jpaType.equals(java.time.Duration.class))
return EdmPrimitiveTypeKind.Duration;
else if (jpaType.equals(java.time.LocalDate.class) || jpaType.equals(java.sql.Date.class))
return EdmPrimitiveTypeKind.Date;
else if (jpaType.equals(Calendar.class) || jpaType.equals(Timestamp.class) || jpaType.equals(
java.util.Date.class)) {
if ((currentAttribute != null) && (determineTemporalType(currentAttribute) == TemporalType.TIME))
return EdmPrimitiveTypeKind.TimeOfDay;
else if ((currentAttribute != null) && (determineTemporalType(currentAttribute) == TemporalType.DATE))
return EdmPrimitiveTypeKind.Date;
else
return EdmPrimitiveTypeKind.DateTimeOffset;
} else if (jpaType.equals(ZonedDateTime.class) || jpaType.equals(LocalDateTime.class) // NOSONAR
|| jpaType.equals(OffsetDateTime.class) || jpaType.equals(Instant.class))
// Looks like Olingo does not support LocalDateTime or OffsetDateTime, which are supported by JPA 2.2. Olingo only
// takes ZonedDateTime.
return EdmPrimitiveTypeKind.DateTimeOffset;
else if (jpaType.equals(UUID.class))
return EdmPrimitiveTypeKind.Guid;
else if (jpaType.equals(Blob.class) && isBlob(currentAttribute))
return EdmPrimitiveTypeKind.Binary;
else if (jpaType.equals(Clob.class) && isBlob(currentAttribute))
return EdmPrimitiveTypeKind.String;
else if (isGeography(currentAttribute))
return convertGeography(jpaType, currentAttribute);
else if (isGeometry(currentAttribute)) return convertGeometry(jpaType, currentAttribute);
if (currentAttribute != null)
// Type (%1$s) of attribute (%2$s) is not supported. Mapping not possible
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.TYPE_NOT_SUPPORTED,
jpaType.getName(), currentAttribute.getName());
else
return null;
}
public static boolean isSimpleType(final Class<?> type, final Attribute<?, ?> currentAttribute) {
return type != null
&& (isScalarType(type)
|| type.equals(Byte[].class)
|| type.equals(Blob.class)
|| type.equals(Clob.class)
|| isGeography(currentAttribute)
|| isGeometry(currentAttribute));
}
public static boolean isScalarType(final Class<?> type) {
return scalarTypes.contains(type);
}
/**
* For supported java types see {@link org.apache.olingo.commons.api.edm.EdmPrimitiveType}. In addition, since 4.7.1,
* also some types from the java.time package are supported, see:
* <ul>
* <li>For EdmDate: LocalDate, see
* {@link org.apache.olingo.commons.core.edm.primitivetype.EdmDate#internalValueToString
* EdmDate.internalValueToString}</li>
* <li>For EdmTimeOfDay: LocalTime, see
* {@link org.apache.olingo.commons.core.edm.primitivetype.EdmTimeOfDay#internalValueToString
* EdmTimeOfDay.internalValueToString}</li>
* <li>For EdmDateTimeOffset: ZonedDateTime, see
* {@link org.apache.olingo.commons.core.edm.primitivetype.EdmDateTimeOffset#internalValueToString
* EdmDateTimeOffset.internalValueToString}</li>
* </ul>
* Not longer supported are e.g.:
* <ul>
* <li>For EdmDate:
* {@link java.sql.Date}
* </ul>
* @param type
* @return
*/
public static boolean isSupportedByOlingo(final Class<?> type) {
return olingoSupportedTypes.contains(type);
}
private static EdmPrimitiveTypeKind convertGeography(final Class<?> jpaType, final Attribute<?, ?> currentAttribute)
throws ODataJPAModelException {
if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.Point.class))
return EdmPrimitiveTypeKind.GeographyPoint;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.MultiPoint.class))
return EdmPrimitiveTypeKind.GeographyMultiPoint;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.LineString.class))
return EdmPrimitiveTypeKind.GeographyLineString;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.MultiLineString.class))
return EdmPrimitiveTypeKind.GeographyMultiLineString;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.Polygon.class))
return EdmPrimitiveTypeKind.GeographyPolygon;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.MultiPolygon.class))
return EdmPrimitiveTypeKind.GeographyMultiPolygon;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.GeospatialCollection.class))
return EdmPrimitiveTypeKind.GeographyCollection;
// Type (%1$s) of attribute (%2$s) is not supported. Mapping not possible
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.TYPE_NOT_SUPPORTED,
jpaType.getName(), currentAttribute.getName());
}
private static EdmPrimitiveTypeKind convertGeometry(final Class<?> jpaType, final Attribute<?, ?> currentAttribute)
throws ODataJPAModelException {
if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.Point.class))
return EdmPrimitiveTypeKind.GeometryPoint;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.MultiPoint.class))
return EdmPrimitiveTypeKind.GeometryMultiPoint;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.LineString.class))
return EdmPrimitiveTypeKind.GeometryLineString;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.MultiLineString.class))
return EdmPrimitiveTypeKind.GeometryMultiLineString;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.Polygon.class))
return EdmPrimitiveTypeKind.GeometryPolygon;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.MultiPolygon.class))
return EdmPrimitiveTypeKind.GeometryMultiPolygon;
else if (jpaType.equals(org.apache.olingo.commons.api.edm.geo.GeospatialCollection.class))
return EdmPrimitiveTypeKind.GeometryCollection;
// Type (%1$s) of attribute (%2$s) is not supported. Mapping not possible
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.TYPE_NOT_SUPPORTED,
jpaType.getName(), currentAttribute.getName());
}
private static TemporalType determineTemporalType(final Attribute<?, ?> currentAttribute) {
if (currentAttribute != null) {
final AnnotatedElement annotatedElement = (AnnotatedElement) currentAttribute.getJavaMember();
if (annotatedElement != null && annotatedElement.getAnnotation(Temporal.class) != null) return annotatedElement
.getAnnotation(Temporal.class).value();
}
return null;
}
private static Dimension getDimension(final Attribute<?, ?> currentAttribute) {
if (currentAttribute.getJavaMember() instanceof AnnotatedElement) {
final AnnotatedElement annotatedElement = (AnnotatedElement) currentAttribute.getJavaMember();
final EdmGeospatial spatialDetails = annotatedElement.getAnnotation(EdmGeospatial.class);
if (spatialDetails != null)
return spatialDetails.dimension();
}
return null;
}
private static boolean isBlob(final Attribute<?, ?> currentAttribute) {
if (currentAttribute != null) {
final AnnotatedElement annotatedElement = (AnnotatedElement) currentAttribute.getJavaMember();
if (annotatedElement != null && annotatedElement.getAnnotation(Lob.class) != null) return true;
}
return false;
}
private static boolean isGeography(final Attribute<?, ?> currentAttribute) {
return currentAttribute != null && getDimension(currentAttribute) == Dimension.GEOGRAPHY;
}
private static boolean isGeometry(final Attribute<?, ?> currentAttribute) {
return currentAttribute != null && getDimension(currentAttribute) == Dimension.GEOMETRY;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateStructuredType.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateStructuredType.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.COMPLEX_PROPERTY_WRONG_PROTECTION_PATH;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.DB_TYPE_NOT_DETERMINED;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.INVALID_NAVIGATION_PROPERTY;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.PROPERTY_REQUIRED_UNKNOWN;
import static jakarta.persistence.metamodel.Attribute.PersistentAttributeType.BASIC;
import static jakarta.persistence.metamodel.Attribute.PersistentAttributeType.ELEMENT_COLLECTION;
import static jakarta.persistence.metamodel.Attribute.PersistentAttributeType.EMBEDDED;
import static jakarta.persistence.metamodel.Attribute.PersistentAttributeType.MANY_TO_MANY;
import static jakarta.persistence.metamodel.Attribute.PersistentAttributeType.MANY_TO_ONE;
import static jakarta.persistence.metamodel.Attribute.PersistentAttributeType.ONE_TO_MANY;
import static jakarta.persistence.metamodel.Attribute.PersistentAttributeType.ONE_TO_ONE;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import jakarta.persistence.AssociationOverride;
import jakarta.persistence.AssociationOverrides;
import jakarta.persistence.AttributeOverride;
import jakarta.persistence.AttributeOverrides;
import jakarta.persistence.Column;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Version;
import jakarta.persistence.metamodel.Attribute;
import jakarta.persistence.metamodel.Attribute.PersistentAttributeType;
import jakarta.persistence.metamodel.IdentifiableType;
import jakarta.persistence.metamodel.ManagedType;
import jakarta.persistence.metamodel.MappedSuperclassType;
import jakarta.persistence.metamodel.PluralAttribute;
import jakarta.persistence.metamodel.SingularAttribute;
import jakarta.persistence.metamodel.Type;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.provider.CsdlStructuralType;
import org.apache.olingo.server.api.uri.UriResourceProperty;
import com.sap.olingo.jpa.metadata.api.JPAJoinColumn;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmDescriptionAssociation;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmIgnore;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTransient;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ODataAnnotatable;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ODataNavigationPath;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ODataPathNotFoundException;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ODataPropertyPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPACollectionAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAElement;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAProtectionInfo;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.InstanceCache;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.InstanceCacheSupplier;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.ListCacheSupplier;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.MapCache;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.MapCacheFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.MapCacheSupplier;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
abstract class IntermediateStructuredType<T> extends IntermediateModelElement implements JPAStructuredType,
ODataAnnotatable {
//
private static final Log LOGGER = LogFactory.getLog(IntermediateStructuredType.class);
private final MapCache<String, IntermediateProperty> declaredPropertiesMap;
private final MapCache<String, IntermediateNavigationProperty<?>> declaredNavigationPropertiesMap;
private final MapCache<String, JPAPath> resolvedPathMap;
private final MapCache<String, JPAPath> intermediatePathMap;
private final MapCache<String, JPAAssociationPathImpl> resolvedAssociationPathMap;
private final InstanceCache<CsdlStructuralType> edmStructuralType;
protected final ManagedType<T> jpaManagedType;
protected final Class<T> jpaJavaType;
protected final List<MappedSuperclassType<? super T>> mappedSuperclass;
protected final IntermediateSchema schema;
protected final ListCacheSupplier<JPAProtectionInfo> protectedAttributes;
private Optional<List<IntermediateSimpleProperty>> streamProperty;
private int buildState = 0;
IntermediateStructuredType(final JPAEdmNameBuilder nameBuilder, final ManagedType<T> jpaManagedType,
final IntermediateSchema schema) {
super(nameBuilder, InternalNameBuilder.buildStructuredTypeName(jpaManagedType.getJavaType()), schema
.getAnnotationInformation(), false);
this.resolvedPathMap = new MapCacheSupplier<>(this::buildCompletePathMap);
this.intermediatePathMap = new MapCacheSupplier<>(this::buildIntermediatePathMap);
this.resolvedAssociationPathMap = new MapCacheSupplier<>(this::buildCompleteAssociationPathMap);
this.protectedAttributes = new ListCacheSupplier<>(this::lazyBuildCompleteProtectionList);
this.declaredNavigationPropertiesMap = new MapCacheSupplier<>(this::buildNavigationPropertyList);
this.declaredPropertiesMap = new MapCacheSupplier<>(this::buildCompletePropertyMap);
this.edmStructuralType = new InstanceCacheSupplier<>(this::buildEdmItem);
this.jpaManagedType = jpaManagedType;
this.jpaJavaType = this.jpaManagedType.getJavaType();
this.schema = schema;
this.mappedSuperclass = determineMappedSuperclass(jpaManagedType);
this.streamProperty = Optional.empty();
determineIgnore();
}
IntermediateStructuredType(final IntermediateStructuredType<T> source, final List<String> requesterUserGroups)
throws ODataJPAModelException {
super(source.nameBuilder, source.getInternalName(), source.schema.getAnnotationInformation(), true);
edmAnnotations.addAll(source.edmAnnotations);
this.jpaManagedType = source.jpaManagedType;
this.jpaJavaType = this.jpaManagedType.getJavaType();
this.schema = source.schema;
this.mappedSuperclass = determineMappedSuperclass(jpaManagedType);
this.streamProperty = Optional.empty();
determineIgnore();
this.protectedAttributes = new ListCacheSupplier<>(this::lazyBuildCompleteProtectionList);
this.resolvedPathMap = new MapCacheFunction<>(this::restrictedPathMap, source.getResolvedPathMap(),
requesterUserGroups);
this.intermediatePathMap = new MapCacheFunction<>(this::restrictedIntermediatePathMap, source
.getIntermediatePathMap(),
requesterUserGroups);
this.resolvedAssociationPathMap = new MapCacheFunction<>(this::extractNavigationPropertyPathElements, source
.getResolvedAssociationPathMap(), requesterUserGroups);
this.declaredNavigationPropertiesMap = new MapCacheFunction<>(this::extractNavigationPropertiesElements, source
.getDeclaredNavigationPropertiesMap(), requesterUserGroups);
this.declaredPropertiesMap = new MapCacheFunction<>(this::extractPropertiesElements, source
.getDeclaredPropertiesMap(), requesterUserGroups);
this.edmStructuralType = new InstanceCacheSupplier<>(this::buildEdmItem);
}
@Override
public JPAAssociationAttribute getAssociation(final String internalName) throws ODataJPAModelException {
for (final JPAAttribute attribute : this.getAssociations()) {
if (attribute.getInternalName().equals(internalName))
return (JPAAssociationAttribute) attribute;
}
return null;
}
@Override
public JPAAssociationPath getAssociationPath(final String externalName) throws ODataJPAModelException {
return getResolvedAssociationPathMap().get(externalName);
}
@Override
public List<JPAAssociationPath> getAssociationPathList() throws ODataJPAModelException {
final List<JPAAssociationPath> associationList = new ArrayList<>();
for (final Entry<String, JPAAssociationPathImpl> associationPat : getResolvedAssociationPathMap().entrySet()) {
associationList.add(associationPat.getValue());
}
return associationList;
}
@Override
public Optional<JPAAttribute> getAttribute(final String internalName) throws ODataJPAModelException {
return getAttribute(internalName, true);
}
@Override
public Optional<JPAAttribute> getAttribute(final String internalName, final boolean respectIgnore)
throws ODataJPAModelException {
Optional<JPAAttribute> result = Optional.ofNullable(getDeclaredPropertiesMap().get(internalName));
final IntermediateStructuredType<?> baseType = getBaseType();
if (!result.isPresent() && baseType != null)
result = baseType.getAttribute(internalName);
else if (result.isPresent() && respectIgnore && ((IntermediateModelElement) result.get()).ignore())
return Optional.empty();
return result;
}
@Override
public Optional<JPAAttribute> getAttribute(final UriResourceProperty uriResourceItem) throws ODataJPAModelException {
final String externalName = uriResourceItem.getProperty().getName();
for (final Entry<String, IntermediateProperty> property : getDeclaredPropertiesMap().entrySet()) {
if (property.getValue().getExternalName().equals(externalName))
return Optional.of(property.getValue());
}
final IntermediateStructuredType<?> baseType = getBaseType();
if (baseType != null)
return baseType.getAttribute(uriResourceItem);
return Optional.empty();
}
@Override
public List<JPAAttribute> getAttributes() throws ODataJPAModelException {
final List<JPAAttribute> result = new ArrayList<>();
result.addAll(getOwnProperties());
result.addAll(getBaseTypeAttributes());
return result;
}
abstract List<JPAAttribute> getBaseTypeAttributes() throws ODataJPAModelException;
private List<JPAAttribute> getOwnProperties() throws ODataJPAModelException {
final List<JPAAttribute> result = new ArrayList<>();
for (final Entry<String, IntermediateProperty> property : getDeclaredPropertiesMap().entrySet()) {
final IntermediateProperty attribute = property.getValue();
if (!attribute.ignore())
result.add(attribute);
}
return result;
}
@Override
public List<JPAPath> getCollectionAttributesPath() throws ODataJPAModelException {
final List<JPAPath> pathList = new ArrayList<>();
for (final Entry<String, JPAPath> path : getResolvedPathMap().entrySet()) {
if (!path.getValue().ignore() && path.getValue().getLeaf() instanceof JPACollectionAttribute)
pathList.add(path.getValue());
}
for (final Entry<String, JPAPath> path : getIntermediatePathMap().entrySet()) {
if (!path.getValue().ignore() && path.getValue().getLeaf() instanceof JPACollectionAttribute)
pathList.add(path.getValue());
}
return pathList;
}
@Override
public List<JPAAssociationAttribute> getDeclaredAssociations() throws ODataJPAModelException {
final List<JPAAssociationAttribute> result = new ArrayList<>();
for (final Entry<String, IntermediateNavigationProperty<?>> naviProperty : getDeclaredNavigationPropertiesMap()
.entrySet())
result.add(naviProperty.getValue());
final IntermediateStructuredType<? super T> baseType = getBaseType();
if (baseType != null)
result.addAll(baseType.getDeclaredAssociations());
return result;
}
@Override
public Optional<JPAAttribute> getDeclaredAttribute(@Nonnull final String internalName) throws ODataJPAModelException {
Optional<JPAAttribute> result = Optional.ofNullable(getDeclaredPropertiesMap().get(internalName));
final IntermediateStructuredType<?> baseType = getBaseType();
if (!result.isPresent() && baseType != null)
result = baseType.getDeclaredAttribute(internalName);
return result;
}
@Override
public List<JPAAttribute> getDeclaredAttributes() throws ODataJPAModelException {
final List<JPAAttribute> result = new ArrayList<>();
for (final Entry<String, IntermediateProperty> property : getDeclaredPropertiesMap().entrySet()) {
result.add(property.getValue());
}
final IntermediateStructuredType<? super T> baseType = getBaseType();
if (baseType != null)
result.addAll(baseType.getDeclaredAttributes());
return result;
}
@Override
public List<JPACollectionAttribute> getDeclaredCollectionAttributes() throws ODataJPAModelException {
final List<JPACollectionAttribute> result = new ArrayList<>();
for (final Entry<String, IntermediateProperty> property : getDeclaredPropertiesMap().entrySet()) {
if (property.getValue().isCollection())
result.add((JPACollectionAttribute) property.getValue());
}
final IntermediateStructuredType<? super T> baseType = getBaseType();
if (baseType != null)
result.addAll(baseType.getDeclaredCollectionAttributes());
return result;
}
@Override
public JPAPath getPath(final String externalName) throws ODataJPAModelException {
return getPath(externalName, true);
}
@Override
public final JPAPath getPath(final String externalName, final boolean respectIgnore) throws ODataJPAModelException {
JPAPath targetPath = getResolvedPathMap().get(externalName);
if (targetPath == null)
targetPath = getIntermediatePathMap().get(externalName);
if (targetPath == null || (targetPath.ignore() && respectIgnore))
return null;
return targetPath;
}
@Override
public List<JPAPath> getPathList() throws ODataJPAModelException {
final List<JPAPath> pathList = new ArrayList<>();
for (final var path : getResolvedPathMap().entrySet()) {
if (!path.getValue().ignore())
pathList.add(path.getValue());
}
return pathList;
}
@Override
public List<JPAPath> searchChildPath(final JPAPath selectItemPath) throws ODataJPAModelException {
final List<JPAPath> result = new ArrayList<>();
for (final JPAPath path : getResolvedPathMap().values()) {
if (!path.ignore() && path.getAlias().startsWith(selectItemPath.getAlias()))
result.add(path);
}
return result;
}
@Override
public List<JPAProtectionInfo> getProtections() throws ODataJPAModelException {
return protectedAttributes.get();
}
@Override
public Class<?> getTypeClass() {
return this.jpaManagedType.getJavaType();
}
@Override
public boolean isAbstract() {
return false;
}
private Map<String, IntermediateProperty> extractPropertiesElements(final Map<String, IntermediateProperty> source,
final List<String> requesterUserGroups) {
try {
final Map<String, IntermediateProperty> result = new HashMap<>();
for (var property : source.entrySet()) {
if (property.getValue().isComplex())
result.put(property.getKey(), property.getValue().asUserGroupRestricted(requesterUserGroups));
else
result.put(property.getKey(), property.getValue());
}
return result;
} catch (ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
private Map<String, IntermediateNavigationProperty<?>> extractNavigationPropertiesElements(
final Map<String, IntermediateNavigationProperty<?>> source, final List<String> requesterUserGroups) {
try {
final Map<String, IntermediateNavigationProperty<?>> result = new HashMap<>(source.size());
for (var navigation : source.entrySet()) {
if (navigation.getValue().getTargetEntity() instanceof JPAEntityType et
&& et.isAccessibleFor(requesterUserGroups))
result.put(navigation.getKey(), navigation.getValue());
}
return result;
} catch (ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
private Map<String, JPAAssociationPathImpl> extractNavigationPropertyPathElements(
final Map<String, JPAAssociationPathImpl> source, final List<String> requesterUserGroups) {
try {
Map<String, JPAAssociationPathImpl> result = new HashMap<>();
for (var path : source.entrySet()) {
if (path.getValue().getTargetType() instanceof JPAEntityType et
&& et.isAccessibleFor(requesterUserGroups))
result.put(path.getKey(), path.getValue());
}
return result;
} catch (ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
<B> IntermediateStructuredType<B> baseTypeRestricted(IntermediateStructuredType<B> type,
List<String> requesterUserGroups) {
try {
return type == null ? null : type.asUserGroupRestricted(requesterUserGroups);
} catch (ODataJPAModelException e) {
return null;
}
}
private Map<String, IntermediateNavigationProperty<?>> buildNavigationPropertyList() {
return buildAllAttributesSet().stream()
.filter(a -> this.isAssociationProperty(a) && !this.isDescriptionProperty(a))
.map(this::asNavigationProperty)
.collect(Collectors.toMap(Pair::key, Pair::value));
}
protected Map<String, IntermediateProperty> addDescriptionProperty() {
return buildAllAttributesSet().stream()
.filter(a -> this.isAssociationProperty(a) && this.isDescriptionProperty(a))
.map(this::asDescriptionProperty)
.collect(Collectors.toMap(Pair::key, Pair::value));
}
private boolean isDescriptionProperty(Attribute<? super T, ?> attribute) {
return attribute.getJavaMember() instanceof AnnotatedElement annotated
&& annotated.getAnnotation(EdmDescriptionAssociation.class) != null;
}
private boolean isAssociationProperty(Attribute<? super T, ?> attribute) {
return attribute.getPersistentAttributeType() == ONE_TO_MANY
|| attribute.getPersistentAttributeType() == ONE_TO_ONE
|| attribute.getPersistentAttributeType() == MANY_TO_MANY
|| attribute.getPersistentAttributeType() == MANY_TO_ONE;
}
protected Map<String, IntermediateProperty> buildPropertyList() {
return buildAllAttributesSet().stream()
.filter(
a -> a.getPersistentAttributeType() == BASIC
|| a.getPersistentAttributeType() == EMBEDDED
|| a.getPersistentAttributeType() == ELEMENT_COLLECTION)
.map(this::convertToProperty)
.collect(Collectors.toMap(Pair::key, Pair::value));
}
/**
* @throws ODataJPAModelException
*
*/
protected void checkPropertyConsistency() throws ODataJPAModelException {
for (final Entry<String, IntermediateProperty> property : getDeclaredPropertiesMap().entrySet()) {
if (property.getValue().isTransient()) {
for (final String internalPath : property.getValue().getRequiredProperties()) {
validateInternalPath(property.getKey(), internalPath);
}
}
}
}
protected FullQualifiedName determineBaseTypeFqn() throws ODataJPAModelException {
final IntermediateStructuredType<? super T> baseEntity = getBaseType();
if (baseEntity != null && !baseEntity.isAbstract() && isAbstract())
// Abstract entity type '%1$s' must not inherit from a non-abstract entity type '%2$s'
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.INHERITANCE_NOT_ALLOWED,
this.internalName, baseEntity.internalName);
return baseEntity != null ? buildFQN(baseEntity.getExternalName()) : null;
}
protected boolean determineHasStream() {
return getStreamProperty().isPresent();
}
protected void determineIgnore() {
final EdmIgnore jpaIgnore = this.jpaManagedType.getJavaType().getAnnotation(EdmIgnore.class);
if (jpaIgnore != null) {
this.setIgnore(true);
}
}
@Override
public abstract IntermediateStructuredType<? super T> getBaseType() throws ODataJPAModelException;
protected Optional<IntermediateSimpleProperty> getStreamProperty() {
if (streamProperty
.orElseGet(this::determineStreamProperties)
.isEmpty())
return Optional.empty();
return Optional.ofNullable(streamProperty.get().get(0));
}
/**
* The managed type (e.g. via jpaManagedType.getDeclaredAttributes()) does not provide transient field. Therefore they
* have to be simulated
* @return
* @throws ODataJPAModelException
*/
Map<String, IntermediateProperty> addTransientProperties() throws ODataJPAModelException {
final Map<String, IntermediateProperty> result = new HashMap<>();
result.putAll(addTransientOfManagedType(Arrays.asList(jpaManagedType.getJavaType().getDeclaredFields())));
result.putAll(addTransientOfManagedType(mappedSuperclass.stream()
.map(MappedSuperclassType::getJavaType)
.map(Class::getDeclaredFields)
.map(Arrays::asList)
.flatMap(List::stream)
.toList()));
return result;
}
Map<String, IntermediateProperty> addVirtualProperties(Map<String, IntermediateProperty> explicitProperties)
throws ODataJPAModelException {
final Map<String, IntermediateProperty> virtualProperties = new HashMap<>();
for (final IntermediateNavigationProperty<?> naviProperty : getDeclaredNavigationPropertiesMap().values()) {
if (!naviProperty.isMapped()) {
for (final JPAJoinColumn joinColumn : naviProperty.getJoinColumns()) {
final String dbColumnName = joinColumn.getName();
final IntermediateModelElement property = this.getPropertyByDBFieldInternal(explicitProperties, dbColumnName);
if (property == null) {
final Class<?> dbType = determineTargetDBType(naviProperty, joinColumn);
final IntermediateProperty virtualProperty = new IntermediateVirtualProperty(nameBuilder,
new VirtualAttribute<>(jpaManagedType, dbColumnName), schema, dbColumnName, dbType);
virtualProperties.put(virtualProperty.getInternalName(), virtualProperty);
}
}
}
}
return virtualProperties;
}
List<JPAAttribute> getAssociations() throws ODataJPAModelException {
final List<JPAAttribute> jpaAttributes = new ArrayList<>();
for (final Entry<String, IntermediateNavigationProperty<?>> naviProperty : getDeclaredNavigationPropertiesMap()
.entrySet()) {
final IntermediateNavigationProperty<?> property = naviProperty.getValue();
if (!property.ignore())
jpaAttributes.add(property);
}
final IntermediateStructuredType<? super T> baseType = getBaseType();
if (baseType != null)
jpaAttributes.addAll(baseType.getAssociations());
return jpaAttributes;
}
JPAAssociationAttribute getCorrespondingAssociation(final IntermediateStructuredType<?> sourceType,
final String sourceRelationshipName) throws ODataJPAModelException {
final Attribute<?, ?> jpaAttribute = findCorrespondingAssociation(sourceType, sourceRelationshipName);
if (jpaAttribute != null) {
final JPAAssociationAttribute association = getDeclaredNavigationPropertiesMap().get(jpaAttribute.getName());
if (association != null)
return association;
return new IntermediateNavigationProperty<>(nameBuilder, this, jpaAttribute, schema);
}
return null;
}
@Override
CsdlStructuralType getEdmItem() throws ODataJPAModelException {
return edmStructuralType.get().orElse(null);
}
abstract CsdlStructuralType buildEdmItem();
Map<String, JPAPath> getIntermediatePathMap() throws ODataJPAModelException {
return intermediatePathMap.get();
}
List<IntermediateJoinColumn> getJoinColumns(final String relationshipName) throws ODataJPAModelException {
final JPAAssociationAttribute association = this.getAssociation(relationshipName);
if (association != null) {
return ((IntermediateNavigationProperty<?>) association).getJoinColumns();
}
// The association '%2$s' has not been found at '%1$s'
throw new ODataJPAModelException(INVALID_NAVIGATION_PROPERTY, relationshipName, getInternalName());
}
/**
* Method follows resolved semantic
*
* @param dbFieldName
* @return
* @throws ODataJPAModelException
*/
JPAPath getPathByDBField(final String dbFieldName) throws ODataJPAModelException {
for (final JPAPath path : getResolvedPathMap().values()) {
if (path.getDBFieldName().equals(dbFieldName)
&& !pathContainsCollection(path))
return path;
}
return null;
}
Map<String, JPAAssociationPathImpl> getResolvedAssociationPathMap() throws ODataJPAModelException {
return resolvedAssociationPathMap.get();
}
private boolean pathContainsCollection(final JPAPath path) {
return path.getPath().stream()
.map(JPAAttribute.class::cast)
.anyMatch(JPAAttribute::isCollection);
}
/**
* Returns an property regardless if it should be ignored or not
* @param internalName
* @return
* @throws ODataJPAModelException
*/
IntermediateProperty getProperty(final String internalName) throws ODataJPAModelException {
IntermediateProperty result = getDeclaredPropertiesMap().get(internalName);
final IntermediateStructuredType<?> baseType = getBaseType();
if (result == null && baseType != null)
result = baseType.getProperty(internalName);
return result;
}
/**
* Gets a property by its database field name.
* <p>
* The resolution respects embedded types as well as super types
* @param dbFieldName
* @return
* @throws ODataJPAModelException
*/
IntermediateModelElement getPropertyByDBField(final String dbFieldName) throws ODataJPAModelException {
return getPropertyByDBFieldInternal(getDeclaredPropertiesMap(), dbFieldName);
}
Map<String, JPAPath> getResolvedPathMap() throws ODataJPAModelException {
return resolvedPathMap.get();
}
Map<String, IntermediateNavigationProperty<?>> getDeclaredNavigationPropertiesMap() throws ODataJPAModelException {
return declaredNavigationPropertiesMap.get();
}
boolean hasBuildStepPerformed(final int step) {
return (buildState & step) != 0;
}
private Map<String, IntermediateProperty> addTransientOfManagedType(final List<Field> fields)
throws ODataJPAModelException {
final Map<String, IntermediateProperty> result = new HashMap<>();
for (final Field jpaAttribute : fields) {
final EdmTransient edmTransient = jpaAttribute.getAnnotation(EdmTransient.class);
if (edmTransient != null) {
IntermediateProperty property = null;
if (Collection.class.isAssignableFrom(jpaAttribute.getType())) {
property = new IntermediateCollectionProperty<>(nameBuilder,
new TransientPluralAttribute<>(jpaManagedType, jpaAttribute, schema), schema, this);
} else {
property = new IntermediateSimpleProperty(nameBuilder,
new TransientSingularAttribute<>(jpaManagedType, jpaAttribute), schema);
}
result.put(property.internalName, property);
}
}
return result;
}
private Set<Attribute<? super T, ?>> buildAllAttributesSet() {
final Set<Attribute<? super T, ?>> attributes = new HashSet<>();
attributes.addAll(jpaManagedType.getDeclaredAttributes());
attributes.addAll(mappedSuperclass.stream()
.map(ManagedType::getDeclaredAttributes)
.flatMap(Set::stream)
.collect(Collectors.toSet()));
return attributes;
}
private String buildPath(final String pathRoot, final String pathElement) {
return pathRoot + JPAPath.PATH_SEPARATOR + pathElement;
}
private Pair<String, IntermediateNavigationProperty<?>> asNavigationProperty(final Attribute<?, ?> jpaAttribute) {
try {
if (LOGGER.isTraceEnabled())
LOGGER.trace(getExternalName() + ": found navigation property, attribute'" + jpaAttribute.getName() + "'");
final IntermediateNavigationProperty<?> navigationProp = new IntermediateNavigationProperty<>(nameBuilder, this,
jpaAttribute, schema);
return new Pair<>(navigationProp.internalName, navigationProp);
} catch (ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
private Pair<String, IntermediateProperty> convertToProperty(final Attribute<?, ?> jpaAttribute) {
final PersistentAttributeType attributeType = jpaAttribute.getPersistentAttributeType();
try {
switch (attributeType) {
case BASIC, EMBEDDED:
if (jpaAttribute instanceof SingularAttribute<?, ?>
&& ((SingularAttribute<?, ?>) jpaAttribute).isId()
&& attributeType == PersistentAttributeType.EMBEDDED) {
IntermediateSimpleProperty property = new IntermediateEmbeddedIdProperty(nameBuilder, jpaAttribute,
schema);
return new Pair<>(property.internalName, property);
} else {
final IntermediateSimpleProperty property = new IntermediateSimpleProperty(nameBuilder, jpaAttribute,
schema);
return new Pair<>(property.internalName, property);
}
case ELEMENT_COLLECTION:
final IntermediateCollectionProperty<T> property = new IntermediateCollectionProperty<>(nameBuilder,
(PluralAttribute<?, ?, ?>) jpaAttribute, schema, this);
return new Pair<>(property.internalName, property);
default:
throw new ODataJPAModelInternalException(
// Attribute Type '%1$s' as of now not supported
new ODataJPAModelException(ODataJPAModelException.MessageKeys.NOT_SUPPORTED_ATTRIBUTE_TYPE,
attributeType.name()));
}
} catch (ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
private Pair<String, IntermediateProperty> asDescriptionProperty(final Attribute<?, ?> jpaAttribute) {
try {
if (LOGGER.isTraceEnabled())
LOGGER.trace(getExternalName() + ": found description property, attribute '" + jpaAttribute.getName()
+ "'");
final IntermediateDescriptionProperty descProperty = new IntermediateDescriptionProperty(nameBuilder,
jpaAttribute, this, schema);
return new Pair<>(descProperty.internalName, descProperty);
} catch (ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
private String determineDBFieldName(final IntermediateProperty property, final JPAPath jpaPath) {
if (!property.isTransient()) {
final Attribute<?, ?> jpaAttribute = jpaManagedType.getAttribute(property.getInternalName());
if (jpaAttribute.getJavaMember() instanceof AnnotatedElement) {
final AnnotatedElement a = (AnnotatedElement) jpaAttribute.getJavaMember();
final AttributeOverrides overwriteList = a.getAnnotation(AttributeOverrides.class);
if (overwriteList != null) {
for (final AttributeOverride overwrite : overwriteList.value()) {
if (overwrite.name().equals(jpaPath.getLeaf().getInternalName()))
return overwrite.column().name();
}
} else {
final AttributeOverride overwrite = a.getAnnotation(AttributeOverride.class);
if (overwrite != null && overwrite.name().equals(jpaPath.getLeaf().getInternalName())) {
return overwrite.column().name();
}
}
}
}
return jpaPath.getDBFieldName();
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | true |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateComplexType.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateComplexType.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import jakarta.persistence.metamodel.EmbeddableType;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.olingo.commons.api.edm.provider.CsdlComplexType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.InstanceCache;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.InstanceCacheFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.InstanceCacheSupplier;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
/**
* Complex Types are used to structure Entity Types by grouping properties that belong together. Complex Types can
* contain of
* <ul>
* <li>Properties
* <li>Navigation Properties
* </ul>
* This means that they can contain of primitive, complex, or enumeration type, or a collection of primitive, complex,
* or enumeration types.
* <p>
* <b>Limitation:</b> As of now the attributes BaseType, Abstract and OpenType are not supported. There is also no
* support for nested complex types
* <p>
* Complex Types are generated from JPA Embeddable Types.
* <p>
* For details about Complex Type metadata see:
* <a href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406397985"
* >OData Version 4.0 Part 3 - 9 Complex Type</a>
* @author Oliver Grande
*
*/
final class IntermediateComplexType<T> extends IntermediateStructuredType<T> {
private static final Log LOGGER = LogFactory.getLog(IntermediateComplexType.class);
private final InstanceCache<IntermediateStructuredType<? super T>> baseType;
IntermediateComplexType(final JPAEdmNameBuilder nameBuilder, final EmbeddableType<T> jpaEmbeddable,
final IntermediateSchema schema) {
super(nameBuilder, jpaEmbeddable, schema);
this.setExternalName(nameBuilder.buildComplexTypeName(jpaEmbeddable));
baseType = new InstanceCacheSupplier<>(this::determineBaseType);
}
private IntermediateComplexType(IntermediateComplexType<T> source, List<String> requesterUserGroups)
throws ODataJPAModelException {
super(source, requesterUserGroups);
setExternalName(source.getExternalName());
baseType = new InstanceCacheFunction<>(this::baseTypeRestricted, source.getBaseType(),
requesterUserGroups);
}
@SuppressWarnings("unchecked")
@Override
protected <X extends IntermediateModelElement> X asUserGroupRestricted(List<String> userGroups)
throws ODataJPAModelException {
return (X) new IntermediateComplexType<>(this, userGroups);
}
@Override
protected void lazyBuildEdmItem() throws ODataJPAModelException {
getEdmItem();
}
@Override
synchronized CsdlComplexType buildEdmItem() {
try {
var edmComplexType = new CsdlComplexType();
edmComplexType.setName(this.getExternalName());
edmComplexType.setProperties(extractEdmModelElements(getDeclaredPropertiesMap()));
edmComplexType.setNavigationProperties(extractEdmModelElements(getDeclaredNavigationPropertiesMap()));
edmComplexType.setBaseType(determineBaseTypeFqn());
// TODO Abstract
// edmComplexType.setAbstract(isAbstract)
// TODO OpenType
// edmComplexType.setOpenType(isOpenType)
if (determineHasStream())
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.NOT_SUPPORTED_EMBEDDED_STREAM,
internalName);
checkPropertyConsistency();
return edmComplexType;
} catch (ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
@Override
protected synchronized Map<String, IntermediateProperty> buildCompletePropertyMap() {
try {
Map<String, IntermediateProperty> result = new HashMap<>();
result.putAll(buildPropertyList());
result.putAll(addDescriptionProperty());
result.putAll(addTransientProperties());
return result;
} catch (ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
@Override
CsdlComplexType getEdmItem() throws ODataJPAModelException {
return (CsdlComplexType) super.getEdmItem();
}
@Override
public IntermediateStructuredType<? super T> getBaseType() throws ODataJPAModelException {
return baseType.get().orElse(null);
}
/**
* Determines if the structured type has a super type that will be part of OData metadata. That is, the method will
* return null in case the entity has a MappedSuperclass.
* @return Determined super type or null
*/
@SuppressWarnings("unchecked")
public IntermediateStructuredType<? super T> determineBaseType() { // NOSONAR
final Class<?> superType = jpaManagedType.getJavaType().getSuperclass();
if (superType != null) {
final IntermediateStructuredType<? super T> baseComplex = (IntermediateStructuredType<? super T>) schema
.getComplexType(superType);
if (baseComplex != null)
return baseComplex;
else if (superType != Object.class)
LOGGER.warn("Embeddable " + jpaManagedType.getJavaType().getName()
+ " is subtype of " + superType.getName() + " but this is not embeddable or shall be ignored");
}
return null;
}
@Override
protected Map<String, JPAPath> getBaseTypeResolvedPathMap() throws ODataJPAModelException {
final IntermediateStructuredType<? super T> superType = getBaseType();
if (superType != null) {
return superType.getResolvedPathMap();
}
return Map.of();
}
@Override
List<JPAAttribute> getBaseTypeAttributes() throws ODataJPAModelException {
final IntermediateStructuredType<? super T> baseType = getBaseType();
if (baseType != null)
return baseType.getAttributes();
return List.of();
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateVirtualProperty.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateVirtualProperty.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import javax.annotation.Nonnull;
import jakarta.persistence.metamodel.Attribute;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
class IntermediateVirtualProperty extends IntermediateProperty {
IntermediateVirtualProperty(final JPAEdmNameBuilder nameBuilder, final Attribute<?, ?> jpaAttribute,
final IntermediateSchema schema, final String dbColumnName, @Nonnull final Class<?> dbType)
throws ODataJPAModelException {
super(nameBuilder, jpaAttribute, schema);
this.dbFieldName = dbColumnName;
this.dbType = dbType;
this.conversionRequired = true;
}
@Override
public boolean isEnum() {
return false;
}
@Override
public boolean isEtag() {
return false;
}
@Override
public boolean isSearchable() {
return false;
}
@Override
public boolean isTransient() {
return false;
}
@Override
public boolean ignore() {
return true;
}
@Override
public boolean isAssociation() {
return false;
}
@Override
public boolean isCollection() {
return false;
}
@Override
public boolean isComplex() {
return false;
}
@Override
public boolean isKey() {
return false;
}
@Override
void checkConsistency() throws ODataJPAModelException {
// Virtual Property are always consistent.
}
@Override
Class<?> determinePropertyType() {
return null;
}
@Override
void determineIsVersion() {
// Virtual Property are never version property.
isVersion = false;
}
@Override
void determineStreamInfo() throws ODataJPAModelException {
// Virtual Property are no stream properties.
}
@Override
void determineStructuredType() {
type = null;
}
@Override
FullQualifiedName determineType() throws ODataJPAModelException {
return null;
}
@Override
String getDefaultValue() throws ODataJPAModelException {
return null;
}
@Override
boolean isStream() {
return false;
}
@Override
boolean isPartOfGroup() {
return false;
}
@Override
public Class<?> getJavaType() {
return dbType;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateJavaFunction.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateJavaFunction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.CheckForNull;
import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.geo.SRID;
import org.apache.olingo.commons.api.edm.provider.CsdlMapping;
import org.apache.olingo.commons.api.edm.provider.CsdlParameter;
import org.apache.olingo.commons.api.edm.provider.CsdlReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunctionType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAJavaFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOperationResultParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys;
class IntermediateJavaFunction extends IntermediateFunction implements JPAJavaFunction {
private final Method javaFunction;
private final Constructor<?> javaConstructor;
private List<JPAParameter> parameterList;
IntermediateJavaFunction(final JPAEdmNameBuilder nameBuilder, final EdmFunction jpaFunction,
final Method javaFunction, final IntermediateSchema schema) throws ODataJPAModelException {
super(nameBuilder, jpaFunction, schema,
InternalNameBuilder.buildFunctionName(jpaFunction).isEmpty() ? javaFunction.getName() : InternalNameBuilder
.buildFunctionName(jpaFunction));
this.setExternalName(jpaFunction.name().isEmpty()
? nameBuilder.buildOperationName(internalName)
: jpaFunction.name());
this.javaFunction = javaFunction;
this.javaConstructor = IntermediateOperationHelper.determineConstructor(javaFunction);
}
@SuppressWarnings("unchecked")
@Override
public <X> Constructor<X> getConstructor() {
return (Constructor<X>) javaConstructor;
}
@Override
public EdmFunctionType getFunctionType() {
return EdmFunctionType.JavaClass;
}
@Override
public Method getMethod() {
return javaFunction;
}
@Override
public List<JPAParameter> getParameter() throws ODataJPAModelException {
if (parameterList == null) {
parameterList = new ArrayList<>();
final Class<?>[] types = javaFunction.getParameterTypes();
final Parameter[] declaredParameters = javaFunction.getParameters();
for (int i = 0; i < declaredParameters.length; i++) {
final Parameter declaredParameter = declaredParameters[i];
final EdmParameter definedParameter = declaredParameter.getAnnotation(EdmParameter.class);
if (definedParameter == null)
// Function parameter %1$s of method %2$s at class %3$s without required annotation
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.FUNC_PARAM_ANNOTATION_MISSING,
declaredParameter.getName(), javaFunction.getName(), javaFunction
.getDeclaringClass().getName());
if (definedParameter.name().isEmpty())
// Fallback not possible. Reflection does not contain parameter name, just returns e.g. arg1
// Name of parameter required. Name missing at function '%1$s' in class '%2$s'.
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.FUNC_PARAM_NAME_REQUIRED,
javaFunction.getName(), javaFunction.getDeclaringClass().getName());
final JPAParameter parameter = new IntermediateFunctionParameter(nameBuilder, definedParameter, nameBuilder
.buildPropertyName(definedParameter.name()), declaredParameter.getName(), types[i],
getAnnotationInformation());
parameterList.add(parameter);
}
}
return parameterList;
}
@Override
public JPAParameter getParameter(final String internalName) throws ODataJPAModelException {
for (final JPAParameter parameter : getParameter()) {
if (parameter.getInternalName().equals(internalName))
return parameter;
}
return null;
}
@Override
@CheckForNull
public JPAParameter getParameter(final Parameter declaredParameter) throws ODataJPAModelException {
for (final JPAParameter param : getParameter()) {
if (param.getInternalName().equals(declaredParameter.getName()))
return param;
}
return null;
}
@Override
public JPAOperationResultParameter getResultParameter() {
return new IntermediateOperationResultParameter(this, jpaFunction.returnType(), javaFunction.getReturnType(),
IntermediateOperationHelper.isCollection(javaFunction.getReturnType()));
}
@Override
public CsdlReturnType getReturnType() {
return edmFunction.getReturnType();
}
@Override
protected List<CsdlParameter> determineEdmInputParameter() throws ODataJPAModelException {
final List<CsdlParameter> parameters = new ArrayList<>();
final List<JPAParameter> jpaParameterList = getParameter();
for (int i = 0; i < jpaParameterList.size(); i++) {
final JPAParameter jpaParameter = jpaParameterList.get(i);
final CsdlParameter parameter = new CsdlParameter();
parameter.setName(jpaParameter.getName());
parameter.setType(jpaParameter.getTypeFQN());
parameter.setPrecision(nullIfNotSet(jpaParameter.getPrecision()));
parameter.setScale(nullIfNotSet(jpaParameter.getScale()));
parameter.setMaxLength(nullIfNotSet(jpaParameter.getMaxLength()));
parameter.setSrid(jpaParameter.getSrid());
parameter.setMapping(new CsdlMapping()
.setInternalName(getInternalName())
.setMappedJavaClass(jpaParameter.getType()));
parameters.add(parameter);
}
return parameters;
}
@Override
protected CsdlReturnType determineEdmResultType(final ReturnType definedReturnType) throws ODataJPAModelException {
final CsdlReturnType edmResultType = new CsdlReturnType();
final Class<?> declaredReturnType = javaFunction.getReturnType();
if (definedReturnType.type() == Void.class || "void".equals(declaredReturnType
.getCanonicalName()))
throw new ODataJPAModelException(MessageKeys.FUNC_RETURN_TYPE_EXP, javaFunction.getName());
if (IntermediateOperationHelper.isCollection(declaredReturnType)) {
if (definedReturnType.type() == Object.class)
// Type parameter expected for %1$s
throw new ODataJPAModelException(MessageKeys.FUNC_RETURN_TYPE_EXP, javaFunction.getName());
edmResultType.setCollection(true);
edmResultType.setType(IntermediateOperationHelper.determineReturnType(definedReturnType, definedReturnType.type(),
schema, javaFunction.getName()));
} else {
if (definedReturnType.type() != Object.class
&& declaredReturnType != Object.class
&& !definedReturnType.type().getCanonicalName().equals(declaredReturnType.getCanonicalName()))
// The return type %1$s from EdmFunction does not match type %2$s declared at method %3$s
throw new ODataJPAModelException(MessageKeys.FUNC_RETURN_TYPE_INVALID, definedReturnType.type().getName(),
declaredReturnType.getName(), javaFunction.getName());
edmResultType.setCollection(false);
edmResultType.setType(IntermediateOperationHelper.determineReturnType(definedReturnType, declaredReturnType,
schema, javaFunction.getName()));
}
edmResultType.setNullable(definedReturnType.isNullable());
if (definedReturnType.maxLength() >= 0)
edmResultType.setMaxLength(definedReturnType.maxLength());
if (definedReturnType.precision() >= 0)
edmResultType.setPrecision(definedReturnType.precision());
if (definedReturnType.scale() >= 0)
edmResultType.setScale(definedReturnType.scale());
if (definedReturnType.srid() != null && !definedReturnType.srid().srid().isEmpty()) {
final SRID srid = SRID.valueOf(definedReturnType.srid().srid());
srid.setDimension(definedReturnType.srid().dimension());
edmResultType.setSrid(srid);
}
return edmResultType;
}
@Override
protected synchronized void lazyBuildEdmItem() throws ODataJPAModelException {
super.lazyBuildEdmItem();
edmFunction.setBound(false);
}
@Override
boolean hasImport() {
return jpaFunction.hasFunctionImport();
}
@Override
protected FullQualifiedName determineParameterType(final Class<?> type,
final EdmParameter definedParameter) throws ODataJPAModelException {
final EdmPrimitiveTypeKind edmType = JPATypeConverter.convertToEdmSimpleType(type);
if (edmType != null)
return edmType.getFullQualifiedName();
else {
final IntermediateEnumerationType enumType = schema.getEnumerationType(type);
if (enumType != null) {
return enumType.getExternalFQN();
} else
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.FUNC_PARAM_ONLY_PRIMITIVE, javaFunction
.getDeclaringClass().getName(), javaFunction.getName(), definedParameter.name());
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateEmbeddedIdProperty.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateEmbeddedIdProperty.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.TRANSIENT_KEY_NOT_SUPPORTED;
import java.lang.reflect.AnnotatedElement;
import java.util.List;
import jakarta.persistence.metamodel.Attribute;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTransient;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
final class IntermediateEmbeddedIdProperty extends IntermediateSimpleProperty {
IntermediateEmbeddedIdProperty(final JPAEdmNameBuilder nameBuilder, final Attribute<?, ?> jpaAttribute,
final IntermediateSchema schema)
throws ODataJPAModelException {
super(nameBuilder, jpaAttribute, schema);
}
IntermediateEmbeddedIdProperty(IntermediateEmbeddedIdProperty source,
List<String> userGroups) throws ODataJPAModelException {
super(source, userGroups);
}
@Override
public boolean isKey() {
return true;
}
@Override
void determineTransient() throws ODataJPAModelException {
final EdmTransient jpaTransient = ((AnnotatedElement) this.jpaAttribute.getJavaMember())
.getAnnotation(EdmTransient.class);
if (jpaTransient != null) {
throw new ODataJPAModelException(TRANSIENT_KEY_NOT_SUPPORTED,
jpaAttribute.getJavaMember().getDeclaringClass().getName());
}
}
@SuppressWarnings("unchecked")
@Override
protected <T extends IntermediateModelElement> T asUserGroupRestricted(List<String> userGroups) // NOSONAR
throws ODataJPAModelException {
return (T) new IntermediateEmbeddedIdProperty(this, userGroups);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateOperation.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateOperation.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.Arrays;
import java.util.List;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmVisibleFor;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOperation;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
abstract class IntermediateOperation extends IntermediateModelElement implements JPAOperation {
private List<String> userGroups;
IntermediateOperation(final JPAEdmNameBuilder nameBuilder, final String internalName,
final IntermediateAnnotationInformation annotationInfo) {
super(nameBuilder, internalName, annotationInfo);
}
abstract boolean hasImport();
abstract boolean isBound() throws ODataJPAModelException;
protected Integer nullIfNotSet(final Integer number) {
if (number != null && number > -1)
return number;
return null;
}
protected void determineUserGroups(EdmVisibleFor jpaUserGroups) {
if (jpaUserGroups != null)
userGroups = Arrays.stream(jpaUserGroups.value()).toList();
else
userGroups = List.of();
}
@Override
public List<String> getUserGroups() throws ODataJPAModelException {
lazyBuildEdmItem();
return userGroups;
}
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateFunctionFactory.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateFunctionFactory.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import jakarta.persistence.metamodel.EntityType;
import org.reflections8.Reflections;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunctions;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataFunction;
final class IntermediateFunctionFactory<F extends IntermediateFunction> implements IntermediateOperationFactory<F> {
/**
* Creates all functions declared at on entity type
* @param nameBuilder
* @param jpaEntityType
* @param schema
* @return
* @throws ODataJPAModelException
*/
Map<String, F> create(final JPAEdmNameBuilder nameBuilder,
final EntityType<?> jpaEntityType, final IntermediateSchema schema) {
final Map<String, F> functionList = new HashMap<>();
if (jpaEntityType.getJavaType() instanceof AnnotatedElement) {
final EdmFunctions jpaStoredProcedureList = jpaEntityType.getJavaType()
.getAnnotation(EdmFunctions.class);
if (jpaStoredProcedureList != null) {
for (final EdmFunction jpaStoredProcedure : jpaStoredProcedureList.value()) {
putFunction(nameBuilder, jpaEntityType, schema, functionList, jpaStoredProcedure);
}
} else {
final EdmFunction jpaStoredProcedure = jpaEntityType.getJavaType()
.getAnnotation(EdmFunction.class);
if (jpaStoredProcedure != null)
putFunction(nameBuilder, jpaEntityType, schema, functionList, jpaStoredProcedure);
}
}
return functionList;
}
Map<String, F> create(final JPAEdmNameBuilder nameBuilder,
final Reflections reflections, final IntermediateSchema schema) throws ODataJPAModelException {
return createOperationMap(nameBuilder, reflections, schema,
ODataFunction.class, EdmFunction.class);
}
@SuppressWarnings("unchecked")
@Override
public F createOperation(final JPAEdmNameBuilder nameBuilder, final IntermediateSchema schema,
final Method method, final Object functionDescription)
throws ODataJPAModelException {
return (F) new IntermediateJavaFunction(nameBuilder, (EdmFunction) functionDescription, method, schema);
}
@SuppressWarnings("unchecked")
private void putFunction(final JPAEdmNameBuilder nameBuilder, final EntityType<?> jpaEntityType,
final IntermediateSchema schema, final Map<String, F> functionList,
final EdmFunction jpaStoredProcedure) {
final IntermediateFunction function = new IntermediateDataBaseFunction(nameBuilder, jpaStoredProcedure,
jpaEntityType.getJavaType(), schema);
functionList.put(function.getInternalName(), (F) function);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateOperationResultParameter.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateOperationResultParameter.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import javax.annotation.CheckForNull;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.geo.SRID;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOperation;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOperationResultParameter;
class IntermediateOperationResultParameter implements JPAOperationResultParameter {
/**
*
*/
private final JPAOperation jpaOperation;
private final ReturnType jpaReturnType;
private final Class<?> type;
private final boolean isCollection;
public IntermediateOperationResultParameter(final JPAOperation jpaOperation, final ReturnType jpaReturnType,
final Class<?> returnType, final boolean isCollection) {
this.jpaOperation = jpaOperation;
this.jpaReturnType = jpaReturnType;
this.isCollection = isCollection;
if (isCollection)
this.type = jpaReturnType.type();
else
this.type = returnType;
}
public IntermediateOperationResultParameter(final JPAOperation jpaOperation, final ReturnType jpaReturnType,
final Class<?> returnType) {
this.jpaOperation = jpaOperation;
this.jpaReturnType = jpaReturnType;
this.isCollection = jpaReturnType.isCollection();
this.type = returnType;
}
@Override
public Class<?> getType() {
return type;
}
@Override
public Integer getMaxLength() {
return jpaReturnType.maxLength();
}
@Override
public Integer getPrecision() {
return jpaReturnType.precision();
}
@Override
public Integer getScale() {
return jpaReturnType.scale();
}
@Override
public FullQualifiedName getTypeFQN() {
return jpaOperation.getReturnType().getTypeFQN();
}
@Override
public boolean isCollection() {
return isCollection;
}
@Override
@CheckForNull
public SRID getSrid() {
if (jpaReturnType.srid().srid().isEmpty())
return null;
final SRID srid = SRID.valueOf(jpaReturnType.srid().srid());
srid.setDimension(jpaReturnType.srid().dimension());
return srid;
}
@Override
public String toString() {
return "IntermediateOperationResultParameter [jpaOperation=" + jpaOperation.getInternalName()
+ ", type=" + type.getName() + ", isCollection=" + isCollection + "]";
}
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/package-info.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/package-info.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl; | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPAAssociationPathImpl.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPAAssociationPathImpl.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nonnull;
import jakarta.persistence.metamodel.Attribute.PersistentAttributeType;
import com.sap.olingo.jpa.metadata.api.JPAJoinColumn;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.Cardinality;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAElement;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAJoinTable;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOnConditionItem;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
final class JPAAssociationPathImpl implements JPAAssociationPath {
private final String alias;
private final List<JPAElement> pathElements;
private final IntermediateStructuredType<?> sourceType;
private final IntermediateStructuredType<?> targetType;
private final List<? extends JPAJoinColumn> joinColumns;
private final PersistentAttributeType cardinality;
private final boolean isCollection;
private final JPAAssociationAttribute partner;
private final JPAJoinTable joinTable;
JPAAssociationPathImpl(final IntermediateNavigationProperty<?> association,
final IntermediateStructuredType<?> source) throws ODataJPAModelException {
final List<JPAElement> pathElementsBuffer = new ArrayList<>();
pathElementsBuffer.add(association);
alias = association.getExternalName();
this.sourceType = source;
this.targetType = (IntermediateStructuredType<?>) association.getTargetEntity();
this.joinColumns = association.getJoinColumns();
this.pathElements = Collections.unmodifiableList(pathElementsBuffer);
this.cardinality = association.getJoinCardinality();
this.isCollection = association.isCollection();
this.partner = association.getPartner();
this.joinTable = association.getJoinTable();
}
JPAAssociationPathImpl(final JPAAssociationPath associationPath, final IntermediateStructuredType<?> source,
final List<? extends JPAJoinColumn> joinColumns, final JPAAttribute attribute) throws ODataJPAModelException {
final List<JPAElement> pathElementsBuffer = new ArrayList<>();
pathElementsBuffer.add(attribute);
pathElementsBuffer.addAll(associationPath.getPath());
alias = buildNavigationPropertyBindingName(associationPath, attribute);
this.sourceType = source;
this.targetType = (IntermediateStructuredType<?>) associationPath.getTargetType();
if (joinColumns.isEmpty())
this.joinColumns = ((JPAAssociationPathImpl) associationPath).getJoinColumns();
else
this.joinColumns = joinColumns;
this.pathElements = Collections.unmodifiableList(pathElementsBuffer);
this.cardinality = ((JPAAssociationPathImpl) associationPath).getCardinality();
this.isCollection = associationPath.isCollection();
this.partner = associationPath.getPartner();
this.joinTable = associationPath.hasJoinTable()
? ((IntermediateJoinTable) associationPath.getJoinTable()).withSource(source)
: null;
}
/**
* Collection Properties
* @param collectionProperty
* @param source
* @param path
* @param joinColumns
* @throws ODataJPAModelException
*/
public JPAAssociationPathImpl(final IntermediateCollectionProperty<?> collectionProperty, final JPAPath path,
final List<? extends JPAJoinColumn> joinColumns) throws ODataJPAModelException {
alias = path.getAlias();
this.sourceType = collectionProperty.getSourceType();
this.targetType = (IntermediateStructuredType<?>) collectionProperty.getTargetEntity();
this.joinColumns = joinColumns;
this.pathElements = path.getPath();
this.cardinality = PersistentAttributeType.ONE_TO_MANY;
this.isCollection = true;
this.partner = null;
this.joinTable = collectionProperty.getJoinTable();
}
@Override
public String getAlias() {
return alias;
}
@Override
public List<JPAPath> getInverseLeftJoinColumnsList() throws ODataJPAModelException {
final List<JPAPath> result = new ArrayList<>();
if (joinTable instanceof final IntermediateJoinTable intermediateJoinTable)
for (final IntermediateJoinColumn column : intermediateJoinTable.buildInverseJoinColumns()) {
result.add(targetType.getPathByDBField(column.getName()));
}
return result;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAAssociationPath#getJoinColumnsList()
*/
@Override
public List<JPAOnConditionItem> getJoinColumnsList() throws ODataJPAModelException {
final List<JPAOnConditionItem> result = new ArrayList<>();
for (final JPAJoinColumn column : this.joinColumns) {
result.add(new JPAOnConditionItemImpl(
sourceType.getPathByDBField(column.getName()),
targetType.getPathByDBField(column.getReferencedColumnName())));
}
return result;
}
@Override
public JPAJoinTable getJoinTable() {
return joinTable;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAAssociationPath#getLeaf()
*/
@Override
public JPAAssociationAttribute getLeaf() {
return (JPAAssociationAttribute) pathElements.get(pathElements.size() - 1);
}
@Override
public List<JPAPath> getLeftColumnsList() throws ODataJPAModelException {
final List<JPAPath> result = new ArrayList<>();
for (final JPAJoinColumn column : this.joinColumns) {
final JPAPath columnPath = sourceType.getPathByDBField(column.getName());
if (columnPath != null)
result.add(columnPath);
}
return result;
}
@Override
public JPAAssociationAttribute getPartner() {
return partner;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAAssociationPath#getPath()
*/
@Override
public List<JPAElement> getPath() {
return pathElements;
}
@Override
public String getPathAsString() {
return getAlias();
}
@Override
public List<JPAPath> getRightColumnsList() throws ODataJPAModelException {
final List<JPAPath> result = new ArrayList<>();
for (final JPAJoinColumn column : this.joinColumns) {
final JPAPath columnPath = targetType.getPathByDBField(column.getReferencedColumnName());
if (columnPath != null)
result.add(columnPath);
}
return result;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAAssociationPath#getSourceType()
*/
@Override
public JPAStructuredType getSourceType() {
return sourceType;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAAssociationPath#getTargetType()
*/
@Override
public JPAStructuredType getTargetType() {
return targetType;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAAssociationPath#isCollection()
*/
@Override
public boolean isCollection() {
return isCollection;
}
@Override
public String toString() {
return "JPAAssociationPathImpl [alias=" + alias + ", pathElements=" + pathElements + ", sourceType=" + sourceType
+ ", targetType=" + targetType + ", joinColumns=" + joinColumns + ", cardinality=" + cardinality
+ ", joinTable=" + joinTable + "]";
}
private PersistentAttributeType getCardinality() {
return cardinality;
}
private List<? extends JPAJoinColumn> getJoinColumns() {
return joinColumns;
}
/**
* A navigation property binding MUST name a navigation property of the
* entity set’s, singleton's, or containment navigation property's entity
* type or one of its subtypes in the Path attribute. If the navigation
* property is defined on a subtype, the path attribute MUST contain the
* QualifiedName of the subtype, followed by a forward slash, followed by
* the navigation property name. If the navigation property is defined on
* a complex type used in the definition of the entity set’s entity type,
* the path attribute MUST contain a forward-slash separated list of complex
* property names and qualified type names that describe the path leading
* to the navigation property. See <a
* href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398035">
* Navigation Property Binding</a>.
* @param associationPath
* @param parent
* @return non empty unique name of a Navigation Property Binding
*/
// TODO respect subtype name
@Nonnull
private String buildNavigationPropertyBindingName(final JPAAssociationPath associationPath,
final JPAAttribute parent) {
final StringBuilder name = new StringBuilder();
name.append(parent.getExternalName());
for (final JPAElement pathElement : associationPath.getPath()) {
name.append(JPAPath.PATH_SEPARATOR);
name.append(pathElement.getExternalName());
}
return name.toString();
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAAssociationPath#hasJoinTable()
*/
@Override
public boolean hasJoinTable() {
return joinTable != null;
}
@Override
public List<JPAPath> getForeignKeyColumns() throws ODataJPAModelException {
return hasJoinTable() ? getLeftColumnsList() : getRightColumnsList();
}
@Override
public Cardinality cardinality() {
return switch (cardinality) {
case MANY_TO_ONE -> Cardinality.MANY_TO_ONE;
case ONE_TO_ONE -> Cardinality.ONE_TO_ONE;
case MANY_TO_MANY -> Cardinality.MANY_TO_MANY;
case ONE_TO_MANY -> Cardinality.ONE_TO_MANY;
default -> null;
};
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateActionFactory.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateActionFactory.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.reflections8.Reflections;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataAction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.ODataOperation;
class IntermediateActionFactory implements IntermediateOperationFactory<IntermediateJavaAction> {
//Description
@Override
public IntermediateJavaAction createOperation(final JPAEdmNameBuilder nameBuilder, final IntermediateSchema schema,
final Method method, final Object functionDescription)
throws ODataJPAModelException {
return new IntermediateJavaAction(nameBuilder, (EdmAction) functionDescription, method, schema);
}
@SuppressWarnings("unchecked")
<F extends IntermediateJavaAction> Map<ODataActionKey, F> create(final JPAEdmNameBuilder nameBuilder,
final Reflections reflections, final IntermediateSchema schema) throws ODataJPAModelException {
return (Map<ODataActionKey, F>) createActionMap(nameBuilder, reflections, schema, ODataAction.class,
EdmAction.class);
}
Map<ODataActionKey, IntermediateJavaAction> createActionMap(final JPAEdmNameBuilder nameBuilder,
final Reflections reflections, final IntermediateSchema schema, final Class<? extends ODataOperation> clazz,
final Class<? extends Annotation> annotation)
throws ODataJPAModelException {
final Map<ODataActionKey, IntermediateJavaAction> operations = new HashMap<>();
if (reflections != null) {
final Set<?> operationClasses = findJavaOperations(reflections, clazz);
for (final Object operationClass : operationClasses) {
for (final Method m : Arrays.asList(((Class<?>) operationClass).getMethods())) {
final Object operationDescription = m.getAnnotation(annotation);
if (operationDescription != null) {
final IntermediateOperation operation = createOperation(nameBuilder, schema, m, operationDescription);
operations.put(new ODataActionKey(operation), (IntermediateJavaAction) operation);
}
}
}
}
return operations;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/DefaultEdmPostProcessor.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/DefaultEdmPostProcessor.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import com.sap.olingo.jpa.metadata.api.JPAEdmMetadataPostProcessor;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateEntityTypeAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateNavigationPropertyAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediatePropertyAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateReferenceList;
final class DefaultEdmPostProcessor implements JPAEdmMetadataPostProcessor {
@Override
public void processNavigationProperty(final IntermediateNavigationPropertyAccess property,
final String jpaManagedTypeClassName) {
// Default shall do nothing
}
@Override
public void processProperty(final IntermediatePropertyAccess property, final String jpaManagedTypeClassName) {
// Default shall do nothing
}
@Override
public void provideReferences(final IntermediateReferenceList references) {
// Default shall do nothing
}
@Override
public void processEntityType(final IntermediateEntityTypeAccess entity) {
// Default shall do nothing
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateModelElement.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateModelElement.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Member;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.provider.CsdlAbstractEdmItem;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlConstantExpression;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlConstantExpression.ConstantExpressionType;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlDynamicExpression;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlExpression;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlPropertyValue;
import com.sap.olingo.jpa.metadata.api.JPAEdmMetadataPostProcessor;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAnnotation;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.AnnotationProvider;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.Applicability;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ODataAnnotatable;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateModelItemAccess;
abstract class IntermediateModelElement implements IntermediateModelItemAccess {
protected static JPAEdmMetadataPostProcessor postProcessor = new DefaultEdmPostProcessor();
protected static final JPANameBuilder InternalNameBuilder = new JPANameBuilder();
protected final JPAEdmNameBuilder nameBuilder;
protected final String internalName;
protected final List<CsdlAnnotation> edmAnnotations;
private final IntermediateAnnotationInformation annotationInformation;
private boolean toBeIgnored;
private String externalName;
private final boolean isRestricted;
static void setPostProcessor(final JPAEdmMetadataPostProcessor processor) {
postProcessor = processor;
}
IntermediateModelElement(final JPAEdmNameBuilder nameBuilder, final String internalName,
final IntermediateAnnotationInformation annotationInformation) {
super();
this.nameBuilder = nameBuilder;
this.internalName = internalName;
this.edmAnnotations = new ArrayList<>();
this.annotationInformation = annotationInformation;
this.isRestricted = false;
}
IntermediateModelElement(final JPAEdmNameBuilder nameBuilder, final String internalName,
final IntermediateAnnotationInformation annotationInformation, final boolean restricted) {
super();
this.nameBuilder = nameBuilder;
this.internalName = internalName;
this.edmAnnotations = new ArrayList<>();
this.annotationInformation = annotationInformation;
this.isRestricted = restricted;
}
@Override
public String getExternalName() {
return externalName;
}
@Override
public FullQualifiedName getExternalFQN() {
return buildFQN(getExternalName());
}
@Override
public String getInternalName() {
return internalName;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateModelItemAccess#ignore()
*/
@Override
public boolean ignore() {
return toBeIgnored;
}
protected void setExternalName(final String externalName) {
this.externalName = externalName;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateModelItemAccess#setIgnore(boolean)
*/
@Override
public void setIgnore(final boolean ignore) {
this.toBeIgnored = ignore;
}
protected abstract void lazyBuildEdmItem() throws ODataJPAModelException;
@SuppressWarnings("unchecked")
protected <T extends CsdlAbstractEdmItem> List<T> extractEdmModelElements(
final Map<?, ? extends IntermediateModelElement> mappingBuffer) throws ODataJPAModelException {
final List<T> extractionTarget = new ArrayList<>();
for (final IntermediateModelElement bufferItem : mappingBuffer.values()) {
if (!bufferItem.toBeIgnored) { // NOSONAR
final var element = bufferItem;
final var edmItem = element.getEdmItem();
if (!element.ignore())
extractionTarget.add((T) edmItem);
}
}
return extractionTarget;
}
protected <T extends IntermediateModelElement> IntermediateModelElement findModelElementByEdmItem(
final String edmEntityItemName, final Map<String, T> buffer) {
for (final T bufferItem : buffer.values()) {
if (edmEntityItemName.equals(bufferItem.getExternalName())) {
return bufferItem;
}
}
return null;
}
protected <T> List<T> returnNullIfEmpty(final List<T> list) {
return list == null ? Collections.emptyList() : list;
}
protected String returnNullIfEmpty(final String value) {
return value == null || value.isEmpty() ? null : value;
}
abstract CsdlAbstractEdmItem getEdmItem() throws ODataJPAModelException;
/**
* Convert annotations at an annotatable element into OData annotations
* {@link com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAnnotation}
*
* @param edmAnnotations
* @param member
* @param internalName
* @param property
* @throws ODataJPAModelException
*/
protected void getAnnotations(final List<CsdlAnnotation> edmAnnotations, final Member member,
final String internalName) throws ODataJPAModelException {
if (member instanceof final AnnotatedElement annotatedElement) {
extractAnnotations(edmAnnotations, annotatedElement, internalName);
}
}
protected void getAnnotations(final List<CsdlAnnotation> edmAnnotations, final Class<?> clazz,
final String internalName) throws ODataJPAModelException {
if (clazz instanceof AnnotatedElement) {
extractAnnotations(edmAnnotations, clazz, internalName);
}
}
/**
* @param t
* @return
*/
protected final String buildFQTableName(final String schema, final String name) {
final var fqt = new StringBuilder();
if (schema != null && !schema.isEmpty()) {
fqt.append(schema);
fqt.append(".");
}
fqt.append(name);
return fqt.toString();
}
private void extractAnnotations(final List<CsdlAnnotation> edmAnnotations, final AnnotatedElement element,
final String internalName) throws ODataJPAModelException {
final var jpaAnnotation = element.getAnnotation(EdmAnnotation.class);
if (jpaAnnotation != null) {
final var edmAnnotation = new CsdlAnnotation();
final var qualifier = jpaAnnotation.qualifier();
edmAnnotation.setTerm(jpaAnnotation.term());
edmAnnotation.setQualifier(qualifier.isEmpty() ? null : qualifier);
if (!(jpaAnnotation.constantExpression().type() == ConstantExpressionType.Int
&& jpaAnnotation.constantExpression().value().equals("default"))
&& !(jpaAnnotation.dynamicExpression().path().isEmpty())) {
throw new ODataJPAModelException(
ODataJPAModelException.MessageKeys.ODATA_ANNOTATION_TWO_EXPRESSIONS, internalName);
} else if (jpaAnnotation.constantExpression() != null) {
edmAnnotation.setExpression(new CsdlConstantExpression(jpaAnnotation.constantExpression().type(),
jpaAnnotation.constantExpression().value()));
}
edmAnnotations.add(edmAnnotation);
}
}
/**
* https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html
* @param javaType
*
* @return
*/
protected Class<?> boxPrimitive(final Class<?> javaType) {// NOSONAR
if (javaType == int.class || javaType == Integer.class)
return Integer.class;
else if (javaType == long.class || javaType == Long.class)
return Long.class;
else if (javaType == boolean.class || javaType == Boolean.class)
return Boolean.class;
else if (javaType == byte.class || javaType == Byte.class)
return Byte.class;
else if (javaType == char.class || javaType == Character.class)
return Character.class;
else if (javaType == float.class || javaType == Float.class)
return Float.class;
else if (javaType == short.class || javaType == Short.class)
return Short.class;
else if (javaType == double.class || javaType == Double.class)
return Double.class;
return null;
}
/**
*
* @param name
* @return
*/
protected final FullQualifiedName buildFQN(final String name) {
return new FullQualifiedName(nameBuilder.getNamespace(), name);
}
@Override
public String toString() {
return "IntermediateModelElement [internalName=" + internalName + ", externalName="
+ externalName + ", toBeIgnored=" + toBeIgnored + "]";
}
/**
* @param value
* @return true if string value is null or empty
*/
protected final boolean emptyString(final String value) {
return value == null || value.isEmpty();
}
protected IntermediateAnnotationInformation getAnnotationInformation() {
return annotationInformation;
}
protected CsdlAnnotation filterAnnotation(final String alias, final String term) {
final var annotationFqn = annotationInformation.getReferences().convertAlias(alias) + "." + term;
return edmAnnotations.stream()
.filter(a -> annotationFqn.equals(a.getTerm()))
.findFirst()
.orElse(null);
}
protected void retrieveAnnotations(final ODataAnnotatable annotatable, final Applicability applicability) {
for (final AnnotationProvider provider : annotationInformation.getAnnotationProvider())
edmAnnotations.addAll(provider.getAnnotations(applicability, annotatable, annotationInformation.getReferences()));
}
protected Object getAnnotationValue(final String property, final CsdlExpression annotation)
throws ODataJPAModelInternalException {
if (annotation.isDynamic()) {
return getAnnotationDynamicValue(property, annotation.asDynamic());
}
return getAnnotationConstantValue(annotation.asConstant());
}
protected Object getAnnotationDynamicValue(final String property, final CsdlDynamicExpression expression)
throws ODataJPAModelInternalException {
return null;
}
protected Object getAnnotationConstantValue(final CsdlConstantExpression expression) {
return switch (expression.getType()) {
case Bool -> Boolean.valueOf(expression.getValue());
case Int -> Integer.valueOf(expression.getValue());
case String -> expression.getValue();
case EnumMember -> expression.getValue();
default -> throw new IllegalArgumentException("Unexpected value: " + expression.getType());
};
}
protected Map<String, Annotation> findJavaAnnotation(final String packageName, final Class<?> clazz) {
return findJavaAnnotation(packageName, clazz.getAnnotations());
}
protected Map<String, Annotation> findJavaAnnotation(final String packageName,
final AnnotatedElement annotatedElement) {
return findJavaAnnotation(packageName, annotatedElement.getAnnotations());
}
@SuppressWarnings("unchecked")
protected <T extends IntermediateModelElement> T asUserGroupRestricted(List<String> userGroups) // NOSONAR
throws ODataJPAModelException { // NOSONAR
return (T) this;
}
private Map<String, Annotation> findJavaAnnotation(final String packageName, final Annotation[] annotations) {
final Map<String, Annotation> result = new HashMap<>();
for (final Annotation a : annotations) {
if (a.annotationType().getPackage().getName().equals(packageName)) {
result.put(a.annotationType().getSimpleName(), a);
}
}
return result;
}
protected Optional<CsdlExpression> findAnnotationPropertyValue(final String property,
final CsdlDynamicExpression expression) {
return expression.asRecord()
.getPropertyValues().stream()
.filter(value -> property.equals(value.getProperty()))
.findFirst()
.map(CsdlPropertyValue::getValue);
}
protected Object getAnnotationCollectionValue(final CsdlDynamicExpression expression) {
final List<Object> pathList = new ArrayList<>();
for (final var item : expression.asCollection().getItems()) {
pathList.add(getAnnotationValue("", item));
}
return pathList;
}
protected boolean isRestricted() {
return isRestricted;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateCollectionProperty.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateCollectionProperty.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.NOT_SUPPORTED_NO_IMPLICIT_COLUMNS;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.NOT_SUPPORTED_NO_IMPLICIT_COLUMNS_COMPLEX;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.NOT_SUPPORTED_PROTECTED_COLLECTION;
import static jakarta.persistence.metamodel.Type.PersistenceType.EMBEDDABLE;
import java.lang.reflect.AnnotatedElement;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.CheckForNull;
import jakarta.persistence.CollectionTable;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.metamodel.PluralAttribute;
import jakarta.persistence.metamodel.Type;
import jakarta.persistence.metamodel.Type.PersistenceType;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import com.sap.olingo.jpa.metadata.api.JPAJoinColumn;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPACollectionAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAElement;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAJoinTable;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOnConditionItem;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys;
/**
* Represents a collection property. That is a property that may occur more than once.
* <p>
* For details about Complex Type metadata see:
* <a href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752525"
* >OData Version 4.0 Part 3 - 9 Complex Type</a>
* @author Oliver Grande
* @param <S>: Source type
*/
class IntermediateCollectionProperty<S> extends IntermediateProperty implements JPACollectionAttribute,
JPAAssociationAttribute {
private final IntermediateStructuredType<S> sourceType;
private IntermediateCollectionTable joinTable; // lazy builded
private JPAAssociationPathImpl associationPath; // lazy builded
private final JPAPath path;
/**
* Copy with in new context
* @param jpaElement
* @param intermediateStructuredType
* @throws ODataJPAModelException
*/
public IntermediateCollectionProperty(final IntermediateCollectionProperty<?> original,
final IntermediateStructuredType<S> parent, final IntermediateProperty pathRoot) throws ODataJPAModelException {
super(original.nameBuilder, original.jpaAttribute, original.schema);
this.sourceType = parent;
final List<JPAElement> newPath = new ArrayList<>();
newPath.add(pathRoot);
if (original.path != null) {
newPath.addAll(original.path.getPath());
this.path = new JPAPathImpl(pathRoot.getExternalName() + JPAPath.PATH_SEPARATOR + original.path.getAlias(), "",
newPath);
} else {
newPath.add(this);
this.path = new JPAPathImpl(pathRoot.getExternalName() + JPAPath.PATH_SEPARATOR + original.getExternalName(), "",
newPath);
}
}
IntermediateCollectionProperty(final JPAEdmNameBuilder nameBuilder,
final PluralAttribute<?, ?, ?> jpaAttribute, final IntermediateSchema schema,
final IntermediateStructuredType<S> parent) throws ODataJPAModelException {
super(nameBuilder, jpaAttribute, schema);
this.sourceType = parent;
this.path = null;
}
@Override
public JPAAssociationPath asAssociation() throws ODataJPAModelException {
if (this.associationPath == null) {
getJoinTable();
this.associationPath = new JPAAssociationPathImpl(this,
path == null ? sourceType.getPath(getExternalName()) : path,
joinTable == null ? null : joinTable.getLeftJoinColumns());
}
return associationPath;
}
@Override
public JPAAssociationAttribute getPartner() {
return null;
}
@Override
public JPAAssociationPath getPath() throws ODataJPAModelException {
return asAssociation();
}
@Override
public JPAAttribute getTargetAttribute() throws ODataJPAModelException {
if (isComplex())
return null;
else {
for (final JPAAttribute a : getTargetEntity().getAttributes()) {
if (dbFieldName.equals(((IntermediateProperty) a).getDBFieldName()))
return a;
}
return null;
}
}
@SuppressWarnings("unchecked")
@Override
public JPAStructuredType getTargetEntity() throws ODataJPAModelException {
final JPAJoinTable joinInfo = getJoinTable();
return joinInfo == null ? null : ((IntermediateCollectionTable) joinInfo).getTargetType();
}
@Override
public boolean isAssociation() {
return false;
}
@Override
public boolean isCollection() {
return true;
}
@Override
public boolean isComplex() {
return getRowType().getPersistenceType() == EMBEDDABLE;
}
@Override
public boolean isEtag() {
return false;
}
@Override
public boolean isKey() {
return false;
}
@Override
public boolean isSearchable() {
return false;
}
@Override
protected synchronized void lazyBuildEdmItem() throws ODataJPAModelException {
super.lazyBuildEdmItem();
if (isComplex()
&& schema.getComplexType(this.edmProperty.getTypeAsFQNObject().getName()) == null)
// Base type of collection '%1$s' of structured type '%2$s' not found
throw new ODataJPAModelException(MessageKeys.INVALID_COLLECTION_TYPE, getInternalName(), sourceType
.getInternalName());
edmProperty.setCollection(true);
}
@Override
void checkConsistency() throws ODataJPAModelException {
// Collection Properties do not support EdmProtectedBy
if (hasProtection() ||
(isComplex() && !getStructuredType().getProtections().isEmpty())) {
throw new ODataJPAModelException(NOT_SUPPORTED_PROTECTED_COLLECTION, this.managedType.getJavaType()
.getCanonicalName(), this.internalName);
}
}
@Override
Class<?> determinePropertyType() {
return getRowType().getJavaType();
}
@Override
void determineIsVersion() {
isVersion = false; // Version is always false
}
@Override
void determineStreamInfo() throws ODataJPAModelException {
// Stream properties not supported
}
@Override
void determineStructuredType() {
if (getRowType().getPersistenceType() == PersistenceType.EMBEDDABLE)
type = schema.getStructuredType((PluralAttribute<?, ?, ?>) jpaAttribute);
else
type = null;
}
@Override
FullQualifiedName determineType() throws ODataJPAModelException {
return determineTypeByPersistenceType(getRowType().getPersistenceType());
}
@Override
String getDefaultValue() throws ODataJPAModelException {
// No defaults for collection properties
return null;
}
@CheckForNull
JPAJoinTable getJoinTable() throws ODataJPAModelException {
if (joinTable == null) {
final jakarta.persistence.CollectionTable jpaJoinTable = ((AnnotatedElement) this.jpaAttribute.getJavaMember())
.getAnnotation(jakarta.persistence.CollectionTable.class);
joinTable = jpaJoinTable != null ? new IntermediateCollectionTable(jpaJoinTable, schema) : null;
}
return joinTable;
}
IntermediateStructuredType<S> getSourceType() {
return sourceType;
}
@Override
boolean isStream() {
// OData Version 4.0. Part 3: Common Schema Definition Language (CSDL) Plus Errata 03:
// Edm.Stream, or a type definition whose underlying type is Edm.Stream, cannot be used in collections or for
// non-binding parameters to functions or actions.
return false;
}
private Type<?> getRowType() {
return ((PluralAttribute<?, ?, ?>) jpaAttribute).getElementType();
}
private class IntermediateCollectionTable implements JPAJoinTable {
private final CollectionTable jpaJoinTable;
private final List<IntermediateJoinColumn> joinColumns;
private final JPAEntityType jpaTargetType;
public IntermediateCollectionTable(final CollectionTable jpaJoinTable, final IntermediateSchema schema)
throws ODataJPAModelException {
super();
this.jpaJoinTable = jpaJoinTable;
this.jpaTargetType = schema.getEntityType(jpaJoinTable.catalog(), jpaJoinTable.schema(), jpaJoinTable.name());
this.joinColumns = buildJoinColumns(sourceType);
}
@Override
public JPAEntityType getEntityType() {
return (JPAEntityType) sourceType;
}
JPAStructuredType getTargetType() {
return jpaTargetType;
}
@Override
public List<JPAOnConditionItem> getInverseJoinColumns() throws ODataJPAModelException {
final List<JPAOnConditionItem> result = new ArrayList<>();
for (final IntermediateJoinColumn column : joinColumns) {
result.add(new JPAOnConditionItemImpl(
sourceType.getPathByDBField(column.getName()),
((IntermediateEntityType<?>) jpaTargetType).getPathByDBField(column.getReferencedColumnName())));
}
return result;
}
@Override
public List<JPAOnConditionItem> getJoinColumns() throws ODataJPAModelException {
assert jpaTargetType != null;
final List<JPAOnConditionItem> result = new ArrayList<>();
// Self Join
for (final IntermediateJoinColumn column : joinColumns) {
result.add(new JPAOnConditionItemImpl(
sourceType.getPathByDBField(column.getName()),
sourceType.getPathByDBField(column.getName())));
}
return result;
}
@SuppressWarnings("unchecked")
@Override
public <T extends JPAJoinColumn> List<T> getRawInverseJoinInformation() throws ODataJPAModelException {
final List<T> inverseColumns = new ArrayList<>(joinColumns.size());
for (final IntermediateJoinColumn column : joinColumns) {
final IntermediateJoinColumn inverseColumn = new IntermediateJoinColumn(column.getReferencedColumnName(), column
.getName());
inverseColumns.add((T) inverseColumn);
}
return inverseColumns;
}
@SuppressWarnings("unchecked")
@Override
public <T extends JPAJoinColumn> List<T> getRawJoinInformation() {
return (List<T>) joinColumns;
}
@Override
public String getTableName() {
return buildFQTableName(jpaJoinTable.schema(), jpaJoinTable.name());
}
List<IntermediateJoinColumn> getLeftJoinColumns() throws ODataJPAModelException {
return buildJoinColumns(sourceType);
}
private List<IntermediateJoinColumn> buildJoinColumns(final IntermediateStructuredType<?> contextType)
throws ODataJPAModelException {
final List<IntermediateJoinColumn> result = new ArrayList<>();
for (final JoinColumn column : jpaJoinTable.joinColumns()) {
if (column.referencedColumnName() == null || column.referencedColumnName().isEmpty()) {
if (jpaJoinTable.joinColumns().length > 1)
throw new ODataJPAModelException(NOT_SUPPORTED_NO_IMPLICIT_COLUMNS, getInternalName());
else if (!(contextType instanceof IntermediateEntityType))
throw new ODataJPAModelException(NOT_SUPPORTED_NO_IMPLICIT_COLUMNS_COMPLEX, contextType.getInternalName());
else {
result.add(new IntermediateJoinColumn(
((IntermediateProperty) ((IntermediateEntityType<?>) contextType).getKey().get(0))
.getDBFieldName(), column.name()));
}
} else {
result.add(new IntermediateJoinColumn(column.referencedColumnName(), column.name()));
}
}
return result;
}
@Override
public List<JPAPath> getRightColumnsList() throws ODataJPAModelException {
return getInverseJoinColumns().stream()
.map(JPAOnConditionItem::getRightPath)
.toList();
}
@Override
public List<JPAPath> getLeftColumnsList() throws ODataJPAModelException {
return getJoinColumns().stream()
.map(JPAOnConditionItem::getLeftPath)
.toList();
}
}
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateOperationParameter.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateOperationParameter.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.geo.SRID;
import org.apache.olingo.commons.api.edm.provider.CsdlAbstractEdmItem;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
class IntermediateOperationParameter extends IntermediateModelElement implements JPAParameter {
private final EdmParameter jpaParameter;
private final String externalName;
private final Class<?> type;
IntermediateOperationParameter(final JPAEdmNameBuilder nameBuilder, final EdmParameter jpaParameter,
final String externalName, final String internalName, final Class<?> type,
final IntermediateAnnotationInformation annotationInfo) {
super(nameBuilder, internalName, annotationInfo);
this.jpaParameter = jpaParameter;
this.externalName = externalName;
this.type = type;
}
@Override
public String getInternalName() {
return internalName;
}
@Override
public String getName() {
return externalName;
}
@Override
public Class<?> getType() {
return type.isPrimitive() ? boxPrimitive(type) : type;
}
@Override
public Integer getMaxLength() {
return jpaParameter.maxLength();
}
@Override
public Integer getPrecision() {
return jpaParameter.precision();
}
@Override
public Integer getScale() {
return jpaParameter.scale();
}
@Override
public FullQualifiedName getTypeFQN() throws ODataJPAModelException {
return JPATypeConverter.convertToEdmSimpleType(jpaParameter.type()).getFullQualifiedName();
}
@Override
protected void lazyBuildEdmItem() throws ODataJPAModelException {
// No build needed, as IntermediateOperationParameter is a facade for EdmParameter annotation
}
@Override
CsdlAbstractEdmItem getEdmItem() throws ODataJPAModelException {
return null;
}
@Override
public SRID getSrid() {
if (jpaParameter.srid() != null && !jpaParameter.srid().srid().isEmpty()) {
final SRID srid = SRID.valueOf(jpaParameter.srid().srid());
srid.setDimension(jpaParameter.srid().dimension());
return srid;
} else {
return null;
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateEntitySet.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateEntitySet.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.ENTITY_TYPE_NOT_FOUND;
import java.util.List;
import javax.annotation.CheckForNull;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet;
import org.apache.olingo.commons.api.edm.provider.CsdlEntityType;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.Applicability;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntitySet;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateEntitySetAccess;
/**
* <a href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398028">OData
* Version 4.0 Part 3 - 13.2 Element edm:EntitySet</a>
* @author Oliver Grande
*
*/
final class IntermediateEntitySet extends IntermediateTopLevelEntity implements IntermediateEntitySetAccess,
JPAEntitySet {
private CsdlEntitySet edmEntitySet;
IntermediateEntitySet(final JPAEdmNameBuilder nameBuilder, final IntermediateEntityType<?> et,
final IntermediateAnnotationInformation annotationInfo) throws ODataJPAModelException {
super(nameBuilder, et, annotationInfo);
setExternalName(nameBuilder.buildEntitySetName(et.getEdmItem()));
}
private IntermediateEntitySet(IntermediateEntitySet source, IntermediateEntityType<?> et)
throws ODataJPAModelException {
super(source.nameBuilder, et, source.getAnnotationInformation());
setExternalName(source.getExternalName());
lazyBuildEdmItem();
}
/**
* Returns the entity type that shall be used to create the metadata document.
* This can differ from the internally used one e.g. if multiple entity sets shall
* point to the same entity type, but base on different tables
* @return
* @throws ODataJPAModelException
*/
@Override
@CheckForNull
public JPAEntityType getODataEntityType() throws ODataJPAModelException {
if (entityType.asTopLevelOnly())
return (JPAEntityType) entityType.getBaseType();
else
return entityType;
}
@Override
public void addAnnotations(final List<CsdlAnnotation> annotations) {
this.edmAnnotations.addAll(annotations);
}
@Override
protected synchronized void lazyBuildEdmItem() throws ODataJPAModelException {
if (edmEntitySet == null) {
retrieveAnnotations(this, Applicability.ENTITY_SET);
postProcessor.processEntitySet(this);
edmEntitySet = new CsdlEntitySet();
final var edmEt = determineEdmType();
edmEntitySet.setName(getExternalName());
edmEntitySet.setType(buildFQN(edmEt.getName()));
// Create navigation Property Binding
// V4: An entity set or a singleton SHOULD contain an edm:NavigationPropertyBinding element for each navigation
// property of its entity type, including navigation properties defined on complex typed properties.
// If omitted, clients MUST assume that the target entity set or singleton can vary per related entity.
edmEntitySet.setNavigationPropertyBindings(returnNullIfEmpty(determinePropertyBinding()));
edmEntitySet.setAnnotations(edmAnnotations);
}
}
@Override
CsdlEntitySet getEdmItem() throws ODataJPAModelException { // New test EdmItem with ODataEntityType
lazyBuildEdmItem();
return edmEntitySet;
}
@Override
public CsdlAnnotation getAnnotation(final String alias, final String term) throws ODataJPAModelException {
lazyBuildEdmItem();
return filterAnnotation(alias, term);
}
@SuppressWarnings("unchecked")
@Override
protected <T extends IntermediateModelElement> T asUserGroupRestricted(List<String> userGroups)
throws ODataJPAModelException {
lazyBuildEdmItem();
return (T) new IntermediateEntitySet(this, entityType.asUserGroupRestricted(userGroups));
}
private CsdlEntityType determineEdmType() throws ODataJPAModelException {
final IntermediateEntityType<?> type = (IntermediateEntityType<?>) getODataEntityType();
if (type != null)
return type.getEdmItem();
throw new ODataJPAModelException(ENTITY_TYPE_NOT_FOUND, getInternalName());
}
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateNavigationProperty.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateNavigationProperty.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.MISSING_ONE_TO_ONE_ANNOTATION;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.REFERENCED_PROPERTY_NOT_FOUND;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import javax.annotation.CheckForNull;
import jakarta.persistence.AssociationOverride;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.CascadeType;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.JoinColumns;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import jakarta.persistence.OneToOne;
import jakarta.persistence.metamodel.Attribute;
import jakarta.persistence.metamodel.Attribute.PersistentAttributeType;
import jakarta.persistence.metamodel.PluralAttribute;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
import org.apache.olingo.commons.api.edm.provider.CsdlNavigationProperty;
import org.apache.olingo.commons.api.edm.provider.CsdlOnDelete;
import org.apache.olingo.commons.api.edm.provider.CsdlOnDeleteAction;
import org.apache.olingo.commons.api.edm.provider.CsdlReferentialConstraint;
import org.apache.olingo.commons.api.edm.provider.annotation.CsdlDynamicExpression;
import com.sap.olingo.jpa.metadata.api.JPAJoinColumn;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmIgnore;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmProtectedBy;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmTransientPropertyCalculator;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmVisibleFor;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.Applicability;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ODataAnnotatable;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAJoinTable;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.ListCache;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.ListCacheSupplier;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelIgnoreException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateNavigationPropertyAccess;
/**
* A navigation property describes a relation of one entity type to another entity type and allows to navigate to it.
* IntermediateNavigationProperty represents a navigation within on service, that is source and target are described by
* the same service document.
* <a href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406397962"
* >OData Version 4.0 Part 3 - 7 Navigation Property</a>
* @author Oliver Grande
* @param <S> Type of the parent the navigation belongs to, also called source type
*/
final class IntermediateNavigationProperty<S> extends IntermediateModelElement implements
IntermediateNavigationPropertyAccess, JPAAssociationAttribute, ODataAnnotatable {
private static final Log LOGGER = LogFactory.getLog(IntermediateNavigationProperty.class);
private final Attribute<?, ?> jpaAttribute;
private final ListCache<CsdlReferentialConstraint> referentialConstraints;
private CsdlNavigationProperty edmNavigationProperty;
private CsdlOnDelete edmOnDelete;
private final IntermediateStructuredType<S> sourceType;
private IntermediateStructuredType<?> targetType;
private JPAAssociationAttribute partner;
private final IntermediateSchema schema;
private IntermediateJoinTable joinTable;
private final ListCache<IntermediateJoinColumn> joinColumns;
private final List<String> requiredDbColumns = new ArrayList<>();
private PersistentAttributeType cardinality;
private Optional<String> mappedBy;
IntermediateNavigationProperty(final JPAEdmNameBuilder nameBuilder, final IntermediateStructuredType<S> parent,
final Attribute<?, ?> jpaAttribute, final IntermediateSchema schema) throws ODataJPAModelException {
super(nameBuilder, InternalNameBuilder.buildAssociationName(jpaAttribute), schema.getAnnotationInformation());
this.jpaAttribute = jpaAttribute;
this.schema = schema;
this.sourceType = parent;
this.referentialConstraints = new ListCacheSupplier<>(this::determineReferentialConstraints);
this.joinColumns = new ListCacheSupplier<>(this::buildJoinColumns);
buildNavigationProperty();
}
@Override
public void addAnnotations(final List<CsdlAnnotation> annotations) {
edmAnnotations.addAll(annotations);
}
@Override
public <T extends EdmTransientPropertyCalculator<?>> Constructor<T> getCalculatorConstructor() {
return null;
}
@Override
public <X, Y extends Object> AttributeConverter<X, Y> getConverter() {
return null;
}
@Override
public Class<?> getDbType() {
return null;
}
@Override
public Class<?> getJavaType() {
return null;
}
@Override
public EdmPrimitiveTypeKind getEdmType() {
return null;
}
public JPAJoinTable getJoinTable() {
return joinTable;
}
@Override
public JPAAssociationAttribute getPartner() {
return partner;
}
@Override
public JPAAssociationPath getPath() throws ODataJPAModelException {
return getStructuredType().getAssociationPath(getExternalName());
}
@Override
public CsdlNavigationProperty getProperty() throws ODataJPAModelException {
return getEdmItem();
}
@Override
public Set<String> getProtectionClaimNames() {
return new HashSet<>(0);
}
@Override
public List<String> getProtectionPath(final String claimName) throws ODataJPAModelException {
return new ArrayList<>(0);
}
@Override
public <X, Y extends Object> AttributeConverter<X, Y> getRawConverter() {
return null;
}
@Override
public List<String> getRequiredProperties() {
return Collections.emptyList();
}
@Override
public JPAStructuredType getStructuredType() throws ODataJPAModelException {
if (edmNavigationProperty == null) {
lazyBuildEdmItem();
}
return sourceType;
}
@Override
public JPAStructuredType getTargetEntity() throws ODataJPAModelException {
if (edmNavigationProperty == null) {
lazyBuildEdmItem();
}
return targetType;
}
@Override
public Class<?> getType() {
return jpaAttribute.getJavaType();
}
@Override
public boolean hasProtection() {
return false;
}
@Override
public boolean isAssociation() {
return true;
}
@Override
public boolean isCollection() {
return jpaAttribute.isCollection();
}
@Override
public boolean isTransient() {
return false;
}
@Override
public void setOnDelete(final CsdlOnDelete onDelete) {
edmOnDelete = onDelete;
}
@Override
public String toString() {
return getExternalName() + ": [sourceType=" + sourceType + ", targetType=" + targetType
+ ", partner=" + partnerToString() + ", joinTable=" + joinTable + "]";
}
private String partnerToString() {
return partner == null ? "null" : partner.getExternalName();
}
@Override
protected synchronized void lazyBuildEdmItem() throws ODataJPAModelException {
if (edmNavigationProperty == null) {
edmNavigationProperty = new CsdlNavigationProperty();
edmNavigationProperty.setName(getExternalName());
edmNavigationProperty.setType(buildFQN(targetType.getExternalName()));
edmNavigationProperty.setCollection(jpaAttribute.isCollection());
edmNavigationProperty.setAnnotations(edmAnnotations);
edmNavigationProperty.getReferentialConstraints().addAll(getReferentialConstraints());
// Optional --> RelationAnnotation
determineOnDelete();
// TODO determine ContainsTarget
determinePartner();
}
}
@Override
CsdlNavigationProperty getEdmItem() throws ODataJPAModelException {
if (edmNavigationProperty == null) {
lazyBuildEdmItem();
}
return edmNavigationProperty;
}
@Override
public CsdlAnnotation getAnnotation(final String alias, final String term) throws ODataJPAModelException {
return filterAnnotation(alias, term);
}
@Override
public Object getAnnotationValue(final String alias, final String term, final String property)
throws ODataJPAModelException {
try {
return Optional.ofNullable(getAnnotation(alias, term))
.map(a -> a.getExpression())
.map(expression -> getAnnotationValue(property, expression))
.orElse(null);
} catch (final ODataJPAModelInternalException e) {
throw (ODataJPAModelException) e.getCause();
}
}
@Override
protected Object getAnnotationDynamicValue(final String property, final CsdlDynamicExpression expression)
throws ODataJPAModelInternalException {
if (expression.isRecord()) {
// This may create a problem if the property in question is a record itself. Currently non is supported in
// standard
final var propertyValue = findAnnotationPropertyValue(property, expression);
if (propertyValue.isPresent()) {
return getAnnotationValue(property, propertyValue.get());
}
}
return null;
}
PersistentAttributeType getJoinCardinality() {
return jpaAttribute.getPersistentAttributeType();
}
@SuppressWarnings("unchecked")
<T extends JPAJoinColumn> List<T> getJoinColumns() throws ODataJPAModelException {
return (List<T>) joinColumns.get();
}
List<String> getRequiredDbColumns() throws ODataJPAModelException {
if (edmNavigationProperty == null)
lazyBuildEdmItem();
if (requiredDbColumns.isEmpty()) {
for (final JPAJoinColumn joinColumn : getJoinColumns()) {
requiredDbColumns.add(joinColumn.getName());
}
}
return requiredDbColumns;
}
IntermediateStructuredType<S> getSourceType() {
return sourceType;
}
boolean isMapped() {
return mappedBy.isPresent();
}
/**
* In case the column name is not given at an association a default name is generated according to the JPA standard.
* The default name will be <association name>_<target key name>, all upper case.
* @param annotatedElement
* @param isSourceOne
* @return
* @throws ODataJPAModelException
*/
private String buildDefaultName(final boolean isSourceOne) throws ODataJPAModelException {
final var columnName = new StringBuilder(jpaAttribute.getName());
columnName.append('_');
if (isSourceOne)
columnName.append(((IntermediateSimpleProperty) ((IntermediateEntityType<?>) targetType)
.getKey().get(0)).getDBFieldName());
else
columnName.append(((IntermediateSimpleProperty) ((IntermediateEntityType<?>) sourceType)
.getKey().get(0)).getDBFieldName());
return columnName.toString().replace("\"", "").toUpperCase(Locale.ENGLISH);
}
private IntermediateJoinColumn buildImplicitJoinColumnPair(final boolean isSourceOne) throws ODataJPAModelException {
final var intermediateColumn = new IntermediateJoinColumn(buildDefaultName(isSourceOne),
fillMissingName());
if (LOGGER.isTraceEnabled())
LOGGER.trace(getExternalName() + ": Add join condition with default name = " + intermediateColumn.toString());
return intermediateColumn;
}
private void buildJoinColumnPairList(final boolean isSourceOne, int implicitColumns,
final List<IntermediateJoinColumn> result, final JoinColumn[] columns) throws ODataJPAModelException {
for (final JoinColumn column : columns) {
final var referencedColumnName = column.referencedColumnName();
final var name = column.name();
result.add(buildOneJoinColumnPair(isSourceOne, column));
if (referencedColumnName == null || referencedColumnName.isEmpty() || name == null || name.isEmpty()) {
implicitColumns += 1;
if (implicitColumns > 1)
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.NOT_SUPPORTED_NO_IMPLICIT_COLUMNS,
getInternalName());
}
}
}
private List<IntermediateJoinColumn> buildJoinColumns() {
try {
List<IntermediateJoinColumn> columns = new ArrayList<>();
if (jpaAttribute.getJavaMember() instanceof final AnnotatedElement annotatedElement) {
// Determine referential constraint
final var isSourceOne = !mappedBy.isPresent();
if (mappedBy.isPresent()) {
joinTable = ((IntermediateJoinTable) ((IntermediateNavigationProperty<?>) targetType.getAssociation(
mappedBy.get())).getJoinTable());
if (joinTable == null)
columns = buildJoinColumnsMapped(mappedBy.get());
else
columns = joinTable.buildInverseJoinColumns();
joinTable = joinTable == null ? null : joinTable.asMapped(this);
} else {
if (joinTable == null)
columns = buildJoinColumnsFromAnnotations(isSourceOne, annotatedElement);
else
columns = joinTable.buildJoinColumns();
}
}
return columns;
} catch (final ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
private List<IntermediateJoinColumn> buildJoinColumnsFromAnnotations(final boolean isSourceOne,
final AnnotatedElement annotatedElement) throws ODataJPAModelException {
final var implicitColumns = 0;
final List<IntermediateJoinColumn> result = new ArrayList<>();
final var columns = annotatedElement.getAnnotation(JoinColumns.class) != null ? annotatedElement
.getAnnotation(JoinColumns.class).value() : null;
if (columns != null) {
buildJoinColumnPairList(isSourceOne, implicitColumns, result, columns);
} else {
final var column = annotatedElement.getAnnotation(JoinColumn.class);
if (column != null) {
result.add(buildOneJoinColumnPair(isSourceOne, column));
} else {
// No explicit Join Columns given: Build implicit one.
result.add(buildImplicitJoinColumnPair(isSourceOne));
}
}
return result;
}
private List<IntermediateJoinColumn> buildJoinColumnsMapped(final String mappedBy) throws ODataJPAModelException {
var implicitColumns = 0;
final var result = invertJoinColumns(targetType.getJoinColumns(mappedBy));
for (final IntermediateJoinColumn intermediateColumn : result) {
final var columnName = intermediateColumn.getName();
if (columnName == null || columnName.isEmpty()) {
implicitColumns += 1;
if (implicitColumns > 1)
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.NOT_SUPPORTED_NO_IMPLICIT_COLUMNS,
getInternalName());
intermediateColumn.setName(((IntermediateProperty) ((IntermediateEntityType<?>) sourceType)
.getKey().get(0)).getDBFieldName());
}
}
return result;
}
@Override
public Map<String, Annotation> javaAnnotations(final String packageName) {
return findJavaAnnotation(packageName, ((AnnotatedElement) this.jpaAttribute.getJavaMember()));
}
private void buildNavigationProperty() throws ODataJPAModelException {
this.setExternalName(nameBuilder.buildNaviPropertyName(jpaAttribute));
retrieveAnnotations(this, Applicability.NAVIGATION_PROPERTY);
evaluateAnnotation();
targetType = schema.getEntityType(determineTargetClass());
if (targetType == null)
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.NAVI_PROPERTY_NOT_FOUND,
jpaAttribute.getName(), sourceType.internalName);
postProcessor.processNavigationProperty(this, jpaAttribute.getDeclaringType().getJavaType()
.getCanonicalName());
// Process annotations after post processing, as external name could have been changed
getAnnotations(edmAnnotations, this.jpaAttribute.getJavaMember(), internalName);
checkConsistency();
if (LOGGER.isTraceEnabled())
LOGGER.trace(toString());
}
private void evaluateAnnotation() throws ODataJPAModelException {
if (this.jpaAttribute.getJavaMember() instanceof AnnotatedElement) {
final var jpaIgnore = ((AnnotatedElement) this.jpaAttribute.getJavaMember()).getAnnotation(
EdmIgnore.class);
if (jpaIgnore != null) {
this.setIgnore(true);
}
final var jpaJoinTable = ((AnnotatedElement) this.jpaAttribute.getJavaMember())
.getAnnotation(jakarta.persistence.JoinTable.class);
joinTable = jpaJoinTable != null ? new IntermediateJoinTable(this, jpaJoinTable, schema) : null;
final var annotatedElement = (AnnotatedElement) jpaAttribute.getJavaMember();
cardinality = jpaAttribute.getPersistentAttributeType();
if (cardinality != null) {
mappedBy = switch (cardinality) {
case ONE_TO_MANY -> {
// Association '%1$s' of '%2$s' requires a cardinality annotation.
final var oneTOMany = Optional.ofNullable(annotatedElement.getAnnotation(OneToMany.class))
.orElseThrow(() -> new ODataJPAModelException(MISSING_ONE_TO_ONE_ANNOTATION, internalName, sourceType
.getInternalName()));
yield Optional.ofNullable(returnNullIfEmpty(oneTOMany.mappedBy()));
}
case ONE_TO_ONE -> {
// Association '%1$s' of '%2$s' requires a cardinality annotation.
final var annotation = Optional.ofNullable(annotatedElement.getAnnotation(OneToOne.class))
.orElseThrow(() -> new ODataJPAModelException(MISSING_ONE_TO_ONE_ANNOTATION, internalName, sourceType
.getInternalName()));
yield Optional.ofNullable(returnNullIfEmpty(annotation.mappedBy()));
}
case MANY_TO_MANY -> Optional.ofNullable(returnNullIfEmpty(
annotatedElement.getAnnotation(ManyToMany.class).mappedBy()));
default -> Optional.empty();
};
} else {
mappedBy = Optional.empty();
}
}
}
private Class<?> determineTargetClass() {
Class<?> targetClass = null;
if (jpaAttribute.isCollection()) {
targetClass = ((PluralAttribute<?, ?, ?>) jpaAttribute).getElementType().getJavaType();
} else {
targetClass = jpaAttribute.getJavaType();
}
return targetClass;
}
private IntermediateJoinColumn buildOneJoinColumnPair(final boolean isSourceOne, final JoinColumn column)
throws ODataJPAModelException {
var intermediateColumn = new IntermediateJoinColumn(column);
if (cardinality == PersistentAttributeType.ONE_TO_MANY)
intermediateColumn = new IntermediateJoinColumn(intermediateColumn.getReferencedColumnName(),
intermediateColumn.getName());
fillMissingName(isSourceOne, intermediateColumn);
if (LOGGER.isTraceEnabled())
LOGGER.trace(getExternalName() + ": Add join condition = " + intermediateColumn.toString());
return intermediateColumn;
}
private void checkConsistency() throws ODataJPAModelException {
final var jpaProtectedBy = ((AnnotatedElement) this.jpaAttribute.getJavaMember())
.getAnnotation(EdmProtectedBy.class);
if (jpaProtectedBy != null) {
// Navigation Properties do not support EdmProtectedBy
throw new ODataJPAModelException(MessageKeys.NOT_SUPPORTED_PROTECTED_NAVIGATION, this.sourceType.getTypeClass()
.getCanonicalName(), this.internalName);
}
final var jpaFieldGroups = ((AnnotatedElement) this.jpaAttribute.getJavaMember())
.getAnnotation(EdmVisibleFor.class);
if (jpaFieldGroups != null) {
throw new ODataJPAModelException(MessageKeys.NOT_SUPPORTED_NAVIGATION_PART_OF_GROUP,
this.sourceType.getTypeClass().getCanonicalName(), this.internalName);
}
}
@CheckForNull
private void determineOnDelete() {
if (jpaAttribute.getJavaMember() instanceof AnnotatedElement) {
final var annotatedElement = (AnnotatedElement) jpaAttribute.getJavaMember();
cardinality = jpaAttribute.getPersistentAttributeType();
switch (cardinality) {
case ONE_TO_MANY:
final var cardinalityOtM = annotatedElement.getAnnotation(OneToMany.class);
edmNavigationProperty.setOnDelete(edmOnDelete != null ? edmOnDelete : setJPAOnDelete(cardinalityOtM
.cascade()));
break;
case ONE_TO_ONE:
final var cardinalityOtO = annotatedElement.getAnnotation(OneToOne.class);
edmNavigationProperty.setNullable(cardinalityOtO.optional());
edmNavigationProperty.setOnDelete(edmOnDelete != null ? edmOnDelete : setJPAOnDelete(cardinalityOtO
.cascade()));
break;
case MANY_TO_ONE:
final var cardinalityMtO = annotatedElement.getAnnotation(ManyToOne.class);
edmNavigationProperty.setNullable(cardinalityMtO.optional());
edmNavigationProperty.setOnDelete(edmOnDelete != null ? edmOnDelete : setJPAOnDelete(cardinalityMtO
.cascade()));
break;
case MANY_TO_MANY:
final var cardinalityMtM = annotatedElement.getAnnotation(ManyToMany.class);
edmNavigationProperty.setOnDelete(edmOnDelete != null ? edmOnDelete : setJPAOnDelete(cardinalityMtM
.cascade()));
break;
default:
break;
}
}
}
private void determinePartner() throws ODataJPAModelException {
if (sourceType instanceof IntermediateEntityType) {
// Partner Attribute must not be defined at Complex Types.
// JPA bi-directional associations are defined at both sides, e.g.
// at the BusinessPartner and at the Roles. JPA only defines the
// "mappedBy" at the Parent.
if (mappedBy.isPresent()) {
partner = targetType.getAssociation(mappedBy.get());
edmNavigationProperty.setPartner(partner.getExternalName());
} else {
partner = targetType.getCorrespondingAssociation(sourceType, getInternalName());
if (partner != null
&& ((IntermediateNavigationProperty<?>) partner).isMapped()) {
edmNavigationProperty.setPartner(partner.getExternalName());
}
}
if (LOGGER.isTraceEnabled())
LOGGER.trace(getExternalName() + ": Found partner = " + partnerToString());
}
}
private Optional<CsdlReferentialConstraint> determineReferentialConstraint(
final IntermediateJoinColumn intermediateColumn) throws ODataJPAModelException, ODataJPAModelIgnoreException {
final var constraint = new CsdlReferentialConstraint();
var ignore = false;
var property = sourceType.getPropertyByDBField(intermediateColumn.getName());
if (property != null) {
if (property.ignore())
ignore = true;
constraint.setProperty(property.getExternalName());
property = targetType.getPropertyByDBField(intermediateColumn.getReferencedColumnName());
if (property != null) {
if (property.ignore())
ignore = true;
constraint.setReferencedProperty(property.getExternalName());
} else {
throw new ODataJPAModelException(REFERENCED_PROPERTY_NOT_FOUND, getInternalName(), intermediateColumn
.getReferencedColumnName(), targetType.getExternalName());
}
} else {
if (targetType.getPropertyByDBField(intermediateColumn.getReferencedColumnName()) != null) {
LOGGER.trace("Cloud not determine referential constraint for " + this.getType().getName() + "#"
+ getInternalName());
throw new ODataJPAModelIgnoreException();
} else
return Optional.empty();
}
if (ignore)
throw new ODataJPAModelIgnoreException();
return Optional.of(constraint);
}
private List<CsdlReferentialConstraint> getReferentialConstraints() throws ODataJPAModelException {
return referentialConstraints.get();
}
private List<CsdlReferentialConstraint> determineReferentialConstraints() {
try {
final List<CsdlReferentialConstraint> constraints = new ArrayList<>();
if (jpaAttribute.getJavaMember() instanceof final AnnotatedElement annotatedElement) {
getJoinColumns();
final var overwrite = annotatedElement.getAnnotation(AssociationOverride.class);
if (overwrite != null || joinTable != null)
return List.of();
var ignore = false;
for (final JPAJoinColumn intermediateColumn : getJoinColumns()) {
try {
var constraint = determineReferentialConstraint((IntermediateJoinColumn) intermediateColumn);
if (!constraint.isPresent())
constraint = determineReverseReferentialConstraint((IntermediateJoinColumn) intermediateColumn);
constraints.add(constraint.orElseThrow(
() -> new ODataJPAModelException(REFERENCED_PROPERTY_NOT_FOUND, getInternalName(), intermediateColumn
.getReferencedColumnName(), sourceType.getExternalName())));
} catch (final ODataJPAModelIgnoreException e) {
ignore = true;
}
}
if (ignore)
constraints.clear();
}
return constraints;
} catch (final ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
private Optional<CsdlReferentialConstraint> determineReverseReferentialConstraint(
final IntermediateJoinColumn intermediateColumn) throws ODataJPAModelException, ODataJPAModelIgnoreException {
final var constraint = new CsdlReferentialConstraint();
var ignore = false;
IntermediateModelElement property = null;
property = sourceType.getPropertyByDBField(intermediateColumn.getReferencedColumnName());
if (property != null) {
if (property.ignore())
ignore = true;
constraint.setProperty(property.getExternalName());
property = targetType.getPropertyByDBField(intermediateColumn.getName());
if (property != null) {
if (property.ignore())
ignore = true;
constraint.setReferencedProperty(property.getExternalName());
} else {
// Target not found: system will fallback to default column names, no referential constraint can be given
LOGGER.trace("Cloud not determine referential constraint for " + this.getType().getName() + "#"
+ getInternalName());
throw new ODataJPAModelIgnoreException();
}
} else {
return Optional.empty();
}
if (ignore)
throw new ODataJPAModelIgnoreException();
return Optional.of(constraint);
}
private String fillMissingName() throws ODataJPAModelException {
return ((IntermediateSimpleProperty) ((IntermediateEntityType<?>) targetType)
.getKey().get(0)).getDBFieldName();
}
private void fillMissingName(final boolean isSourceOne, final IntermediateJoinColumn intermediateColumn)
throws ODataJPAModelException {
final var referencedColumnName = intermediateColumn.getReferencedColumnName();
final var name = intermediateColumn.getName();
if (isSourceOne && (name == null || name.isEmpty()))
intermediateColumn.setName(((IntermediateSimpleProperty) ((IntermediateEntityType<?>) sourceType)
.getKey().get(0)).getDBFieldName());
else if (isSourceOne && (referencedColumnName == null || referencedColumnName.isEmpty()))
intermediateColumn.setReferencedColumnName(((IntermediateSimpleProperty) ((IntermediateEntityType<?>) targetType)
.getKey().get(0)).getDBFieldName());
else if (!isSourceOne && (referencedColumnName == null || referencedColumnName.isEmpty()))
intermediateColumn.setName(((IntermediateSimpleProperty) ((IntermediateEntityType<?>) targetType)
.getKey().get(0)).getDBFieldName());
else if (!isSourceOne && (name == null || name.isEmpty()))
intermediateColumn.setReferencedColumnName(((IntermediateSimpleProperty) ((IntermediateEntityType<?>) sourceType)
.getKey().get(0)).getDBFieldName());
}
private List<IntermediateJoinColumn> invertJoinColumns(final List<IntermediateJoinColumn> joinColumns) {
final List<IntermediateJoinColumn> invertedJoinColumns = new ArrayList<>(joinColumns.size());
for (final IntermediateJoinColumn joinColumn : joinColumns) {
invertedJoinColumns.add(
new IntermediateJoinColumn(joinColumn.getReferencedColumnName(), joinColumn.getName()));
}
return invertedJoinColumns;
}
private CsdlOnDelete setJPAOnDelete(final CascadeType[] cascades) {
for (final CascadeType cascade : cascades) {
if (cascade == CascadeType.REMOVE || cascade == CascadeType.ALL) {
final var onDelete = new CsdlOnDelete();
onDelete.setAction(CsdlOnDeleteAction.Cascade);
return onDelete;
}
}
return null;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateDataBaseFunction.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateDataBaseFunction.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.ArrayList;
import java.util.List;
import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.geo.SRID;
import org.apache.olingo.commons.api.edm.provider.CsdlParameter;
import org.apache.olingo.commons.api.edm.provider.CsdlReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunctionType;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPADataBaseFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOperationResultParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAParameter;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys;
class IntermediateDataBaseFunction extends IntermediateFunction implements JPADataBaseFunction {
private final Class<?> jpaDefiningPOJO;
IntermediateDataBaseFunction(final JPAEdmNameBuilder nameBuilder, final EdmFunction jpaFunction,
final Class<?> definingPOJO, final IntermediateSchema schema) {
super(nameBuilder, jpaFunction, schema, InternalNameBuilder.buildFunctionName(jpaFunction));
this.setExternalName(jpaFunction.name());
this.jpaDefiningPOJO = definingPOJO;
}
@Override
public String getDBName() {
return jpaFunction.functionName();
}
@Override
public EdmFunctionType getFunctionType() {
return EdmFunctionType.UserDefinedFunction;
}
@Override
public List<JPAParameter> getParameter() {
final List<JPAParameter> parameterList = new ArrayList<>();
for (final EdmParameter jpaParameter : jpaFunction.parameter()) {
parameterList.add(new IntermediateFunctionParameter(nameBuilder, jpaParameter, getAnnotationInformation()));
}
return parameterList;
}
@Override
public JPAParameter getParameter(final String internalName) {
for (final JPAParameter parameter : getParameter()) {
if (parameter.getInternalName().equals(internalName))
return parameter;
}
return null;
}
@Override
public JPAOperationResultParameter getResultParameter() {
final IntermediateStructuredType<?> et = schema.getEntityType(jpaDefiningPOJO);
if (et != null)
return new IntermediateOperationResultParameter(this, jpaFunction.returnType(),
jpaFunction.returnType().type().equals(Object.class) ? et.getTypeClass()
: jpaFunction.returnType().type());
throw new IllegalArgumentException("Cloud not determine return paramter. " + jpaDefiningPOJO
+ " can not be mapped to an entity type");
}
@Override
public CsdlReturnType getReturnType() {
return edmFunction.getReturnType();
}
@Override
protected List<CsdlParameter> determineEdmInputParameter() throws ODataJPAModelException {
int noParameterToSkip = 0;
final List<CsdlParameter> edmInputParameterList = new ArrayList<>();
if (jpaFunction.isBound()) {
noParameterToSkip = ((IntermediateEntityType<?>) schema.getEntityType(this.jpaDefiningPOJO)).getKey().size();
final CsdlParameter edmInputParameter = new CsdlParameter();
final IntermediateStructuredType<?> et = schema.getEntityType(jpaDefiningPOJO);
edmInputParameter.setName("Key");
edmInputParameter.setType(buildFQN(et.getEdmItem().getName()));
edmInputParameter.setNullable(false);
edmInputParameterList.add(edmInputParameter);
}
for (int i = noParameterToSkip; i < jpaFunction.parameter().length; i++) {
final EdmParameter jpaParameter = jpaFunction.parameter()[i];
final CsdlParameter edmInputParameter = new CsdlParameter();
edmInputParameter.setName(jpaParameter.name());
edmInputParameter.setType(determineParameterType(null, jpaParameter));
edmInputParameter.setNullable(false);
edmInputParameter.setCollection(jpaParameter.isCollection());
if (jpaParameter.maxLength() >= 0)
edmInputParameter.setMaxLength(jpaParameter.maxLength());
if (jpaParameter.precision() >= 0)
edmInputParameter.setPrecision(jpaParameter.precision());
if (jpaParameter.scale() >= 0)
edmInputParameter.setScale(jpaParameter.scale());
if (jpaParameter.srid() != null && !jpaParameter.srid().srid().isEmpty()) {
final SRID srid = SRID.valueOf(jpaParameter.srid().srid());
srid.setDimension(jpaParameter.srid().dimension());
edmInputParameter.setSrid(srid);
}
edmInputParameterList.add(edmInputParameter);
}
return edmInputParameterList;
}
// TODO handle multiple schemas
@Override
protected CsdlReturnType determineEdmResultType(final ReturnType returnType) throws ODataJPAModelException {
final CsdlReturnType edmResultType = new CsdlReturnType();
edmResultType.setType(determineReturnType(returnType));
edmResultType.setCollection(returnType.isCollection());
edmResultType.setNullable(returnType.isNullable());
if (returnType.maxLength() >= 0)
edmResultType.setMaxLength(returnType.maxLength());
if (returnType.precision() >= 0)
edmResultType.setPrecision(returnType.precision());
if (returnType.scale() >= 0)
edmResultType.setScale(returnType.scale());
if (returnType.srid() != null && !returnType.srid().srid().isEmpty()) {
final SRID srid = SRID.valueOf(returnType.srid().srid());
srid.setDimension(returnType.srid().dimension());
edmResultType.setSrid(srid);
}
return edmResultType;
}
@Override
protected FullQualifiedName determineParameterType(final Class<?> type, final EdmParameter definedParameter)
throws ODataJPAModelException {
final EdmPrimitiveTypeKind edmType = JPATypeConverter.convertToEdmSimpleType(definedParameter.type());
if (edmType != null)
return edmType.getFullQualifiedName();
else {
final IntermediateEnumerationType enumType = schema.getEnumerationType(definedParameter.type());
if (enumType != null) {
return enumType.getExternalFQN();
} else {
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.FUNC_CONV_ERROR);
}
}
}
private FullQualifiedName determineReturnType(final ReturnType returnType) throws ODataJPAModelException {
if (returnType.type() == Object.class) {
return determineReturnTypeObject();
} else {
return determineStructuredReturnType(returnType);
}
}
private FullQualifiedName determineStructuredReturnType(final ReturnType returnType) throws ODataJPAModelException {
final IntermediateStructuredType<?> st = schema.getStructuredType(returnType.type());
if (st != null) {
this.setIgnore(st.ignore()); // If the result type shall be ignored, ignore also a function that returns it
return buildFQN(st.getEdmItem().getName());
} else {
final IntermediateEnumerationType enumType = schema.getEnumerationType(returnType.type());
if (enumType != null) {
return enumType.getExternalFQN();
} else {
final EdmPrimitiveTypeKind pt = JPATypeConverter.convertToEdmSimpleType(returnType.type());
if (pt != null)
return pt.getFullQualifiedName();
else
throw new ODataJPAModelException(MessageKeys.FUNC_RETURN_TYPE_UNKNOWN);
}
}
}
private FullQualifiedName determineReturnTypeObject() throws ODataJPAModelException {
final IntermediateStructuredType<?> et = schema.getEntityType(jpaDefiningPOJO);
if (et == null)
throw new IllegalArgumentException("Cloud not determine return paramter. " + jpaDefiningPOJO
+ " can not be mapped to an entity type");
this.setIgnore(et.ignore()); // If the result type shall be ignored, ignore also a function that returns it
return buildFQN(et.getEdmItem().getName());
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateInheritanceInformationSingleTable.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateInheritanceInformationSingleTable.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.List;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAInheritanceInformation;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAInheritanceType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOnConditionItem;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
class IntermediateInheritanceInformationSingleTable implements JPAInheritanceInformation {
@Override
public JPAInheritanceType getInheritanceType() {
return JPAInheritanceType.SINGLE_TABLE;
}
@Override
public List<JPAOnConditionItem> getJoinColumnsList() throws ODataJPAModelException {
return List.of();
}
@Override
public List<JPAOnConditionItem> getReversedJoinColumnsList() throws ODataJPAModelException {
return List.of();
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateAnnotationInformation.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateAnnotationInformation.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.List;
import org.apache.olingo.commons.api.edm.provider.CsdlSchema;
import org.apache.olingo.commons.api.edmx.EdmxReference;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.AnnotationProvider;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.JPAReferences;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateReferenceList;
final class IntermediateAnnotationInformation {
private final List<AnnotationProvider> annotationProvider;
private final IntermediateReferences references;
IntermediateAnnotationInformation(final List<AnnotationProvider> annotationProvider,
final IntermediateReferences references) {
super();
this.annotationProvider = annotationProvider;
this.references = references;
}
IntermediateAnnotationInformation(final List<AnnotationProvider> annotationProvider) {
this(annotationProvider, new IntermediateReferences());
}
List<AnnotationProvider> getAnnotationProvider() {
return annotationProvider;
}
JPAReferences getReferences() {
return references;
}
IntermediateReferenceList asReferenceList() {
return references;
}
/**
* Returns the schemas of the provided references
*/
List<CsdlSchema> getSchemas() {
return references.getSchemas();
}
List<EdmxReference> getEdmReferences() {
return references.getEdmReferences();
}
@Override
public String toString() {
return "IntermediateAnnotationInformation [references=" + references + ", annotationProvider=" + annotationProvider
+ "]";
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateOperationHelper.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateOperationHelper.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.FUNC_CONSTRUCTOR_MISSING;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.FUNC_RETURN_NOT_SUPPORTED;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.FUNC_RETURN_TYPE_INVALID;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.OPERATION_CONSTRUCTOR_WRONG_PARAMETER;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.OPERATION_CONSTRUCTOR_WRONG_PARAMETER_COMBINATION;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.sql.Blob;
import java.sql.Clob;
import java.util.Arrays;
import java.util.Collection;
import jakarta.persistence.EntityManager;
import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.api.JPAODataQueryContext;
import com.sap.olingo.jpa.metadata.api.JPARequestParameterMap;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction.ReturnType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
public class IntermediateOperationHelper {
private IntermediateOperationHelper() {
// Must not create instances
}
@SuppressWarnings("unchecked")
static <T> Constructor<T> determineConstructor(final Method javaOperation) throws ODataJPAModelException {
Constructor<T> result = null;
final Constructor<T>[] constructors = (Constructor<T>[]) ((Class<T>) javaOperation.getDeclaringClass())
.getConstructors();
for (final Constructor<T> constructor : constructors) {
final Parameter[] parameters = constructor.getParameters();
if (parameters.length == 0)
result = constructor;
else {
checkConstructorParameter(javaOperation, constructor);
result = constructor;
}
}
if (result == null)
throw new ODataJPAModelException(FUNC_CONSTRUCTOR_MISSING, javaOperation.getClass().getName());
return result;
}
private static <T> void checkConstructorParameter(final Method javaOperation, final Constructor<T> constructor)
throws ODataJPAModelException {
boolean queryContextFound = false;
boolean otherFound = false;
for (final Parameter p : constructor.getParameters()) {
if (!(p.getType().isAssignableFrom(EntityManager.class)
|| p.getType().isAssignableFrom(JPARequestParameterMap.class)
|| p.getType().isAssignableFrom(JPAHttpHeaderMap.class)
|| p.getType().isAssignableFrom(JPAODataQueryContext.class)))
throw new ODataJPAModelException(OPERATION_CONSTRUCTOR_WRONG_PARAMETER,
javaOperation.getDeclaringClass().getName(), p.getName(), p.getType().getName());
if (p.getType().isAssignableFrom(JPAODataQueryContext.class))
queryContextFound = true;
else
otherFound = true;
}
if (queryContextFound && otherFound)
throw new ODataJPAModelException(OPERATION_CONSTRUCTOR_WRONG_PARAMETER_COMBINATION,
javaOperation.getDeclaringClass().getName());
}
static boolean isCollection(final Class<?> declaredReturnType) {
for (final Class<?> inter : Arrays.asList(declaredReturnType.getInterfaces())) {
if (inter == Collection.class) {
return true;
} else if (isCollection(inter))
return true;
}
return false;
}
static FullQualifiedName determineReturnType(final ReturnType definedReturnType, final Class<?> declaredReturnType,
final IntermediateSchema schema, final String operationName) throws ODataJPAModelException {
final IntermediateStructuredType<?> structuredType = schema.getStructuredType(declaredReturnType);
if (structuredType != null)
return structuredType.getExternalFQN();
else {
final IntermediateEnumerationType enumType = schema.getEnumerationType(declaredReturnType);
if (enumType != null) {
return enumType.getExternalFQN();
} else if (declaredReturnType.equals(Blob.class) || declaredReturnType.equals(Clob.class)) {
// The return type '%1$s' used at method '%3$s' is not supported
throw new ODataJPAModelException(FUNC_RETURN_NOT_SUPPORTED, declaredReturnType.getName(),
operationName);
} else {
EdmPrimitiveTypeKind edmType = JPATypeConverter.convertToEdmSimpleType(declaredReturnType);
if (edmType == null) {
edmType = JPATypeConverter.convertToEdmSimpleType(definedReturnType.type());
if (edmType == null)
throw new ODataJPAModelException(FUNC_RETURN_TYPE_INVALID, definedReturnType.type().getName(),
declaredReturnType.getName(), operationName);
}
return edmType.getFullQualifiedName();
}
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateSingleton.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateSingleton.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.List;
import org.apache.olingo.commons.api.edm.provider.CsdlAnnotation;
import org.apache.olingo.commons.api.edm.provider.CsdlSingleton;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.Applicability;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPASingleton;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateSingletonAccess;
/**
* <a href=
* "http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_Toc406398032">OData
* Version 4.0 Part 3 - 13.3 Element edm:Singleton</a>
* @author Oliver Grande
* @since 1.0.3
*/
final class IntermediateSingleton extends IntermediateTopLevelEntity implements IntermediateSingletonAccess,
JPASingleton {
private CsdlSingleton edmSingleton;
IntermediateSingleton(final JPAEdmNameBuilder nameBuilder, final IntermediateEntityType<?> et,
final IntermediateAnnotationInformation annotationInfo)
throws ODataJPAModelException {
super(nameBuilder, et, annotationInfo);
setExternalName(nameBuilder.buildSingletonName(et.getEdmItem()));
}
private IntermediateSingleton(IntermediateSingleton source,
IntermediateEntityType<?> et) throws ODataJPAModelException {
super(source.nameBuilder, et, source.getAnnotationInformation());
setExternalName(source.getExternalName());
lazyBuildEdmItem();
}
@Override
public void addAnnotations(final List<CsdlAnnotation> annotations) {
this.edmAnnotations.addAll(annotations);
}
@Override
protected synchronized void lazyBuildEdmItem() throws ODataJPAModelException {
if (edmSingleton == null) {
retrieveAnnotations(this, Applicability.SINGLETON);
postProcessor.processSingleton(this);
edmSingleton = new CsdlSingleton();
final var edmEt = ((IntermediateEntityType<?>) getODataEntityType()).getEdmItem();
edmSingleton.setName(getExternalName());
edmSingleton.setType(buildFQN(edmEt.getName()));
edmSingleton.setMapping(null);
// Create navigation Property Binding
// V4: An entity set or a singleton SHOULD contain an edm:NavigationPropertyBinding element for each navigation
// property of its entity type, including navigation properties defined on complex typed properties.
// If omitted, clients MUST assume that the target entity set or singleton can vary per related entity.
edmSingleton.setNavigationPropertyBindings(determinePropertyBinding());
edmSingleton.setAnnotations(edmAnnotations);
}
}
@Override
CsdlSingleton getEdmItem() throws ODataJPAModelException {
if (edmSingleton == null) {
lazyBuildEdmItem();
}
return edmSingleton;
}
@Override
public CsdlAnnotation getAnnotation(final String alias, final String term) throws ODataJPAModelException {
if (edmSingleton == null) {
lazyBuildEdmItem();
}
return filterAnnotation(alias, term);
}
@SuppressWarnings("unchecked")
@Override
protected <T extends IntermediateModelElement> T asUserGroupRestricted(List<String> userGroups)
throws ODataJPAModelException {
lazyBuildEdmItem();
return (T) new IntermediateSingleton(this, entityType.asUserGroupRestricted(userGroups));
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPAQueryExtensionProvider.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPAQueryExtensionProvider.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.EXTENSION_PROVIDER_TOO_MANY_CONSTRUCTORS;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.EXTENSION_PROVIDER_WRONG_PARAMETER;
import java.lang.reflect.Constructor;
import java.lang.reflect.Parameter;
import javax.annotation.Nonnull;
import com.sap.olingo.jpa.metadata.api.JPAHttpHeaderMap;
import com.sap.olingo.jpa.metadata.api.JPARequestParameterMap;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmQueryExtensionProvider;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAQueryExtension;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
class JPAQueryExtensionProvider<X extends EdmQueryExtensionProvider> implements JPAQueryExtension<X> {
private final Constructor<X> constructor;
@SuppressWarnings("unchecked")
JPAQueryExtensionProvider(@Nonnull final Class<X> provider)
throws ODataJPAModelException {
final Constructor<?>[] constructors = provider.getConstructors();
if (constructors.length > 1)
throw new ODataJPAModelException(EXTENSION_PROVIDER_TOO_MANY_CONSTRUCTORS, provider.getCanonicalName());
final Constructor<?> c = provider.getConstructors()[0];
for (final Parameter p : c.getParameters()) {
if (p.getType() != JPAHttpHeaderMap.class
&& p.getType() != JPARequestParameterMap.class)
throw new ODataJPAModelException(EXTENSION_PROVIDER_WRONG_PARAMETER, provider.getCanonicalName());
}
this.constructor = (Constructor<X>) provider.getConstructors()[0];
}
@Override
public Constructor<X> getConstructor() {
return constructor;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateDescriptionProperty.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateDescriptionProperty.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.JoinColumns;
import jakarta.persistence.metamodel.Attribute;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmDescriptionAssociation;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.Cardinality;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAssociationPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPADescriptionAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAElement;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAJoinTable;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOnConditionItem;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.InstanceCache;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.InstanceCacheSupplier;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.MapCache;
import com.sap.olingo.jpa.metadata.core.edm.mapper.cache.MapCacheSupplier;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelInternalException;
final class IntermediateDescriptionProperty extends IntermediateSimpleProperty implements JPADescriptionAttribute,
JPAAssociationAttribute {
private IntermediateSimpleProperty descriptionProperty;
private String localeAttribute;
private final IntermediateStructuredType<?> sourceType;
private final InstanceCache<JPAStructuredType> targetEntity;
private final MapCache<JPAPath, String> fixedValues;
private JPAPath localFieldPath;
private Optional<JPAAssociationPath> associationPath;
IntermediateDescriptionProperty(final JPAEdmNameBuilder nameBuilder, final Attribute<?, ?> jpaAttribute,
final IntermediateStructuredType<?> parent, final IntermediateSchema schema) throws ODataJPAModelException {
super(nameBuilder, jpaAttribute, schema);
this.sourceType = parent;
this.associationPath = Optional.empty();
this.targetEntity = new InstanceCacheSupplier<>(this::determineTargetEntityType);
this.fixedValues = new MapCacheSupplier<>(this::determineFixedValues);
}
@Override
public JPAAttribute getDescriptionAttribute() {
return descriptionProperty;
}
@Override
public Map<JPAPath, String> getFixedValueAssignment() {
try {
return fixedValues.get();
} catch (final ODataJPAModelException e) {
throw new IllegalArgumentException(e);
}
}
@Override
public JPAPath getLocaleFieldName() {
return localFieldPath;
}
/**
* @return Type of description attribute
*/
@Override
public Class<?> getType() {
return descriptionProperty.getType();
}
@Override
public boolean isAssociation() {
return true;
}
@Override
public boolean isLocationJoin() {
return !localeAttribute.isEmpty();
}
@SuppressWarnings("unchecked")
@Override
protected <T extends IntermediateModelElement> T asUserGroupRestricted(final List<String> userGroups) // NOSONAR
throws ODataJPAModelException {
return (T) this;
}
@Override
protected synchronized void lazyBuildEdmItem() throws ODataJPAModelException {
final Member jpaMember = jpaAttribute.getJavaMember();
if (this.edmProperty == null) {
super.lazyBuildEdmItem();
if (jpaMember instanceof final AnnotatedElement annotatedElement) {
final EdmDescriptionAssociation association = annotatedElement.getAnnotation(EdmDescriptionAssociation.class);
if (association != null) {
// determine generic type of a collection in case of an OneToMany association
descriptionProperty = (IntermediateSimpleProperty) getTargetType().getAttribute(association
.descriptionAttribute())
.orElseThrow(() ->
// The attribute %2$s has not been found at entity %1$s
new ODataJPAModelException(MessageKeys.INVALID_DESCRIPTION_PROPERTY, getTargetType().getInternalName(),
association.descriptionAttribute()));
final var languageAttribute = association.languageAttribute();
localeAttribute = association.localeAttribute();
checkConsistencyOfLocalInfo(languageAttribute);
localFieldPath = convertAttributeToPath(!languageAttribute.isEmpty() ? languageAttribute : localeAttribute);
edmProperty.setType(JPATypeConverter.convertToEdmSimpleType(descriptionProperty.getType())
.getFullQualifiedName());
edmProperty.setMaxLength(descriptionProperty.getEdmItem().getMaxLength());
} else {
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.DESCRIPTION_ANNOTATION_MISSING,
sourceType.getInternalName(), this.internalName);
}
}
}
}
private Map<JPAPath, String> determineFixedValues() {
if (jpaAttribute.getJavaMember() instanceof final AnnotatedElement annotatedElement) {
try {
final EdmDescriptionAssociation association = annotatedElement.getAnnotation(EdmDescriptionAssociation.class);
if (association != null) {
final HashMap<JPAPath, String> result = new HashMap<>();
for (final EdmDescriptionAssociation.valueAssignment value : association.valueAssignments()) {
result.put(convertAttributeToPath(value.attribute()), value.value());
}
return result;
}
} catch (final ODataJPAModelException e) {
throw new ODataJPAModelInternalException(e);
}
}
return Map.of();
}
private JPAStructuredType getTargetType() {
try {
return targetEntity.get().orElseThrow(() -> new NullPointerException(
"Description proerty not target type available"));
} catch (final ODataJPAModelException e) {
throw new IllegalArgumentException(e);
}
}
private JPAStructuredType determineTargetEntityType() {
final Member jpaMember = jpaAttribute.getJavaMember();
if (jpaMember instanceof final Field jpaField) {
final ParameterizedType jpaTargetEntityType = (ParameterizedType) jpaField.getGenericType();
if (jpaTargetEntityType != null)
return schema.getEntityType((Class<?>) jpaTargetEntityType.getActualTypeArguments()[0]);
else
return schema.getEntityType(jpaAttribute.getJavaType());
} else {
return schema.getEntityType(jpaAttribute.getJavaType());
}
}
private void checkConsistencyOfLocalInfo(final String languageAttribute) throws ODataJPAModelException {
if ((emptyString(languageAttribute) && emptyString(localeAttribute)) ||
(!languageAttribute.isEmpty() && !localeAttribute.isEmpty()))
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.DESCRIPTION_LOCALE_FIELD_MISSING,
getTargetType().getInternalName(), this.internalName);
if (!descriptionProperty.getType().equals(String.class))
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.DESCRIPTION_FIELD_WRONG_TYPE,
getTargetType().getInternalName(), this.internalName);
}
private JPAPath convertAttributeToPath(final String attribute) throws ODataJPAModelException {
final String[] pathItems = attribute.split(JPAPath.PATH_SEPARATOR);
if (pathItems.length > 1) {
final List<JPAElement> targetPath = new ArrayList<>();
IntermediateSimpleProperty nextHop = (IntermediateSimpleProperty) getTargetType().getAttribute(pathItems[0])
.orElseThrow(() -> new ODataJPAModelException(MessageKeys.PATH_ELEMENT_NOT_FOUND, pathItems[0], attribute));
targetPath.add(nextHop);
for (int i = 1; i < pathItems.length; i++) {
if (nextHop.isComplex()) {
nextHop = (IntermediateSimpleProperty) nextHop.getStructuredType().getAttribute(pathItems[i])
.orElseThrow(() -> new ODataJPAModelException(MessageKeys.PATH_ELEMENT_NOT_FOUND, pathItems[0],
attribute));
targetPath.add(nextHop);
}
}
return new JPAPathImpl(nextHop.getExternalName(), nextHop.getDBFieldName(), targetPath);
} else {
final IntermediateSimpleProperty property = (IntermediateSimpleProperty) getTargetType().getAttribute(attribute)
.orElseThrow(() -> new ODataJPAModelException(MessageKeys.PATH_ELEMENT_NOT_FOUND, pathItems[0], attribute));
return new JPAPathImpl(property.getExternalName(), property.getDBFieldName(), property);
}
}
@Override
public JPAAssociationAttribute asAssociationAttribute() {
return this;
}
@Override
public JPAStructuredType getTargetEntity() throws ODataJPAModelException {
return getTargetType();
}
@Override
public JPAAssociationAttribute getPartner() {
return null;
}
@Override
public JPAAssociationPath getPath() throws ODataJPAModelException {
return associationPath.orElseGet(() -> {
associationPath = Optional.of(new AssociationPath(getTargetType()));
return associationPath.get();
});
}
private class AssociationPath implements JPAAssociationPath {
private List<IntermediateJoinColumn> joinColumns = null;
private final JPAStructuredType target;
private AssociationPath(final JPAStructuredType target) {
super();
this.target = target;
}
@Override
public String getAlias() {
return null;
}
@Override
public List<JPAOnConditionItem> getJoinColumnsList() throws ODataJPAModelException {
if (joinColumns == null)
joinColumns = buildJoinColumnsFromAnnotations(true, (AnnotatedElement) jpaAttribute.getJavaMember());
final List<JPAOnConditionItem> result = new ArrayList<>();
for (final IntermediateJoinColumn column : this.joinColumns) {
result.add(new JPAOnConditionItemImpl(
sourceType.getPathByDBField(column.getReferencedColumnName()),
((IntermediateStructuredType<?>) target).getPathByDBField(column.getName())));
}
return result;
}
@Override
public List<JPAPath> getLeftColumnsList() throws ODataJPAModelException {
return Collections.emptyList();
}
@Override
public List<JPAPath> getRightColumnsList() throws ODataJPAModelException {
return Collections.emptyList();
}
@Override
public List<JPAPath> getForeignKeyColumns() throws ODataJPAModelException {
return List.of();
}
@Override
public JPAAssociationAttribute getLeaf() {
return null;
}
@Override
public List<JPAElement> getPath() {
return Collections.emptyList();
}
@Override
public JPAStructuredType getTargetType() {
return target;
}
@Override
public JPAStructuredType getSourceType() {
return sourceType;
}
@Override
public boolean isCollection() {
return false;
}
@Override
public JPAAssociationAttribute getPartner() {
return null;
}
@Override
public JPAJoinTable getJoinTable() {
return null;
}
@Override
public List<JPAPath> getInverseLeftJoinColumnsList() throws ODataJPAModelException {
return Collections.emptyList();
}
private List<IntermediateJoinColumn> buildJoinColumnsFromAnnotations(final boolean isSourceOne,
final AnnotatedElement annotatedElement) throws ODataJPAModelException {
int implicitColumns = 0;
final List<IntermediateJoinColumn> result = new ArrayList<>();
final JoinColumn[] columns = annotatedElement.getAnnotation(JoinColumns.class) != null ? annotatedElement
.getAnnotation(JoinColumns.class).value() : null;
if (columns != null) {
for (final JoinColumn column : columns) {
final IntermediateJoinColumn intermediateColumn = new IntermediateJoinColumn(column);
final String referencedColumnName = intermediateColumn.getReferencedColumnName();
final String name = intermediateColumn.getName();
if (referencedColumnName == null || referencedColumnName.isEmpty() || name == null || name.isEmpty()) {
implicitColumns += 1;
if (implicitColumns > 1)
throw new ODataJPAModelException(ODataJPAModelException.MessageKeys.NOT_SUPPORTED_NO_IMPLICIT_COLUMNS,
getInternalName());
fillMissingName(isSourceOne, intermediateColumn);
}
result.add(intermediateColumn);
}
} else {
final JoinColumn column = annotatedElement.getAnnotation(JoinColumn.class);
if (column != null) {
final IntermediateJoinColumn intermediateColumn = new IntermediateJoinColumn(column);
fillMissingName(isSourceOne, intermediateColumn);
result.add(intermediateColumn);
}
}
return result;
}
private void fillMissingName(final boolean isSourceOne, final IntermediateJoinColumn intermediateColumn)
throws ODataJPAModelException {
final String referencedColumnName = intermediateColumn.getReferencedColumnName();
final String name = intermediateColumn.getName();
if (isSourceOne && (emptyString(referencedColumnName)))
intermediateColumn.setReferencedColumnName(
((IntermediateSimpleProperty) ((IntermediateEntityType<?>) sourceType)
.getKey().get(0)).getDBFieldName());
else if (isSourceOne && (emptyString(name)))
intermediateColumn.setReferencedColumnName(
((IntermediateSimpleProperty) ((IntermediateEntityType<?>) target)
.getKey().get(0)).getDBFieldName());
else if (!isSourceOne && (emptyString(referencedColumnName)))
intermediateColumn.setReferencedColumnName(
((IntermediateSimpleProperty) ((IntermediateEntityType<?>) target)
.getKey().get(0)).getDBFieldName());
else if (!isSourceOne && (emptyString(name)))
intermediateColumn.setReferencedColumnName(
((IntermediateSimpleProperty) ((IntermediateEntityType<?>) sourceType)
.getKey().get(0)).getDBFieldName());
}
@Override
public boolean hasJoinTable() {
return false;
}
@Override
public String getPathAsString() {
return getAlias();
}
@Override
public Cardinality cardinality() {
throw new IllegalAccessError("Not supported for description properties");
}
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateServiceDocument.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateServiceDocument.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import javax.annotation.CheckForNull;
import jakarta.persistence.metamodel.Metamodel;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.olingo.commons.api.edm.EdmAction;
import org.apache.olingo.commons.api.edm.EdmBindingTarget;
import org.apache.olingo.commons.api.edm.EdmComplexType;
import org.apache.olingo.commons.api.edm.EdmEntityType;
import org.apache.olingo.commons.api.edm.EdmEnumType;
import org.apache.olingo.commons.api.edm.EdmFunction;
import org.apache.olingo.commons.api.edm.EdmOperation;
import org.apache.olingo.commons.api.edm.EdmType;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.provider.CsdlEntityContainer;
import org.apache.olingo.commons.api.edm.provider.CsdlSchema;
import org.apache.olingo.commons.api.edm.provider.CsdlTerm;
import org.apache.olingo.commons.api.edmx.EdmxReference;
import org.reflections8.Reflections;
import org.reflections8.scanners.SubTypesScanner;
import org.reflections8.scanners.TypeAnnotationsScanner;
import org.reflections8.util.ConfigurationBuilder;
import org.reflections8.util.FilterBuilder;
import com.sap.olingo.jpa.metadata.api.JPAEdmMetadataPostProcessor;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.AnnotationProvider;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ODataVocabularyReadException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAAction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntitySet;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEntityType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEnumerationAttribute;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAProtectionInfo;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPATopLevelEntity;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
/**
* http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/schemas/edmx.xsd
* A Service Document can contain multiple schemas, but only
* one Entity Container. This container is assigned to one of the schemas.
* <p>
* http://services.odata.org/V4/Northwind/Northwind.svc/$metadata
*/
class IntermediateServiceDocument implements JPAServiceDocument {
private static final Log LOGGER = LogFactory.getLog(IntermediateServiceDocument.class);
private final Metamodel jpaMetamodel;
private final JPAEdmNameBuilder nameBuilder;
private final IntermediateEntityContainer container;
private final Map<String, IntermediateSchema> schemaListInternalKey;
private final Reflections reflections;
private Map<String, JPAProtectionInfo> claims;
private final IntermediateAnnotationInformation annotationInfo;
IntermediateServiceDocument(final String namespace, final Metamodel jpaMetamodel,
final JPAEdmMetadataPostProcessor postProcessor, final String[] packageName,
final List<AnnotationProvider> annotationProvider) throws ODataJPAModelException {
this(new JPADefaultEdmNameBuilder(namespace), jpaMetamodel, postProcessor, packageName, annotationProvider);
}
/**
* @param customJPANameBuilder
* @param metamodel
* @param postProcessor
* @param packageName
* @param annotationProvider
* @throws ODataJPAModelException
*/
IntermediateServiceDocument(final JPAEdmNameBuilder nameBuilder, final Metamodel jpaMetamodel,
final JPAEdmMetadataPostProcessor postProcessor, final String[] packageName,
final List<AnnotationProvider> annotationProvider) throws ODataJPAModelException {
var post = postProcessor != null ? postProcessor : new DefaultEdmPostProcessor();
IntermediateModelElement.setPostProcessor(post);
reflections = createReflections(packageName);
this.annotationInfo = new IntermediateAnnotationInformation(annotationProvider);
post.provideReferences(annotationInfo.asReferenceList());
addReferencesFromAnnotationProvider(annotationProvider);
this.nameBuilder = nameBuilder;
this.jpaMetamodel = jpaMetamodel;
this.schemaListInternalKey = new HashMap<>();
buildIntermediateSchemas();
this.container = new IntermediateEntityContainer(nameBuilder, schemaListInternalKey, annotationInfo);
setContainer();
}
private IntermediateServiceDocument(IntermediateServiceDocument source, List<String> userGroups)
throws ODataJPAModelException {
this.annotationInfo = source.annotationInfo;
this.nameBuilder = source.nameBuilder;
this.jpaMetamodel = source.jpaMetamodel;
this.schemaListInternalKey = restrictedSchemas(source.schemaListInternalKey, userGroups);
this.container = source.container.asUserGroupRestricted(schemaListInternalKey, userGroups);
this.reflections = source.reflections;
this.claims = source.getClaims();
setContainer();
}
private Map<String, IntermediateSchema> restrictedSchemas(Map<String, IntermediateSchema> source,
List<String> userGroups) throws ODataJPAModelException {
final Map<String, IntermediateSchema> restricted = new HashMap<>(source.size());
for (var schema : source.entrySet()) {
restricted.put(schema.getKey(), schema.getValue().asUserGroupRestricted(userGroups));
}
return restricted;
}
private void addReferencesFromAnnotationProvider(final List<AnnotationProvider> annotationProvider)
throws ODataJPAModelException {
try {
for (final AnnotationProvider provider : annotationProvider) {
provider.addReferences(this.annotationInfo.asReferenceList());
}
} catch (final ODataVocabularyReadException e) {
throw new ODataJPAModelException(e);
}
}
JPAServiceDocument asUserGroupRestricted(List<String> userGroups) throws ODataJPAModelException {
return new IntermediateServiceDocument(this, userGroups);
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getAllSchemas()
*/
@Override
public List<CsdlSchema> getAllSchemas() throws ODataJPAModelException {
final List<CsdlSchema> allSchemas = getEdmSchemas();
allSchemas.addAll(annotationInfo.getSchemas());
return allSchemas;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getEdmEntityContainer()
*/
@Override
public CsdlEntityContainer getEdmEntityContainer() throws ODataJPAModelException {
return container.getEdmItem();
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getEdmSchemas()
*/
@Override
public List<CsdlSchema> getEdmSchemas() throws ODataJPAModelException {
return extractEdmSchemas();
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getEntity(org.apache.olingo.commons.api.edm.
* EdmType)
*/
@Override
public JPAEntityType getEntity(final EdmType edmType) throws ODataJPAModelException {
final IntermediateSchema schema = schemaListInternalKey.get(edmType.getNamespace());
if (schema != null)
return schema.getEntityType(edmType.getName());
return null;
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getEntity(java.lang.Class)
*/
@Override
public JPAEntityType getEntity(final Class<?> entityClass) throws ODataJPAModelException {
for (final Entry<String, IntermediateSchema> schema : schemaListInternalKey.entrySet()) {
final JPAEntityType et = (JPAEntityType) schema.getValue().getEntityType(entityClass);
if (et != null)
return et;
}
return null;
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument#getComplexType(org.apache.olingo.commons.api.edm
* .EdmComplexType)
*/
@Override
public JPAStructuredType getComplexType(final EdmComplexType edmType) {
final IntermediateSchema schema = schemaListInternalKey.get(edmType.getNamespace());
if (schema != null)
return schema.getComplexType(edmType.getName());
return null;
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAServiceDocument#getComplexType(java.lang.Class)
*/
@Override
public JPAStructuredType getComplexType(final Class<?> typeClass) {
for (final IntermediateSchema schema : schemaListInternalKey.values()) {
final IntermediateStructuredType<?> result = schema.getComplexType(typeClass);
if (result != null)
return result;
}
return null;
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getEntity(org.apache.olingo.commons.api.edm.
* FullQualifiedName)
*/
@Override
public JPAEntityType getEntity(final FullQualifiedName typeName) {
final IntermediateSchema schema = schemaListInternalKey.get(typeName.getNamespace());
if (schema != null)
return schema.getEntityType(typeName.getName());
return null;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getEntity(java.lang.String)
*/
@Override
public JPAEntityType getEntity(final String edmTargetName) throws ODataJPAModelException {
final IntermediateTopLevelEntity target = determineTopLevelEntity(edmTargetName);
return target != null ? target.getEntityType() : null;
}
@CheckForNull
private IntermediateTopLevelEntity determineTopLevelEntity(final String edmTargetName) throws ODataJPAModelException {
final Optional<IntermediateTopLevelEntity> target = Optional.ofNullable(container.getEntitySet(edmTargetName));
return target.orElse(container.getSingleton(edmTargetName));
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getEntitySet(com.sap.olingo.jpa.metadata.core.
* edm.mapper.api.JPAEntityType)
*/
@Override
public JPAEntitySet getEntitySet(final JPAEntityType entityType) throws ODataJPAModelException {
return container.getEntitySet(entityType);
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getEntitySet(com.sap.olingo.jpa.metadata.core.
* edm.mapper.api.JPAEntityType)
*/
@Override
public Optional<JPAEntitySet> getEntitySet(final String edmTargetName) throws ODataJPAModelException {
return Optional.ofNullable(container.getEntitySet(edmTargetName));
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getTopLevelEntity(java.lang.String)
*/
@Override
public Optional<JPATopLevelEntity> getTopLevelEntity(final String edmTargetName) throws ODataJPAModelException {
return Optional.ofNullable(container.getEntitySet(edmTargetName) != null
? container.getEntitySet(edmTargetName)
: container.getSingleton(edmTargetName));
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getFunction(org.apache.olingo.commons.api.edm.
* EdmFunction)
*/
@Override
public JPAFunction getFunction(final EdmFunction function) {
final IntermediateSchema schema = schemaListInternalKey.get(function.getNamespace());
if (schema != null)
return schema.getFunction(function.getName());
return null;
}
/*
* (non-Javadoc)
*
* @see
* com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getAction(org.apache.olingo.commons.api.edm.
* EdmAction)
*/
@Override
public JPAAction getAction(final EdmAction action) {
final IntermediateSchema schema = schemaListInternalKey.get(action.getNamespace());
if (schema != null)
return schema.getAction(action.getName(), determineBindingParameter(action));
return null;
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getReferences()
*/
@Override
public List<EdmxReference> getReferences() {
return annotationInfo.getEdmReferences();
}
/*
* (non-Javadoc)
*
* @see com.sap.olingo.jpa.metadata.core.edm.mapper.impl.JPAServiceDocument#getTerm(org.apache.olingo.commons.api.edm.
* FullQualifiedName)
*/
@Override
public CsdlTerm getTerm(final FullQualifiedName termName) {
return annotationInfo.getReferences().getTerm(termName).orElse(null);
}
/*
* (non-Javadoc)
*
* @see
* org.apache.olingo.server.api.etag.CustomETagSupport#hasETag(org.apache.olingo.commons.api.edm.EdmBindingTarget)
*/
@Override
public boolean hasETag(final EdmBindingTarget entitySetOrSingleton) {
try {
final Optional<JPAEntityType> et = Optional.ofNullable(entitySetOrSingleton.getEntityType())
.map(EdmEntityType::getFullQualifiedName)
.map(this::getEntity);
if (et.isPresent())
return et.get().hasEtag();
else
return false;
} catch (final ODataJPAModelException e) {
LOGGER.debug("Error during binding target determination", e);
return false;
}
}
/**
* Currently not supported => method always returns false
*/
@Override
public boolean hasMediaETag(final EdmBindingTarget entitySetOrSingleton) {
// TODO Not Supported yet
return false;
}
@Override
public JPAEdmNameBuilder getNameBuilder() {
return nameBuilder;
}
private void buildIntermediateSchemas() throws ODataJPAModelException {
final IntermediateSchema schema = new IntermediateSchema(nameBuilder, jpaMetamodel, reflections, annotationInfo);
schemaListInternalKey.put(schema.internalName, schema);
}
private Reflections createReflections(final String... packageName) {
if (packageName != null && packageName.length > 0) {
final ConfigurationBuilder configBuilder = new ConfigurationBuilder();
configBuilder.setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner());
configBuilder.forPackages(packageName);
configBuilder.filterInputsBy(new FilterBuilder().includePackage(packageName));
return new Reflections(configBuilder);
} else {
return null;
}
}
private List<CsdlSchema> extractEdmSchemas() throws ODataJPAModelException {
final List<CsdlSchema> schemas = new ArrayList<>();
try {
if (schemaListInternalKey.isEmpty())
buildIntermediateSchemas();
for (final IntermediateSchema schema : schemaListInternalKey.values()) {
schemas.add(schema.getEdmItem());
}
} catch (final ODataJPAModelException e) {
schemaListInternalKey.clear();
throw e;
}
return schemas;
}
private void setContainer() {
for (final IntermediateSchema schema : schemaListInternalKey.values()) {
schema.setContainer(container);
// OData allows to combine multiple schemas in one metadata document. The container has to be added to one of
// those.
// We pick the first that we can get:
break; // NOSONAR
}
}
@Override
public JPAEnumerationAttribute getEnumType(final EdmEnumType type) {
final IntermediateSchema schema = schemaListInternalKey.get(type.getFullQualifiedName().getNamespace());
if (schema != null)
return schema.getEnumerationType(type);
return null;
}
@Override
public JPAEnumerationAttribute getEnumType(final String fqnAsString) {
final FullQualifiedName fqn = new FullQualifiedName(fqnAsString);
final IntermediateSchema schema = schemaListInternalKey.get(fqn.getNamespace());
if (schema != null)
return schema.getEnumerationType(fqn.getName());
return null;
}
@Override
public Map<String, JPAProtectionInfo> getClaims() throws ODataJPAModelException {
if (claims == null) {
claims = new HashMap<>();
for (final IntermediateSchema schema : schemaListInternalKey.values()) {
for (final IntermediateEntityType<?> et : schema.getEntityTypes()) {
for (final JPAProtectionInfo protection : et.getProtections()) {
claims.put(protection.getClaimName(), protection);
}
}
}
}
return claims;
}
@CheckForNull
private FullQualifiedName determineBindingParameter(final EdmOperation operation) {
return operation.isBound() ? operation.getBindingParameterTypeFqn() : null;
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPAOnConditionItemImpl.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPAOnConditionItemImpl.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import java.util.Objects;
import javax.annotation.Nonnull;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAOnConditionItem;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAPath;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys;
final class JPAOnConditionItemImpl implements JPAOnConditionItem {
private final JPAPath jpaLeftAttribute;
private final JPAPath jpaRightAttribute;
JPAOnConditionItemImpl(@Nonnull final JPAPath jpaLeftAttribute, @Nonnull final JPAPath jpaRightAttribute) {
super();
Objects.requireNonNull(jpaLeftAttribute, new ODataJPAModelException(MessageKeys.ON_LEFT_ATTRIBUTE_NULL)
.getMessage());
Objects.requireNonNull(jpaRightAttribute, new ODataJPAModelException(MessageKeys.ON_RIGHT_ATTRIBUTE_NULL)
.getMessage());
this.jpaLeftAttribute = jpaLeftAttribute;
this.jpaRightAttribute = jpaRightAttribute;
}
@Override
public JPAPath getLeftPath() {
return jpaLeftAttribute;
}
@Override
public JPAPath getRightPath() {
return jpaRightAttribute;
}
@Override
public String toString() {
return "JPAOnConditionItem [LeftAttribute=("
+ jpaLeftAttribute.getAlias() + "/"
+ jpaLeftAttribute.getDBFieldName() + "), RightAttribute=("
+ jpaRightAttribute.getAlias() + "/"
+ jpaRightAttribute.getDBFieldName()
+ ")]";
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPANameBuilder.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/JPANameBuilder.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import jakarta.persistence.metamodel.Attribute;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmAction;
import com.sap.olingo.jpa.metadata.core.edm.annotation.EdmFunction;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAEdmNameBuilder;
import com.sap.olingo.jpa.metadata.core.edm.mapper.api.JPAStructuredType;
/**
* Build the internal name for Intermediate Model Elements
*
* @author Oliver Grande
*
*/
final class JPANameBuilder {
public String buildStructuredTypeName(final Class<?> clazz) {
return clazz.getCanonicalName();
}
public String buildAttributeName(final Attribute<?, ?> jpaAttribute) {
return jpaAttribute.getName();
}
public String buildAssociationName(final Attribute<?, ?> jpaAttribute) {
return jpaAttribute.getName();
}
public String buildFunctionName(final EdmFunction jpaFunction) {
return jpaFunction.name();
}
public String buildActionName(final EdmAction jpaAction) {
return jpaAction.name();
}
public String buildEntitySetName(final JPAEdmNameBuilder nameBuilder, final JPAStructuredType entityType) {
return buildFQN(entityType.getInternalName(), nameBuilder).getFullQualifiedNameAsString();
}
public String buildSingletonName(final JPAEdmNameBuilder nameBuilder, final JPAStructuredType entityType) {
return buildFQN(entityType.getInternalName(), nameBuilder).getFullQualifiedNameAsString();
}
protected final FullQualifiedName buildFQN(final String name, final JPAEdmNameBuilder nameBuilder) {
return new FullQualifiedName(nameBuilder.getNamespace(), name);
}
}
| java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
SAP/olingo-jpa-processor-v4 | https://github.com/SAP/olingo-jpa-processor-v4/blob/c6fddac331f51f37fd9e4b46aa6bf7ab256c386b/jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateReferences.java | jpa/odata-jpa-metadata/src/main/java/com/sap/olingo/jpa/metadata/core/edm/mapper/impl/IntermediateReferences.java | package com.sap.olingo.jpa.metadata.core.edm.mapper.impl;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.ANNOTATION_PARSE_ERROR;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.ANNOTATION_PATH_NOT_FOUND;
import static com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException.MessageKeys.MISSING_TERM_NAMESPACE;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import javax.annotation.Nonnull;
import org.apache.olingo.commons.api.edm.FullQualifiedName;
import org.apache.olingo.commons.api.edm.provider.CsdlNamed;
import org.apache.olingo.commons.api.edm.provider.CsdlSchema;
import org.apache.olingo.commons.api.edm.provider.CsdlTerm;
import org.apache.olingo.commons.api.edmx.EdmxReference;
import org.apache.olingo.commons.api.edmx.EdmxReferenceInclude;
import org.apache.olingo.commons.api.edmx.EdmxReferenceIncludeAnnotation;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.Applicability;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.JPAReferences;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ODataVocabularyReadException;
import com.sap.olingo.jpa.metadata.core.edm.extension.vocabularies.ReferenceAccess;
import com.sap.olingo.jpa.metadata.core.edm.mapper.exception.ODataJPAModelException;
import com.sap.olingo.jpa.metadata.core.edm.mapper.extension.IntermediateReferenceList;
import com.sap.olingo.jpa.metadata.core.edm.mapper.vocabularies.CsdlDocument;
import com.sap.olingo.jpa.metadata.core.edm.mapper.vocabularies.CsdlDocumentReader;
import com.sap.olingo.jpa.metadata.core.edm.mapper.vocabularies.ODataJPAVocabulariesException;
class IntermediateReferences implements IntermediateReferenceList, JPAReferences {
final List<IntermediateReference> references = new ArrayList<>();
private List<EdmxReference> edmxReferences = new ArrayList<>();
final Map<String, Map<String, CsdlTerm>> terms = new HashMap<>();
final Map<String, CsdlSchema> schemas = new HashMap<>();
final Map<String, String> aliasDirectory = new HashMap<>();
@Override
public IntermediateReferenceAccess addReference(final String uri) throws ODataJPAModelException {
try {
final URI sourceURI = new URI(uri);
final CsdlDocument vocabulary = new CsdlDocumentReader().readFromURI(sourceURI);
return createReference(sourceURI, "", vocabulary);
} catch (final URISyntaxException e) {
throw new ODataJPAModelException(e);
} catch (final IOException e) {
throw new ODataJPAModelException(ANNOTATION_PARSE_ERROR, e, uri, e.getMessage());
}
}
@Override
public IntermediateReferenceAccess addReference(@Nonnull final String uri, @Nonnull final String path)
throws ODataJPAModelException {
return addReference(uri, path, Charset.defaultCharset());
}
@Override
public IntermediateReferenceAccess addReference(@Nonnull final String uri, @Nonnull final String path,
@Nonnull final Charset charset) throws ODataJPAModelException {
try {
final URI sourceURI = new URI(uri);
final CsdlDocument vocabulary = new CsdlDocumentReader().readFromResource(path, charset);
if (vocabulary == null)
// Path '%1$s' to read the file containing vocabulary '%2$s' is wrong
throw new ODataJPAModelException(ANNOTATION_PATH_NOT_FOUND, path, uri);
return createReference(sourceURI, path, vocabulary);
} catch (final URISyntaxException e) {
throw new ODataJPAModelException(e);
} catch (final IOException | ODataJPAVocabulariesException e) {
// Parsing of %1$s failed with message %2$s
throw new ODataJPAModelException(ANNOTATION_PARSE_ERROR, e, path, e.getMessage());
}
}
@Override
public ReferenceAccess addReference(@Nonnull final URI uri, @Nonnull final String path)
throws ODataVocabularyReadException {
try {
return addReference(uri.toString(), path);
} catch (final ODataJPAModelException e) {
throw new ODataVocabularyReadException(uri, path, e);
}
}
@Override
public String convertAlias(final String alias) {
return aliasDirectory.get(alias);
}
public List<CsdlSchema> getSchemas() {
final List<CsdlSchema> result = new ArrayList<>();
for (final Entry<String, CsdlSchema> schema : schemas.entrySet())
result.add(schema.getValue());
return result;
}
@Override
public Optional<CsdlTerm> getTerm(final FullQualifiedName termName) {
Map<String, CsdlTerm> termsMap = terms.get(termName.getNamespace());
if (termsMap == null) {
termsMap =
Optional.ofNullable(convertAlias(termName.getNamespace()))
.map(terms::get)
.orElseGet(Collections::emptyMap);
}
return Optional.ofNullable(termsMap.get(termName.getName()));
}
@Override
public List<CsdlTerm> getTerms(final String schemaAlias, final Applicability appliesTo) {
final List<CsdlTerm> result = new ArrayList<>();
final Optional<List<CsdlTerm>> termsOfSchema = getSchema(schemaAlias).map(CsdlSchema::getTerms);
if (termsOfSchema.isPresent()) {
for (final CsdlTerm term : termsOfSchema.get()) {
term.getAppliesTo().stream()
.filter(a -> a.equals(appliesTo.value()))
.findFirst()
.ifPresent(applies -> result.add(term));
}
}
return result;
}
@Override
@SuppressWarnings("unchecked")
public <T extends CsdlNamed> Optional<T> getType(final FullQualifiedName fqn) {
// namespace of fqn can either be the namespace of the schema or the alias of the schema
final Optional<CsdlSchema> schema = getSchema(fqn.getNamespace());
if (schema.isPresent()) {
final CsdlSchema s = schema.get();
final FullQualifiedName alternativeName = new FullQualifiedName(s.getNamespace(), fqn.getName());
T type = (T) Optional.ofNullable(s.getComplexType(fqn.getName()))
.orElseGet(() -> s.getComplexType(alternativeName.getFullQualifiedNameAsString()));
if (type == null) {
type = (T) Optional.ofNullable(s.getTypeDefinition(fqn.getName()))
.orElseGet(() -> s.getTypeDefinition(alternativeName.getFullQualifiedNameAsString()));
}
if (type == null) {
type = (T) s.getEnumType(fqn.getName());
}
return Optional.of(type);
}
return Optional.empty();
}
List<EdmxReference> getEdmReferences() {
if (references.size() != edmxReferences.size()) {
edmxReferences = new ArrayList<>(references.size());
for (final IntermediateReference r : references)
edmxReferences.add(r.getEdmReference());
}
return edmxReferences;
}
Optional<CsdlSchema> getSchema(final String namespace) {
return Optional.ofNullable(Optional.ofNullable(schemas.get(namespace))
.orElseGet(() -> schemas.get(convertAlias(namespace))));
}
private IntermediateReference createReference(final URI sourceURI, final String path, final CsdlDocument vocabulary) {
final IntermediateReference reference = new IntermediateReference(sourceURI, path);
schemas.putAll(vocabulary.getSchemas());
terms.putAll(vocabulary.getTerms());
references.add(reference);
aliasDirectory.putAll(getAliases(vocabulary.getSchemas()));
return reference;
}
private Map<String, String> getAliases(final Map<String, CsdlSchema> schemas) {
final Map<String, String> aliases = new HashMap<>();
for (final Entry<String, CsdlSchema> schema : schemas.entrySet()) {
if (schema.getValue().getAlias() != null)
aliases.put(schema.getValue().getAlias(), schema.getKey());
}
return aliases;
}
private class IntermediateReference implements IntermediateReferenceList.IntermediateReferenceAccess {
private final URI uri;
private final String path;
final EdmxReference edmxReference;
private final List<IntermediateReferenceInclude> includes = new ArrayList<>();
private final List<IntermediateReferenceAnnotationInclude> annotation = new ArrayList<>();
public IntermediateReference(final URI uri, final String path) {
super();
this.uri = uri;
this.path = path;
edmxReference = new EdmxReference(uri);
}
@Override
public void addInclude(final String namespace) {
addInclude(namespace, null);
}
@Override
public void addInclude(final String namespace, final String alias) {
final IntermediateReferenceInclude include = new IntermediateReferenceInclude(namespace, alias);
this.includes.add(include);
edmxReference.addInclude(include.getEdmInclude());
if (alias != null)
aliasDirectory.put(alias, namespace);
}
@Override
public void addIncludeAnnotation(final String termNamespace) throws ODataJPAModelException {
addIncludeAnnotation(termNamespace, null, null);
}
@Override
public void addIncludeAnnotation(@Nonnull final String termNamespace, final String qualifier,
final String targetNamespace) throws ODataJPAModelException {
final IntermediateReferenceAnnotationInclude include = new IntermediateReferenceAnnotationInclude(termNamespace,
qualifier, targetNamespace);
this.annotation.add(include);
edmxReference.addIncludeAnnotation(include.getEdmIncludeAnnotation());
}
@Override
public String getPath() {
return path;
}
@Override
public URI getURI() {
return uri;
}
EdmxReference getEdmReference() {
return edmxReference;
}
private class IntermediateReferenceAnnotationInclude {
private final String termNamespace;
private final String qualifier;
private final String targetNamespace;
public IntermediateReferenceAnnotationInclude(final String termNamespace, final String qualifier,
final String targetNamespace) throws ODataJPAModelException {
super();
if (termNamespace == null || termNamespace.isEmpty())
throw new ODataJPAModelException(MISSING_TERM_NAMESPACE);
this.termNamespace = termNamespace;
this.qualifier = qualifier;
this.targetNamespace = targetNamespace;
}
EdmxReferenceIncludeAnnotation getEdmIncludeAnnotation() {
return new EdmxReferenceIncludeAnnotation(termNamespace, qualifier, targetNamespace);
}
}
private class IntermediateReferenceInclude {
private final String namespace;
private final String alias;
public IntermediateReferenceInclude(final String namespace, final String alias) {
this.namespace = namespace;
this.alias = alias;
}
EdmxReferenceInclude getEdmInclude() {
return new EdmxReferenceInclude(namespace, alias);
}
}
}
} | java | Apache-2.0 | c6fddac331f51f37fd9e4b46aa6bf7ab256c386b | 2026-01-05T02:41:58.937563Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.