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/JPAMPlainAttrUniqueValue.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrUniqueValue.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrUniqueValue.java new file mode 100644 index 0000000..3bf92ce --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrUniqueValue.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.membership; + +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.membership.MPlainAttr; +import org.apache.syncope.core.persistence.api.entity.membership.MPlainAttrUniqueValue; +import org.apache.syncope.core.persistence.api.entity.membership.MPlainSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttrValue; + +@Entity +@Table(name = JPAMPlainAttrUniqueValue.TABLE) +public class JPAMPlainAttrUniqueValue extends AbstractPlainAttrValue implements MPlainAttrUniqueValue { + + private static final long serialVersionUID = 3985867531873453718L; + + public static final String TABLE = "MPlainAttrUniqueValue"; + + @Id + private Long id; + + @OneToOne(optional = false) + private JPAMPlainAttr attribute; + + @ManyToOne(optional = false) + @JoinColumn(name = "schema_name") + private JPAMPlainSchema schema; + + @Override + public Long getKey() { + return id; + } + + @Override + public MPlainAttr getAttr() { + return attribute; + } + + @Override + public void setAttr(final PlainAttr attr) { + checkType(attr, JPAMPlainAttr.class); + this.attribute = (JPAMPlainAttr) attr; + } + + @Override + public MPlainSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final PlainSchema schema) { + checkType(schema, JPAMPlainSchema.class); + this.schema = (JPAMPlainSchema) 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/JPAMPlainAttrValue.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrValue.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrValue.java new file mode 100644 index 0000000..0327211 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainAttrValue.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.membership; + +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.membership.MPlainAttr; +import org.apache.syncope.core.persistence.api.entity.membership.MPlainAttrValue; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttrValue; + +@Entity +@Table(name = JPAMPlainAttrValue.TABLE) +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +public class JPAMPlainAttrValue extends AbstractPlainAttrValue implements MPlainAttrValue { + + private static final long serialVersionUID = -7188881172631198385L; + + public static final String TABLE = "MPlainAttrValue"; + + @Id + private Long id; + + @ManyToOne + @NotNull + private JPAMPlainAttr attribute; + + @Override + public Long getKey() { + return id; + } + + @Override + public MPlainAttr getAttr() { + return attribute; + } + + @Override + public void setAttr(final PlainAttr attr) { + checkType(attr, JPAMPlainAttr.class); + this.attribute = (JPAMPlainAttr) 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/membership/JPAMPlainSchema.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainSchema.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainSchema.java new file mode 100644 index 0000000..fd000d6 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMPlainSchema.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.membership; + +import javax.persistence.Cacheable; +import javax.persistence.Entity; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.membership.MPlainSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainSchema; + +@Entity +@Table(name = JPAMPlainSchema.TABLE) +@Cacheable +public class JPAMPlainSchema extends AbstractPlainSchema implements MPlainSchema { + + private static final long serialVersionUID = -8053736450044590651L; + + public static final String TABLE = "MPlainSchema"; + +} 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/JPAMVirAttr.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMVirAttr.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMVirAttr.java new file mode 100644 index 0000000..6a1bc39 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMVirAttr.java @@ -0,0 +1,81 @@ +/* + * 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.VirSchema; +import org.apache.syncope.core.persistence.api.entity.membership.MVirAttr; +import org.apache.syncope.core.persistence.api.entity.membership.MVirAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.membership.MVirSchema; +import org.apache.syncope.core.persistence.api.entity.membership.Membership; +import org.apache.syncope.core.persistence.jpa.entity.AbstractVirAttr; + +@Entity +@Table(name = JPAMVirAttr.TABLE) +public class JPAMVirAttr extends AbstractVirAttr implements MVirAttr { + + private static final long serialVersionUID = 7774760571251641332L; + + public static final String TABLE = "MVirAttr"; + + @ManyToOne + private JPAMembership owner; + + @Column(nullable = false) + @OneToOne(cascade = CascadeType.MERGE) + private JPAMVirAttrTemplate template; + + @Override + public Membership getOwner() { + return owner; + } + + @Override + public void setOwner(final Attributable<?, ?, ?> owner) { + checkType(owner, JPAMembership.class); + this.owner = (JPAMembership) owner; + } + + @Override + public MVirAttrTemplate getTemplate() { + return template; + } + + @Override + public void setTemplate(final MVirAttrTemplate template) { + checkType(template, JPAMVirAttrTemplate.class); + this.template = (JPAMVirAttrTemplate) template; + } + + @Override + public MVirSchema getSchema() { + return template == null ? null : template.getSchema(); + } + + @Override + public void setSchema(final VirSchema 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/JPAMVirAttrTemplate.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMVirAttrTemplate.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMVirAttrTemplate.java new file mode 100644 index 0000000..b2a90f8 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMVirAttrTemplate.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.MVirAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.membership.MVirSchema; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.jpa.entity.AbstractVirAttrTemplate; +import org.apache.syncope.core.persistence.jpa.entity.role.JPARole; + +@Entity +@Table(name = JPAMVirAttrTemplate.TABLE) +public class JPAMVirAttrTemplate extends AbstractVirAttrTemplate<MVirSchema> implements MVirAttrTemplate { + + private static final long serialVersionUID = 6618560912535667392L; + + public static final String TABLE = "MVirAttrTemplate"; + + @ManyToOne + private JPARole owner; + + @ManyToOne + @JoinColumn(name = "schema_name") + private JPAMVirSchema schema; + + @Override + public MVirSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final MVirSchema schema) { + checkType(schema, JPAMVirSchema.class); + this.schema = (JPAMVirSchema) schema; + } + + @Override + public Role getOwner() { + return owner; + } + + @Override + public void setOwner(final Role role) { + checkType(role, JPARole.class); + this.owner = (JPARole) role; + } +} 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/JPAMVirSchema.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMVirSchema.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMVirSchema.java new file mode 100644 index 0000000..589ec6e --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMVirSchema.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.membership; + +import javax.persistence.Cacheable; +import javax.persistence.Entity; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.membership.MVirSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractVirSchema; + +@Entity +@Table(name = JPAMVirSchema.TABLE) +@Cacheable +public class JPAMVirSchema extends AbstractVirSchema implements MVirSchema { + + private static final long serialVersionUID = 6255905733563668766L; + + public static final String TABLE = "MVirSchema"; + +} 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/JPAMembership.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMembership.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMembership.java new file mode 100644 index 0000000..939fbc7 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/membership/JPAMembership.java @@ -0,0 +1,195 @@ +/* + * 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.Entity; +import javax.persistence.Id; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.UniqueConstraint; +import javax.validation.Valid; +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.MPlainAttr; +import org.apache.syncope.core.persistence.api.entity.membership.MVirAttr; +import org.apache.syncope.core.persistence.api.entity.membership.MVirAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.membership.Membership; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.api.entity.user.User; +import org.apache.syncope.core.persistence.jpa.entity.AbstractAttributable; +import org.apache.syncope.core.persistence.jpa.entity.role.JPARole; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUser; + +@Entity +@Table(name = JPAMembership.TABLE, uniqueConstraints = + @UniqueConstraint(columnNames = { "user_id", "role_id" })) +public class JPAMembership extends AbstractAttributable<MPlainAttr, MDerAttr, MVirAttr> implements Membership { + + private static final long serialVersionUID = 5030106264797289469L; + + public static final String TABLE = "Membership"; + + @Id + private Long id; + + @ManyToOne + private JPAUser user; + + @ManyToOne + private JPARole role; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPAMPlainAttr> plainAttrs; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPAMDerAttr> derAttrs; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPAMVirAttr> virAttrs; + + public JPAMembership() { + super(); + + plainAttrs = new ArrayList<>(); + derAttrs = new ArrayList<>(); + virAttrs = new ArrayList<>(); + } + + @Override + public Long getKey() { + return id; + } + + @Override + public Role getRole() { + return role; + } + + @Override + public void setRole(final Role role) { + checkType(role, JPARole.class); + this.role = (JPARole) role; + } + + @Override + public User getUser() { + return user; + } + + @Override + public void setUser(final User user) { + checkType(user, JPAUser.class); + this.user = (JPAUser) user; + } + + @Override + public boolean addPlainAttr(final MPlainAttr attr) { + checkType(attr, JPAMPlainAttr.class); + return plainAttrs.add((JPAMPlainAttr) attr); + } + + @Override + public boolean removePlainAttr(final MPlainAttr attr) { + checkType(attr, JPAMPlainAttr.class); + return plainAttrs.remove((JPAMPlainAttr) attr); + } + + @Override + public List<? extends MPlainAttr> getPlainAttrs() { + return plainAttrs; + } + + @Override + public boolean addDerAttr(final MDerAttr derAttr) { + checkType(derAttr, JPAMDerAttr.class); + + if (getRole() != null && derAttr.getSchema() != null) { + MDerAttrTemplate found = null; + for (MDerAttrTemplate template : getRole().findInheritedTemplates(MDerAttrTemplate.class)) { + if (derAttr.getSchema().equals(template.getSchema())) { + found = template; + } + } + if (found != null) { + derAttr.setTemplate(found); + return derAttrs.add((JPAMDerAttr) derAttr); + } + } + + LOG.warn("Attribute not added because either role was not yet set, " + + "schema was not specified or no template for that schema is available"); + return false; + } + + @Override + public boolean removeDerAttr(final MDerAttr derAttr) { + checkType(derAttr, JPAMDerAttr.class); + return derAttrs.remove((JPAMDerAttr) derAttr); + } + + @Override + public List<? extends MDerAttr> getDerAttrs() { + return derAttrs; + } + + @Override + public boolean addVirAttr(final MVirAttr virAttr) { + checkType(virAttr, JPAMVirAttr.class); + + if (getRole() != null && virAttr.getSchema() != null) { + MVirAttrTemplate found = null; + for (MVirAttrTemplate template : getRole().findInheritedTemplates(MVirAttrTemplate.class)) { + if (virAttr.getSchema().equals(template.getSchema())) { + found = template; + } + } + if (found != null) { + virAttr.setTemplate(found); + return virAttrs.add((JPAMVirAttr) virAttr); + } + } + + LOG.warn("Attribute not added because either " + + "schema was not specified or no template for that schema is available"); + return false; + } + + @Override + public boolean removeVirAttr(final MVirAttr virAttr) { + checkType(virAttr, JPAMVirAttr.class); + return virAttrs.remove((JPAMVirAttr) virAttr); + } + + @Override + public List<? extends MVirAttr> getVirAttrs() { + return virAttrs; + } + + @Override + public String toString() { + return "Membership[" + "id=" + id + ", " + user + ", " + role + ']'; + } +} 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/role/JPARDerAttr.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARDerAttr.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARDerAttr.java new file mode 100644 index 0000000..8cffa45 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARDerAttr.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.role; + +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.role.RDerAttr; +import org.apache.syncope.core.persistence.api.entity.role.RDerAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RDerSchema; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.jpa.entity.AbstractDerAttr; + +@Entity +@Table(name = JPARDerAttr.TABLE) +public class JPARDerAttr extends AbstractDerAttr implements RDerAttr { + + private static final long serialVersionUID = 8007080005675899946L; + + public static final String TABLE = "RDerAttr"; + + @ManyToOne + private JPARole owner; + + @Column(nullable = false) + @OneToOne(cascade = CascadeType.MERGE) + private JPARDerAttrTemplate template; + + @Override + public Role getOwner() { + return owner; + } + + @Override + public void setOwner(final Attributable<?, ?, ?> owner) { + checkType(owner, JPARole.class); + this.owner = (JPARole) owner; + } + + @Override + public RDerAttrTemplate getTemplate() { + return template; + } + + @Override + public void setTemplate(final RDerAttrTemplate template) { + checkType(template, JPARDerAttrTemplate.class); + this.template = (JPARDerAttrTemplate) template; + } + + @Override + public RDerSchema 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/role/JPARDerAttrTemplate.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARDerAttrTemplate.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARDerAttrTemplate.java new file mode 100644 index 0000000..022358e --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARDerAttrTemplate.java @@ -0,0 +1,66 @@ +/* + * 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.role; + +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.role.RDerAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RDerSchema; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.jpa.entity.AbstractDerAttrTemplate; + +@Entity +@Table(name = JPARDerAttrTemplate.TABLE) +public class JPARDerAttrTemplate extends AbstractDerAttrTemplate<RDerSchema> implements RDerAttrTemplate { + + private static final long serialVersionUID = 624868884107016649L; + + public static final String TABLE = "RDerAttrTemplate"; + + @ManyToOne + private JPARole owner; + + @ManyToOne + @JoinColumn(name = "schema_name") + private JPARDerSchema schema; + + @Override + public RDerSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final RDerSchema schema) { + checkType(schema, JPARDerSchema.class); + this.schema = (JPARDerSchema) 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/role/JPARDerSchema.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARDerSchema.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARDerSchema.java new file mode 100644 index 0000000..2ef23fc --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARDerSchema.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.role; + +import javax.persistence.Entity; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.role.RDerSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractDerSchema; + +@Entity +@Table(name = JPARDerSchema.TABLE) +public class JPARDerSchema extends AbstractDerSchema implements RDerSchema { + + private static final long serialVersionUID = -6868889736207576372L; + + public static final String TABLE = "RDerSchema"; + +} 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/role/JPARMapping.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARMapping.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARMapping.java new file mode 100644 index 0000000..9a5f82d --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARMapping.java @@ -0,0 +1,103 @@ +/* + * 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.role; + +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.OneToMany; +import javax.persistence.OneToOne; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.ExternalResource; +import org.apache.syncope.core.persistence.api.entity.role.RMapping; +import org.apache.syncope.core.persistence.api.entity.role.RMappingItem; +import org.apache.syncope.core.persistence.jpa.entity.AbstractMapping; +import org.apache.syncope.core.persistence.jpa.entity.JPAExternalResource; + +@Entity +@Table(name = JPARMapping.TABLE) +public class JPARMapping extends AbstractMapping<RMappingItem> implements RMapping { + + public static final String TABLE = "RMapping"; + + private static final long serialVersionUID = 4578756002867863392L; + + @Id + private Long id; + + /** + * Resource owning this mapping. + */ + @OneToOne + private JPAExternalResource resource; + + /** + * Attribute mappings. + */ + @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER, mappedBy = "mapping") + private List<JPARMappingItem> items; + + public JPARMapping() { + super(); + + items = new ArrayList<>(); + } + + @Override + public Long getKey() { + return id; + } + + @Override + public ExternalResource getResource() { + return resource; + } + + @Override + public void setResource(final ExternalResource resource) { + checkType(resource, JPAExternalResource.class); + this.resource = (JPAExternalResource) resource; + } + + @Override + public void setAccountIdItem(final RMappingItem item) { + checkType(item, JPARMappingItem.class); + this.addAccountIdItem((JPARMappingItem) item); + } + + @Override + public List<? extends RMappingItem> getItems() { + return items; + } + + @Override + public boolean addItem(final RMappingItem item) { + checkType(item, JPARMappingItem.class); + return items.contains((JPARMappingItem) item) || items.add((JPARMappingItem) item); + } + + @Override + public boolean removeItem(final RMappingItem item) { + checkType(item, JPARMappingItem.class); + return items.remove((JPARMappingItem) item); + } +} 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/role/JPARMappingItem.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARMappingItem.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARMappingItem.java new file mode 100644 index 0000000..931d543 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARMappingItem.java @@ -0,0 +1,58 @@ +/* + * 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.role; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.ManyToOne; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.Mapping; +import org.apache.syncope.core.persistence.api.entity.role.RMappingItem; +import org.apache.syncope.core.persistence.jpa.entity.AbstractMappingItem; + +@Entity +@Table(name = JPARMappingItem.TABLE) +public class JPARMappingItem extends AbstractMappingItem implements RMappingItem { + + public static final String TABLE = "RMappingItem"; + + private static final long serialVersionUID = -2670787666933476166L; + + @Id + private Long id; + + @ManyToOne + private JPARMapping mapping; + + @Override + public Long getKey() { + return id; + } + + @Override + public Mapping<RMappingItem> getMapping() { + return mapping; + } + + @Override + public void setMapping(final Mapping<?> mapping) { + checkType(mapping, JPARMapping.class); + this.mapping = (JPARMapping) mapping; + } +} 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/role/JPARPlainAttr.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttr.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttr.java new file mode 100644 index 0000000..a640d8d --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttr.java @@ -0,0 +1,140 @@ +/* + * 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.role; + +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.role.RPlainAttr; +import org.apache.syncope.core.persistence.api.entity.role.RPlainAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RPlainAttrUniqueValue; +import org.apache.syncope.core.persistence.api.entity.role.RPlainAttrValue; +import org.apache.syncope.core.persistence.api.entity.role.RPlainSchema; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttr; + +@Entity +@Table(name = JPARPlainAttr.TABLE) +public class JPARPlainAttr extends AbstractPlainAttr implements RPlainAttr { + + private static final long serialVersionUID = 2848159565890995780L; + + public static final String TABLE = "RPlainAttr"; + + @Id + private Long id; + + @ManyToOne(fetch = FetchType.EAGER) + private JPARole owner; + + @Column(nullable = false) + @OneToOne(cascade = CascadeType.MERGE) + private JPARPlainAttrTemplate template; + + @OneToMany(cascade = CascadeType.MERGE, orphanRemoval = true, mappedBy = "attribute") + @Valid + private List<JPARPlainAttrValue> values; + + @OneToOne(cascade = CascadeType.ALL, mappedBy = "attribute") + @Valid + private JPARPlainAttrUniqueValue uniqueValue; + + public JPARPlainAttr() { + super(); + values = new ArrayList<>(); + } + + @Override + public Long getKey() { + return id; + } + + @Override + public Role getOwner() { + return owner; + } + + @Override + public void setOwner(final Attributable<?, ?, ?> owner) { + checkType(owner, JPARole.class); + this.owner = (JPARole) owner; + } + + @Override + public RPlainAttrTemplate getTemplate() { + return template; + } + + @Override + public void setTemplate(final RPlainAttrTemplate template) { + checkType(template, JPARPlainAttrTemplate.class); + this.template = (JPARPlainAttrTemplate) template; + } + + @Override + public RPlainSchema 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, JPARPlainAttrValue.class); + return values.add((JPARPlainAttrValue) attrValue); + } + + @Override + public boolean removeValue(final PlainAttrValue attrValue) { + checkType(attrValue, JPARPlainAttrValue.class); + return values.remove((JPARPlainAttrValue) attrValue); + } + + @Override + public List<? extends RPlainAttrValue> getValues() { + return values; + } + + @Override + public RPlainAttrUniqueValue getUniqueValue() { + return uniqueValue; + } + + @Override + public void setUniqueValue(final PlainAttrUniqueValue uniqueValue) { + checkType(owner, JPARPlainAttrUniqueValue.class); + this.uniqueValue = (JPARPlainAttrUniqueValue) 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/role/JPARPlainAttrTemplate.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttrTemplate.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttrTemplate.java new file mode 100644 index 0000000..b3e2a3c --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttrTemplate.java @@ -0,0 +1,75 @@ +/* + * 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.role; + +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.role.RPlainAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RPlainSchema; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttrTemplate; + +@Entity +@Table(name = JPARPlainAttrTemplate.TABLE) +public class JPARPlainAttrTemplate extends AbstractPlainAttrTemplate<RPlainSchema> implements RPlainAttrTemplate { + + private static final long serialVersionUID = 6943917051517266268L; + + public static final String TABLE = "RPlainAttrTemplate"; + + @Id + private Long id; + + @ManyToOne + private JPARole owner; + + @Override + public Long getKey() { + return id; + } + + @ManyToOne + @JoinColumn(name = "schema_name") + private JPARPlainSchema schema; + + @Override + public RPlainSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final RPlainSchema schema) { + checkType(schema, JPARPlainSchema.class); + this.schema = (JPARPlainSchema) 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/role/JPARPlainAttrUniqueValue.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttrUniqueValue.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttrUniqueValue.java new file mode 100644 index 0000000..59ffb2a --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttrUniqueValue.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.role; + +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.role.RPlainAttr; +import org.apache.syncope.core.persistence.api.entity.role.RPlainAttrUniqueValue; +import org.apache.syncope.core.persistence.api.entity.role.RPlainSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttrValue; + +@Entity +@Table(name = JPARPlainAttrUniqueValue.TABLE) +public class JPARPlainAttrUniqueValue extends AbstractPlainAttrValue implements RPlainAttrUniqueValue { + + private static final long serialVersionUID = 4681561795607192855L; + + public static final String TABLE = "RPlainAttrUniqueValue"; + + @Id + private Long id; + + @OneToOne(optional = false) + private JPARPlainAttr attribute; + + @ManyToOne(optional = false) + @JoinColumn(name = "schema_name") + private JPARPlainSchema schema; + + @Override + public Long getKey() { + return id; + } + + @Override + public RPlainAttr getAttr() { + return attribute; + } + + @Override + public void setAttr(final PlainAttr attr) { + checkType(attr, JPARPlainAttr.class); + this.attribute = (JPARPlainAttr) attr; + } + + @Override + public RPlainSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final PlainSchema schema) { + checkType(schema, JPARPlainSchema.class); + this.schema = (JPARPlainSchema) 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/role/JPARPlainAttrValue.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttrValue.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttrValue.java new file mode 100644 index 0000000..6db5e98 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainAttrValue.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.role; + +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.role.RPlainAttr; +import org.apache.syncope.core.persistence.api.entity.role.RPlainAttrValue; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainAttrValue; + +@Entity +@Table(name = JPARPlainAttrValue.TABLE) +@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) +public class JPARPlainAttrValue extends AbstractPlainAttrValue implements RPlainAttrValue { + + private static final long serialVersionUID = -766808291128424707L; + + public static final String TABLE = "RPlainAttrValue"; + + @Id + private Long id; + + @ManyToOne + @NotNull + private JPARPlainAttr attribute; + + @Override + public Long getKey() { + return id; + } + + @Override + public RPlainAttr getAttr() { + return attribute; + } + + @Override + public void setAttr(final PlainAttr attr) { + checkType(attr, JPARPlainAttr.class); + this.attribute = (JPARPlainAttr) 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/role/JPARPlainSchema.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainSchema.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainSchema.java new file mode 100644 index 0000000..98d3285 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARPlainSchema.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.role; + +import javax.persistence.Cacheable; +import javax.persistence.Entity; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.role.RPlainSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractPlainSchema; + +@Entity +@Table(name = JPARPlainSchema.TABLE) +@Cacheable +public class JPARPlainSchema extends AbstractPlainSchema implements RPlainSchema { + + private static final long serialVersionUID = -7417234690221851342L; + + public static final String TABLE = "RPlainSchema"; + +} 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/role/JPARVirAttr.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARVirAttr.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARVirAttr.java new file mode 100644 index 0000000..e82282d --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARVirAttr.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.role; + +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.VirSchema; +import org.apache.syncope.core.persistence.api.entity.role.RVirAttr; +import org.apache.syncope.core.persistence.api.entity.role.RVirAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RVirSchema; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.jpa.entity.AbstractVirAttr; + +@Entity +@Table(name = JPARVirAttr.TABLE) +public class JPARVirAttr extends AbstractVirAttr implements RVirAttr { + + private static final long serialVersionUID = -1747430556914428649L; + + public static final String TABLE = "RVirAttr"; + + @ManyToOne + private JPARole owner; + + @Column(nullable = false) + @OneToOne(cascade = CascadeType.MERGE) + private JPARVirAttrTemplate template; + + @Override + public Role getOwner() { + return owner; + } + + @Override + public void setOwner(final Attributable<?, ?, ?> owner) { + checkType(owner, JPARole.class); + this.owner = (JPARole) owner; + } + + @Override + public RVirAttrTemplate getTemplate() { + return template; + } + + @Override + public void setTemplate(final RVirAttrTemplate template) { + checkType(template, JPARVirAttrTemplate.class); + this.template = (JPARVirAttrTemplate) template; + } + + @Override + public RVirSchema getSchema() { + return template == null ? null : template.getSchema(); + } + + @Override + public void setSchema(final VirSchema 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/role/JPARVirAttrTemplate.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARVirAttrTemplate.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARVirAttrTemplate.java new file mode 100644 index 0000000..067eb26 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARVirAttrTemplate.java @@ -0,0 +1,66 @@ +/* + * 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.role; + +import javax.persistence.Entity; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.role.RVirAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RVirSchema; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.jpa.entity.AbstractVirAttrTemplate; + +@Entity +@Table(name = JPARVirAttrTemplate.TABLE) +public class JPARVirAttrTemplate extends AbstractVirAttrTemplate<RVirSchema> implements RVirAttrTemplate { + + private static final long serialVersionUID = 4896495904794493479L; + + public static final String TABLE = "RVirAttrTemplate"; + + @ManyToOne + private JPARole owner; + + @ManyToOne + @JoinColumn(name = "schema_name") + private JPARVirSchema schema; + + @Override + public RVirSchema getSchema() { + return schema; + } + + @Override + public void setSchema(final RVirSchema schema) { + checkType(schema, JPARVirSchema.class); + this.schema = (JPARVirSchema) schema; + } + + @Override + public Role getOwner() { + return owner; + } + + @Override + public void setOwner(final Role role) { + checkType(role, JPARole.class); + this.owner = (JPARole) role; + } +} 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/role/JPARVirSchema.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARVirSchema.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARVirSchema.java new file mode 100644 index 0000000..cadf3dc --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARVirSchema.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.role; + +import javax.persistence.Cacheable; +import javax.persistence.Entity; +import javax.persistence.Table; +import org.apache.syncope.core.persistence.api.entity.role.RVirSchema; +import org.apache.syncope.core.persistence.jpa.entity.AbstractVirSchema; + +@Entity +@Table(name = JPARVirSchema.TABLE) +@Cacheable +public class JPARVirSchema extends AbstractVirSchema implements RVirSchema { + + private static final long serialVersionUID = -2595041749349652939L; + + public static final String TABLE = "RVirSchema"; + +} 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/role/JPARole.java ---------------------------------------------------------------------- diff --git a/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARole.java b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARole.java new file mode 100644 index 0000000..2990ad4 --- /dev/null +++ b/syncope620/core/persistence-jpa/src/main/java/org/apache/syncope/core/persistence/jpa/entity/role/JPARole.java @@ -0,0 +1,593 @@ +/* + * 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.role; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import javax.persistence.Basic; +import javax.persistence.Cacheable; +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.ManyToMany; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; +import javax.persistence.Table; +import javax.persistence.UniqueConstraint; +import javax.validation.Valid; +import javax.validation.constraints.Max; +import javax.validation.constraints.Min; +import javax.validation.constraints.NotNull; +import org.apache.syncope.core.persistence.api.entity.AccountPolicy; +import org.apache.syncope.core.persistence.api.entity.AttrTemplate; +import org.apache.syncope.core.persistence.api.entity.DerSchema; +import org.apache.syncope.core.persistence.api.entity.Entitlement; +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.PlainSchema; +import org.apache.syncope.core.persistence.api.entity.Schema; +import org.apache.syncope.core.persistence.api.entity.VirSchema; +import org.apache.syncope.core.persistence.api.entity.membership.MDerAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.membership.MPlainAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.membership.MVirAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RDerAttr; +import org.apache.syncope.core.persistence.api.entity.role.RDerAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RDerSchema; +import org.apache.syncope.core.persistence.api.entity.role.RPlainAttr; +import org.apache.syncope.core.persistence.api.entity.role.RPlainAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RVirAttr; +import org.apache.syncope.core.persistence.api.entity.role.RVirAttrTemplate; +import org.apache.syncope.core.persistence.api.entity.role.RVirSchema; +import org.apache.syncope.core.persistence.api.entity.role.Role; +import org.apache.syncope.core.persistence.api.entity.user.User; +import org.apache.syncope.core.persistence.jpa.validation.entity.RoleCheck; +import org.apache.syncope.core.persistence.jpa.entity.AbstractSubject; +import org.apache.syncope.core.persistence.jpa.entity.JPAAccountPolicy; +import org.apache.syncope.core.persistence.jpa.entity.JPAEntitlement; +import org.apache.syncope.core.persistence.jpa.entity.JPAExternalResource; +import org.apache.syncope.core.persistence.jpa.entity.JPAPasswordPolicy; +import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMPlainAttrTemplate; +import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMDerAttrTemplate; +import org.apache.syncope.core.persistence.jpa.entity.membership.JPAMVirAttrTemplate; +import org.apache.syncope.core.persistence.jpa.entity.user.JPAUser; + +@Entity +@Table(name = JPARole.TABLE, uniqueConstraints = + @UniqueConstraint(columnNames = { "name", "parent_id" })) +@Cacheable +@RoleCheck +public class JPARole extends AbstractSubject<RPlainAttr, RDerAttr, RVirAttr> implements Role { + + private static final long serialVersionUID = -5281258853142421875L; + + public static final String TABLE = "SyncopeRole"; + + @Id + private Long id; + + @NotNull + private String name; + + @ManyToOne(optional = true) + private JPARole parent; + + @ManyToOne(optional = true) + private JPAUser userOwner; + + @ManyToOne(optional = true) + private JPARole roleOwner; + + @ManyToMany(fetch = FetchType.EAGER) + @JoinTable(joinColumns = + @JoinColumn(name = "role_id"), + inverseJoinColumns = + @JoinColumn(name = "entitlement_name")) + private Set<JPAEntitlement> entitlements; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPARPlainAttrTemplate> rAttrTemplates; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPARDerAttrTemplate> rDerAttrTemplates; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPARVirAttrTemplate> rVirAttrTemplates; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPAMPlainAttrTemplate> mAttrTemplates; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPAMDerAttrTemplate> mDerAttrTemplates; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPAMVirAttrTemplate> mVirAttrTemplates; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPARPlainAttr> plainAttrs; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPARDerAttr> derAttrs; + + @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner") + @Valid + private List<JPARVirAttr> virAttrs; + + @Basic(optional = true) + @Min(0) + @Max(1) + private Integer inheritOwner; + + @Basic(optional = true) + @Min(0) + @Max(1) + private Integer inheritTemplates; + + @Basic(optional = true) + @Min(0) + @Max(1) + private Integer inheritPlainAttrs; + + @Basic(optional = true) + @Min(0) + @Max(1) + private Integer inheritDerAttrs; + + @Basic(optional = true) + @Min(0) + @Max(1) + private Integer inheritVirAttrs; + + @Basic(optional = true) + @Min(0) + @Max(1) + private Integer inheritPasswordPolicy; + + @Basic(optional = true) + @Min(0) + @Max(1) + private Integer inheritAccountPolicy; + + @ManyToOne(fetch = FetchType.EAGER, optional = true) + private JPAPasswordPolicy passwordPolicy; + + @ManyToOne(fetch = FetchType.EAGER, optional = true) + private JPAAccountPolicy accountPolicy; + + /** + * Provisioning external resources. + */ + @ManyToMany(fetch = FetchType.EAGER) + @JoinTable(joinColumns = + @JoinColumn(name = "role_id"), + inverseJoinColumns = + @JoinColumn(name = "resource_name")) + @Valid + private Set<JPAExternalResource> resources; + + public JPARole() { + super(); + + entitlements = new HashSet<>(); + + rAttrTemplates = new ArrayList<>(); + rDerAttrTemplates = new ArrayList<>(); + rVirAttrTemplates = new ArrayList<>(); + mAttrTemplates = new ArrayList<>(); + mDerAttrTemplates = new ArrayList<>(); + mVirAttrTemplates = new ArrayList<>(); + + plainAttrs = new ArrayList<>(); + derAttrs = new ArrayList<>(); + virAttrs = new ArrayList<>(); + + inheritOwner = getBooleanAsInteger(false); + inheritTemplates = getBooleanAsInteger(false); + inheritPlainAttrs = getBooleanAsInteger(false); + inheritDerAttrs = getBooleanAsInteger(false); + inheritVirAttrs = getBooleanAsInteger(false); + inheritPasswordPolicy = getBooleanAsInteger(false); + inheritAccountPolicy = getBooleanAsInteger(false); + + resources = new HashSet<>(); + } + + @Override + public Long getKey() { + return id; + } + + @Override + protected Set<? extends ExternalResource> internalGetResources() { + return resources; + } + + @Override + public String getName() { + return name; + } + + @Override + public void setName(final String name) { + this.name = name; + } + + @Override + public Role getParent() { + return parent; + } + + @Override + public void setParent(final Role parent) { + checkType(parent, JPARole.class); + this.parent = (JPARole) parent; + } + + @Override + public boolean isInheritOwner() { + return isBooleanAsInteger(inheritOwner); + } + + @Override + public void setInheritOwner(final boolean inheritOwner) { + this.inheritOwner = getBooleanAsInteger(inheritOwner); + } + + @Override + public User getUserOwner() { + return userOwner; + } + + @Override + public void setUserOwner(final User userOwner) { + checkType(userOwner, JPAUser.class); + this.userOwner = (JPAUser) userOwner; + } + + @Override + public JPARole getRoleOwner() { + return roleOwner; + } + + @Override + public void setRoleOwner(final Role roleOwner) { + checkType(roleOwner, JPARole.class); + this.roleOwner = (JPARole) roleOwner; + } + + @Override + public boolean addEntitlement(final Entitlement entitlement) { + checkType(entitlement, JPAEntitlement.class); + return entitlements.add((JPAEntitlement) entitlement); + } + + @Override + public boolean removeEntitlement(final Entitlement entitlement) { + checkType(entitlement, JPAEntitlement.class); + return entitlements.remove((JPAEntitlement) entitlement); + } + + @Override + public Set<? extends Entitlement> getEntitlements() { + return entitlements; + } + + @Override + public boolean isInheritTemplates() { + return isBooleanAsInteger(inheritTemplates); + } + + @Override + public void setInheritTemplates(final boolean inheritAttrTemplates) { + this.inheritTemplates = getBooleanAsInteger(inheritAttrTemplates); + } + + @Override + @SuppressWarnings("unchecked") + public <T extends AttrTemplate<K>, K extends Schema> List<T> getAttrTemplates(final Class<T> reference) { + List<T> result = new ArrayList<>(); + + if (RPlainAttrTemplate.class.isAssignableFrom(reference)) { + result = (List<T>) rAttrTemplates; + } else if (RDerAttrTemplate.class.isAssignableFrom(reference)) { + result = (List<T>) rDerAttrTemplates; + } else if (RVirAttrTemplate.class.isAssignableFrom(reference)) { + result = (List<T>) rVirAttrTemplates; + } else if (MPlainAttrTemplate.class.isAssignableFrom(reference)) { + result = (List<T>) mAttrTemplates; + } else if (MDerAttrTemplate.class.isAssignableFrom(reference)) { + result = (List<T>) mDerAttrTemplates; + } else if (MVirAttrTemplate.class.isAssignableFrom(reference)) { + result = (List<T>) mVirAttrTemplates; + } + + return result; + } + + @Override + public <T extends AttrTemplate<K>, K extends Schema> T getAttrTemplate( + final Class<T> reference, final String schemaName) { + + T result = null; + + for (T template : findInheritedTemplates(reference)) { + if (schemaName.equals(template.getSchema().getKey())) { + result = template; + } + } + + return result; + } + + @Override + public <T extends AttrTemplate<K>, K extends Schema> List<K> getAttrTemplateSchemas(final Class<T> reference) { + final List<K> result = new ArrayList<>(); + + for (T template : findInheritedTemplates(reference)) { + result.add(template.getSchema()); + } + + return result; + } + + @Override + public <T extends AttrTemplate<K>, K extends Schema> List<T> findInheritedTemplates(final Class<T> reference) { + final List<T> result = new ArrayList<>(getAttrTemplates(reference)); + + if (isInheritTemplates() && getParent() != null) { + result.addAll(getParent().findInheritedTemplates(reference)); + } + + return result; + } + + @Override + public boolean addPlainAttr(final RPlainAttr attr) { + checkType(attr, JPARPlainAttr.class); + return plainAttrs.add((JPARPlainAttr) attr); + } + + @Override + public boolean removePlainAttr(final RPlainAttr attr) { + checkType(attr, JPARPlainAttr.class); + return plainAttrs.remove((JPARPlainAttr) attr); + } + + @Override + public List<? extends RPlainAttr> getPlainAttrs() { + return plainAttrs; + } + + @Override + public boolean addDerAttr(final RDerAttr attr) { + checkType(attr, JPARDerAttr.class); + return derAttrs.add((JPARDerAttr) attr); + } + + @Override + public boolean removeDerAttr(final RDerAttr attr) { + checkType(attr, JPARDerAttr.class); + return derAttrs.remove((JPARDerAttr) attr); + } + + @Override + public List<? extends RDerAttr> getDerAttrs() { + return derAttrs; + } + + @Override + public boolean addVirAttr(final RVirAttr attr) { + checkType(attr, JPARVirAttr.class); + return virAttrs.add((JPARVirAttr) attr); + } + + @Override + public boolean removeVirAttr(final RVirAttr attr) { + checkType(attr, JPARVirAttr.class); + return virAttrs.remove((JPARVirAttr) attr); + } + + @Override + public List<? extends RVirAttr> getVirAttrs() { + return virAttrs; + } + + @Override + public boolean isInheritPlainAttrs() { + return isBooleanAsInteger(inheritPlainAttrs); + } + + @Override + public void setInheritPlainAttrs(final boolean inheritPlainAttrs) { + this.inheritPlainAttrs = getBooleanAsInteger(inheritPlainAttrs); + } + + /** + * Get all inherited attributes from the ancestors. + * + * @return a list of inherited and only inherited attributes. + */ + @Override + public List<? extends RPlainAttr> findLastInheritedAncestorPlainAttrs() { + final Map<JPARPlainSchema, RPlainAttr> result = new HashMap<>(); + + if (!isInheritPlainAttrs()) { + return plainAttrs; + } + if (isInheritPlainAttrs() && getParent() != null) { + final Map<PlainSchema, RPlainAttr> attrMap = getPlainAttrMap(); + + // Add inherit attributes + for (RPlainAttr attr : getParent().findLastInheritedAncestorPlainAttrs()) { + if (attrMap.containsKey(attr.getSchema())) { + result.remove((JPARPlainSchema) attr.getSchema()); + } + result.put((JPARPlainSchema) attr.getSchema(), attr); + } + } + return new ArrayList<>(result.values()); + } + + @Override + public boolean isInheritDerAttrs() { + return isBooleanAsInteger(inheritDerAttrs); + } + + @Override + public void setInheritDerAttrs(final boolean inheritDerAttrs) { + this.inheritDerAttrs = getBooleanAsInteger(inheritDerAttrs); + + } + + /** + * Get all inherited derived attributes from the ancestors. + * + * @return a list of inherited and only inherited attributes. + */ + @Override + public List<? extends RDerAttr> findLastInheritedAncestorDerAttrs() { + final Map<RDerSchema, RDerAttr> result = new HashMap<>(); + + if (!isInheritDerAttrs()) { + return derAttrs; + } + if (isInheritDerAttrs() && getParent() != null) { + Map<DerSchema, RDerAttr> derAttrMap = getDerAttrMap(); + + // Add inherit derived attributes + for (RDerAttr attr : getParent().findLastInheritedAncestorDerAttrs()) { + if (derAttrMap.containsKey(attr.getSchema())) { + result.remove(attr.getSchema()); + } + result.put(attr.getSchema(), attr); + } + } + return new ArrayList<>(result.values()); + } + + @Override + public boolean isInheritVirAttrs() { + return isBooleanAsInteger(inheritVirAttrs); + } + + @Override + public void setInheritVirAttrs(final boolean inheritVirAttrs) { + this.inheritVirAttrs = getBooleanAsInteger(inheritVirAttrs); + + } + + /** + * Get all inherited virtual attributes from the ancestors. + * + * @return a list of inherited and only inherited attributes. + */ + @Override + public List<? extends RVirAttr> findLastInheritedAncestorVirAttrs() { + final Map<RVirSchema, RVirAttr> result = new HashMap<>(); + + if (!isInheritVirAttrs()) { + return virAttrs; + } + + if (isInheritVirAttrs() && getParent() != null) { + Map<VirSchema, RVirAttr> virAttrMap = getVirAttrMap(); + + // Add inherit virtual attributes + for (RVirAttr attr : getParent().findLastInheritedAncestorVirAttrs()) { + if (virAttrMap.containsKey(attr.getSchema())) { + result.remove(attr.getSchema()); + } + result.put(attr.getSchema(), attr); + } + } + return new ArrayList<>(result.values()); + } + + /** + * Get first valid password policy. + * + * @return parent password policy if isInheritPasswordPolicy is 'true' and parent is not null, local password policy + * otherwise + */ + @Override + public PasswordPolicy getPasswordPolicy() { + return isInheritPasswordPolicy() && getParent() != null + ? getParent().getPasswordPolicy() + : passwordPolicy; + } + + @Override + public void setPasswordPolicy(final PasswordPolicy passwordPolicy) { + checkType(passwordPolicy, JPAPasswordPolicy.class); + this.passwordPolicy = (JPAPasswordPolicy) passwordPolicy; + } + + @Override + public boolean isInheritPasswordPolicy() { + return isBooleanAsInteger(inheritPasswordPolicy); + } + + @Override + public void setInheritPasswordPolicy(final boolean inheritPasswordPolicy) { + this.inheritPasswordPolicy = getBooleanAsInteger(inheritPasswordPolicy); + } + + /** + * Get first valid account policy. + * + * @return parent account policy if isInheritAccountPolicy is 'true' and parent is not null, local account policy + * otherwise. + */ + @Override + public AccountPolicy getAccountPolicy() { + return isInheritAccountPolicy() && getParent() != null + ? getParent().getAccountPolicy() + : accountPolicy; + } + + @Override + public void setAccountPolicy(final AccountPolicy accountPolicy) { + checkType(accountPolicy, JPAAccountPolicy.class); + this.accountPolicy = (JPAAccountPolicy) accountPolicy; + } + + @Override + public boolean isInheritAccountPolicy() { + return isBooleanAsInteger(inheritAccountPolicy); + } + + @Override + public void setInheritAccountPolicy(boolean inheritAccountPolicy) { + this.inheritAccountPolicy = getBooleanAsInteger(inheritAccountPolicy); + } +}
