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