1 package de.dlr.shepard.context.version.daos;
2
3 import de.dlr.shepard.common.neo4j.daos.GenericDAO;
4 import de.dlr.shepard.common.util.CypherQueryHelper;
5 import de.dlr.shepard.common.util.CypherQueryHelper.Neighborhood;
6 import de.dlr.shepard.context.version.entities.Version;
7 import jakarta.enterprise.context.RequestScoped;
8 import java.util.ArrayList;
9 import java.util.HashMap;
10 import java.util.HashSet;
11 import java.util.Iterator;
12 import java.util.List;
13 import java.util.Map;
14 import java.util.UUID;
15
16 @RequestScoped
17 public class VersionDAO extends GenericDAO<Version> {
18
19
20
21
22
23
24
25 public Version find(UUID id) {
26 return session.load(getEntityType(), id, DEPTH_ENTITY);
27 }
28
29 @Override
30 public Class<Version> getEntityType() {
31 return Version.class;
32 }
33
34 public List<Version> findAllVersions(long collectionId) {
35 HashSet<Version> resultHashSet = new HashSet<>();
36 Map<String, Object> paramsMap = new HashMap<>();
37 String query = "";
38 query = query + "MATCH (col:Collection)-[]->(ver:Version) WHERE col.shepardId = " + collectionId + " ";
39 query = query + CypherQueryHelper.getReturnPart("ver", Neighborhood.EVERYTHING);
40
41 var resultSet = findByQuery(query, paramsMap);
42 for (Version next : resultSet) {
43 resultHashSet.add(find(next.getUid()));
44 }
45 return new ArrayList<>(resultHashSet);
46 }
47
48 public Version findHEADVersion(long collectionId) {
49 Version ret = null;
50 String query =
51 "MATCH (c:Collection)-[:has_version]->(v:Version) WHERE c.shepardId = " +
52 collectionId +
53 " AND " +
54 CypherQueryHelper.getVersionHeadPart("v") +
55 " " +
56 CypherQueryHelper.getReturnPart("v", Neighborhood.EVERYTHING);
57 Map<String, Object> paramsMap = new HashMap<>();
58 var resultSet = findByQuery(query, paramsMap);
59 Iterator<Version> it = resultSet.iterator();
60 if (it.hasNext()) {
61 ret = it.next();
62 }
63 return ret;
64 }
65
66 public Version findVersionLightByNeo4jId(long neo4jId) {
67 Version ret = null;
68 String query = "MATCH (ve:VersionableEntity)-[:has_version]->(v) WHERE id(ve) = " + neo4jId + " RETURN v";
69 Map<String, Object> paramsMap = new HashMap<>();
70 var resultSet = findByQuery(query, paramsMap);
71 Iterator<Version> it = resultSet.iterator();
72 if (it.hasNext()) {
73 ret = it.next();
74 }
75 return ret;
76 }
77
78 public void createLink(long versionableEntityId, UUID versionUID) {
79 HashMap<String, Object> params = new HashMap<>();
80 params.put("versionableEntityId", versionableEntityId);
81 params.put("versionUID", versionUID);
82 String query =
83 """
84 MATCH (ve:VersionableEntity), (v:Version) WHERE id(ve) = $versionableEntityId AND v.uid = $versionUID
85 CREATE (ve)-[:has_version]->(v)
86 """;
87 runQuery(query, params);
88 }
89
90 public void copyDataObjectsWithParentsAndPredecessors(UUID sourceVersionUID, UUID targetVersionUID) {
91 copyDataObjects(sourceVersionUID, targetVersionUID);
92 copyChildRelations(sourceVersionUID, targetVersionUID);
93 copySuccessorRelations(sourceVersionUID, targetVersionUID);
94 copyDataObjectCreatedByRelations(sourceVersionUID, targetVersionUID);
95 }
96
97 private void copyDataObjectCreatedByRelations(UUID sourceVersionUID, UUID targetVersionUID) {
98 HashMap<String, Object> params = new HashMap<>();
99 params.put("sourceVersionUID", sourceVersionUID);
100 params.put("targetVersionUID", targetVersionUID);
101 String query =
102 """
103 MATCH (u_creator:User)<-[:created_by]-(do_source:DataObject)-[:has_version]->(v_source:Version),(do_target:DataObject)-[:has_version]->(v_target:Version)
104 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID AND do_source.shepardId = do_target.shepardId
105 CREATE (do_target)-[:created_by]->(u_creator)
106 """;
107 runQuery(query, params);
108 }
109
110 private void copyDataObjects(UUID sourceVersionUID, UUID targetVersionUID) {
111 HashMap<String, Object> params = new HashMap<>();
112 params.put("sourceVersionUID", sourceVersionUID);
113 params.put("targetVersionUID", targetVersionUID);
114 String query =
115 """
116 MATCH (do_source:DataObject)-[:has_version]->(v_source:Version)-[:has_predecessor]->(v_target:Version)<-[:has_version]-(col_target:Collection)
117 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
118 CREATE (col_target)-[:has_dataobject]->(do_target:DataObject:VersionableEntity:BasicEntity)-[:has_version]->(v_target)
119 SET do_target = do_source
120 """;
121 runQuery(query, params);
122 }
123
124 private void copyChildRelations(UUID sourceVersionUID, UUID targetVersionUID) {
125 HashMap<String, Object> params = new HashMap<>();
126 params.put("sourceVersionUID", sourceVersionUID);
127 params.put("targetVersionUID", targetVersionUID);
128 String query =
129 """
130 MATCH (do_source_parent:DataObject)-[:has_child]->(do_source_child:DataObject)-[:has_version]->(v_source:Version)-[:has_predecessor]->(v_target:Version)<-[:has_version]-(do_target_parent:DataObject),
131 (v_target)<-[:has_version]-(do_target_child:DataObject)
132 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID AND do_source_parent.shepardId=do_target_parent.shepardId AND do_source_child.shepardId=do_target_child.shepardId
133 CREATE (do_target_parent)-[:has_child]->(do_target_child)
134 """;
135 runQuery(query, params);
136 }
137
138 private void copySuccessorRelations(UUID sourceVersionUID, UUID targetVersionUID) {
139 HashMap<String, Object> params = new HashMap<>();
140 params.put("sourceVersionUID", sourceVersionUID);
141 params.put("targetVersionUID", targetVersionUID);
142 String query =
143 """
144 MATCH (do_source_predecessor:DataObject)-[:has_successor]->(do_source_successor:DataObject)-[:has_version]->(v_source:Version)-[:has_predecessor]->(v_target:Version)<-[:has_version]-(do_target_predecessor:DataObject),
145 (v_target)<-[:has_version]-(do_target_successor:DataObject)
146 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
147 AND do_source_predecessor.shepardId=do_target_predecessor.shepardId AND do_source_successor.shepardId=do_target_successor.shepardId
148 CREATE (do_target_predecessor)-[:has_successor]->(do_target_successor)
149 """;
150 runQuery(query, params);
151 }
152
153 public void copyDataObjectReferences(UUID sourceVersionUID, UUID targetVersionUID) {
154 copyInternalDataObjectReferences(sourceVersionUID, targetVersionUID);
155 copyExternalDataObjectReferences(sourceVersionUID, targetVersionUID);
156 }
157
158 public void copyCollectionReferences(UUID sourceVersionUID, UUID targetVersionUID) {
159 HashMap<String, Object> params = new HashMap<>();
160 params.put("sourceVersionUID", sourceVersionUID);
161 params.put("targetVersionUID", targetVersionUID);
162 String query =
163 """
164 MATCH (v_source:Version)<-[has_version]-(do_source:DataObject)-[:has_reference]->(cr_source:CollectionReference)-[:points_to]->(c_pointed:Collection),
165 (cr_source)-[:created_by]->(u_creator:User),
166 (v_target:Version)<-[:has_version]-(do_target:DataObject)
167 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
168 AND do_source.shepardId = do_target.shepardId
169 CREATE (v_target)<-[:has_version]-(cr_target:CollectionReference:BasicReference)<-[:has_reference]-(do_target),
170 (c_pointed)<-[:points_to]-(cr_target)-[:created_by]->(u_creator)
171 SET cr_target = cr_source
172 """;
173 runQuery(query, params);
174 }
175
176 public void copyExternalDataObjectReferences(UUID sourceVersionUID, UUID targetVersionUID) {
177 HashMap<String, Object> params = new HashMap<>();
178 params.put("sourceVersionUID", sourceVersionUID);
179 params.put("targetVersionUID", targetVersionUID);
180 String query =
181 """
182 MATCH (v_source_pointer:Version)<-[:has_version]-(c_pointer:Collection)-[:has_dataobject]->(do_source_pointer:DataObject)-[:has_reference]->(dor_source:DataObjectReference)-[:points_to]->(do_pointed_to:DataObject)<-[:has_dataobject]-(c_pointed_to:Collection)-[:has_version]->(v_source_pointed_to:Version),
183 (dor_source:DataObjectReference)-[:created_by]->(u_creator:User),
184 (v_target_pointer:Version)<-[:has_version]-(do_target_pointer:DataObject)
185 WHERE v_source_pointer.uid = $sourceVersionUID AND v_target_pointer.uid = $targetVersionUID
186 AND do_source_pointer.shepardId = do_target_pointer.shepardId AND NOT(c_pointer.shepardId = c_pointed_to.shepardId)
187 CREATE (do_target_pointer)-[:has_reference]->(dor_target:DataObjectReference:BasicReference:VersionableEntity:BasicEntity)-[:points_to]->(do_pointed_to),
188 (v_target_pointer)<-[:has_version]-(dor_target)-[:created_by]->(u_creator)
189 SET dor_target=dor_source
190 """;
191 runQuery(query, params);
192 }
193
194 public void copyInternalDataObjectReferences(UUID sourceVersionUID, UUID targetVersionUID) {
195 HashMap<String, Object> params = new HashMap<>();
196 params.put("sourceVersionUID", sourceVersionUID);
197 params.put("targetVersionUID", targetVersionUID);
198 String query =
199 """
200 MATCH (v_source:Version)<-[:has_version]-(c_pointer:Collection)-[:has_dataobject]->(do_source_pointer:DataObject)-[:has_reference]->(dor_source:DataObjectReference)-[:points_to]->(do_source_pointed_to:DataObject)<-[:has_dataobject]-(c_pointed_to:Collection),
201 (do_target_pointed_to:DataObject)-[:has_version]->(v_target:Version)<-[:has_version]-(do_target_pointer:DataObject)
202 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
203 AND do_source_pointer.shepardId = do_target_pointer.shepardId AND do_source_pointed_to.shepardId = do_target_pointed_to.shepardId AND id(c_pointer) = id(c_pointed_to)
204 CREATE (do_target_pointer)-[:has_reference]->(dor_target:DataObjectReference:BasicReference:VersionableEntity:BasicEntity)-[:points_to]->(do_target_pointed_to)
205 SET dor_target = dor_source
206 """;
207 runQuery(query, params);
208 attachVersionAndCreatedByToDataObjectReferences(sourceVersionUID, targetVersionUID);
209 }
210
211 public void attachVersionAndCreatedByToDataObjectReferences(UUID sourceVersionUID, UUID targetVersionUID) {
212 HashMap<String, Object> params = new HashMap<>();
213 params.put("sourceVersionUID", sourceVersionUID);
214 params.put("targetVersionUID", targetVersionUID);
215 String query =
216 """
217 MATCH (v_source:Version)<-[:has_version]-(dor_source:DataObjectReference)-[:created_by]->(u_creator:User), (v_target:Version)<-[:has_version]-(do_target_pointer:DataObject)-[:has_reference]->(dor_target:DataObjectReference)
218 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
219 AND dor_source.shepardId = dor_target.shepardId
220 CREATE (v_target)<-[:has_version]-(dor_target)-[:created_by]->(u_creator)
221 """;
222 runQuery(query, params);
223 }
224
225 public void copyFileReferences(UUID sourceVersionUID, UUID targetVersionUID) {
226 HashMap<String, Object> params = new HashMap<>();
227 params.put("sourceVersionUID", sourceVersionUID);
228 params.put("targetVersionUID", targetVersionUID);
229 String query =
230 """
231 MATCH (v_source:Version)<-[has_version]-(do_source:DataObject)-[:has_reference]->(fr_source:FileReference)-[:is_in_container]->(fc_pointed:FileContainer),
232 (fr_source)-[:created_by]->(u_creator:User), (v_target:Version)<-[:has_version]-(do_target:DataObject)
233 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID AND do_source.shepardId = do_target.shepardId
234 CREATE (v_target)<-[:has_version]-(fr_target:FileReference:BasicReference:VersionableEntity:BasicEntity)<-[:has_reference]-(do_target),
235 (fc_pointed)<-[:is_in_container]-(fr_target)-[:created_by]->(u_creator)
236 SET fr_target = fr_source
237 """;
238 runQuery(query, params);
239 query = """
240 MATCH (v_source:Version)<-[:has_version]-(fr_source:FileReference)-[:has_payload]->(sf:ShepardFile),
241 (v_target:Version)<-[:has_version]-(fr_target:FileReference)
242 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID AND fr_source.shepardId = fr_target.shepardId
243 CREATE (fr_target)-[:has_payload]->(sf)
244 """;
245 runQuery(query, params);
246 }
247
248 public void copyStructuredDataReferences(UUID sourceVersionUID, UUID targetVersionUID) {
249 HashMap<String, Object> params = new HashMap<>();
250 params.put("sourceVersionUID", sourceVersionUID);
251 params.put("targetVersionUID", targetVersionUID);
252 String query =
253 """
254 MATCH (v_source:Version)<-[has_version]-(do_source:DataObject)-[:has_reference]->(sdr_source:StructuredDataReference)-[:is_in_container]->(sdc_pointed:StructuredDataContainer),
255 (sdr_source)-[:created_by]->(u_creator:User),
256 (v_target:Version)<-[:has_version]-(do_target:DataObject)
257 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
258 AND do_source.shepardId = do_target.shepardId
259 CREATE (v_target)<-[:has_version]-(sdr_target:StructuredDataReference:BasicReference:VersionableEntity:BasicEntity)<-[:has_reference]-(do_target),
260 (sdc_pointed)<-[:is_in_container]-(sdr_target)-[:created_by]->(u_creator)
261 SET sdr_target = sdr_source
262 """;
263 runQuery(query, params);
264 query = """
265 MATCH (v_source:Version)<-[:has_version]-(sdr_source:StructuredDataReference)-[:has_payload]->(sd:StructuredData),
266 (v_target:Version)<-[:has_version]-(sdr_target:StructuredDataReference)
267 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
268 AND sdr_source.shepardId = sdr_target.shepardId
269 CREATE (sdr_target)-[:has_payload]->(sd)
270 """;
271 runQuery(query, params);
272 }
273
274 public void copyTimeseriesReferences(UUID sourceVersionUID, UUID targetVersionUID) {
275 HashMap<String, Object> params = new HashMap<>();
276 params.put("sourceVersionUID", sourceVersionUID);
277 params.put("targetVersionUID", targetVersionUID);
278 String query =
279 """
280 MATCH (v_source:Version)<-[has_version]-(do_source:DataObject)-[:has_reference]->(tsr_source:TimeseriesReference)-[:is_in_container]->(tsc_pointed:TimeseriesContainer),
281 (tsr_source)-[:created_by]->(u_creator:User),
282 (v_target:Version)<-[:has_version]-(do_target:DataObject)
283 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
284 AND do_source.shepardId = do_target.shepardId
285 CREATE (v_target)<-[:has_version]-(tsr_target:TimeseriesReference:BasicReference:VersionableEntity:BasicEntity)<-[:has_reference]-(do_target),
286 (tsc_pointed)<-[:is_in_container]-(tsr_target)-[:created_by]->(u_creator)
287 SET tsr_target = tsr_source
288 """;
289 runQuery(query, params);
290 query = """
291 MATCH (v_source:Version)<-[:has_version]-(tsr_source:TimeseriesReference)-[:has_payload]->(ts:TimeseriesTuple),
292 (v_target:Version)<-[:has_version]-(tsr_target:TimeseriesReference)
293 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
294 AND tsr_source.shepardId = tsr_target.shepardId
295 CREATE (tsr_target)-[:has_payload]->(ts)
296 """;
297 runQuery(query, params);
298 }
299
300 public void copyURIReferences(UUID sourceVersionUID, UUID targetVersionUID) {
301 HashMap<String, Object> params = new HashMap<>();
302 params.put("sourceVersionUID", sourceVersionUID);
303 params.put("targetVersionUID", targetVersionUID);
304 String query =
305 """
306 MATCH (v_source:Version)<-[:has_version]-(do_source:DataObject)-[:has_reference]->(ur_source:URIReference)-[:created_by]->(u_creator:User),
307 (v_target:Version)<-[:has_version]-(do_target:DataObject)
308 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
309 AND do_source.shepardId = do_target.shepardId
310 CREATE (v_target)<-[:has_version]-(ur_target:URIReference:BasicReference:VersionableEntity:BasicEntity)<-[:has_reference]-(do_target),
311 (ur_target)-[:created_by]->(u_creator)
312 SET ur_target=ur_source
313 """;
314 runQuery(query, params);
315 }
316
317 public void addAnnotations(UUID sourceVersionUID, UUID targetVersionUID) {
318 HashMap<String, Object> params = new HashMap<>();
319 params.put("sourceVersionUID", sourceVersionUID);
320 params.put("targetVersionUID", targetVersionUID);
321 String query =
322 """
323 MATCH (v_source:Version)<-[:has_version]-(sourceEntity)-[:has_annotation]->(a:SemanticAnnotation),
324 (v_target:Version)<-[:has_version]-(targetEntity)
325 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
326 AND sourceEntity.shepardId = targetEntity.shepardId
327 CREATE (targetEntity)-[:has_annotation]->(a)
328 """;
329 runQuery(query, params);
330 }
331
332 public void removeHasPredecessor(UUID sourceVersionUID, UUID targetVersionUID) {
333 HashMap<String, Object> params = new HashMap<>();
334 params.put("sourceVersionUID", sourceVersionUID);
335 params.put("targetVersionUID", targetVersionUID);
336 String query =
337 """
338 MATCH (v_source:Version)-[hp:has_predecessor]->(v_target:Version)
339 WHERE v_source.uid = $sourceVersionUID AND v_target.uid = $targetVersionUID
340 DELETE hp
341 """;
342 runQuery(query, params);
343 }
344 }