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.dao;
20
21 import java.util.Collection;
22 import java.util.List;
23 import javax.persistence.Query;
24 import javax.persistence.TypedQuery;
25 import org.apache.syncope.common.lib.types.AnyTypeKind;
26 import org.apache.syncope.core.persistence.api.dao.ExternalResourceDAO;
27 import org.apache.syncope.core.persistence.api.dao.PlainAttrDAO;
28 import org.apache.syncope.core.persistence.api.dao.PlainSchemaDAO;
29 import org.apache.syncope.core.persistence.api.entity.AnyTypeClass;
30 import org.apache.syncope.core.persistence.api.entity.AnyUtilsFactory;
31 import org.apache.syncope.core.persistence.api.entity.Implementation;
32 import org.apache.syncope.core.persistence.api.entity.PlainAttr;
33 import org.apache.syncope.core.persistence.api.entity.PlainSchema;
34 import org.apache.syncope.core.persistence.api.entity.anyobject.APlainAttr;
35 import org.apache.syncope.core.persistence.api.entity.group.GPlainAttr;
36 import org.apache.syncope.core.persistence.jpa.entity.JPAPlainSchema;
37 import org.apache.syncope.core.persistence.jpa.entity.anyobject.JPAAPlainAttr;
38 import org.apache.syncope.core.persistence.jpa.entity.group.JPAGPlainAttr;
39 import org.apache.syncope.core.persistence.jpa.entity.user.JPAUPlainAttr;
40
41 public class JPAPlainSchemaDAO extends AbstractDAO<PlainSchema> implements PlainSchemaDAO {
42
43 private final AnyUtilsFactory anyUtilsFactory;
44
45 private final PlainAttrDAO plainAttrDAO;
46
47 private final ExternalResourceDAO resourceDAO;
48
49 public JPAPlainSchemaDAO(
50 final AnyUtilsFactory anyUtilsFactory,
51 final PlainAttrDAO plainAttrDAO,
52 final ExternalResourceDAO resourceDAO) {
53
54 this.anyUtilsFactory = anyUtilsFactory;
55 this.plainAttrDAO = plainAttrDAO;
56 this.resourceDAO = resourceDAO;
57 }
58
59 @Override
60 public PlainSchema find(final String key) {
61 return entityManager().find(JPAPlainSchema.class, key);
62 }
63
64 @Override
65 public List<PlainSchema> findByAnyTypeClasses(final Collection<AnyTypeClass> anyTypeClasses) {
66 StringBuilder queryString = new StringBuilder("SELECT e FROM ").
67 append(JPAPlainSchema.class.getSimpleName()).
68 append(" e WHERE ");
69 anyTypeClasses.forEach(anyTypeClass -> queryString.
70 append("e.anyTypeClass.id='").
71 append(anyTypeClass.getKey()).append("' OR "));
72
73 TypedQuery<PlainSchema> query = entityManager().createQuery(
74 queryString.substring(0, queryString.length() - 4), PlainSchema.class);
75
76 return query.getResultList();
77 }
78
79 @Override
80 public List<PlainSchema> findByValidator(final Implementation validator) {
81 TypedQuery<PlainSchema> query = entityManager().createQuery(
82 "SELECT e FROM " + JPAPlainSchema.class.getSimpleName()
83 + " e WHERE e.validator=:validator", PlainSchema.class);
84 query.setParameter("validator", validator);
85
86 return query.getResultList();
87 }
88
89 @Override
90 public List<PlainSchema> findByKeyword(final String keyword) {
91 TypedQuery<PlainSchema> query = entityManager().createQuery(
92 "SELECT e FROM " + JPAPlainSchema.class.getSimpleName() + " e"
93 + " WHERE e.id LIKE :keyword", PlainSchema.class);
94 query.setParameter("keyword", keyword);
95 return query.getResultList();
96 }
97
98 @Override
99 public List<PlainSchema> findAll() {
100 TypedQuery<PlainSchema> query = entityManager().createQuery(
101 "SELECT e FROM " + JPAPlainSchema.class.getSimpleName() + " e", PlainSchema.class);
102 return query.getResultList();
103 }
104
105 @Override
106 public <T extends PlainAttr<?>> List<T> findAttrs(final PlainSchema schema, final Class<T> reference) {
107 TypedQuery<T> query = entityManager().createQuery(
108 "SELECT e FROM " + JPAPlainAttrDAO.getEntityReference(reference).getSimpleName()
109 + " e WHERE e.schema=:schema", reference);
110 query.setParameter("schema", schema);
111
112 return query.getResultList();
113 }
114
115 @Override
116 public <T extends PlainAttr<?>> boolean hasAttrs(final PlainSchema schema, final Class<T> reference) {
117 String plainAttrTable = getPlainAttrTable(reference);
118 Query query = entityManager().createNativeQuery(
119 "SELECT COUNT(" + plainAttrTable + ".id) FROM " + JPAPlainSchema.TABLE
120 + " JOIN " + plainAttrTable + " ON " + JPAPlainSchema.TABLE + ".id = " + plainAttrTable
121 + ".schema_id WHERE " + JPAPlainSchema.TABLE + ".id = ?1");
122 query.setParameter(1, schema.getKey());
123
124 return ((Number) query.getSingleResult()).intValue() > 0;
125 }
126
127 @Override
128 public PlainSchema save(final PlainSchema schema) {
129 ((JPAPlainSchema) schema).map2json();
130 return entityManager().merge(schema);
131 }
132
133 protected void deleteAttrs(final PlainSchema schema) {
134 for (AnyTypeKind anyTypeKind : AnyTypeKind.values()) {
135 findAttrs(schema, anyUtilsFactory.getInstance(anyTypeKind).plainAttrClass()).
136 forEach(attr -> plainAttrDAO.delete(attr));
137 }
138 }
139
140 @Override
141 public void delete(final String key) {
142 PlainSchema schema = find(key);
143 if (schema == null) {
144 return;
145 }
146
147 deleteAttrs(schema);
148
149 resourceDAO.deleteMapping(key);
150
151 if (schema.getAnyTypeClass() != null) {
152 schema.getAnyTypeClass().getPlainSchemas().remove(schema);
153 }
154
155 entityManager().remove(schema);
156 }
157
158 private <T extends PlainAttr<?>> String getPlainAttrTable(final Class<T> plainAttrClass) {
159 if (GPlainAttr.class.isAssignableFrom(plainAttrClass)) {
160 return JPAGPlainAttr.TABLE;
161 }
162 if (APlainAttr.class.isAssignableFrom(plainAttrClass)) {
163 return JPAAPlainAttr.TABLE;
164 }
165 return JPAUPlainAttr.TABLE;
166 }
167 }