View Javadoc
1   package de.dlr.shepard.context.references.dataobject.services;
2   
3   import de.dlr.shepard.auth.users.entities.User;
4   import de.dlr.shepard.auth.users.services.UserService;
5   import de.dlr.shepard.common.exceptions.InvalidAuthException;
6   import de.dlr.shepard.common.exceptions.InvalidBodyException;
7   import de.dlr.shepard.common.exceptions.InvalidPathException;
8   import de.dlr.shepard.common.util.DateHelper;
9   import de.dlr.shepard.context.collection.entities.DataObject;
10  import de.dlr.shepard.context.collection.services.CollectionService;
11  import de.dlr.shepard.context.collection.services.DataObjectService;
12  import de.dlr.shepard.context.references.IReferenceService;
13  import de.dlr.shepard.context.references.dataobject.daos.DataObjectReferenceDAO;
14  import de.dlr.shepard.context.references.dataobject.entities.DataObjectReference;
15  import de.dlr.shepard.context.references.dataobject.io.DataObjectReferenceIO;
16  import de.dlr.shepard.context.version.entities.Version;
17  import de.dlr.shepard.context.version.services.VersionService;
18  import io.quarkus.logging.Log;
19  import jakarta.enterprise.context.RequestScoped;
20  import jakarta.inject.Inject;
21  import jakarta.ws.rs.NotFoundException;
22  import java.util.List;
23  import java.util.UUID;
24  
25  @RequestScoped
26  public class DataObjectReferenceService implements IReferenceService<DataObjectReference, DataObjectReferenceIO> {
27  
28    @Inject
29    DataObjectReferenceDAO dataObjectReferenceDAO;
30  
31    @Inject
32    DataObjectService dataObjectService;
33  
34    @Inject
35    VersionService versionService;
36  
37    @Inject
38    UserService userService;
39  
40    @Inject
41    DateHelper dateHelper;
42  
43    @Inject
44    CollectionService collectionService;
45  
46    /**
47     * Gets DataObjectReference list for a given dataobject.
48     *
49     * @param collectionShepardId
50     * @param dataObjectShepardId
51     * @param versionUID          the version UUID
52     * @return List<DataObjectReference>
53     * @throws InvalidPathException If collection or dataobject cannot be found, or
54     *                              no association between dataobject and collection
55     *                              exists
56     * @throws InvalidAuthException If user has no read permissions on collection or
57     *                              dataobject specified by request path
58     */
59    @Override
60    public List<DataObjectReference> getAllReferencesByDataObjectId(
61      long collectionShepardId,
62      long dataObjectShepardId,
63      UUID versionUID
64    ) {
65      dataObjectService.getDataObject(collectionShepardId, dataObjectShepardId, versionUID);
66      var references = dataObjectReferenceDAO.findByDataObjectShepardId(dataObjectShepardId, versionUID);
67      return references;
68    }
69  
70    /**
71     * Gets DataObjectReference by dataObjectReference Id.
72     *
73     * @param collectionShepardId
74     * @param dataObjectShepardId
75     * @param dataObjectReferenceShepardId
76     * @param versionUID                   the collections UUID
77     * @return CollectionReference
78     * @throws InvalidPathException If reference with Id does not exist or is
79     *                              deleted, or if collection or dataobject Id of
80     *                              path is not valid
81     * @throws InvalidAuthException If user has no read permissions on collection or
82     *                              dataobject specified by request path
83     */
84    @Override
85    public DataObjectReference getReference(
86      long collectionShepardId,
87      long dataObjectShepardId,
88      long dataObjectReferenceShepardId,
89      UUID versionUID
90    ) {
91      dataObjectService.getDataObject(collectionShepardId, dataObjectShepardId, versionUID);
92  
93      DataObjectReference reference = dataObjectReferenceDAO.findByShepardId(dataObjectReferenceShepardId, versionUID);
94      if (reference == null || reference.isDeleted()) {
95        String errorMsg =
96          "ID ERROR - Data Object Reference with id %s is null or deleted".formatted(dataObjectReferenceShepardId);
97        Log.error(errorMsg);
98        throw new InvalidPathException(errorMsg);
99      }
100 
101     if (reference.getDataObject() == null || !reference.getDataObject().getShepardId().equals(dataObjectShepardId)) {
102       String errorMsg = "ID ERROR - There is no association between dataObject and reference";
103       Log.error(errorMsg);
104       throw new InvalidPathException(errorMsg);
105     }
106 
107     return reference;
108   }
109 
110   /**
111    * Creates a new DataObject reference
112    *
113    * @param collectionShepardId
114    * @param dataObjectShepardId DataObject id for the reference to be created
115    * @param dataObjectReference Reference object for DataObjects
116    * @return DataObjectReference
117    * @throws InvalidPathException if collection or dataobject specified by their
118    *                              Ids are null or deleted
119    * @throws InvalidAuthException if user has no permissions to request the
120    *                              collection, which the reference is assigned to
121    * @throws InvalidBodyException if referenced DataObject cannot be found or
122    *                              requester does not have enough permissions
123    */
124   @Override
125   public DataObjectReference createReference(
126     long collectionShepardId,
127     long dataObjectShepardId,
128     DataObjectReferenceIO dataObjectReference
129   ) {
130     DataObject dataObject = dataObjectService.getDataObject(collectionShepardId, dataObjectShepardId);
131     collectionService.assertIsAllowedToEditCollection(collectionShepardId);
132 
133     User user = userService.getCurrentUser();
134     DataObject referenced;
135 
136     try {
137       referenced = dataObjectService.getDataObject(dataObjectReference.getReferencedDataObjectId());
138     } catch (InvalidPathException e) {
139       throw new InvalidBodyException(
140         "The referenced DataObject with id %d could not be found.".formatted(
141             dataObjectReference.getReferencedDataObjectId()
142           )
143       );
144     } catch (InvalidAuthException e) {
145       throw new InvalidBodyException(
146         "You do not have permissions to access the referenced DataObject with id %d.".formatted(
147             dataObjectReference.getReferencedDataObjectId()
148           )
149       );
150     }
151 
152     DataObjectReference toCreate = new DataObjectReference();
153     toCreate.setCreatedAt(dateHelper.getDate());
154     toCreate.setCreatedBy(user);
155     toCreate.setDataObject(dataObject);
156     toCreate.setName(dataObjectReference.getName());
157     toCreate.setReferencedDataObject(referenced);
158     toCreate.setRelationship(dataObjectReference.getRelationship());
159     DataObjectReference created = dataObjectReferenceDAO.createOrUpdate(toCreate);
160     created.setShepardId(created.getId());
161     created = dataObjectReferenceDAO.createOrUpdate(created);
162     Version version = versionService.attachToVersionOfVersionableEntityAndReturnVersion(
163       dataObject.getId(),
164       created.getId()
165     );
166     created.setVersion(version);
167     return created;
168   }
169 
170   /**
171    * Deletes the dataobject reference.
172    *
173    * @param collectionShepardId
174    * @param dataObjectShepardId
175    * @param dataObjectReferenceShepardId
176    * @throws InvalidPathException if collection or dataobject specified by their
177    *                              Ids are null or deleted
178    * @throws InvalidAuthException if user has no permissions to request the
179    *                              collection, which the reference is assigned to
180    * @throws InvalidBodyException If user has no permissions to access the
181    *                              referenced collection or the referenced
182    *                              collection cannot be found
183    */
184   @Override
185   public void deleteReference(long collectionShepardId, long dataObjectShepardId, long dataObjectReferenceShepardId) {
186     DataObjectReference old = getReference(
187       collectionShepardId,
188       dataObjectShepardId,
189       dataObjectReferenceShepardId,
190       null
191     );
192     collectionService.assertIsAllowedToEditCollection(collectionShepardId);
193 
194     User user = userService.getCurrentUser();
195     old.setDeleted(true);
196     old.setUpdatedAt(dateHelper.getDate());
197     old.setUpdatedBy(user);
198     dataObjectReferenceDAO.createOrUpdate(old);
199   }
200 
201   /**
202    * Returns the payload of a referenced DataObject
203    *
204    * @param collectionShepardId
205    * @param dataObjectShepardId
206    * @param dataObjectReferenceShepardId
207    * @param versionUID
208    * @return DataObject
209    * @throws InvalidPathException if collection or dataobject specified by their
210    *                              Ids are null or deleted, or if DataObject
211    *                              referenced by DataObject reference is deleted
212    * @throws InvalidAuthException if user has no permissions to request the
213    *                              collection, which the reference is assigned to
214    * @throws InvalidBodyException if the referenced DataObject cannot be found or
215    *                              is deleted or the requester do not have
216    *                              permissions to access the referenced DataObject
217    */
218   public DataObject getPayload(
219     long collectionShepardId,
220     long dataObjectShepardId,
221     long dataObjectReferenceShepardId,
222     UUID versionUID
223   ) {
224     DataObjectReference reference = getReference(
225       collectionShepardId,
226       dataObjectShepardId,
227       dataObjectReferenceShepardId,
228       versionUID
229     );
230 
231     if (reference.getReferencedDataObject() == null || reference.getReferencedDataObject().isDeleted()) {
232       String errorMsg =
233         "DataObject referenced by DataObject reference with id %s is not accessible".formatted(
234             reference.getShepardId()
235           );
236       Log.errorf(errorMsg);
237       throw new NotFoundException(errorMsg);
238     }
239 
240     try {
241       return dataObjectService.getDataObject(reference.getReferencedDataObject().getShepardId());
242     } catch (InvalidPathException e) {
243       throw new NotFoundException(
244         "The referenced DataObject with id %d could not be found.".formatted(
245             reference.getReferencedDataObject().getShepardId()
246           )
247       );
248     }
249   }
250 }