http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyAbout.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyAbout.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyAbout.java new file mode 100644 index 0000000..4d7e9c5 --- /dev/null +++ b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyAbout.java @@ -0,0 +1,89 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.syncope.core.persistence.jpa.entity; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.Table; +import javax.persistence.UniqueConstraint; +import org.apache.syncope.core.persistence.api.entity.AnyAbout; +import org.apache.syncope.core.persistence.api.entity.AnyType; +import org.apache.syncope.core.persistence.api.entity.Notification; + +@Entity +@Table(name = JPAAnyAbout.TABLE, uniqueConstraints = + @UniqueConstraint(columnNames = { "notification_id", "anyType_name" })) +public class JPAAnyAbout extends AbstractEntity<Long> implements AnyAbout { + + private static final long serialVersionUID = 3517381731849788407L; + + public static final String TABLE = "AnyAbout"; + + @Id + private Long id; + + @ManyToOne + private JPANotification notification; + + @ManyToOne + private JPAAnyType anyType; + + @Lob + private String about; + + @Override + public Long getKey() { + return id; + } + + @Override + public Notification getNotification() { + return notification; + } + + @Override + public void setNotification(final Notification notification) { + checkType(notification, JPANotification.class); + this.notification = (JPANotification) notification; + } + + @Override + public AnyType getAnyType() { + return anyType; + } + + @Override + public void setAnyType(final AnyType anyType) { + checkType(anyType, JPAAnyType.class); + this.anyType = (JPAAnyType) anyType; + } + + @Override + public String get() { + return about; + } + + @Override + public void set(final String filter) { + this.about = filter; + } + +}
http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyType.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyType.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyType.java new file mode 100644 index 0000000..2615520 --- /dev/null +++ b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyType.java @@ -0,0 +1,97 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.syncope.core.persistence.jpa.entity; + +import java.util.ArrayList; +import java.util.List; +import javax.persistence.Cacheable; +import javax.persistence.Entity; +import javax.persistence.EnumType; +import javax.persistence.Enumerated; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.ManyToMany; +import javax.persistence.Table; +import javax.validation.constraints.NotNull; +import org.apache.syncope.common.lib.types.AnyTypeKind; +import org.apache.syncope.core.persistence.api.entity.AnyType; +import org.apache.syncope.core.persistence.api.entity.AnyTypeClass; + +@Entity +@Table(name = JPAAnyType.TABLE) +@Cacheable +public class JPAAnyType extends AbstractEntity<String> implements AnyType { + + private static final long serialVersionUID = 2668267884059219835L; + + public static final String TABLE = "AnyType"; + + @Id + private String name; + + @NotNull + @Enumerated(EnumType.STRING) + private AnyTypeKind kind; + + @ManyToMany(fetch = FetchType.EAGER) + @JoinTable(joinColumns = + @JoinColumn(name = "anyType_name"), + inverseJoinColumns = + @JoinColumn(name = "anyTypeClass_name")) + private List<JPAAnyTypeClass> classes = new ArrayList<>(); + + @Override + public String getKey() { + return name; + } + + @Override + public void setKey(final String name) { + this.name = name; + } + + @Override + public AnyTypeKind getKind() { + return kind; + } + + @Override + public void setKind(final AnyTypeKind kind) { + this.kind = kind; + } + + @Override + public boolean add(final AnyTypeClass anyTypeClass) { + checkType(anyTypeClass, JPAAnyTypeClass.class); + return this.classes.add((JPAAnyTypeClass) anyTypeClass); + } + + @Override + public boolean remove(final AnyTypeClass anyTypeClass) { + checkType(anyTypeClass, JPAAnyTypeClass.class); + return this.classes.remove((JPAAnyTypeClass) anyTypeClass); + } + + @Override + public List<? extends AnyTypeClass> getClasses() { + return classes; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyTypeClass.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyTypeClass.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyTypeClass.java new file mode 100644 index 0000000..5c52097 --- /dev/null +++ b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyTypeClass.java @@ -0,0 +1,131 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.syncope.core.persistence.jpa.entity; + +import java.util.ArrayList; +import java.util.List; +import javax.persistence.Cacheable; +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.AnyTypeClass; +import org.apache.syncope.core.persistence.api.entity.DerSchema; +import org.apache.syncope.core.persistence.api.entity.PlainSchema; +import org.apache.syncope.core.persistence.api.entity.VirSchema; + +@Entity +@Table(name = JPAAnyTypeClass.TABLE) +@Cacheable +public class JPAAnyTypeClass extends AbstractEntity<String> implements AnyTypeClass { + + private static final long serialVersionUID = -1750247153774475453L; + + public static final String TABLE = "AnyTypeClass"; + + @Id + private String name; + + @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER) + @JoinTable(joinColumns = + @JoinColumn(name = "anyTypeClass_name"), + inverseJoinColumns = + @JoinColumn(name = "plainSchema_name")) + private List<JPAPlainSchema> plainSchemas = new ArrayList<>(); + + @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER) + @JoinTable(joinColumns = + @JoinColumn(name = "anyTypeClass_name"), + inverseJoinColumns = + @JoinColumn(name = "derSchema_name")) + private List<JPADerSchema> derSchemas = new ArrayList<>(); + + @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER) + @JoinTable(joinColumns = + @JoinColumn(name = "anyTypeClass_name"), + inverseJoinColumns = + @JoinColumn(name = "virSchema_name")) + private List<JPAVirSchema> virSchemas = new ArrayList<>(); + + @Override + public String getKey() { + return name; + } + + @Override + public void setKey(final String name) { + this.name = name; + } + + @Override + public boolean add(final PlainSchema facet) { + checkType(facet, JPAPlainSchema.class); + return this.plainSchemas.add((JPAPlainSchema) facet); + } + + @Override + public boolean remove(final PlainSchema facet) { + checkType(facet, JPAPlainSchema.class); + return this.plainSchemas.remove((JPAPlainSchema) facet); + } + + @Override + public List<? extends PlainSchema> getPlainSchemas() { + return plainSchemas; + } + + @Override + public boolean add(final DerSchema facet) { + checkType(facet, JPADerSchema.class); + return this.derSchemas.add((JPADerSchema) facet); + } + + @Override + public boolean remove(final DerSchema facet) { + checkType(facet, JPAPlainSchema.class); + return this.derSchemas.remove((JPADerSchema) facet); + } + + @Override + public List<? extends DerSchema> getDerSchemas() { + return derSchemas; + } + + @Override + public boolean add(final VirSchema facet) { + checkType(facet, JPAVirSchema.class); + return this.virSchemas.add((JPAVirSchema) facet); + } + + @Override + public boolean remove(final VirSchema facet) { + checkType(facet, JPAPlainSchema.class); + return this.virSchemas.remove((JPAVirSchema) facet); + } + + @Override + public List<? extends VirSchema> getVirSchemas() { + return virSchemas; + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyUtils.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyUtils.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyUtils.java new file mode 100644 index 0000000..989c642 --- /dev/null +++ b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyUtils.java @@ -0,0 +1,488 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.syncope.core.persistence.jpa.entity; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import org.apache.syncope.common.lib.to.AnyObjectTO; +import org.apache.syncope.common.lib.to.AnyTO; +import org.apache.syncope.common.lib.to.GroupTO; +import org.apache.syncope.common.lib.to.UserTO; +import org.apache.syncope.common.lib.types.AnyTypeKind; +import org.apache.syncope.common.lib.types.IntMappingType; +import org.apache.syncope.common.lib.types.MappingPurpose; +import org.apache.syncope.core.persistence.api.entity.Any; +import org.apache.syncope.core.persistence.api.entity.AnyUtils; +import org.apache.syncope.core.persistence.api.entity.DerAttr; +import org.apache.syncope.core.persistence.api.entity.resource.MappingItem; +import org.apache.syncope.core.persistence.api.entity.PlainAttr; +import org.apache.syncope.core.persistence.api.entity.PlainAttrValue; +import org.apache.syncope.core.persistence.api.entity.VirAttr; +import org.apache.syncope.core.persistence.api.entity.resource.Mapping; +import org.apache.syncope.core.persistence.api.entity.resource.Provision; +import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAADerAttr; +import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAAPlainAttr; +import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAAPlainAttrUniqueValue; +import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAAPlainAttrValue; +import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAAVirAttr; +import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAAnyObject; +import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerAttr; +import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttr; +import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrUniqueValue; +import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrValue; +import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirAttr; +import org.apache.syncope.core.persistence.jpa.entity.group.JPAGroup; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDerAttr; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttr; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttrUniqueValue; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttrValue; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUVirAttr; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUser; + +@SuppressWarnings({ "unchecked", "rawtypes" }) +public class JPAAnyUtils implements AnyUtils { + + private final AnyTypeKind anyTypeKind; + + protected JPAAnyUtils(final AnyTypeKind typeKind) { + this.anyTypeKind = typeKind; + } + + @Override + public AnyTypeKind getAnyTypeKind() { + return anyTypeKind; + } + + @Override + public <T extends Any<?, ?, ?>> Class<T> anyClass() { + Class result; + + switch (anyTypeKind) { + case GROUP: + result = JPAGroup.class; + break; + + case ANY_OBJECT: + result = JPAAnyObject.class; + break; + + case USER: + default: + result = JPAUser.class; + } + + return result; + } + + @Override + public <T extends PlainAttr<?>> Class<T> plainAttrClass() { + Class result = null; + + switch (anyTypeKind) { + case GROUP: + result = JPAGPlainAttr.class; + break; + + case ANY_OBJECT: + result = JPAAPlainAttr.class; + break; + + case USER: + default: + result = JPAUPlainAttr.class; + break; + } + + return result; + } + + @Override + public <T extends PlainAttr<?>> T newPlainAttr() { + T result = null; + + switch (anyTypeKind) { + case USER: + result = (T) new JPAUPlainAttr(); + break; + + case GROUP: + result = (T) new JPAGPlainAttr(); + break; + + case ANY_OBJECT: + result = (T) new JPAAPlainAttr(); + break; + + default: + } + + return result; + } + + @Override + public <T extends PlainAttrValue> Class<T> plainAttrValueClass() { + Class result; + + switch (anyTypeKind) { + case GROUP: + result = JPAGPlainAttrValue.class; + break; + + case ANY_OBJECT: + result = JPAAPlainAttrValue.class; + break; + + case USER: + default: + result = JPAUPlainAttrValue.class; + break; + } + + return result; + } + + @Override + public <T extends PlainAttrValue> T newPlainAttrValue() { + T result = null; + + switch (anyTypeKind) { + case USER: + result = (T) new JPAUPlainAttrValue(); + break; + + case GROUP: + result = (T) new JPAGPlainAttrValue(); + break; + + case ANY_OBJECT: + result = (T) new JPAAPlainAttrValue(); + break; + + default: + } + + return result; + } + + @Override + public <T extends PlainAttrValue> Class<T> plainAttrUniqueValueClass() { + Class result; + + switch (anyTypeKind) { + case GROUP: + result = JPAGPlainAttrUniqueValue.class; + break; + + case ANY_OBJECT: + result = JPAAPlainAttrUniqueValue.class; + break; + + case USER: + default: + result = JPAUPlainAttrUniqueValue.class; + break; + } + + return result; + } + + @Override + public <T extends PlainAttrValue> T newPlainAttrUniqueValue() { + T result = null; + + switch (anyTypeKind) { + case USER: + result = (T) new JPAUPlainAttrUniqueValue(); + break; + + case GROUP: + result = (T) new JPAGPlainAttrUniqueValue(); + break; + + case ANY_OBJECT: + result = (T) new JPAAPlainAttrUniqueValue(); + break; + + default: + } + + return result; + } + + @Override + public <T extends DerAttr<?>> Class<T> derAttrClass() { + Class result = null; + + switch (anyTypeKind) { + case USER: + result = JPAUDerAttr.class; + break; + + case GROUP: + result = JPAGDerAttr.class; + break; + + case ANY_OBJECT: + result = JPAADerAttr.class; + break; + + default: + } + + return result; + } + + @Override + public <T extends DerAttr<?>> T newDerAttr() { + T result = null; + + switch (anyTypeKind) { + case USER: + result = (T) new JPAUDerAttr(); + break; + + case GROUP: + result = (T) new JPAGDerAttr(); + break; + + case ANY_OBJECT: + result = (T) new JPAADerAttr(); + break; + + default: + } + + return result; + } + + @Override + public <T extends VirAttr<?>> Class<T> virAttrClass() { + Class result = null; + + switch (anyTypeKind) { + case USER: + result = JPAUVirAttr.class; + break; + + case GROUP: + result = JPAGVirAttr.class; + break; + + case ANY_OBJECT: + result = JPAAVirAttr.class; + break; + + default: + } + + return result; + } + + @Override + public <T extends VirAttr<?>> T newVirAttr() { + T result = null; + + switch (anyTypeKind) { + case USER: + result = (T) new JPAUVirAttr(); + break; + + case GROUP: + result = (T) new JPAGVirAttr(); + break; + + case ANY_OBJECT: + result = (T) new JPAAVirAttr(); + break; + + default: + } + + return result; + } + + @Override + public MappingItem getConnObjectKeyItem(final Provision provision) { + Mapping mapping = null; + if (provision != null) { + mapping = provision.getMapping(); + } + + return mapping == null + ? null + : mapping.getConnObjectKeyItem(); + } + + @Override + public String getConnObjectLink(final Provision provision) { + Mapping mapping = null; + if (provision != null) { + mapping = provision.getMapping(); + } + + return mapping == null + ? null + : mapping.getConnObjectLink(); + } + + @Override + public List<MappingItem> getMappingItems(final Provision provision, final MappingPurpose purpose) { + List<? extends MappingItem> items = Collections.<MappingItem>emptyList(); + if (provision != null) { + items = provision.getMapping().getItems(); + } + + List<MappingItem> result = new ArrayList<>(); + + switch (purpose) { + case SYNCHRONIZATION: + for (MappingItem item : items) { + if (MappingPurpose.PROPAGATION != item.getPurpose() + && MappingPurpose.NONE != item.getPurpose()) { + + result.add(item); + } + } + break; + + case PROPAGATION: + for (MappingItem item : items) { + if (MappingPurpose.SYNCHRONIZATION != item.getPurpose() + && MappingPurpose.NONE != item.getPurpose()) { + + result.add(item); + } + } + break; + + case BOTH: + for (MappingItem item : items) { + if (MappingPurpose.NONE != item.getPurpose()) { + result.add(item); + } + } + break; + + case NONE: + for (MappingItem item : items) { + if (MappingPurpose.NONE == item.getPurpose()) { + result.add(item); + } + } + break; + + default: + } + + return result; + } + + @Override + public IntMappingType plainIntMappingType() { + IntMappingType result = null; + + switch (anyTypeKind) { + case GROUP: + result = IntMappingType.GroupPlainSchema; + break; + + case ANY_OBJECT: + result = IntMappingType.AnyPlainSchema; + break; + + case USER: + result = IntMappingType.UserPlainSchema; + break; + + default: + } + + return result; + } + + @Override + public IntMappingType derIntMappingType() { + IntMappingType result = null; + + switch (anyTypeKind) { + case GROUP: + result = IntMappingType.GroupDerivedSchema; + break; + + case ANY_OBJECT: + result = IntMappingType.AnyDerivedSchema; + break; + + case USER: + result = IntMappingType.UserDerivedSchema; + break; + + default: + } + + return result; + } + + @Override + public IntMappingType virIntMappingType() { + IntMappingType result = null; + + switch (anyTypeKind) { + case GROUP: + result = IntMappingType.GroupVirtualSchema; + break; + + case ANY_OBJECT: + result = IntMappingType.AnyVirtualSchema; + break; + + case USER: + result = IntMappingType.UserVirtualSchema; + break; + + default: + } + + return result; + } + + @Override + public <T extends AnyTO> T newAnyTO() { + T result = null; + + switch (anyTypeKind) { + case USER: + result = (T) new UserTO(); + break; + + case GROUP: + result = (T) new GroupTO(); + break; + + case ANY_OBJECT: + result = (T) new AnyObjectTO(); + break; + + default: + } + + return result; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyUtilsFactory.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyUtilsFactory.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyUtilsFactory.java new file mode 100644 index 0000000..f68b3f9 --- /dev/null +++ b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAnyUtilsFactory.java @@ -0,0 +1,61 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.syncope.core.persistence.jpa.entity; + +import org.apache.syncope.common.lib.types.AnyTypeKind; +import org.apache.syncope.core.persistence.api.entity.Any; +import org.apache.syncope.core.persistence.api.entity.AnyUtils; +import org.apache.syncope.core.persistence.api.entity.AnyUtilsFactory; +import org.apache.syncope.core.persistence.api.entity.anyobject.AnyObject; +import org.apache.syncope.core.persistence.api.entity.group.Group; +import org.apache.syncope.core.persistence.api.entity.user.User; +import org.springframework.stereotype.Component; + +@Component +public class JPAAnyUtilsFactory implements AnyUtilsFactory { + + @Override + public AnyUtils getInstance(final AnyTypeKind anyTypeKind) { + return new JPAAnyUtils(anyTypeKind); + } + + @Override + public AnyUtils getInstance(final String anyTypeKind) { + return new JPAAnyUtils(AnyTypeKind.valueOf(anyTypeKind)); + } + + @Override + public AnyUtils getInstance(final Any<?, ?, ?> any) { + AnyTypeKind type = null; + if (any instanceof User) { + type = AnyTypeKind.USER; + } else if (any instanceof Group) { + type = AnyTypeKind.GROUP; + } else if (any instanceof AnyObject) { + type = AnyTypeKind.ANY_OBJECT; + } + + if (type == null) { + throw new IllegalArgumentException("Any type not supported: " + any.getClass().getName()); + } + + return new JPAAnyUtils(type); + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAttributableUtils.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAttributableUtils.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAttributableUtils.java deleted file mode 100644 index 2fe1ae9..0000000 --- a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAAttributableUtils.java +++ /dev/null @@ -1,862 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ -package org.apache.syncope.core.persistence.jpa.entity; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import org.apache.syncope.common.lib.to.AbstractAttributableTO; -import org.apache.syncope.common.lib.to.AbstractSubjectTO; -import org.apache.syncope.common.lib.to.ConfTO; -import org.apache.syncope.common.lib.to.MembershipTO; -import org.apache.syncope.common.lib.to.GroupTO; -import org.apache.syncope.common.lib.to.UserTO; -import org.apache.syncope.common.lib.types.AttributableType; -import org.apache.syncope.common.lib.types.IntMappingType; -import org.apache.syncope.common.lib.types.MappingPurpose; -import org.apache.syncope.core.persistence.api.entity.AttrTemplate; -import org.apache.syncope.core.persistence.api.entity.Attributable; -import org.apache.syncope.core.persistence.api.entity.AttributableUtils; -import org.apache.syncope.core.persistence.api.entity.DerAttr; -import org.apache.syncope.core.persistence.api.entity.DerSchema; -import org.apache.syncope.core.persistence.api.entity.ExternalResource; -import org.apache.syncope.core.persistence.api.entity.MappingItem; -import org.apache.syncope.core.persistence.api.entity.PlainAttr; -import org.apache.syncope.core.persistence.api.entity.PlainAttrValue; -import org.apache.syncope.core.persistence.api.entity.PlainSchema; -import org.apache.syncope.core.persistence.api.entity.VirAttr; -import org.apache.syncope.core.persistence.api.entity.VirSchema; -import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttr; -import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttrUniqueValue; -import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttrValue; -import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainSchema; -import org.apache.syncope.core.persistence.jpa.entity.conf.JPAConf; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerAttr; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerSchema; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttr; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrUniqueValue; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrValue; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainSchema; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirAttr; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirSchema; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMembership; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerAttr; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerSchema; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGMappingItem; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttr; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrUniqueValue; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrValue; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainSchema; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirAttr; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirSchema; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGroup; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDerAttr; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDerSchema; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUMappingItem; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttr; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttrUniqueValue; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttrValue; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainSchema; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUVirAttr; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUVirSchema; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUser; -import org.slf4j.LoggerFactory; - -@SuppressWarnings({ "unchecked", "rawtypes" }) -public class JPAAttributableUtils implements AttributableUtils { - - /** - * Logger. - */ - private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(AttributableUtils.class); - - private final AttributableType type; - - protected JPAAttributableUtils(final AttributableType type) { - this.type = type; - } - - @Override - public AttributableType getType() { - return type; - } - - @Override - public <T extends Attributable<?, ?, ?>> Class<T> attributableClass() { - Class result; - - switch (type) { - case GROUP: - result = JPAGroup.class; - break; - - case MEMBERSHIP: - result = JPAMembership.class; - break; - - case CONFIGURATION: - result = JPAConf.class; - break; - - case USER: - default: - result = JPAUser.class; - } - - return result; - } - - @Override - public <T extends PlainSchema> Class<T> plainSchemaClass() { - Class result; - - switch (type) { - case GROUP: - result = JPAGPlainSchema.class; - break; - - case MEMBERSHIP: - result = JPAMPlainSchema.class; - break; - - case CONFIGURATION: - result = JPACPlainSchema.class; - break; - - case USER: - default: - result = JPAUPlainSchema.class; - break; - } - - return result; - } - - @Override - public <T extends PlainSchema> T newPlainSchema() { - T result = null; - - switch (type) { - case USER: - result = (T) new JPAUPlainSchema(); - break; - - case GROUP: - result = (T) new JPAGPlainSchema(); - break; - - case MEMBERSHIP: - result = (T) new JPAMPlainSchema(); - break; - - case CONFIGURATION: - result = (T) new JPACPlainSchema(); - default: - } - - return result; - } - - @Override - public <T extends PlainAttr> Class<T> plainAttrClass() { - Class result = null; - - switch (type) { - case GROUP: - result = JPAGPlainAttr.class; - break; - - case MEMBERSHIP: - result = JPAMPlainAttr.class; - break; - - case CONFIGURATION: - result = JPACPlainAttr.class; - break; - - case USER: - default: - result = JPAUPlainAttr.class; - break; - } - - return result; - } - - @Override - public <T extends PlainAttr> T newPlainAttr() { - T result = null; - - switch (type) { - case USER: - result = (T) new JPAUPlainAttr(); - break; - - case GROUP: - result = (T) new JPAGPlainAttr(); - break; - - case MEMBERSHIP: - result = (T) new JPAMPlainAttr(); - break; - - case CONFIGURATION: - result = (T) new JPACPlainAttr(); - - default: - } - - return result; - } - - @Override - public <T extends PlainAttrValue> Class<T> plainAttrValueClass() { - Class result; - - switch (type) { - case GROUP: - result = JPAGPlainAttrValue.class; - break; - - case MEMBERSHIP: - result = JPAMPlainAttrValue.class; - break; - - case CONFIGURATION: - result = JPACPlainAttrValue.class; - break; - - case USER: - default: - result = JPAUPlainAttrValue.class; - break; - } - - return result; - } - - @Override - public <T extends PlainAttrValue> T newPlainAttrValue() { - T result = null; - - switch (type) { - case USER: - result = (T) new JPAUPlainAttrValue(); - break; - - case GROUP: - result = (T) new JPAGPlainAttrValue(); - break; - - case MEMBERSHIP: - result = (T) new JPAMPlainAttrValue(); - break; - - case CONFIGURATION: - result = (T) new JPACPlainAttrValue(); - break; - - default: - } - - return result; - } - - @Override - public <T extends PlainAttrValue> Class<T> plainAttrUniqueValueClass() { - Class result; - - switch (type) { - case GROUP: - result = JPAGPlainAttrUniqueValue.class; - break; - - case MEMBERSHIP: - result = JPAMPlainAttrUniqueValue.class; - break; - - case CONFIGURATION: - result = JPACPlainAttrUniqueValue.class; - break; - - case USER: - default: - result = JPAUPlainAttrUniqueValue.class; - break; - } - - return result; - } - - @Override - public <T extends PlainAttrValue> T newPlainAttrUniqueValue() { - T result = null; - - switch (type) { - case USER: - result = (T) new JPAUPlainAttrUniqueValue(); - break; - - case GROUP: - result = (T) new JPAGPlainAttrUniqueValue(); - break; - - case MEMBERSHIP: - result = (T) new JPAMPlainAttrUniqueValue(); - break; - - case CONFIGURATION: - result = (T) new JPACPlainAttrUniqueValue(); - break; - - default: - } - - return result; - } - - @Override - public <T extends AttrTemplate<PlainSchema>> Class<T> plainAttrTemplateClass() { - Class result; - - switch (type) { - case GROUP: - result = JPAGPlainAttrTemplate.class; - break; - - case MEMBERSHIP: - result = JPAMPlainAttrTemplate.class; - break; - - case USER: - case CONFIGURATION: - default: - result = null; - } - - return result; - } - - @Override - public <T extends DerSchema> Class<T> derSchemaClass() { - Class result; - - switch (type) { - case USER: - result = JPAUDerSchema.class; - break; - - case GROUP: - result = JPAGDerSchema.class; - break; - - case MEMBERSHIP: - result = JPAMDerSchema.class; - break; - - case CONFIGURATION: - default: - result = null; - } - - return result; - } - - @Override - public <T extends DerSchema> T newDerSchema() { - T result = null; - - switch (type) { - case USER: - result = (T) new JPAUDerSchema(); - break; - - case GROUP: - result = (T) new JPAGDerSchema(); - break; - - case MEMBERSHIP: - result = (T) new JPAMDerSchema(); - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends DerAttr> Class<T> derAttrClass() { - Class result = null; - - switch (type) { - case USER: - result = JPAUDerAttr.class; - break; - - case GROUP: - result = JPAGDerAttr.class; - break; - - case MEMBERSHIP: - result = JPAMDerAttr.class; - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends DerAttr> T newDerAttr() { - T result = null; - - switch (type) { - case USER: - result = (T) new JPAUDerAttr(); - break; - - case GROUP: - result = (T) new JPAGDerAttr(); - break; - - case MEMBERSHIP: - result = (T) new JPAMDerAttr(); - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends AttrTemplate<DerSchema>> Class<T> derAttrTemplateClass() { - Class result = null; - - switch (type) { - case USER: - break; - - case GROUP: - result = JPAGDerAttrTemplate.class; - break; - - case MEMBERSHIP: - result = JPAMDerAttrTemplate.class; - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends VirSchema> Class<T> virSchemaClass() { - Class result = null; - - switch (type) { - case USER: - result = JPAUVirSchema.class; - break; - - case GROUP: - result = JPAGVirSchema.class; - break; - - case MEMBERSHIP: - result = JPAMVirSchema.class; - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends VirSchema> T newVirSchema() { - T result = null; - - switch (type) { - case USER: - result = (T) new JPAUVirSchema(); - break; - - case GROUP: - result = (T) new JPAGVirSchema(); - break; - - case MEMBERSHIP: - result = (T) new JPAMVirSchema(); - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends VirAttr> Class<T> virAttrClass() { - Class result = null; - - switch (type) { - case USER: - result = JPAUVirAttr.class; - break; - - case GROUP: - result = JPAGVirAttr.class; - break; - - case MEMBERSHIP: - result = JPAMVirAttr.class; - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends VirAttr> T newVirAttr() { - T result = null; - - switch (type) { - case USER: - result = (T) new JPAUVirAttr(); - break; - - case GROUP: - result = (T) new JPAGVirAttr(); - break; - - case MEMBERSHIP: - result = (T) new JPAMVirAttr(); - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends AttrTemplate<VirSchema>> Class<T> virAttrTemplateClass() { - Class result = null; - - switch (type) { - case USER: - break; - - case GROUP: - result = JPAGVirAttrTemplate.class; - break; - - case MEMBERSHIP: - result = JPAMVirAttrTemplate.class; - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends MappingItem> T getAccountIdItem(final ExternalResource resource) { - T result = null; - - if (resource != null) { - switch (type) { - case GROUP: - if (resource.getGmapping() != null) { - result = (T) resource.getGmapping().getAccountIdItem(); - } - break; - - case MEMBERSHIP: - case USER: - if (resource.getUmapping() != null) { - result = (T) resource.getUmapping().getAccountIdItem(); - } - break; - - default: - } - } - - return result; - } - - @Override - public String getAccountLink(final ExternalResource resource) { - String result = null; - - if (resource != null) { - switch (type) { - case USER: - if (resource.getUmapping() != null) { - result = resource.getUmapping().getAccountLink(); - } - break; - - case GROUP: - if (resource.getGmapping() != null) { - result = resource.getGmapping().getAccountLink(); - } - break; - - case MEMBERSHIP: - case CONFIGURATION: - default: - } - } - - return result; - } - - @Override - public <T extends MappingItem> List<T> getMappingItems( - final ExternalResource resource, final MappingPurpose purpose) { - - List<T> items = Collections.<T>emptyList(); - - if (resource != null) { - switch (type) { - case GROUP: - if (resource.getGmapping() != null) { - items = (List<T>) resource.getGmapping().getItems(); - } - break; - - case MEMBERSHIP: - case USER: - if (resource.getUmapping() != null) { - items = (List<T>) resource.getUmapping().getItems(); - } - break; - - default: - } - } - - final List<T> result = new ArrayList<>(); - - switch (purpose) { - case SYNCHRONIZATION: - for (T item : items) { - if (MappingPurpose.PROPAGATION != item.getPurpose() - && MappingPurpose.NONE != item.getPurpose()) { - - result.add(item); - } - } - break; - - case PROPAGATION: - for (T item : items) { - if (MappingPurpose.SYNCHRONIZATION != item.getPurpose() - && MappingPurpose.NONE != item.getPurpose()) { - - result.add(item); - } - } - break; - - case BOTH: - for (T item : items) { - if (MappingPurpose.NONE != item.getPurpose()) { - result.add(item); - } - } - break; - - case NONE: - for (T item : items) { - if (MappingPurpose.NONE == item.getPurpose()) { - result.add(item); - } - } - break; - default: - LOG.error("You requested not existing purpose {}", purpose); - } - - return result; - } - - @Override - public IntMappingType plainIntMappingType() { - IntMappingType result = null; - - switch (type) { - case GROUP: - result = IntMappingType.GroupPlainSchema; - break; - - case MEMBERSHIP: - result = IntMappingType.MembershipPlainSchema; - break; - - case USER: - result = IntMappingType.UserPlainSchema; - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public IntMappingType derIntMappingType() { - IntMappingType result = null; - - switch (type) { - case GROUP: - result = IntMappingType.GroupDerivedSchema; - break; - - case MEMBERSHIP: - result = IntMappingType.MembershipDerivedSchema; - break; - - case USER: - result = IntMappingType.UserDerivedSchema; - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public IntMappingType virIntMappingType() { - IntMappingType result = null; - - switch (type) { - case GROUP: - result = IntMappingType.GroupVirtualSchema; - break; - - case MEMBERSHIP: - result = IntMappingType.MembershipVirtualSchema; - break; - - case USER: - result = IntMappingType.UserVirtualSchema; - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends MappingItem> Class<T> mappingItemClass() { - Class result = null; - - switch (type) { - case USER: - result = JPAUMappingItem.class; - break; - - case GROUP: - result = JPAGMappingItem.class; - break; - - case MEMBERSHIP: - result = AbstractMappingItem.class; - break; - - case CONFIGURATION: - default: - } - - return result; - } - - @Override - public <T extends AbstractAttributableTO> T newAttributableTO() { - T result = null; - - switch (type) { - case USER: - result = (T) new UserTO(); - break; - case GROUP: - result = (T) new GroupTO(); - break; - case MEMBERSHIP: - result = (T) new MembershipTO(); - break; - case CONFIGURATION: - result = (T) new ConfTO(); - break; - default: - } - - return result; - } - - @Override - public <T extends AbstractSubjectTO> T newSubjectTO() { - T result = null; - - switch (type) { - case USER: - result = (T) new UserTO(); - break; - case GROUP: - result = (T) new GroupTO(); - break; - case MEMBERSHIP: - case CONFIGURATION: - default: - break; - } - - return result; - } -} http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAConnInstance.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAConnInstance.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAConnInstance.java index 746bf48..3929496 100644 --- a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAConnInstance.java +++ b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAConnInstance.java @@ -18,6 +18,7 @@ */ package org.apache.syncope.core.persistence.jpa.entity; +import org.apache.syncope.core.persistence.jpa.entity.resource.JPAExternalResource; import java.util.ArrayList; import java.util.HashSet; import java.util.List; @@ -41,7 +42,7 @@ import org.apache.syncope.common.lib.types.ConnConfProperty; import org.apache.syncope.common.lib.types.ConnectorCapability; import org.apache.syncope.core.persistence.api.entity.ConnInstance; import org.apache.syncope.core.persistence.api.entity.ConnPoolConf; -import org.apache.syncope.core.persistence.api.entity.ExternalResource; +import org.apache.syncope.core.persistence.api.entity.resource.ExternalResource; import org.apache.syncope.core.persistence.jpa.validation.entity.ConnInstanceCheck; import org.apache.syncope.core.misc.serialization.POJOHelper; http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADerSchema.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADerSchema.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADerSchema.java new file mode 100644 index 0000000..0b9a31b --- /dev/null +++ b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADerSchema.java @@ -0,0 +1,91 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.syncope.core.persistence.jpa.entity; + +import javax.persistence.Cacheable; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; +import org.apache.syncope.common.lib.types.AttrSchemaType; +import org.apache.syncope.core.persistence.api.entity.DerSchema; +import org.apache.syncope.core.persistence.jpa.validation.entity.SchemaNameCheck; + +@Entity +@Table(name = JPADerSchema.TABLE) +@Cacheable +@SchemaNameCheck +public class JPADerSchema extends AbstractEntity<String> implements DerSchema { + + private static final long serialVersionUID = -6173643493348674060L; + + public static final String TABLE = "DerSchema"; + + @Id + private String name; + + @Column(nullable = false) + private String expression; + + @Override + public String getKey() { + return name; + } + + @Override + public void setKey(final String key) { + this.name = key; + } + + @Override + public String getExpression() { + return expression; + } + + @Override + public void setExpression(final String expression) { + this.expression = expression; + } + + @Override + public AttrSchemaType getType() { + return AttrSchemaType.String; + } + + @Override + public String getMandatoryCondition() { + return Boolean.FALSE.toString().toLowerCase(); + } + + @Override + public boolean isMultivalue() { + return Boolean.TRUE; + } + + @Override + public boolean isUniqueConstraint() { + return Boolean.FALSE; + } + + @Override + public boolean isReadonly() { + return Boolean.FALSE; + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADynGroupMembership.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADynGroupMembership.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADynGroupMembership.java deleted file mode 100644 index 1f55348..0000000 --- a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADynGroupMembership.java +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ -package org.apache.syncope.core.persistence.jpa.entity; - -import java.util.ArrayList; -import java.util.List; -import javax.persistence.Entity; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.ManyToMany; -import javax.persistence.OneToOne; -import javax.persistence.Table; -import org.apache.syncope.core.persistence.api.entity.DynGroupMembership; -import org.apache.syncope.core.persistence.api.entity.group.Group; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGroup; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUser; - -@Entity -@Table(name = JPADynGroupMembership.TABLE) -public class JPADynGroupMembership extends AbstractDynMembership implements DynGroupMembership { - - private static final long serialVersionUID = -7336814163949640354L; - - public static final String TABLE = "DynGroupMembership"; - - @Id - private Long id; - - @OneToOne - private JPAGroup group; - - @ManyToMany - @JoinTable(joinColumns = - @JoinColumn(name = "dynGroupMembership_id"), - inverseJoinColumns = - @JoinColumn(name = "user_id")) - private List<JPAUser> users = new ArrayList<>(); - - @Override - public Long getKey() { - return id; - } - - @Override - protected List<JPAUser> internalGetUsers() { - return users; - } - - @Override - public Group getGroup() { - return group; - } - - @Override - public void setGroup(final Group role) { - checkType(role, JPAGroup.class); - this.group = (JPAGroup) role; - } - -} http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADynRoleMembership.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADynRoleMembership.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADynRoleMembership.java deleted file mode 100644 index 4796abf..0000000 --- a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPADynRoleMembership.java +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ -package org.apache.syncope.core.persistence.jpa.entity; - -import java.util.ArrayList; -import java.util.List; -import javax.persistence.Entity; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.ManyToMany; -import javax.persistence.OneToOne; -import javax.persistence.Table; -import org.apache.syncope.core.persistence.api.entity.DynRoleMembership; -import org.apache.syncope.core.persistence.api.entity.Role; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUser; - -@Entity -@Table(name = JPADynRoleMembership.TABLE) -public class JPADynRoleMembership extends AbstractDynMembership implements DynRoleMembership { - - private static final long serialVersionUID = -7336814163949640354L; - - public static final String TABLE = "DynRoleMembership"; - - @Id - private Long id; - - @OneToOne - private JPARole role; - - @ManyToMany - @JoinTable(joinColumns = - @JoinColumn(name = "dynRoleMembership_id"), - inverseJoinColumns = - @JoinColumn(name = "user_id")) - private List<JPAUser> users = new ArrayList<>(); - - @Override - public Long getKey() { - return id; - } - - @Override - protected List<JPAUser> internalGetUsers() { - return users; - } - - @Override - public Role getRole() { - return role; - } - - @Override - public void setRole(final Role role) { - checkType(role, JPARole.class); - this.role = (JPARole) role; - } - -} http://git-wip-us.apache.org/repos/asf/syncope/blob/081d9a04/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAEntityFactory.java ---------------------------------------------------------------------- diff --git a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAEntityFactory.java b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAEntityFactory.java index 048955b..92f9855 100644 --- a/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAEntityFactory.java +++ b/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAEntityFactory.java @@ -18,17 +18,21 @@ */ package org.apache.syncope.core.persistence.jpa.entity; +import org.apache.syncope.core.persistence.jpa.entity.user.JPADynRoleMembership; +import org.apache.syncope.core.persistence.jpa.entity.resource.JPAExternalResource; import org.apache.syncope.core.persistence.api.entity.AccountPolicy; +import org.apache.syncope.core.persistence.api.entity.AnyAbout; import org.apache.syncope.core.persistence.api.entity.ConnInstance; import org.apache.syncope.core.persistence.api.entity.ConnPoolConf; -import org.apache.syncope.core.persistence.api.entity.DynGroupMembership; -import org.apache.syncope.core.persistence.api.entity.DynRoleMembership; +import org.apache.syncope.core.persistence.api.entity.DerSchema; +import org.apache.syncope.core.persistence.api.entity.user.DynRoleMembership; import org.apache.syncope.core.persistence.api.entity.Entity; import org.apache.syncope.core.persistence.api.entity.EntityFactory; -import org.apache.syncope.core.persistence.api.entity.ExternalResource; +import org.apache.syncope.core.persistence.api.entity.resource.ExternalResource; import org.apache.syncope.core.persistence.api.entity.Logger; import org.apache.syncope.core.persistence.api.entity.Notification; import org.apache.syncope.core.persistence.api.entity.PasswordPolicy; +import org.apache.syncope.core.persistence.api.entity.PlainSchema; import org.apache.syncope.core.persistence.api.entity.PushPolicy; import org.apache.syncope.core.persistence.api.entity.Realm; import org.apache.syncope.core.persistence.api.entity.Report; @@ -36,37 +40,25 @@ import org.apache.syncope.core.persistence.api.entity.ReportExec; import org.apache.syncope.core.persistence.api.entity.ReportletConfInstance; import org.apache.syncope.core.persistence.api.entity.Role; import org.apache.syncope.core.persistence.api.entity.SyncPolicy; +import org.apache.syncope.core.persistence.api.entity.VirSchema; +import org.apache.syncope.core.persistence.api.entity.anyobject.ADynGroupMembership; +import org.apache.syncope.core.persistence.api.entity.anyobject.AMembership; +import org.apache.syncope.core.persistence.api.entity.anyobject.ARelationship; import org.apache.syncope.core.persistence.api.entity.conf.CPlainAttr; import org.apache.syncope.core.persistence.api.entity.conf.CPlainAttrUniqueValue; import org.apache.syncope.core.persistence.api.entity.conf.CPlainAttrValue; -import org.apache.syncope.core.persistence.api.entity.conf.CPlainSchema; import org.apache.syncope.core.persistence.api.entity.conf.Conf; -import org.apache.syncope.core.persistence.api.entity.membership.MDerAttr; -import org.apache.syncope.core.persistence.api.entity.membership.MDerAttrTemplate; -import org.apache.syncope.core.persistence.api.entity.membership.MDerSchema; -import org.apache.syncope.core.persistence.api.entity.membership.MPlainAttr; -import org.apache.syncope.core.persistence.api.entity.membership.MPlainAttrTemplate; -import org.apache.syncope.core.persistence.api.entity.membership.MPlainAttrUniqueValue; -import org.apache.syncope.core.persistence.api.entity.membership.MPlainAttrValue; -import org.apache.syncope.core.persistence.api.entity.membership.MPlainSchema; -import org.apache.syncope.core.persistence.api.entity.membership.MVirAttr; -import org.apache.syncope.core.persistence.api.entity.membership.MVirAttrTemplate; -import org.apache.syncope.core.persistence.api.entity.membership.MVirSchema; -import org.apache.syncope.core.persistence.api.entity.membership.Membership; import org.apache.syncope.core.persistence.api.entity.group.GDerAttr; -import org.apache.syncope.core.persistence.api.entity.group.GDerAttrTemplate; -import org.apache.syncope.core.persistence.api.entity.group.GDerSchema; -import org.apache.syncope.core.persistence.api.entity.group.GMapping; -import org.apache.syncope.core.persistence.api.entity.group.GMappingItem; import org.apache.syncope.core.persistence.api.entity.group.GPlainAttr; -import org.apache.syncope.core.persistence.api.entity.group.GPlainAttrTemplate; import org.apache.syncope.core.persistence.api.entity.group.GPlainAttrUniqueValue; import org.apache.syncope.core.persistence.api.entity.group.GPlainAttrValue; -import org.apache.syncope.core.persistence.api.entity.group.GPlainSchema; import org.apache.syncope.core.persistence.api.entity.group.GVirAttr; -import org.apache.syncope.core.persistence.api.entity.group.GVirAttrTemplate; -import org.apache.syncope.core.persistence.api.entity.group.GVirSchema; import org.apache.syncope.core.persistence.api.entity.group.Group; +import org.apache.syncope.core.persistence.api.entity.resource.Mapping; +import org.apache.syncope.core.persistence.api.entity.resource.MappingItem; +import org.apache.syncope.core.persistence.api.entity.resource.Provision; +import org.apache.syncope.core.persistence.api.entity.task.AnyFilter; +import org.apache.syncope.core.persistence.api.entity.task.AnyTemplate; import org.apache.syncope.core.persistence.api.entity.task.NotificationTask; import org.apache.syncope.core.persistence.api.entity.task.PropagationTask; import org.apache.syncope.core.persistence.api.entity.task.PushTask; @@ -75,47 +67,32 @@ import org.apache.syncope.core.persistence.api.entity.task.SyncTask; import org.apache.syncope.core.persistence.api.entity.task.TaskExec; import org.apache.syncope.core.persistence.api.entity.user.SecurityQuestion; import org.apache.syncope.core.persistence.api.entity.user.UDerAttr; -import org.apache.syncope.core.persistence.api.entity.user.UDerSchema; -import org.apache.syncope.core.persistence.api.entity.user.UMapping; -import org.apache.syncope.core.persistence.api.entity.user.UMappingItem; +import org.apache.syncope.core.persistence.api.entity.user.UDynGroupMembership; +import org.apache.syncope.core.persistence.api.entity.user.UMembership; import org.apache.syncope.core.persistence.api.entity.user.UPlainAttr; import org.apache.syncope.core.persistence.api.entity.user.UPlainAttrUniqueValue; import org.apache.syncope.core.persistence.api.entity.user.UPlainAttrValue; -import org.apache.syncope.core.persistence.api.entity.user.UPlainSchema; +import org.apache.syncope.core.persistence.api.entity.user.URelationship; import org.apache.syncope.core.persistence.api.entity.user.UVirAttr; -import org.apache.syncope.core.persistence.api.entity.user.UVirSchema; import org.apache.syncope.core.persistence.api.entity.user.User; +import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAADynGroupMembership; +import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAAMembership; +import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAARelationship; import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttr; import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttrUniqueValue; import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainAttrValue; -import org.apache.syncope.core.persistence.jpa.entity.conf.JPACPlainSchema; import org.apache.syncope.core.persistence.jpa.entity.conf.JPAConf; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerAttr; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerSchema; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttr; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrUniqueValue; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrValue; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainSchema; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirAttr; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirSchema; -import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMembership; import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerAttr; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGDerSchema; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGMapping; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGMappingItem; import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttr; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrTemplate; import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrUniqueValue; import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttrValue; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainSchema; import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirAttr; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirAttrTemplate; -import org.apache.syncope.core.persistence.jpa.entity.group.JPAGVirSchema; import org.apache.syncope.core.persistence.jpa.entity.group.JPAGroup; +import org.apache.syncope.core.persistence.jpa.entity.resource.JPAMapping; +import org.apache.syncope.core.persistence.jpa.entity.resource.JPAMappingItem; +import org.apache.syncope.core.persistence.jpa.entity.resource.JPAProvision; +import org.apache.syncope.core.persistence.jpa.entity.task.JPAAnyFilter; +import org.apache.syncope.core.persistence.jpa.entity.task.JPAAnyTemplate; import org.apache.syncope.core.persistence.jpa.entity.task.JPANotificationTask; import org.apache.syncope.core.persistence.jpa.entity.task.JPAPropagationTask; import org.apache.syncope.core.persistence.jpa.entity.task.JPAPushTask; @@ -123,15 +100,13 @@ import org.apache.syncope.core.persistence.jpa.entity.task.JPASchedTask; import org.apache.syncope.core.persistence.jpa.entity.task.JPASyncTask; import org.apache.syncope.core.persistence.jpa.entity.task.JPATaskExec; import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDerAttr; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDerSchema; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUMapping; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUMappingItem; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDynGroupMembership; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUMembership; import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttr; import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttrUniqueValue; import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttrValue; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainSchema; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAURelationship; import org.apache.syncope.core.persistence.jpa.entity.user.JPAUVirAttr; -import org.apache.syncope.core.persistence.jpa.entity.user.JPAUVirSchema; import org.apache.syncope.core.persistence.jpa.entity.user.JPAUser; import org.springframework.stereotype.Component; @@ -159,86 +134,56 @@ public class JPAEntityFactory implements EntityFactory { result = (T) new JPAUser(); } else if (reference.equals(Group.class)) { result = (T) new JPAGroup(); - } else if (reference.equals(Membership.class)) { - result = (T) new JPAMembership(); + } else if (reference.equals(ARelationship.class)) { + result = (T) new JPAARelationship(); + } else if (reference.equals(URelationship.class)) { + result = (T) new JPAURelationship(); + } else if (reference.equals(AMembership.class)) { + result = (T) new JPAAMembership(); + } else if (reference.equals(UMembership.class)) { + result = (T) new JPAUMembership(); } else if (reference.equals(Conf.class)) { result = (T) new JPAConf(); + } else if (reference.equals(AnyAbout.class)) { + result = (T) new JPAAnyAbout(); } else if (reference.equals(Notification.class)) { result = (T) new JPANotification(); } else if (reference.equals(ExternalResource.class)) { result = (T) new JPAExternalResource(); + } else if (reference.equals(Provision.class)) { + result = (T) new JPAProvision(); } else if (reference.equals(ConnInstance.class)) { result = (T) new JPAConnInstance(); - } else if (reference.equals(UPlainSchema.class)) { - result = (T) new JPAUPlainSchema(); + } else if (reference.equals(PlainSchema.class)) { + result = (T) new JPAPlainSchema(); } else if (reference.equals(UPlainAttr.class)) { result = (T) new JPAUPlainAttr(); } else if (reference.equals(UPlainAttrValue.class)) { result = (T) new JPAUPlainAttrValue(); } else if (reference.equals(UPlainAttrUniqueValue.class)) { result = (T) new JPAUPlainAttrUniqueValue(); - } else if (reference.equals(UDerSchema.class)) { - result = (T) new JPAUDerSchema(); + } else if (reference.equals(DerSchema.class)) { + result = (T) new JPADerSchema(); } else if (reference.equals(UDerAttr.class)) { result = (T) new JPAUDerAttr(); - } else if (reference.equals(UVirSchema.class)) { - result = (T) new JPAUVirSchema(); + } else if (reference.equals(VirSchema.class)) { + result = (T) new JPAVirSchema(); } else if (reference.equals(UVirAttr.class)) { result = (T) new JPAUVirAttr(); - } else if (reference.equals(UMapping.class)) { - result = (T) new JPAUMapping(); - } else if (reference.equals(UMappingItem.class)) { - result = (T) new JPAUMappingItem(); - } else if (reference.equals(GPlainSchema.class)) { - result = (T) new JPAGPlainSchema(); + } else if (reference.equals(Mapping.class)) { + result = (T) new JPAMapping(); + } else if (reference.equals(MappingItem.class)) { + result = (T) new JPAMappingItem(); } else if (reference.equals(GPlainAttr.class)) { result = (T) new JPAGPlainAttr(); } else if (reference.equals(GPlainAttrValue.class)) { result = (T) new JPAGPlainAttrValue(); } else if (reference.equals(GPlainAttrUniqueValue.class)) { result = (T) new JPAGPlainAttrUniqueValue(); - } else if (reference.equals(GPlainAttrTemplate.class)) { - result = (T) new JPAGPlainAttrTemplate(); - } else if (reference.equals(GDerAttrTemplate.class)) { - result = (T) new JPAGDerAttrTemplate(); - } else if (reference.equals(GVirAttrTemplate.class)) { - result = (T) new JPAGVirAttrTemplate(); - } else if (reference.equals(GDerSchema.class)) { - result = (T) new JPAGDerSchema(); } else if (reference.equals(GDerAttr.class)) { result = (T) new JPAGDerAttr(); - } else if (reference.equals(GVirSchema.class)) { - result = (T) new JPAGVirSchema(); } else if (reference.equals(GVirAttr.class)) { result = (T) new JPAGVirAttr(); - } else if (reference.equals(GMapping.class)) { - result = (T) new JPAGMapping(); - } else if (reference.equals(GMappingItem.class)) { - result = (T) new JPAGMappingItem(); - } else if (reference.equals(MPlainSchema.class)) { - result = (T) new JPAMPlainSchema(); - } else if (reference.equals(MPlainAttr.class)) { - result = (T) new JPAMPlainAttr(); - } else if (reference.equals(MPlainAttrValue.class)) { - result = (T) new JPAMPlainAttrValue(); - } else if (reference.equals(MPlainAttrUniqueValue.class)) { - result = (T) new JPAMPlainAttrUniqueValue(); - } else if (reference.equals(MDerSchema.class)) { - result = (T) new JPAMDerSchema(); - } else if (reference.equals(MDerAttr.class)) { - result = (T) new JPAMDerAttr(); - } else if (reference.equals(MVirSchema.class)) { - result = (T) new JPAMVirSchema(); - } else if (reference.equals(MVirAttr.class)) { - result = (T) new JPAMVirAttr(); - } else if (reference.equals(MPlainAttrTemplate.class)) { - result = (T) new JPAMPlainAttrTemplate(); - } else if (reference.equals(MDerAttrTemplate.class)) { - result = (T) new JPAMDerAttrTemplate(); - } else if (reference.equals(MVirAttrTemplate.class)) { - result = (T) new JPAMVirAttrTemplate(); - } else if (reference.equals(CPlainSchema.class)) { - result = (T) new JPACPlainSchema(); } else if (reference.equals(CPlainAttr.class)) { result = (T) new JPACPlainAttr(); } else if (reference.equals(CPlainAttrValue.class)) { @@ -263,14 +208,20 @@ public class JPAEntityFactory implements EntityFactory { result = (T) new JPASchedTask(); } else if (reference.equals(TaskExec.class)) { result = (T) new JPATaskExec(); + } else if (reference.equals(AnyFilter.class)) { + result = (T) new JPAAnyFilter(); + } else if (reference.equals(AnyTemplate.class)) { + result = (T) new JPAAnyTemplate(); } else if (reference.equals(SecurityQuestion.class)) { result = (T) new JPASecurityQuestion(); } else if (reference.equals(Logger.class)) { result = (T) new JPALogger(); } else if (reference.equals(DynRoleMembership.class)) { result = (T) new JPADynRoleMembership(); - } else if (reference.equals(DynGroupMembership.class)) { - result = (T) new JPADynGroupMembership(); + } else if (reference.equals(ADynGroupMembership.class)) { + result = (T) new JPAADynGroupMembership(); + } else if (reference.equals(UDynGroupMembership.class)) { + result = (T) new JPAUDynGroupMembership(); } else { throw new IllegalArgumentException("Could not find a JPA implementation of " + reference.getName()); }
