1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.syncope.core.persistence.jpa.entity.group;
20
21 import java.util.ArrayList;
22 import java.util.List;
23 import java.util.Optional;
24 import javax.persistence.Cacheable;
25 import javax.persistence.CascadeType;
26 import javax.persistence.Column;
27 import javax.persistence.Entity;
28 import javax.persistence.FetchType;
29 import javax.persistence.JoinColumn;
30 import javax.persistence.JoinTable;
31 import javax.persistence.ManyToMany;
32 import javax.persistence.OneToMany;
33 import javax.persistence.OneToOne;
34 import javax.persistence.Table;
35 import javax.persistence.UniqueConstraint;
36 import javax.validation.Valid;
37 import javax.validation.constraints.NotNull;
38 import org.apache.syncope.core.persistence.api.dao.AnyTypeDAO;
39 import org.apache.syncope.core.persistence.api.entity.AnyType;
40 import org.apache.syncope.core.persistence.api.entity.AnyTypeClass;
41 import org.apache.syncope.core.persistence.api.entity.ExternalResource;
42 import org.apache.syncope.core.persistence.api.entity.anyobject.ADynGroupMembership;
43 import org.apache.syncope.core.persistence.api.entity.group.GPlainAttr;
44 import org.apache.syncope.core.persistence.api.entity.group.Group;
45 import org.apache.syncope.core.persistence.api.entity.group.TypeExtension;
46 import org.apache.syncope.core.persistence.api.entity.user.UDynGroupMembership;
47 import org.apache.syncope.core.persistence.api.entity.user.User;
48 import org.apache.syncope.core.persistence.jpa.entity.AbstractAny;
49 import org.apache.syncope.core.persistence.jpa.entity.JPAAnyTypeClass;
50 import org.apache.syncope.core.persistence.jpa.entity.JPAExternalResource;
51 import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAADynGroupMembership;
52 import org.apache.syncope.core.persistence.jpa.entity.user.JPAUDynGroupMembership;
53 import org.apache.syncope.core.persistence.jpa.entity.user.JPAUser;
54 import org.apache.syncope.core.persistence.jpa.validation.entity.GroupCheck;
55 import org.apache.syncope.core.spring.ApplicationContextProvider;
56
57 @Entity
58 @Table(name = JPAGroup.TABLE)
59 @Cacheable
60 @GroupCheck
61 public class JPAGroup extends AbstractAny<GPlainAttr> implements Group {
62
63 private static final long serialVersionUID = -5281258853142421875L;
64
65 public static final String TABLE = "SyncopeGroup";
66
67 @Column(unique = true)
68 @NotNull
69 private String name;
70
71 protected User userOwner;
72
73 protected Group groupOwner;
74
75 @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, mappedBy = "owner")
76 @Valid
77 private List<JPAGPlainAttr> plainAttrs = new ArrayList<>();
78
79 @ManyToMany(fetch = FetchType.LAZY)
80 @JoinTable(joinColumns =
81 @JoinColumn(name = "group_id"),
82 inverseJoinColumns =
83 @JoinColumn(name = "resource_id"),
84 uniqueConstraints = @UniqueConstraint(columnNames = { "group_id", "resource_id" }))
85 private List<JPAExternalResource> resources = new ArrayList<>();
86
87 @ManyToMany(fetch = FetchType.LAZY)
88 @JoinTable(joinColumns =
89 @JoinColumn(name = "group_id"),
90 inverseJoinColumns =
91 @JoinColumn(name = "anyTypeClass_id"),
92 uniqueConstraints = @UniqueConstraint(columnNames = { "group_id", "anyTypeClass_id" }))
93 private List<JPAAnyTypeClass> auxClasses = new ArrayList<>();
94
95 @OneToOne(cascade = CascadeType.ALL, orphanRemoval = true, mappedBy = "group")
96 @Valid
97 private JPAUDynGroupMembership uDynMembership;
98
99 @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER, mappedBy = "group")
100 private List<JPAADynGroupMembership> aDynMemberships = new ArrayList<>();
101
102 @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER, mappedBy = "group")
103 private List<JPATypeExtension> typeExtensions = new ArrayList<>();
104
105 @Override
106 public String getName() {
107 return name;
108 }
109
110 @Override
111 public void setName(final String name) {
112 this.name = name;
113 }
114
115 @Override
116 public AnyType getType() {
117 return ApplicationContextProvider.getBeanFactory().getBean(AnyTypeDAO.class).findGroup();
118 }
119
120 @Override
121 public void setType(final AnyType type) {
122
123 }
124
125 @Override
126 public boolean add(final ExternalResource resource) {
127 checkType(resource, JPAExternalResource.class);
128 return resources.contains((JPAExternalResource) resource) || resources.add((JPAExternalResource) resource);
129 }
130
131 @Override
132 public List<? extends ExternalResource> getResources() {
133 return resources;
134 }
135
136 @Override
137 public User getUserOwner() {
138 return userOwner;
139 }
140
141 @Override
142 public void setUserOwner(final User userOwner) {
143 checkType(userOwner, JPAUser.class);
144 this.userOwner = (JPAUser) userOwner;
145 }
146
147 @Override
148 public Group getGroupOwner() {
149 return groupOwner;
150 }
151
152 @Override
153 public void setGroupOwner(final Group group) {
154 checkType(group, JPAGroup.class);
155 this.groupOwner = (JPAGroup) group;
156 }
157
158 @Override
159 public boolean add(final GPlainAttr attr) {
160 checkType(attr, JPAGPlainAttr.class);
161 return plainAttrs.add((JPAGPlainAttr) attr);
162 }
163
164 @Override
165 public boolean remove(final GPlainAttr attr) {
166 checkType(attr, JPAGPlainAttr.class);
167 return getPlainAttrs().remove((JPAGPlainAttr) attr);
168 }
169
170 @Override
171 public Optional<? extends GPlainAttr> getPlainAttr(final String plainSchema) {
172 return getPlainAttrs().stream().filter(plainAttr
173 -> plainAttr != null && plainAttr.getSchema() != null
174 && plainSchema.equals(plainAttr.getSchema().getKey())).findFirst();
175 }
176
177 @Override
178 public List<? extends GPlainAttr> getPlainAttrs() {
179 return plainAttrs;
180 }
181
182 @Override
183 public UDynGroupMembership getUDynMembership() {
184 return uDynMembership;
185 }
186
187 @Override
188 public void setUDynMembership(final UDynGroupMembership uDynMembership) {
189 checkType(uDynMembership, JPAUDynGroupMembership.class);
190 this.uDynMembership = (JPAUDynGroupMembership) uDynMembership;
191 }
192
193 @Override
194 public boolean add(final AnyTypeClass auxClass) {
195 checkType(auxClass, JPAAnyTypeClass.class);
196 return auxClasses.contains((JPAAnyTypeClass) auxClass) || this.auxClasses.add((JPAAnyTypeClass) auxClass);
197 }
198
199 @Override
200 public List<? extends AnyTypeClass> getAuxClasses() {
201 return auxClasses;
202 }
203
204 @Override
205 public boolean add(final ADynGroupMembership dynGroupMembership) {
206 checkType(dynGroupMembership, JPAADynGroupMembership.class);
207 return this.aDynMemberships.add((JPAADynGroupMembership) dynGroupMembership);
208 }
209
210 @Override
211 public Optional<? extends ADynGroupMembership> getADynMembership(final AnyType anyType) {
212 return aDynMemberships.stream().
213 filter(dynGroupMembership -> anyType != null && anyType.equals(dynGroupMembership.getAnyType())).
214 findFirst();
215 }
216
217 @Override
218 public List<? extends ADynGroupMembership> getADynMemberships() {
219 return aDynMemberships;
220 }
221
222 @Override
223 public boolean add(final TypeExtension typeExtension) {
224 checkType(typeExtension, JPATypeExtension.class);
225 return this.typeExtensions.add((JPATypeExtension) typeExtension);
226 }
227
228 @Override
229 public Optional<? extends TypeExtension> getTypeExtension(final AnyType anyType) {
230 return typeExtensions.stream().
231 filter(typeExtension -> typeExtension.getAnyType().equals(anyType)).
232 findFirst();
233 }
234
235 @Override
236 public List<? extends TypeExtension> getTypeExtensions() {
237 return typeExtensions;
238 }
239 }