http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAExternalResource.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAExternalResource.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAExternalResource.java new file mode 100644 index 0000000..49be3dc --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAExternalResource.java @@ -0,0 +1,426 @@ +/* + * 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.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.CollectionTable; +import javax.persistence.Column; +import javax.persistence.ElementCollection; +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.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.OneToOne; +import javax.persistence.Table; +import javax.validation.constraints.Max; +import javax.validation.constraints.Min; +import javax.validation.constraints.NotNull; +import org.apache.commons.lang3.StringUtils; +import org.apache.syncope.common.lib.types.ConnConfProperty; +import org.apache.syncope.common.lib.types.PropagationMode; +import org.apache.syncope.common.lib.types.TraceLevel; +import org.apache.syncope.core.persistence.api.entity.AccountPolicy; +import org.apache.syncope.core.persistence.api.entity.ConnInstance; +import org.apache.syncope.core.persistence.api.entity.ExternalResource; +import org.apache.syncope.core.persistence.api.entity.PasswordPolicy; +import org.apache.syncope.core.persistence.api.entity.SyncPolicy; +import org.apache.syncope.core.persistence.api.entity.role.RMapping; +import org.apache.syncope.core.persistence.api.entity.user.UMapping; +import org.apache.syncope.core.persistence.jpa.validation.entity.ExternalResourceCheck; +import org.apache.syncope.core.persistence.jpa.entity.role.JPARMapping; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUMapping; +import org.apache.syncope.core.misc.serialization.POJOHelper; +import org.identityconnectors.framework.common.objects.SyncToken; + +/** + * Resource for propagation and synchronization. + */ +@Entity +@Table(name = JPAExternalResource.TABLE) +@ExternalResourceCheck +public class JPAExternalResource extends AbstractAnnotatedEntity<String> implements ExternalResource { + + private static final long serialVersionUID = -6937712883512073278L; + + public static final String TABLE = "ExternalResource"; + + /** + * The resource identifier is the name. + */ + @Id + private String name; + + /** + * Should this resource enforce the mandatory constraints? + */ + @Column(nullable = false) + @Basic + @Min(0) + @Max(1) + private Integer enforceMandatoryCondition; + + /** + * The resource type is identified by the associated connector. + */ + @ManyToOne(fetch = FetchType.EAGER, cascade = { CascadeType.MERGE }) + @NotNull + private JPAConnInstance connector; + + /** + * Mapping for user objects. + */ + @OneToOne(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER, mappedBy = "resource") + private JPAUMapping umapping; + + /** + * Mapping for role objects. + */ + @OneToOne(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER, mappedBy = "resource") + private JPARMapping rmapping; + + /** + * Is this resource primary, for propagations? + */ + @Column(nullable = false) + @Basic + @Min(0) + @Max(1) + private Integer propagationPrimary; + + /** + * Priority index for propagation ordering. + */ + @Column(nullable = false) + private Integer propagationPriority; + + /** + * Generate random password for propagation, if not provided? + */ + @Column(nullable = false) + @Basic + @Min(0) + @Max(1) + private Integer randomPwdIfNotProvided; + + @Enumerated(EnumType.STRING) + @Column(nullable = false) + private PropagationMode propagationMode; + + @Enumerated(EnumType.STRING) + @Column(nullable = false) + private TraceLevel createTraceLevel; + + @Enumerated(EnumType.STRING) + @Column(nullable = false) + private TraceLevel updateTraceLevel; + + @Enumerated(EnumType.STRING) + @Column(nullable = false) + private TraceLevel deleteTraceLevel; + + @Enumerated(EnumType.STRING) + @Column(nullable = false) + private TraceLevel syncTraceLevel; + + @ManyToOne(fetch = FetchType.EAGER, optional = true) + private JPAPasswordPolicy passwordPolicy; + + @ManyToOne(fetch = FetchType.EAGER, optional = true) + private JPAAccountPolicy accountPolicy; + + @ManyToOne(fetch = FetchType.EAGER, optional = true) + private JPASyncPolicy syncPolicy; + + /** + * Configuration properties that are overridden from the connector instance. + */ + @Lob + private String jsonConf; + + /** + * SyncToken for calling ConnId's sync() on users. + */ + @Lob + private String userializedSyncToken; + + /** + * SyncToken for calling ConnId's sync() on roles. + */ + @Lob + private String rserializedSyncToken; + + /** + * (Optional) classes for PropagationAction. + */ + @ElementCollection(fetch = FetchType.EAGER) + @Column(name = "action") + @CollectionTable(name = "ExternalResource_PropActions", + joinColumns = + @JoinColumn(name = "ExternalResource_name", referencedColumnName = "name")) + private List<String> propagationActionsClassNames = new ArrayList<>(); + + /** + * Default constructor. + */ + public JPAExternalResource() { + super(); + + enforceMandatoryCondition = getBooleanAsInteger(false); + propagationPrimary = 0; + propagationPriority = 0; + randomPwdIfNotProvided = 0; + propagationMode = PropagationMode.TWO_PHASES; + + createTraceLevel = TraceLevel.FAILURES; + updateTraceLevel = TraceLevel.FAILURES; + deleteTraceLevel = TraceLevel.FAILURES; + syncTraceLevel = TraceLevel.FAILURES; + } + + @Override + public boolean isEnforceMandatoryCondition() { + return isBooleanAsInteger(enforceMandatoryCondition); + } + + @Override + public void setEnforceMandatoryCondition(boolean enforceMandatoryCondition) { + this.enforceMandatoryCondition = getBooleanAsInteger(enforceMandatoryCondition); + } + + @Override + public ConnInstance getConnector() { + return connector; + } + + @Override + public void setConnector(final ConnInstance connector) { + checkType(connector, JPAConnInstance.class); + this.connector = (JPAConnInstance) connector; + } + + @Override + public UMapping getUmapping() { + return umapping; + } + + @Override + public void setUmapping(final UMapping umapping) { + checkType(umapping, JPAUMapping.class); + this.umapping = (JPAUMapping) umapping; + } + + @Override + public RMapping getRmapping() { + return rmapping; + } + + @Override + public void setRmapping(final RMapping rmapping) { + checkType(rmapping, JPARMapping.class); + this.rmapping = (JPARMapping) rmapping; + } + + @Override + public boolean isPropagationPrimary() { + return isBooleanAsInteger(propagationPrimary); + } + + @Override + public void setPropagationPrimary(boolean propagationPrimary) { + this.propagationPrimary = getBooleanAsInteger(propagationPrimary); + } + + @Override + public Integer getPropagationPriority() { + return propagationPriority; + } + + @Override + public void setPropagationPriority(Integer propagationPriority) { + if (propagationPriority != null) { + this.propagationPriority = propagationPriority; + } + } + + @Override + public boolean isRandomPwdIfNotProvided() { + return isBooleanAsInteger(randomPwdIfNotProvided); + } + + @Override + public void setRandomPwdIfNotProvided(boolean randomPwdIfNotProvided) { + this.randomPwdIfNotProvided = getBooleanAsInteger(randomPwdIfNotProvided); + } + + @Override + public PropagationMode getPropagationMode() { + return propagationMode; + } + + @Override + public void setPropagationMode(PropagationMode propagationMode) { + this.propagationMode = propagationMode; + } + + @Override + public String getKey() { + return name; + } + + @Override + public void setKey(final String name) { + this.name = name; + } + + @Override + public TraceLevel getCreateTraceLevel() { + return createTraceLevel; + } + + @Override + public void setCreateTraceLevel(final TraceLevel createTraceLevel) { + this.createTraceLevel = createTraceLevel; + } + + @Override + + public TraceLevel getDeleteTraceLevel() { + return deleteTraceLevel; + } + + @Override + public void setDeleteTraceLevel(final TraceLevel deleteTraceLevel) { + this.deleteTraceLevel = deleteTraceLevel; + } + + @Override + public TraceLevel getUpdateTraceLevel() { + return updateTraceLevel; + } + + @Override + public void setUpdateTraceLevel(final TraceLevel updateTraceLevel) { + this.updateTraceLevel = updateTraceLevel; + } + + @Override + public TraceLevel getSyncTraceLevel() { + return syncTraceLevel; + } + + @Override + public void setSyncTraceLevel(final TraceLevel syncTraceLevel) { + this.syncTraceLevel = syncTraceLevel; + } + + @Override + public AccountPolicy getAccountPolicy() { + return accountPolicy; + } + + @Override + public void setAccountPolicy(final AccountPolicy accountPolicy) { + checkType(accountPolicy, JPAAccountPolicy.class); + this.accountPolicy = (JPAAccountPolicy) accountPolicy; + } + + @Override + public PasswordPolicy getPasswordPolicy() { + return passwordPolicy; + } + + @Override + public void setPasswordPolicy(final PasswordPolicy passwordPolicy) { + checkType(passwordPolicy, JPAPasswordPolicy.class); + this.passwordPolicy = (JPAPasswordPolicy) passwordPolicy; + } + + @Override + public SyncPolicy getSyncPolicy() { + return syncPolicy; + } + + @Override + public void setSyncPolicy(final SyncPolicy syncPolicy) { + checkType(syncPolicy, JPASyncPolicy.class); + this.syncPolicy = (JPASyncPolicy) syncPolicy; + } + + @Override + public Set<ConnConfProperty> getConnInstanceConfiguration() { + return StringUtils.isBlank(jsonConf) + ? Collections.<ConnConfProperty>emptySet() + : new HashSet<>(Arrays.asList(POJOHelper.deserialize(jsonConf, ConnConfProperty[].class))); + } + + @Override + public void setConnInstanceConfiguration(final Set<ConnConfProperty> properties) { + jsonConf = POJOHelper.serialize(new HashSet<>(properties)); + } + + @Override + public String getSerializedUSyncToken() { + return userializedSyncToken; + } + + @Override + public SyncToken getUsyncToken() { + return userializedSyncToken == null + ? null + : POJOHelper.deserialize(userializedSyncToken, SyncToken.class); + } + + @Override + public void setUsyncToken(final SyncToken syncToken) { + this.userializedSyncToken = syncToken == null ? null : POJOHelper.serialize(syncToken); + } + + @Override + public String getSerializedRSyncToken() { + return rserializedSyncToken; + } + + @Override + public SyncToken getRsyncToken() { + return rserializedSyncToken == null + ? null + : POJOHelper.deserialize(rserializedSyncToken, SyncToken.class); + } + + @Override + public void setRsyncToken(final SyncToken syncToken) { + this.rserializedSyncToken = syncToken == null ? null : POJOHelper.serialize(syncToken); + } + + @Override + public List<String> getPropagationActionsClassNames() { + return propagationActionsClassNames; + } +}
http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPALogger.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPALogger.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPALogger.java new file mode 100644 index 0000000..3704055 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPALogger.java @@ -0,0 +1,80 @@ +/* + * 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.Column; +import javax.persistence.Entity; +import javax.persistence.EnumType; +import javax.persistence.Enumerated; +import javax.persistence.Id; +import javax.persistence.Table; +import org.apache.syncope.common.lib.types.LoggerLevel; +import org.apache.syncope.common.lib.types.LoggerType; +import org.apache.syncope.core.persistence.api.entity.Logger; + +@Entity +@Table(name = JPALogger.TABLE) +public class JPALogger extends AbstractEntity<String> implements Logger { + + private static final long serialVersionUID = 943012777014416027L; + + public static final String TABLE = "SyncopeLogger"; + + @Id + @Column(name = "logName") + private String name; + + @Column(name = "logLevel", nullable = false) + @Enumerated(EnumType.STRING) + private LoggerLevel level; + + @Column(name = "logType", nullable = false) + @Enumerated(EnumType.STRING) + private LoggerType type; + + @Override + public String getKey() { + return name; + } + + @Override + public void setKey(final String name) { + this.name = name; + } + + @Override + public LoggerLevel getLevel() { + return level; + } + + @Override + public void setLevel(final LoggerLevel level) { + this.level = level; + } + + @Override + public LoggerType getType() { + return type; + } + + @Override + public void setType(final LoggerType type) { + this.type = type; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPANotification.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPANotification.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPANotification.java new file mode 100644 index 0000000..de591e2 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPANotification.java @@ -0,0 +1,262 @@ +/* + * 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.Basic; +import javax.persistence.CollectionTable; +import javax.persistence.Column; +import javax.persistence.ElementCollection; +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.Table; +import javax.validation.constraints.Max; +import javax.validation.constraints.Min; +import javax.validation.constraints.NotNull; +import org.apache.syncope.common.lib.types.IntMappingType; +import org.apache.syncope.common.lib.types.TraceLevel; +import org.apache.syncope.core.persistence.api.entity.Notification; +import org.apache.syncope.core.persistence.jpa.validation.entity.NotificationCheck; + +@Entity +@Table(name = JPANotification.TABLE) +@NotificationCheck +public class JPANotification extends AbstractEntity<Long> implements Notification { + + private static final long serialVersionUID = 3112582296912757537L; + + public static final String TABLE = "Notification"; + + @Id + private Long id; + + @ElementCollection(fetch = FetchType.EAGER) + @CollectionTable(name = "Notification_events", + joinColumns = + @JoinColumn(name = "Notification_id", referencedColumnName = "id")) + @Column(name = "events") + private List<String> events; + + private String userAbout; + + private String roleAbout; + + private String recipients; + + @ElementCollection(fetch = FetchType.EAGER) + @CollectionTable(name = "Notification_staticRecipients", + joinColumns = + @JoinColumn(name = "Notification_id", referencedColumnName = "id")) + @Column(name = "staticRecipients") + private List<String> staticRecipients; + + @NotNull + @Enumerated(EnumType.STRING) + private IntMappingType recipientAttrType; + + @NotNull + private String recipientAttrName; + + @Column(nullable = false) + @Basic + @Min(0) + @Max(1) + private Integer selfAsRecipient; + + @NotNull + private String sender; + + @NotNull + private String subject; + + @NotNull + private String template; + + @NotNull + @Enumerated(EnumType.STRING) + private TraceLevel traceLevel; + + @Column(nullable = false) + @Basic + @Min(0) + @Max(1) + private Integer active; + + public JPANotification() { + events = new ArrayList<>(); + staticRecipients = new ArrayList<>(); + selfAsRecipient = getBooleanAsInteger(false); + active = getBooleanAsInteger(true); + traceLevel = TraceLevel.ALL; + } + + @Override + public Long getKey() { + return id; + } + + @Override + public String getUserAbout() { + return userAbout; + } + + @Override + public void setUserAbout(final String userAbout) { + this.userAbout = userAbout; + } + + @Override + public String getRoleAbout() { + return roleAbout; + } + + @Override + public void setRoleAbout(final String roleAbout) { + this.roleAbout = roleAbout; + } + + @Override + public String getRecipients() { + return recipients; + } + + @Override + public void setRecipients(final String recipients) { + this.recipients = recipients; + } + + @Override + public String getRecipientAttrName() { + return recipientAttrName; + } + + @Override + public void setRecipientAttrName(final String recipientAttrName) { + this.recipientAttrName = recipientAttrName; + } + + @Override + public IntMappingType getRecipientAttrType() { + return recipientAttrType; + } + + @Override + + public void setRecipientAttrType(final IntMappingType recipientAttrType) { + this.recipientAttrType = recipientAttrType; + } + + @Override + public List<String> getEvents() { + return events; + } + + @Override + public boolean addEvent(final String event) { + return event != null && !events.contains(event) && events.add(event); + } + + @Override + public boolean removeEvent(final String event) { + return event != null && events.remove(event); + } + + @Override + public List<String> getStaticRecipients() { + return staticRecipients; + } + + @Override + public boolean addStaticRecipient(final String staticRecipient) { + return staticRecipient != null && !staticRecipients.contains(staticRecipient) + && staticRecipients.add(staticRecipient); + } + + @Override + public boolean removeStaticRecipient(final String staticRecipient) { + return staticRecipient != null && staticRecipients.remove(staticRecipient); + } + + @Override + public boolean isSelfAsRecipient() { + return isBooleanAsInteger(selfAsRecipient); + } + + @Override + public void setSelfAsRecipient(final boolean selfAsRecipient) { + this.selfAsRecipient = getBooleanAsInteger(selfAsRecipient); + } + + @Override + public String getSender() { + return sender; + } + + @Override + public void setSender(final String sender) { + this.sender = sender; + } + + @Override + public String getSubject() { + return subject; + } + + @Override + + public void setSubject(final String subject) { + this.subject = subject; + } + + @Override + public String getTemplate() { + return template; + } + + @Override + public void setTemplate(final String template) { + this.template = template; + } + + @Override + public TraceLevel getTraceLevel() { + return traceLevel; + } + + @Override + public void setTraceLevel(final TraceLevel traceLevel) { + this.traceLevel = traceLevel; + } + + @Override + public boolean isActive() { + return isBooleanAsInteger(active); + } + + @Override + public void setActive(final boolean active) { + this.active = getBooleanAsInteger(active); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPasswordPolicy.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPasswordPolicy.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPasswordPolicy.java new file mode 100644 index 0000000..d46575a --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPasswordPolicy.java @@ -0,0 +1,43 @@ +/* + * 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.DiscriminatorValue; +import javax.persistence.Entity; +import org.apache.syncope.common.lib.types.PolicyType; +import org.apache.syncope.core.persistence.api.entity.PasswordPolicy; + +@Entity +@DiscriminatorValue("PasswordPolicy") +public class JPAPasswordPolicy extends JPAPolicy implements PasswordPolicy { + + private static final long serialVersionUID = 9138550910385232849L; + + public JPAPasswordPolicy() { + this(false); + } + + public JPAPasswordPolicy(final boolean global) { + super(); + + this.type = global + ? PolicyType.GLOBAL_PASSWORD + : PolicyType.PASSWORD; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPolicy.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPolicy.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPolicy.java new file mode 100644 index 0000000..3104c23 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPolicy.java @@ -0,0 +1,90 @@ +/* + * 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.DiscriminatorColumn; +import javax.persistence.Entity; +import javax.persistence.EnumType; +import javax.persistence.Enumerated; +import javax.persistence.Id; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.Lob; +import javax.persistence.Table; +import javax.validation.constraints.NotNull; +import org.apache.syncope.common.lib.types.PolicySpec; +import org.apache.syncope.common.lib.types.PolicyType; +import org.apache.syncope.core.persistence.api.entity.Policy; +import org.apache.syncope.core.persistence.jpa.validation.entity.PolicyCheck; +import org.apache.syncope.core.misc.serialization.POJOHelper; + +@Entity +@Table(name = JPAPolicy.TABLE) +@Inheritance(strategy = InheritanceType.SINGLE_TABLE) +@DiscriminatorColumn(name = "DTYPE") +@PolicyCheck +public abstract class JPAPolicy extends AbstractEntity<Long> implements Policy { + + private static final long serialVersionUID = -5844833125843247458L; + + public static final String TABLE = "Policy"; + + @Id + private Long id; + + @NotNull + private String description; + + @NotNull + @Enumerated(EnumType.STRING) + protected PolicyType type; + + @Lob + private String specification; + + @Override + public Long getKey() { + return id; + } + + @Override + public String getDescription() { + return description; + } + + @Override + public void setDescription(final String description) { + this.description = description; + } + + @Override + public PolicyType getType() { + return type; + } + + @Override + public <T extends PolicySpec> T getSpecification(final Class<T> reference) { + return POJOHelper.deserialize(specification, reference); + } + + @Override + public void setSpecification(final PolicySpec policy) { + this.specification = POJOHelper.serialize(policy); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPushPolicy.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPushPolicy.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPushPolicy.java new file mode 100644 index 0000000..fe8868f --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAPushPolicy.java @@ -0,0 +1,42 @@ +/* + * 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 org.apache.syncope.common.lib.types.PolicyType; +import org.apache.syncope.core.persistence.api.entity.PushPolicy; + +@Entity +public class JPAPushPolicy extends JPAPolicy implements PushPolicy { + + private static final long serialVersionUID = -5875589156893921113L; + + public JPAPushPolicy() { + this(false); + } + + public JPAPushPolicy(final boolean global) { + super(); + + this.type = global + ? PolicyType.GLOBAL_PUSH + : PolicyType.PUSH; + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReport.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReport.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReport.java new file mode 100644 index 0000000..788863e --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReport.java @@ -0,0 +1,148 @@ +/* + * 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.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import org.apache.syncope.common.lib.report.ReportletConf; +import org.apache.syncope.core.persistence.api.entity.Report; +import org.apache.syncope.core.persistence.api.entity.ReportExec; +import org.apache.syncope.core.persistence.jpa.validation.entity.ReportCheck; + +@Entity +@Table(name = JPAReport.TABLE) +@ReportCheck +public class JPAReport extends AbstractEntity<Long> implements Report { + + private static final long serialVersionUID = -587652654964285834L; + + public static final String TABLE = "Report"; + + @Id + private Long id; + + @Column(unique = true, nullable = false) + private String name; + + @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER, mappedBy = "report") + private List<JPAReportletConfInstance> reportletConfs; + + private String cronExpression; + + @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER, mappedBy = "report") + private List<JPAReportExec> executions; + + public JPAReport() { + super(); + + reportletConfs = new ArrayList<>(); + executions = new ArrayList<>(); + } + + @Override + public Long getKey() { + return id; + } + + @Override + public String getName() { + return name; + } + + @Override + public void setName(final String name) { + this.name = name; + } + + @Override + public boolean addExec(final ReportExec exec) { + checkType(exec, JPAReportExec.class); + return exec != null && !executions.contains((JPAReportExec) exec) && executions.add((JPAReportExec) exec); + } + + @Override + public boolean removeExec(final ReportExec exec) { + checkType(exec, JPAReportExec.class); + return exec != null && executions.remove((JPAReportExec) exec); + } + + @Override + public List<? extends ReportExec> getExecs() { + return executions; + } + + @Override + public boolean addReportletConf(final ReportletConf reportletConf) { + if (reportletConf == null) { + return false; + } + + JPAReportletConfInstance instance = new JPAReportletConfInstance(); + instance.setReport(this); + instance.setInstance(reportletConf); + + return reportletConfs.add(instance); + } + + @Override + public boolean removeReportletConf(final ReportletConf reportletConf) { + if (reportletConf == null) { + return false; + } + + JPAReportletConfInstance found = null; + for (JPAReportletConfInstance instance : reportletConfs) { + if (reportletConf.equals(instance.getInstance())) { + found = instance; + } + } + + return found == null + ? false + : reportletConfs.remove(found); + } + + @Override + public List<ReportletConf> getReportletConfs() { + List<ReportletConf> result = new ArrayList<>(reportletConfs.size()); + + for (JPAReportletConfInstance instance : reportletConfs) { + result.add(instance.getInstance()); + } + + return result; + } + + @Override + public String getCronExpression() { + return cronExpression; + } + + @Override + public void setCronExpression(final String cronExpression) { + this.cronExpression = cronExpression; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReportExec.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReportExec.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReportExec.java new file mode 100644 index 0000000..f5f0777 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReportExec.java @@ -0,0 +1,87 @@ +/* + * 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.Basic; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.Table; +import org.apache.commons.lang3.ArrayUtils; +import org.apache.syncope.common.lib.types.ReportExecStatus; +import org.apache.syncope.core.persistence.api.entity.Report; +import org.apache.syncope.core.persistence.api.entity.ReportExec; + +@Entity +@Table(name = JPAReportExec.TABLE) +public class JPAReportExec extends AbstractExec implements ReportExec { + + private static final long serialVersionUID = -6178274296037547769L; + + public static final String TABLE = "ReportExec"; + + @Id + private Long id; + + /** + * The referred report. + */ + @ManyToOne(optional = false) + private JPAReport report; + + /** + * Report execution result, stored as an XML stream. + */ + @Lob + @Basic(fetch = FetchType.LAZY) + private Byte[] execResult; + + @Override + public Long getKey() { + return id; + } + + @Override + public Report getReport() { + return report; + } + + @Override + public void setReport(final Report report) { + checkType(report, JPAReport.class); + this.report = (JPAReport) report; + } + + @Override + public byte[] getExecResult() { + return execResult == null ? null : ArrayUtils.toPrimitive(execResult); + } + + @Override + public void setExecResult(final byte[] execResult) { + this.execResult = execResult == null ? null : ArrayUtils.toObject(execResult); + } + + @Override + public void setStatus(final ReportExecStatus status) { + super.setStatus(status.name()); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReportletConfInstance.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReportletConfInstance.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReportletConfInstance.java new file mode 100644 index 0000000..c7edcdc --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAReportletConfInstance.java @@ -0,0 +1,77 @@ +/* + * 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.core.persistence.api.entity.ReportletConfInstance; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.ManyToOne; +import javax.persistence.Table; +import org.apache.syncope.common.lib.report.ReportletConf; +import org.apache.syncope.core.persistence.api.entity.Report; +import org.apache.syncope.core.misc.serialization.POJOHelper; + +@Entity +@Table(name = JPAReportletConfInstance.TABLE) +public class JPAReportletConfInstance extends AbstractEntity<Long> implements ReportletConfInstance { + + private static final long serialVersionUID = -2436055132955674610L; + + public static final String TABLE = "ReportletConfInstance"; + + @Id + private Long id; + + @Lob + private String serializedInstance; + + @ManyToOne + private JPAReport report; + + @Override + public Long getKey() { + return id; + } + + @Override + public Report getReport() { + return report; + } + + @Override + public void setReport(final Report report) { + checkType(report, JPAReport.class); + this.report = (JPAReport) report; + } + + @Override + public ReportletConf getInstance() { + return serializedInstance == null + ? null + : POJOHelper.deserialize(serializedInstance, ReportletConf.class); + } + + @Override + public void setInstance(final ReportletConf instance) { + this.serializedInstance = instance == null + ? null + : POJOHelper.serialize(instance); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPASecurityQuestion.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPASecurityQuestion.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPASecurityQuestion.java new file mode 100644 index 0000000..324095e --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPASecurityQuestion.java @@ -0,0 +1,56 @@ +/* + * 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.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.user.SecurityQuestion; + +@Entity +@Table(name = JPASecurityQuestion.TABLE) +public class JPASecurityQuestion extends AbstractEntity<Long> implements SecurityQuestion { + + private static final long serialVersionUID = 7675321820453579744L; + + public static final String TABLE = "SecurityQuestion"; + + @Id + private Long id; + + @Column(unique = true) + private String content; + + @Override + public Long getKey() { + return id; + } + + @Override + public String getContent() { + return content; + } + + @Override + public void setContent(final String content) { + this.content = content; + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPASyncPolicy.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPASyncPolicy.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPASyncPolicy.java new file mode 100644 index 0000000..b96a4c4 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPASyncPolicy.java @@ -0,0 +1,43 @@ +/* + * 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.DiscriminatorValue; +import javax.persistence.Entity; +import org.apache.syncope.common.lib.types.PolicyType; +import org.apache.syncope.core.persistence.api.entity.SyncPolicy; + +@Entity +@DiscriminatorValue("SyncPolicy") +public class JPASyncPolicy extends JPAPolicy implements SyncPolicy { + + private static final long serialVersionUID = -6090413855809521279L; + + public JPASyncPolicy() { + this(false); + } + + public JPASyncPolicy(final boolean global) { + super(); + + this.type = global + ? PolicyType.GLOBAL_SYNC + : PolicyType.SYNC; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAttributableUtilFactory.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAttributableUtilFactory.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAttributableUtilFactory.java new file mode 100644 index 0000000..427e828 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/JPAttributableUtilFactory.java @@ -0,0 +1,85 @@ +/* + * 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.AttributableType; +import org.apache.syncope.core.persistence.api.entity.Attributable; +import org.apache.syncope.core.persistence.api.entity.AttributableUtil; +import org.apache.syncope.core.persistence.api.entity.AttributableUtilFactory; +import org.apache.syncope.core.persistence.api.entity.conf.Conf; +import org.apache.syncope.core.persistence.api.entity.membership.Membership; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.api.entity.user.User; +import org.identityconnectors.framework.common.objects.ObjectClass; +import org.springframework.stereotype.Component; + +@Component +public class JPAttributableUtilFactory implements AttributableUtilFactory { + + @Override + public AttributableUtil getInstance(final AttributableType type) { + return new JPAAttributableUtil(type); + } + + @Override + public AttributableUtil getInstance(final String attributableType) { + return new JPAAttributableUtil(AttributableType.valueOf(attributableType)); + } + + @Override + public AttributableUtil getInstance(final ObjectClass objectClass) { + AttributableType type = null; + if (ObjectClass.ACCOUNT.equals(objectClass)) { + type = AttributableType.USER; + } + if (ObjectClass.GROUP.equals(objectClass)) { + type = AttributableType.ROLE; + } + + if (type == null) { + throw new IllegalArgumentException("ObjectClass not supported: " + objectClass); + } + + return new JPAAttributableUtil(type); + } + + @Override + public AttributableUtil getInstance(final Attributable<?, ?, ?> attributable) { + AttributableType type = null; + if (attributable instanceof User) { + type = AttributableType.USER; + } + if (attributable instanceof Role) { + type = AttributableType.ROLE; + } + if (attributable instanceof Membership) { + type = AttributableType.MEMBERSHIP; + } + if (attributable instanceof Conf) { + type = AttributableType.CONFIGURATION; + } + + if (type == null) { + throw new IllegalArgumentException("Attributable type not supported: " + attributable.getClass().getName()); + } + + return new JPAAttributableUtil(type); + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttr.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttr.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttr.java new file mode 100644 index 0000000..20e8d68 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttr.java @@ -0,0 +1,150 @@ +/* + * 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.conf; + +import java.util.ArrayList; +import java.util.List; +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; +import javax.persistence.OneToOne; +import javax.persistence.Table; +import javax.validation.Valid; +import org.apache.syncope.core.persistence.api.entity.Attributable; +import org.apache.syncope.core.persistence.api.entity.PlainAttrUniqueValue; +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.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.jpa.entity.AbstractPlainAttr; + +/** + * Configuration attribute. + */ +@Entity +@Table(name = JPACPlainAttr.TABLE) +public class JPACPlainAttr extends AbstractPlainAttr implements CPlainAttr { + + private static final long serialVersionUID = 8022331942314540648L; + + public static final String TABLE = "CPlainAttr"; + + /** + * Auto-generated id for this table. + */ + @Id + private Long id; + + /** + * The owner of this attribute. + */ + @ManyToOne(fetch = FetchType.EAGER) + private JPAConf owner; + + /** + * The schema of this attribute. + */ + @ManyToOne(fetch = FetchType.EAGER) + @JoinColumn(name = "schema_name") + private JPACPlainSchema schema; + + /** + * Values of this attribute (if schema is not UNIQUE). + */ + @OneToMany(cascade = CascadeType.MERGE, orphanRemoval = true, mappedBy = "attribute") + @Valid + private List<JPACPlainAttrValue> values; + + /** + * Value of this attribute (if schema is UNIQUE). + */ + @OneToOne(cascade = CascadeType.ALL, mappedBy = "attribute") + @Valid + private JPACPlainAttrUniqueValue uniqueValue; + + /** + * Default constructor. + */ + public JPACPlainAttr() { + super(); + values = new ArrayList<>(); + } + + @Override + public Long getKey() { + return id; + } + + @Override + public Conf getOwner() { + return owner; + } + + @Override + public void setOwner(final Attributable<?, ?, ?> owner) { + checkType(owner, JPAConf.class); + this.owner = (JPAConf) owner; + } + + @Override + public CPlainSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final PlainSchema schema) { + checkType(schema, JPACPlainSchema.class); + this.schema = (JPACPlainSchema) schema; + } + + @Override + protected boolean addValue(final PlainAttrValue attrValue) { + checkType(attrValue, JPACPlainAttrValue.class); + return values.add((JPACPlainAttrValue) attrValue); + } + + @Override + public boolean removeValue(final PlainAttrValue attrValue) { + checkType(attrValue, JPACPlainAttrValue.class); + return values.remove((JPACPlainAttrValue) attrValue); + } + + @Override + public List<? extends CPlainAttrValue> getValues() { + return values; + } + + @Override + public CPlainAttrUniqueValue getUniqueValue() { + return uniqueValue; + } + + @Override + public void setUniqueValue(final PlainAttrUniqueValue uniqueValue) { + checkType(owner, JPACPlainAttrUniqueValue.class); + this.uniqueValue = (JPACPlainAttrUniqueValue) uniqueValue; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttrUniqueValue.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttrUniqueValue.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttrUniqueValue.java new file mode 100644 index 0000000..097a046 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttrUniqueValue.java @@ -0,0 +1,78 @@ +/* + * 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.conf; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.OneToOne; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.PlainAttr; +import org.apache.syncope.core.persistence.api.entity.PlainSchema; +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.CPlainSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttrValue; + +@Entity +@Table(name = JPACPlainAttrUniqueValue.TABLE) +public class JPACPlainAttrUniqueValue extends AbstractPlainAttrValue implements CPlainAttrUniqueValue { + + private static final long serialVersionUID = -2072445894710677162L; + + public static final String TABLE = "CPlainAttrUniqueValue"; + + @Id + private Long id; + + @OneToOne(optional = false) + private JPACPlainAttr attribute; + + @ManyToOne(optional = false) + @JoinColumn(name = "schema_name") + private JPACPlainSchema schema; + + @Override + public Long getKey() { + return id; + } + + @Override + public CPlainAttr getAttr() { + return attribute; + } + + @Override + public void setAttr(final PlainAttr attr) { + checkType(attr, JPACPlainAttr.class); + this.attribute = (JPACPlainAttr) attr; + } + + @Override + public CPlainSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final PlainSchema schema) { + checkType(schema, JPACPlainSchema.class); + this.schema = (JPACPlainSchema) schema; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttrValue.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttrValue.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttrValue.java new file mode 100644 index 0000000..2761a84 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainAttrValue.java @@ -0,0 +1,64 @@ +/* + * 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.conf; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.ManyToOne; +import javax.persistence.Table; +import javax.validation.constraints.NotNull; +import org.apache.syncope.core.persistence.api.entity.PlainAttr; +import org.apache.syncope.core.persistence.api.entity.conf.CPlainAttr; +import org.apache.syncope.core.persistence.api.entity.conf.CPlainAttrValue; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttrValue; + +@Entity +@Table(name = JPACPlainAttrValue.TABLE) +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +public class JPACPlainAttrValue extends AbstractPlainAttrValue implements CPlainAttrValue { + + private static final long serialVersionUID = -4029895248193486171L; + + public static final String TABLE = "CPlainAttrValue"; + + @Id + private Long id; + + @ManyToOne + @NotNull + private JPACPlainAttr attribute; + + @Override + public Long getKey() { + return id; + } + + @Override + public CPlainAttr getAttr() { + return attribute; + } + + @Override + public void setAttr(final PlainAttr attr) { + checkType(attr, JPACPlainAttr.class); + this.attribute = (JPACPlainAttr) attr; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainSchema.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainSchema.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainSchema.java new file mode 100644 index 0000000..590443b --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPACPlainSchema.java @@ -0,0 +1,36 @@ +/* + * 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.conf; + +import javax.persistence.Cacheable; +import javax.persistence.Entity; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.conf.CPlainSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainSchema; + +@Entity +@Table(name = JPACPlainSchema.TABLE) +@Cacheable +public class JPACPlainSchema extends AbstractPlainSchema implements CPlainSchema { + + private static final long serialVersionUID = 3363019039331594433L; + + public static final String TABLE = "CPlainSchema"; + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPAConf.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPAConf.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPAConf.java new file mode 100644 index 0000000..13e529f --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/conf/JPAConf.java @@ -0,0 +1,116 @@ +/* + * 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.conf; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import javax.persistence.Cacheable; +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.validation.Valid; +import org.apache.syncope.core.persistence.api.entity.DerAttr; +import org.apache.syncope.core.persistence.api.entity.VirAttr; +import org.apache.syncope.core.persistence.api.entity.conf.CPlainAttr; +import org.apache.syncope.core.persistence.api.entity.conf.Conf; +import org.apache.syncope.core.persistence.jpa.entity.AbstractAttributable; + +@Entity +@Table(name = JPAConf.TABLE) +@Cacheable +public class JPAConf extends AbstractAttributable<CPlainAttr, DerAttr, VirAttr> implements Conf { + + private static final long serialVersionUID = 7671699609879382195L; + + public static final String TABLE = "SyncopeConf"; + + @Id + private Long id; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPACPlainAttr> plainAttrs; + + public JPAConf() { + super(); + + plainAttrs = new ArrayList<>(); + } + + @Override + public Long getKey() { + return id; + } + + @Override + public void setKey(final Long key) { + this.id = key; + } + + @Override + public boolean addPlainAttr(final CPlainAttr attr) { + checkType(attr, JPACPlainAttr.class); + return plainAttrs.add((JPACPlainAttr) attr); + } + + @Override + public boolean removePlainAttr(final CPlainAttr attr) { + checkType(attr, JPACPlainAttr.class); + return plainAttrs.remove((JPACPlainAttr) attr); + } + + @Override + public List<? extends CPlainAttr> getPlainAttrs() { + return plainAttrs; + } + + @Override + public boolean addDerAttr(final DerAttr attr) { + return false; + } + + @Override + public boolean removeDerAttr(final DerAttr derAttr) { + return false; + } + + @Override + public List<? extends DerAttr> getDerAttrs() { + return Collections.emptyList(); + } + + @Override + public boolean addVirAttr(final VirAttr attr) { + return false; + } + + @Override + public boolean removeVirAttr(final VirAttr virAttr) { + return false; + } + + @Override + public List<? extends VirAttr> getVirAttrs() { + return Collections.emptyList(); + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerAttr.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerAttr.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerAttr.java new file mode 100644 index 0000000..f2d1ff0 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerAttr.java @@ -0,0 +1,82 @@ +/* + * 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.membership; + +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.ManyToOne; +import javax.persistence.OneToOne; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.Attributable; +import org.apache.syncope.core.persistence.api.entity.DerSchema; +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.Membership; +import org.apache.syncope.core.persistence.jpa.entity.AbstractDerAttr; + +@Entity +@Table(name = JPAMDerAttr.TABLE) +public class JPAMDerAttr extends AbstractDerAttr implements MDerAttr { + + private static final long serialVersionUID = -443509121923448129L; + + public static final String TABLE = "MDerAttr"; + + @ManyToOne + private JPAMembership owner; + + @Column(nullable = false) + @OneToOne(cascade = CascadeType.MERGE) + private JPAMDerAttrTemplate template; + + @Override + public Membership getOwner() { + return owner; + } + + @Override + public void setOwner(final Attributable<?, ?, ?> owner) { + checkType(owner, JPAMembership.class); + this.owner = (JPAMembership) owner; + } + + @Override + public MDerAttrTemplate getTemplate() { + return template; + } + + @Override + public void setTemplate(final MDerAttrTemplate template) { + checkType(template, JPAMDerAttrTemplate.class); + this.template = (JPAMDerAttrTemplate) template; + } + + @Override + public MDerSchema getSchema() { + return template == null ? null : template.getSchema(); + } + + @Override + public void setSchema(final DerSchema schema) { + LOG.warn("This is role attribute, set template to select schema"); + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerAttrTemplate.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerAttrTemplate.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerAttrTemplate.java new file mode 100644 index 0000000..0586c38 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerAttrTemplate.java @@ -0,0 +1,67 @@ +/* + * 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.membership; + +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.Table; +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.role.Role; +import org.apache.syncope.core.persistence.jpa.entity.AbstractDerAttrTemplate; +import org.apache.syncope.core.persistence.jpa.entity.role.JPARole; + +@Entity +@Table(name = JPAMDerAttrTemplate.TABLE) +public class JPAMDerAttrTemplate extends AbstractDerAttrTemplate<MDerSchema> implements MDerAttrTemplate { + + private static final long serialVersionUID = -4465930976210263434L; + + public static final String TABLE = "MDerAttrTemplate"; + + @ManyToOne + private JPARole owner; + + @ManyToOne + @JoinColumn(name = "schema_name") + private JPAMDerSchema schema; + + @Override + public MDerSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final MDerSchema schema) { + checkType(schema, JPAMDerSchema.class); + this.schema = (JPAMDerSchema) schema; + } + + @Override + public Role getOwner() { + return owner; + } + + @Override + public void setOwner(final Role owner) { + checkType(owner, JPARole.class); + this.owner = (JPARole) owner; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerSchema.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerSchema.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerSchema.java new file mode 100644 index 0000000..e6711d6 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMDerSchema.java @@ -0,0 +1,34 @@ +/* + * 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.membership; + +import javax.persistence.Entity; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.membership.MDerSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractDerSchema; + +@Entity +@Table(name = JPAMDerSchema.TABLE) +public class JPAMDerSchema extends AbstractDerSchema implements MDerSchema { + + private static final long serialVersionUID = -4694082505732174583L; + + public static final String TABLE = "MDerSchema"; + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttr.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttr.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttr.java new file mode 100644 index 0000000..330f7ec --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttr.java @@ -0,0 +1,141 @@ +/* + * 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.membership; + +import java.util.ArrayList; +import java.util.List; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; +import javax.persistence.OneToOne; +import javax.persistence.Table; +import javax.validation.Valid; +import org.apache.syncope.core.persistence.api.entity.Attributable; +import org.apache.syncope.core.persistence.api.entity.PlainAttrUniqueValue; +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.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.Membership; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttr; + +@Entity +@Table(name = JPAMPlainAttr.TABLE) +public class JPAMPlainAttr extends AbstractPlainAttr implements MPlainAttr { + + private static final long serialVersionUID = 3755864809152866489L; + + public static final String TABLE = "MPlainAttr"; + + @Id + private Long id; + + @ManyToOne(fetch = FetchType.EAGER) + private JPAMembership owner; + + @Column(nullable = false) + @OneToOne(cascade = CascadeType.MERGE) + private JPAMPlainAttrTemplate template; + + @OneToMany(cascade = CascadeType.MERGE, orphanRemoval = true, mappedBy = "attribute") + @Valid + private List<JPAMPlainAttrValue> values; + + @OneToOne(cascade = CascadeType.ALL, mappedBy = "attribute") + @Valid + private JPAMPlainAttrUniqueValue uniqueValue; + + public JPAMPlainAttr() { + super(); + values = new ArrayList<>(); + } + + @Override + public Long getKey() { + return id; + } + + @Override + public Membership getOwner() { + return owner; + } + + @Override + public void setOwner(final Attributable<?, ?, ?> owner) { + checkType(owner, JPAMembership.class); + this.owner = (JPAMembership) owner; + } + + @Override + public MPlainAttrTemplate getTemplate() { + return template; + } + + @Override + public void setTemplate(final MPlainAttrTemplate template) { + checkType(template, JPAMPlainAttrTemplate.class); + this.template = (JPAMPlainAttrTemplate) template; + } + + @Override + public MPlainSchema getSchema() { + return template == null ? null : template.getSchema(); + } + + @Override + public void setSchema(final PlainSchema schema) { + LOG.warn("This is role attribute, set template to select schema"); + } + + @Override + protected boolean addValue(final PlainAttrValue attrValue) { + checkType(attrValue, JPAMPlainAttrValue.class); + return values.add((JPAMPlainAttrValue) attrValue); + } + + @Override + public boolean removeValue(final PlainAttrValue attrValue) { + checkType(attrValue, JPAMPlainAttrValue.class); + return values.remove((JPAMPlainAttrValue) attrValue); + } + + @Override + public List<? extends MPlainAttrValue> getValues() { + return values; + } + + @Override + public MPlainAttrUniqueValue getUniqueValue() { + return uniqueValue; + } + + @Override + public void setUniqueValue(final PlainAttrUniqueValue uniqueValue) { + checkType(owner, JPAMPlainAttrUniqueValue.class); + this.uniqueValue = (JPAMPlainAttrUniqueValue) uniqueValue; + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/d30c8526/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrTemplate.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrTemplate.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrTemplate.java new file mode 100644 index 0000000..7379564 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrTemplate.java @@ -0,0 +1,77 @@ +/* + * 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.membership; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.membership.MPlainAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.membership.MPlainSchema; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttrTemplate; +import org.apache.syncope.core.persistence.jpa.entity.role.JPARole; + +@Entity +@Table(name = JPAMPlainAttrTemplate.TABLE) +public class JPAMPlainAttrTemplate extends AbstractPlainAttrTemplate<MPlainSchema> implements MPlainAttrTemplate { + + private static final long serialVersionUID = -8768086609963244514L; + + public static final String TABLE = "MPlainAttrTemplate"; + + @Id + private Long id; + + @ManyToOne + private JPARole owner; + + @ManyToOne + @JoinColumn(name = "schema_name") + private JPAMPlainSchema schema; + + @Override + public Long getKey() { + return id; + } + + @Override + public MPlainSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final MPlainSchema schema) { + checkType(schema, JPAMPlainSchema.class); + this.schema = (JPAMPlainSchema) schema; + } + + @Override + public JPARole getOwner() { + return owner; + } + + @Override + public void setOwner(final Role owner) { + checkType(owner, JPARole.class); + this.owner = (JPARole) owner; + } + +}
