Return-Path: X-Original-To: apmail-syncope-commits-archive@www.apache.org Delivered-To: apmail-syncope-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id B592A10DED for ; Thu, 1 Jan 2015 18:11:56 +0000 (UTC) Received: (qmail 20092 invoked by uid 500); 1 Jan 2015 18:11:57 -0000 Delivered-To: apmail-syncope-commits-archive@syncope.apache.org Received: (qmail 20023 invoked by uid 500); 1 Jan 2015 18:11:57 -0000 Mailing-List: contact commits-help@syncope.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@syncope.apache.org Delivered-To: mailing list commits@syncope.apache.org Received: (qmail 19552 invoked by uid 99); 1 Jan 2015 18:11:57 -0000 Received: from tyr.zones.apache.org (HELO tyr.zones.apache.org) (140.211.11.114) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 01 Jan 2015 18:11:57 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id C51AEA3BEDF; Thu, 1 Jan 2015 18:11:56 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: ilgrosso@apache.org To: commits@syncope.apache.org Date: Thu, 01 Jan 2015 18:12:20 -0000 Message-Id: <501cdc50cff341dcb405ec8a1c4352be@git.apache.org> In-Reply-To: <26e85fe0744e424d9ba456a9194977e6@git.apache.org> References: <26e85fe0744e424d9ba456a9194977e6@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [25/32] syncope git commit: [SYNCOPE-620] JPA entities + basic tests http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractPlainSchema.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractPlainSchema.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractPlainSchema.java new file mode 100644 index 0000000..075252a --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractPlainSchema.java @@ -0,0 +1,271 @@ +/* + * 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.persistence.jpa.entity; + +import java.lang.reflect.Constructor; +import javax.persistence.Basic; +import javax.persistence.Column; +import javax.persistence.EnumType; +import javax.persistence.Enumerated; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.MappedSuperclass; +import javax.persistence.Transient; +import javax.validation.constraints.Max; +import javax.validation.constraints.Min; +import org.apache.syncope.common.lib.types.AttrSchemaType; +import org.apache.syncope.common.lib.types.CipherAlgorithm; +import org.apache.syncope.persistence.api.attrvalue.validation.Validator; +import org.apache.syncope.persistence.api.entity.PlainSchema; +import org.apache.syncope.persistence.jpa.attrvalue.validation.BasicValidator; +import org.apache.syncope.persistence.jpa.validation.entity.PlainSchemaCheck; +import org.apache.syncope.persistence.jpa.validation.entity.SchemaNameCheck; + +@MappedSuperclass +@PlainSchemaCheck +@SchemaNameCheck +public abstract class AbstractPlainSchema extends AbstractEntity implements PlainSchema { + + private static final long serialVersionUID = -8621028596062054739L; + + @Id + private String name; + + @Column(nullable = false) + @Enumerated(EnumType.STRING) + private AttrSchemaType type; + + @Column(nullable = false) + private String mandatoryCondition; + + @Basic + @Min(0) + @Max(1) + private Integer multivalue; + + @Basic + @Min(0) + @Max(1) + private Integer uniqueConstraint; + + @Basic + @Min(0) + @Max(1) + private Integer readonly; + + @Column(nullable = true) + private String conversionPattern; + + @Column(nullable = true) + private String validatorClass; + + @Column(nullable = true) + @Lob + private String enumerationValues; + + @Column(nullable = true) + @Lob + private String enumerationKeys; + + @Column(nullable = true) + private String secretKey; + + @Column(nullable = true) + @Enumerated(EnumType.STRING) + private CipherAlgorithm cipherAlgorithm; + + @Column(nullable = true) + private String mimeType; + + @Transient + private Validator validator; + + public AbstractPlainSchema() { + super(); + + type = AttrSchemaType.String; + mandatoryCondition = Boolean.FALSE.toString(); + multivalue = getBooleanAsInteger(false); + uniqueConstraint = getBooleanAsInteger(false); + readonly = getBooleanAsInteger(false); + } + + @Override + public String getKey() { + return name; + } + + @Override + public void setKey(final String name) { + this.name = name; + } + + @Override + public AttrSchemaType getType() { + return type; + } + + @Override + public void setType(final AttrSchemaType type) { + this.type = type; + } + + @Override + public String getMandatoryCondition() { + return mandatoryCondition; + } + + @Override + public void setMandatoryCondition(final String condition) { + this.mandatoryCondition = condition; + } + + @Override + public boolean isMultivalue() { + return isBooleanAsInteger(multivalue); + } + + @Override + public void setMultivalue(boolean multivalue) { + this.multivalue = getBooleanAsInteger(multivalue); + } + + @Override + public boolean isUniqueConstraint() { + return isBooleanAsInteger(uniqueConstraint); + } + + @Override + public void setUniqueConstraint(final boolean uniquevalue) { + this.uniqueConstraint = getBooleanAsInteger(uniquevalue); + } + + @Override + public boolean isReadonly() { + return isBooleanAsInteger(readonly); + } + + @Override + public void setReadonly(final boolean readonly) { + this.readonly = getBooleanAsInteger(readonly); + } + + @Override + public Validator getValidator() { + if (validator != null) { + return validator; + } + + if (getValidatorClass() != null && getValidatorClass().length() > 0) { + try { + Constructor validatorConstructor = Class.forName(getValidatorClass()). + getConstructor(new Class[] { PlainSchema.class }); + validator = (Validator) validatorConstructor.newInstance(this); + } catch (Exception e) { + LOG.error("Could not instantiate validator of type {}, reverting to {}", + getValidatorClass(), BasicValidator.class.getSimpleName(), e); + } + } + + if (validator == null) { + validator = new BasicValidator(this); + } + + return validator; + } + + @Override + public String getValidatorClass() { + return validatorClass; + } + + @Override + public void setValidatorClass(final String validatorClass) { + this.validatorClass = validatorClass; + } + + @Override + public String getEnumerationValues() { + return enumerationValues; + } + + @Override + public void setEnumerationValues(final String enumerationValues) { + this.enumerationValues = enumerationValues; + } + + @Override + public String getEnumerationKeys() { + return enumerationKeys; + } + + @Override + public void setEnumerationKeys(String enumerationKeys) { + this.enumerationKeys = enumerationKeys; + } + + @Override + public String getConversionPattern() { + if (!getType().isConversionPatternNeeded()) { + LOG.debug("Conversion pattern is not needed: {}'s type is {}", this, getType()); + } + + return conversionPattern; + } + + @Override + public void setConversionPattern(final String conversionPattern) { + if (!getType().isConversionPatternNeeded()) { + LOG.warn("Conversion pattern will be ignored: this attribute type is {}", getType()); + } + + this.conversionPattern = conversionPattern; + } + + @Override + public String getSecretKey() { + return secretKey; + } + + @Override + public void setSecretKey(final String secretKey) { + this.secretKey = secretKey; + } + + @Override + public CipherAlgorithm getCipherAlgorithm() { + return cipherAlgorithm; + } + + @Override + public void setCipherAlgorithm(final CipherAlgorithm cipherAlgorithm) { + this.cipherAlgorithm = cipherAlgorithm; + } + + @Override + public String getMimeType() { + return mimeType; + } + + @Override + public void setMimeType(final String mimeType) { + this.mimeType = mimeType; + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractSubject.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractSubject.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractSubject.java new file mode 100644 index 0000000..3628697 --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractSubject.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.persistence.jpa.entity; + +import java.util.HashSet; +import java.util.Set; +import org.apache.syncope.persistence.api.entity.DerAttr; +import org.apache.syncope.persistence.api.entity.ExternalResource; +import org.apache.syncope.persistence.api.entity.PlainAttr; +import org.apache.syncope.persistence.api.entity.Subject; +import org.apache.syncope.persistence.api.entity.VirAttr; + +public abstract class AbstractSubject

+ extends AbstractAttributable implements Subject { + + private static final long serialVersionUID = -6876467491398928855L; + + protected abstract Set internalGetResources(); + + @Override + @SuppressWarnings("unchecked") + public boolean addResource(final ExternalResource resource) { + return ((Set) internalGetResources()).add(resource); + } + + @Override + public boolean removeResource(final ExternalResource resource) { + return internalGetResources().remove(resource); + } + + @Override + public Set getResources() { + return internalGetResources(); + } + + @Override + public Set getResourceNames() { + Set ownResources = getResources(); + + Set result = new HashSet<>(ownResources.size()); + for (ExternalResource resource : ownResources) { + result.add(resource.getKey()); + } + + return result; + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractVirAttr.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractVirAttr.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractVirAttr.java new file mode 100644 index 0000000..3805489 --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractVirAttr.java @@ -0,0 +1,62 @@ +/* + * 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.persistence.jpa.entity; + +import java.util.ArrayList; +import java.util.List; + +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.MappedSuperclass; +import javax.persistence.Transient; +import org.apache.syncope.persistence.api.entity.VirAttr; + +@MappedSuperclass +public abstract class AbstractVirAttr extends AbstractEntity implements VirAttr { + + private static final long serialVersionUID = 5023204776925954907L; + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + protected Long id; + + @Transient + protected List values = new ArrayList<>(); + + @Override + public Long getKey() { + return id; + } + + @Override + public List getValues() { + return values; + } + + @Override + public boolean addValue(final String value) { + return !values.contains(value) && values.add(value); + } + + @Override + public boolean removeValue(final String value) { + return values.remove(value); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractVirSchema.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractVirSchema.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractVirSchema.java new file mode 100644 index 0000000..311350e --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AbstractVirSchema.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.persistence.jpa.entity; + +import javax.persistence.Basic; +import javax.persistence.Id; +import javax.persistence.MappedSuperclass; +import javax.validation.constraints.Max; +import javax.validation.constraints.Min; +import org.apache.syncope.common.lib.types.AttrSchemaType; +import org.apache.syncope.persistence.api.entity.VirSchema; +import org.apache.syncope.persistence.jpa.validation.entity.SchemaNameCheck; + +@MappedSuperclass +@SchemaNameCheck +public abstract class AbstractVirSchema extends AbstractEntity implements VirSchema { + + private static final long serialVersionUID = 3274006935328590141L; + + @Id + private String name; + + @Basic + @Min(0) + @Max(1) + private Integer readonly; + + public AbstractVirSchema() { + super(); + + readonly = getBooleanAsInteger(false); + } + + @Override + public String getKey() { + return name; + } + + @Override + public void setKey(final String key) { + this.name = key; + } + + @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 isBooleanAsInteger(readonly); + } + + @Override + public void setReadonly(final boolean readonly) { + this.readonly = getBooleanAsInteger(readonly); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AnnotatedEntityListener.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AnnotatedEntityListener.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AnnotatedEntityListener.java new file mode 100644 index 0000000..e6ce64f --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/AnnotatedEntityListener.java @@ -0,0 +1,54 @@ +/* + * 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.persistence.jpa.entity; + +import java.util.Date; +import javax.persistence.PrePersist; +import javax.persistence.PreUpdate; +import org.apache.syncope.persistence.api.entity.AnnotatedEntity; +import org.apache.syncope.server.security.AuthContextUtil; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class AnnotatedEntityListener { + + /** + * Logger. + */ + private static final Logger LOG = LoggerFactory.getLogger(AnnotatedEntityListener.class); + + @PrePersist + @PreUpdate + public void setSysInfo(final AnnotatedEntity entity) { + final String username = AuthContextUtil.getAuthenticatedUsername(); + LOG.debug("Set system properties for '{}'", entity); + + final Date now = new Date(); + + if (entity.getCreationDate() == null) { + LOG.debug("Set creation date '{}' and creator '{}' for '{}'", now, username, entity); + entity.setCreationDate(now); + entity.setCreator(username); + } + + LOG.debug("Set last change date '{}' and modifier '{}' for '{}'", now, username, entity); + entity.setLastModifier(username); + entity.setLastChangeDate(now); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAAccountPolicy.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAAccountPolicy.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAAccountPolicy.java new file mode 100644 index 0000000..229dd43 --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAAccountPolicy.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.persistence.jpa.entity; + +import java.util.HashSet; +import java.util.Set; +import javax.persistence.DiscriminatorValue; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.ManyToMany; +import javax.validation.Valid; +import org.apache.syncope.common.lib.types.PolicyType; +import org.apache.syncope.persistence.api.entity.AccountPolicy; +import org.apache.syncope.persistence.api.entity.ExternalResource; + +@Entity +@DiscriminatorValue("AccountPolicy") +public class JPAAccountPolicy extends JPAPolicy implements AccountPolicy { + + private static final long serialVersionUID = -2767606675667839060L; + + /** + * Resources for alternative user authentication: if empty, only internal storage will be used. + */ + @ManyToMany(fetch = FetchType.EAGER) + @JoinTable(joinColumns = + @JoinColumn(name = "account_policy_id"), + inverseJoinColumns = + @JoinColumn(name = "resource_name")) + @Valid + private Set resources; + + public JPAAccountPolicy() { + this(false); + this.resources = new HashSet<>(); + } + + public JPAAccountPolicy(final boolean global) { + super(); + + this.type = global + ? PolicyType.GLOBAL_ACCOUNT + : PolicyType.ACCOUNT; + } + + @Override + public boolean addResource(final ExternalResource resource) { + checkType(resource, JPAExternalResource.class); + return resources.add((JPAExternalResource) resource); + } + + @Override + public boolean removeResource(final ExternalResource resource) { + checkType(resource, JPAExternalResource.class); + return resources.remove((JPAExternalResource) resource); + } + + @Override + public Set getResources() { + return resources; + } + + @Override + public Set getResourceNames() { + Set result = new HashSet<>(resources.size()); + for (ExternalResource resource : resources) { + result.add(resource.getKey()); + } + + return result; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAAttributableUtil.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAAttributableUtil.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAAttributableUtil.java new file mode 100644 index 0000000..2705285 --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAAttributableUtil.java @@ -0,0 +1,882 @@ +/* + * 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.persistence.jpa.entity; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +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.persistence.api.entity.AttrTemplate; +import org.apache.syncope.persistence.api.entity.Attributable; +import org.apache.syncope.persistence.api.entity.AttributableUtil; +import org.apache.syncope.persistence.api.entity.DerAttr; +import org.apache.syncope.persistence.api.entity.DerSchema; +import org.apache.syncope.persistence.api.entity.ExternalResource; +import org.apache.syncope.persistence.api.entity.MappingItem; +import org.apache.syncope.persistence.api.entity.PlainAttr; +import org.apache.syncope.persistence.api.entity.PlainAttrValue; +import org.apache.syncope.persistence.api.entity.PlainSchema; +import org.apache.syncope.persistence.api.entity.VirAttr; +import org.apache.syncope.persistence.api.entity.VirSchema; +import org.apache.syncope.persistence.api.entity.conf.Conf; +import org.apache.syncope.persistence.api.entity.membership.Membership; +import org.apache.syncope.persistence.api.entity.role.Role; +import org.apache.syncope.persistence.api.entity.user.User; +import org.apache.syncope.persistence.jpa.entity.conf.JPACPlainAttr; +import org.apache.syncope.persistence.jpa.entity.conf.JPACPlainAttrUniqueValue; +import org.apache.syncope.persistence.jpa.entity.conf.JPACPlainAttrValue; +import org.apache.syncope.persistence.jpa.entity.conf.JPACPlainSchema; +import org.apache.syncope.persistence.jpa.entity.conf.JPAConf; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMDerAttr; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMDerAttrTemplate; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMDerSchema; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMPlainAttr; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMPlainAttrTemplate; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMPlainAttrUniqueValue; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMPlainAttrValue; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMPlainSchema; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMVirAttr; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMVirAttrTemplate; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMVirSchema; +import org.apache.syncope.persistence.jpa.entity.membership.JPAMembership; +import org.apache.syncope.persistence.jpa.entity.role.JPARDerAttr; +import org.apache.syncope.persistence.jpa.entity.role.JPARDerAttrTemplate; +import org.apache.syncope.persistence.jpa.entity.role.JPARDerSchema; +import org.apache.syncope.persistence.jpa.entity.role.JPARMappingItem; +import org.apache.syncope.persistence.jpa.entity.role.JPARPlainAttr; +import org.apache.syncope.persistence.jpa.entity.role.JPARPlainAttrTemplate; +import org.apache.syncope.persistence.jpa.entity.role.JPARPlainAttrUniqueValue; +import org.apache.syncope.persistence.jpa.entity.role.JPARPlainAttrValue; +import org.apache.syncope.persistence.jpa.entity.role.JPARPlainSchema; +import org.apache.syncope.persistence.jpa.entity.role.JPARVirAttr; +import org.apache.syncope.persistence.jpa.entity.role.JPARVirAttrTemplate; +import org.apache.syncope.persistence.jpa.entity.role.JPARVirSchema; +import org.apache.syncope.persistence.jpa.entity.role.JPARole; +import org.apache.syncope.persistence.jpa.entity.user.JPAUDerAttr; +import org.apache.syncope.persistence.jpa.entity.user.JPAUDerSchema; +import org.apache.syncope.persistence.jpa.entity.user.JPAUMappingItem; +import org.apache.syncope.persistence.jpa.entity.user.JPAUPlainAttr; +import org.apache.syncope.persistence.jpa.entity.user.JPAUPlainAttrUniqueValue; +import org.apache.syncope.persistence.jpa.entity.user.JPAUPlainAttrValue; +import org.apache.syncope.persistence.jpa.entity.user.JPAUPlainSchema; +import org.apache.syncope.persistence.jpa.entity.user.JPAUVirAttr; +import org.apache.syncope.persistence.jpa.entity.user.JPAUVirSchema; +import org.apache.syncope.persistence.jpa.entity.user.JPAUser; +import org.apache.syncope.server.spring.BeanUtils; +import org.identityconnectors.framework.common.objects.ObjectClass; +import org.identityconnectors.framework.common.objects.Uid; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({ "unchecked", "rawtypes" }) +public class JPAAttributableUtil implements AttributableUtil { + + /** + * Logger. + */ + private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(AttributableUtil.class); + + public static AttributableUtil getInstance(final AttributableType type) { + return new JPAAttributableUtil(type); + } + + public static AttributableUtil valueOf(final String name) { + return new JPAAttributableUtil(AttributableType.valueOf(name)); + } + + public static 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); + } + + public static 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); + } + + private final AttributableType type; + + private JPAAttributableUtil(final AttributableType type) { + this.type = type; + } + + @Override + public AttributableType getType() { + return type; + } + + @Override + public > Class attributableClass() { + Class result; + + switch (type) { + case ROLE: + result = JPARole.class; + break; + + case MEMBERSHIP: + result = JPAMembership.class; + break; + + case CONFIGURATION: + result = JPAConf.class; + break; + + case USER: + default: + result = JPAUser.class; + } + + return result; + } + + @Override + public Class plainSchemaClass() { + Class result; + + switch (type) { + case ROLE: + result = JPARPlainSchema.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 newPlainSchema() { + T result = null; + + switch (type) { + case USER: + result = (T) new JPAUPlainSchema(); + break; + + case ROLE: + result = (T) new JPARPlainSchema(); + break; + + case MEMBERSHIP: + result = (T) new JPAMPlainSchema(); + break; + + case CONFIGURATION: + result = (T) new JPACPlainSchema(); + default: + } + + return result; + } + + @Override + public Class plainAttrClass() { + Class result = null; + + switch (type) { + case ROLE: + result = JPARPlainAttr.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 newPlainAttr() { + T result = null; + + switch (type) { + case USER: + result = (T) new JPAUPlainAttr(); + break; + + case ROLE: + result = (T) new JPARPlainAttr(); + break; + + case MEMBERSHIP: + result = (T) new JPAMPlainAttr(); + break; + + case CONFIGURATION: + result = (T) new JPACPlainAttr(); + + default: + } + + return result; + } + + @Override + public Class plainAttrValueClass() { + Class result; + + switch (type) { + case ROLE: + result = JPARPlainAttrValue.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 newPlainAttrValue() { + T result = null; + + switch (type) { + case USER: + result = (T) new JPAUPlainAttrValue(); + break; + + case ROLE: + result = (T) new JPARPlainAttrValue(); + break; + + case MEMBERSHIP: + result = (T) new JPAMPlainAttrValue(); + break; + + case CONFIGURATION: + result = (T) new JPACPlainAttrValue(); + break; + + default: + } + + return result; + } + + @Override + public Class plainAttrUniqueValueClass() { + Class result; + + switch (type) { + case ROLE: + result = JPARPlainAttrUniqueValue.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 newPlainAttrUniqueValue() { + T result = null; + + switch (type) { + case USER: + result = (T) new JPAUPlainAttrUniqueValue(); + break; + + case ROLE: + result = (T) new JPARPlainAttrUniqueValue(); + break; + + case MEMBERSHIP: + result = (T) new JPAMPlainAttrUniqueValue(); + break; + + case CONFIGURATION: + result = (T) new JPACPlainAttrUniqueValue(); + break; + + default: + } + + return result; + } + + @Override + public > Class plainAttrTemplateClass() { + Class result; + + switch (type) { + case ROLE: + result = JPARPlainAttrTemplate.class; + break; + + case MEMBERSHIP: + result = JPAMPlainAttrTemplate.class; + break; + + case USER: + case CONFIGURATION: + default: + result = null; + } + + return result; + } + + @Override + public Class derSchemaClass() { + Class result; + + switch (type) { + case USER: + result = JPAUDerSchema.class; + break; + + case ROLE: + result = JPARDerSchema.class; + break; + + case MEMBERSHIP: + result = JPAMDerSchema.class; + break; + + case CONFIGURATION: + default: + result = null; + } + + return result; + } + + @Override + public T newDerSchema() { + T result = null; + + switch (type) { + case USER: + result = (T) new JPAUDerSchema(); + break; + + case ROLE: + result = (T) new JPARDerSchema(); + break; + + case MEMBERSHIP: + result = (T) new JPAMDerSchema(); + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public Class derAttrClass() { + Class result = null; + + switch (type) { + case USER: + result = JPAUDerAttr.class; + break; + + case ROLE: + result = JPARDerAttr.class; + break; + + case MEMBERSHIP: + result = JPAMDerAttr.class; + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public T newDerAttr() { + T result = null; + + switch (type) { + case USER: + result = (T) new JPAUDerAttr(); + break; + + case ROLE: + result = (T) new JPARDerAttr(); + break; + + case MEMBERSHIP: + result = (T) new JPAMDerAttr(); + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public > Class derAttrTemplateClass() { + Class result = null; + + switch (type) { + case USER: + break; + + case ROLE: + result = JPARDerAttrTemplate.class; + break; + + case MEMBERSHIP: + result = JPAMDerAttrTemplate.class; + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public Class virSchemaClass() { + Class result = null; + + switch (type) { + case USER: + result = JPAUVirSchema.class; + break; + + case ROLE: + result = JPARVirSchema.class; + break; + + case MEMBERSHIP: + result = JPAMVirSchema.class; + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public T newVirSchema() { + T result = null; + + switch (type) { + case USER: + result = (T) new JPAUVirSchema(); + break; + + case ROLE: + result = (T) new JPARVirSchema(); + break; + + case MEMBERSHIP: + result = (T) new JPAMVirSchema(); + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public Class virAttrClass() { + Class result = null; + + switch (type) { + case USER: + result = JPAUVirAttr.class; + break; + + case ROLE: + result = JPARVirAttr.class; + break; + + case MEMBERSHIP: + result = JPAMVirAttr.class; + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public T newVirAttr() { + T result = null; + + switch (type) { + case USER: + result = (T) new JPAUVirAttr(); + break; + + case ROLE: + result = (T) new JPARVirAttr(); + break; + + case MEMBERSHIP: + result = (T) new JPAMVirAttr(); + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public > Class virAttrTemplateClass() { + Class result = null; + + switch (type) { + case USER: + break; + + case ROLE: + result = JPARVirAttrTemplate.class; + break; + + case MEMBERSHIP: + result = JPAMVirAttrTemplate.class; + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public T getAccountIdItem(final ExternalResource resource) { + T result = null; + + if (resource != null) { + switch (type) { + case ROLE: + if (resource.getRmapping() != null) { + result = (T) resource.getRmapping().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 ROLE: + if (resource.getRmapping() != null) { + result = resource.getRmapping().getAccountLink(); + } + break; + + case MEMBERSHIP: + case CONFIGURATION: + default: + } + } + + return result; + } + + @Override + public List getMappingItems( + final ExternalResource resource, final MappingPurpose purpose) { + + List items = Collections.emptyList(); + + if (resource != null) { + switch (type) { + case ROLE: + if (resource.getRmapping() != null) { + items = (List) resource.getRmapping().getItems(); + } + break; + + case MEMBERSHIP: + case USER: + if (resource.getUmapping() != null) { + items = (List) resource.getUmapping().getItems(); + } + break; + + default: + } + } + + final List 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 List getUidToMappingItems( + final ExternalResource resource, final MappingPurpose purpose) { + + List items = getMappingItems(resource, purpose); + + MappingItem uidItem = type == AttributableType.USER ? new JPAUMappingItem() : new JPARMappingItem(); + BeanUtils.copyProperties(getAccountIdItem(resource), uidItem); + uidItem.setExtAttrName(Uid.NAME); + uidItem.setAccountid(false); + items.add((T) uidItem); + + return items; + } + + @Override + public IntMappingType intMappingType() { + IntMappingType result = null; + + switch (type) { + case ROLE: + result = IntMappingType.RoleSchema; + break; + + case MEMBERSHIP: + result = IntMappingType.MembershipSchema; + break; + + case USER: + result = IntMappingType.UserSchema; + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public IntMappingType derIntMappingType() { + IntMappingType result = null; + + switch (type) { + case ROLE: + result = IntMappingType.RoleSchema; + break; + + case MEMBERSHIP: + result = IntMappingType.MembershipSchema; + break; + + case USER: + result = IntMappingType.UserSchema; + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public IntMappingType virIntMappingType() { + IntMappingType result = null; + + switch (type) { + case ROLE: + result = IntMappingType.RoleVirtualSchema; + break; + + case MEMBERSHIP: + result = IntMappingType.MembershipVirtualSchema; + break; + + case USER: + result = IntMappingType.UserVirtualSchema; + break; + + case CONFIGURATION: + default: + } + + return result; + } + + @Override + public Class mappingItemClass() { + Class result = null; + + switch (type) { + case USER: + result = JPAUMappingItem.class; + break; + + case ROLE: + result = JPARMappingItem.class; + break; + + case MEMBERSHIP: + result = AbstractMappingItem.class; + break; + + case CONFIGURATION: + default: + } + + return result; + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAConnInstance.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAConnInstance.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAConnInstance.java new file mode 100644 index 0000000..271f899 --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAConnInstance.java @@ -0,0 +1,268 @@ +/* + * 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.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.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.OneToMany; +import javax.persistence.Table; +import org.apache.commons.lang3.ArrayUtils; +import org.apache.commons.lang3.StringUtils; +import org.apache.syncope.common.lib.types.ConnConfProperty; +import org.apache.syncope.common.lib.types.ConnectorCapability; +import org.apache.syncope.persistence.api.entity.ConnInstance; +import org.apache.syncope.persistence.api.entity.ConnPoolConf; +import org.apache.syncope.persistence.api.entity.ExternalResource; +import org.apache.syncope.persistence.jpa.validation.entity.ConnInstanceCheck; +import org.apache.syncope.server.utils.serialization.POJOHelper; + +@Entity +@Table(name = JPAConnInstance.TABLE) +@ConnInstanceCheck +public class JPAConnInstance extends AbstractEntity implements ConnInstance { + + private static final long serialVersionUID = -2294708794497208872L; + + public static final String TABLE = "ConnInstance"; + + private static final int DEFAULT_TIMEOUT = 10; + + @Id + private Long id; + + /** + * URI identifying the local / remote ConnId location where the related connector bundle is found. + */ + @Column(nullable = false) + private String location; + + /** + * Connector bundle class name. + * Within a given location, the triple + * (ConnectorBundle-Name, ConnectorBundle-Version, ConnectorBundle-Version) must be unique. + */ + @Column(nullable = false) + private String connectorName; + + /** + * Qualified name for the connector bundle. + * Within a given location, the triple + * (ConnectorBundle-Name, ConnectorBundle-Version, ConnectorBundle-Version) must be unique. + */ + @Column(nullable = false) + private String bundleName; + + /** + * Version of the bundle. + * Within a given location, the triple + * (ConnectorBundle-Name, ConnectorBundle-Version, ConnectorBundle-Version) must be unique. + */ + @Column(nullable = false) + private String version; + + /** + * The set of capabilities supported by this connector instance. + */ + @ElementCollection(fetch = FetchType.EAGER) + @Enumerated(EnumType.STRING) + @Column(name = "capabilities") + @CollectionTable(name = "ConnInstance_capabilities", + joinColumns = + @JoinColumn(name = "ConnInstance_id", referencedColumnName = "id")) + private Set capabilities; + + /** + * The main configuration for the connector instance. This is directly implemented by the Configuration bean class + * which contains annotated ConfigurationProperties. + * + * @see org.identityconnectors.framework.api.ConfigurationProperty + */ + @Lob + private String jsonConf; + + @Column(unique = true) + private String displayName; + + /** + * External resources associated to the connector. + */ + @OneToMany(cascade = { CascadeType.ALL }, mappedBy = "connector") + private List resources; + + /** + * Connector request timeout. It is not applied in case of sync, full reconciliation and search. + * DEFAULT_TIMEOUT is the default value to be used in case of unspecified timeout. + */ + private Integer connRequestTimeout = DEFAULT_TIMEOUT; + + private JPAConnPoolConf poolConf; + + public JPAConnInstance() { + super(); + + capabilities = new HashSet<>(); + resources = new ArrayList<>(); + } + + @Override + public Long getKey() { + return id; + } + + @Override + public String getLocation() { + return location; + } + + @Override + public void setLocation(final String location) { + this.location = location; + } + + @Override + public String getConnectorName() { + return connectorName; + } + + @Override + public void setConnectorName(final String connectorName) { + this.connectorName = connectorName; + } + + @Override + public String getBundleName() { + return bundleName; + } + + @Override + public void setBundleName(final String bundleName) { + this.bundleName = bundleName; + } + + @Override + public String getVersion() { + return version; + } + + @Override + public void setVersion(final String version) { + this.version = version; + } + + @Override + public Set getConfiguration() { + Set configuration = Collections.emptySet(); + if (!StringUtils.isBlank(jsonConf)) { + ConnConfProperty[] deserialized = POJOHelper.deserialize(jsonConf, ConnConfProperty[].class); + if (ArrayUtils.isNotEmpty(deserialized)) { + configuration = new HashSet(Arrays.asList(deserialized)); + } + } + + return configuration; + } + + @Override + public void setConfiguration(final Set configuration) { + jsonConf = POJOHelper.serialize(new HashSet(configuration)); + } + + @Override + public String getDisplayName() { + return displayName; + } + + @Override + public void setDisplayName(final String displayName) { + this.displayName = displayName; + } + + @Override + public List getResources() { + return this.resources; + } + + @Override + public boolean addResource(final ExternalResource resource) { + checkType(resource, JPAExternalResource.class); + return this.resources.contains((JPAExternalResource) resource) + || this.resources.add((JPAExternalResource) resource); + } + + @Override + public boolean removeResource(final ExternalResource resource) { + checkType(resource, JPAExternalResource.class); + return this.resources.remove((JPAExternalResource) resource); + } + + @Override + public boolean addCapability(final ConnectorCapability capabitily) { + return capabilities.add(capabitily); + } + + @Override + public boolean removeCapability(final ConnectorCapability capabitily) { + return capabilities.remove(capabitily); + } + + @Override + public Set getCapabilities() { + return capabilities; + } + + @Override + public Integer getConnRequestTimeout() { + // DEFAULT_TIMEOUT will be returned in case of null timeout: + // * instances created by the content loader + // * or with a timeout nullified explicitely + return connRequestTimeout == null ? DEFAULT_TIMEOUT : connRequestTimeout; + } + + @Override + public void setConnRequestTimeout(final Integer timeout) { + this.connRequestTimeout = timeout; + } + + @Override + public ConnPoolConf getPoolConf() { + return poolConf; + } + + @Override + public void setPoolConf(final ConnPoolConf poolConf) { + checkType(poolConf, JPAConnPoolConf.class); + this.poolConf = (JPAConnPoolConf) poolConf; + } + +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAConnPoolConf.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAConnPoolConf.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAConnPoolConf.java new file mode 100644 index 0000000..a7ed759 --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAConnPoolConf.java @@ -0,0 +1,107 @@ +/* + * 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.persistence.jpa.entity; + +import java.io.Serializable; +import javax.persistence.Embeddable; +import org.apache.commons.lang3.builder.EqualsBuilder; +import org.apache.commons.lang3.builder.HashCodeBuilder; +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.apache.syncope.persistence.api.entity.ConnPoolConf; + +@Embeddable +public class JPAConnPoolConf implements ConnPoolConf, Serializable { + + private static final long serialVersionUID = -34259572059178970L; + + private Integer maxObjects; + + private Integer minIdle; + + private Integer maxIdle; + + private Long maxWait; + + private Long minEvictableIdleTimeMillis; + + @Override + public Integer getMaxObjects() { + return maxObjects; + } + + @Override + public void setMaxObjects(final Integer maxObjects) { + this.maxObjects = maxObjects; + } + + @Override + public Integer getMinIdle() { + return minIdle; + } + + @Override + public void setMinIdle(final Integer minIdle) { + this.minIdle = minIdle; + } + + @Override + public Integer getMaxIdle() { + return maxIdle; + } + + @Override + public void setMaxIdle(final Integer maxIdle) { + this.maxIdle = maxIdle; + } + + @Override + public Long getMaxWait() { + return maxWait; + } + + @Override + public void setMaxWait(final Long maxWait) { + this.maxWait = maxWait; + } + + @Override + public Long getMinEvictableIdleTimeMillis() { + return minEvictableIdleTimeMillis; + } + + @Override + public void setMinEvictableIdleTimeMillis(final Long minEvictableIdleTimeMillis) { + this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis; + } + + @Override + public boolean equals(final Object obj) { + return EqualsBuilder.reflectionEquals(this, obj); + } + + @Override + public int hashCode() { + return HashCodeBuilder.reflectionHashCode(this); + } + + @Override + public String toString() { + return ToStringBuilder.reflectionToString(this); + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAEntitlement.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAEntitlement.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAEntitlement.java new file mode 100644 index 0000000..f96f4bc --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAEntitlement.java @@ -0,0 +1,62 @@ +/* + * 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.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.persistence.api.entity.Entitlement; + +@Entity +@Table(name = JPAEntitlement.TABLE) +@Cacheable +public class JPAEntitlement extends AbstractEntity implements Entitlement { + + private static final long serialVersionUID = 8044745999246422483L; + + public static final String TABLE = "Entitlement"; + + @Id + private String name; + + @Column(nullable = true) + private String description; + + @Override + public String getKey() { + return name; + } + + @Override + public void setKey(final String key) { + this.name = key; + } + + @Override + public String getDescription() { + return description; + } + + @Override + public void setDescription(final String description) { + this.description = description; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAExternalResource.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAExternalResource.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPAExternalResource.java new file mode 100644 index 0000000..2b055bd --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/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.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.persistence.api.entity.AccountPolicy; +import org.apache.syncope.persistence.api.entity.ConnInstance; +import org.apache.syncope.persistence.api.entity.ExternalResource; +import org.apache.syncope.persistence.api.entity.PasswordPolicy; +import org.apache.syncope.persistence.api.entity.SyncPolicy; +import org.apache.syncope.persistence.api.entity.role.RMapping; +import org.apache.syncope.persistence.api.entity.user.UMapping; +import org.apache.syncope.persistence.jpa.validation.entity.ExternalResourceCheck; +import org.apache.syncope.persistence.jpa.entity.role.JPARMapping; +import org.apache.syncope.persistence.jpa.entity.user.JPAUMapping; +import org.apache.syncope.server.utils.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 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 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 getConnInstanceConfiguration() { + return StringUtils.isBlank(jsonConf) + ? Collections.emptySet() + : new HashSet<>(Arrays.asList(POJOHelper.deserialize(jsonConf, ConnConfProperty[].class))); + } + + @Override + public void setConnInstanceConfiguration(final Set 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 getPropagationActionsClassNames() { + return propagationActionsClassNames; + } +} http://git-wip-us.apache.org/repos/asf/syncope/blob/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPALogger.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPALogger.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPALogger.java new file mode 100644 index 0000000..c20856d --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/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.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.persistence.api.entity.Logger; + +@Entity +@Table(name = JPALogger.TABLE) +public class JPALogger extends AbstractEntity 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/556d5186/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPANotification.java ---------------------------------------------------------------------- diff --git a/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPANotification.java b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/persistence/jpa/entity/JPANotification.java new file mode 100644 index 0000000..8f93dbd --- /dev/null +++ b/syncope620/server/persistence-jpa/src/main/java/org/apache/syncope/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.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.persistence.api.entity.Notification; +import org.apache.syncope.persistence.jpa.validation.entity.NotificationCheck; + +@Entity +@Table(name = JPANotification.TABLE) +@NotificationCheck +public class JPANotification extends AbstractEntity 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 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 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 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 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); + } +}