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 = String.format(
96          "ID ERROR - Data Object Reference with id %s is null or deleted",
97          dataObjectReferenceShepardId
98        );
99        Log.error(errorMsg);
100       throw new InvalidPathException(errorMsg);
101     }
102 
103     if (reference.getDataObject() == null || !reference.getDataObject().getShepardId().equals(dataObjectShepardId)) {
104       String errorMsg = "ID ERROR - There is no association between dataObject and reference";
105       Log.error(errorMsg);
106       throw new InvalidPathException(errorMsg);
107     }
108 
109     return reference;
110   }
111 
112   /**
113    * Creates a new DataObject reference
114    *
115    * @param collectionShepardId
116    * @param dataObjectShepardId DataObject id for the reference to be created
117    * @param dataObjectReference Reference object for DataObjects
118    * @return DataObjectReference
119    * @throws InvalidPathException if collection or dataobject specified by their
120    *                              Ids are null or deleted
121    * @throws InvalidAuthException if user has no permissions to request the
122    *                              collection, which the reference is assigned to
123    * @throws InvalidBodyException if referenced DataObject cannot be found or
124    *                              requester does not have enough permissions
125    */
126   @Override
127   public DataObjectReference createReference(
128     long collectionShepardId,
129     long dataObjectShepardId,
130     DataObjectReferenceIO dataObjectReference
131   ) {
132     DataObject dataObject = dataObjectService.getDataObject(collectionShepardId, dataObjectShepardId);
133     collectionService.assertIsAllowedToEditCollection(collectionShepardId);
134 
135     User user = userService.getCurrentUser();
136     DataObject referenced;
137 
138     try {
139       referenced = dataObjectService.getDataObject(dataObjectReference.getReferencedDataObjectId());
140     } catch (InvalidPathException e) {
141       throw new InvalidBodyException(
142         String.format(
143           "The referenced DataObject with id %d could not be found.",
144           dataObjectReference.getReferencedDataObjectId()
145         )
146       );
147     } catch (InvalidAuthException e) {
148       throw new InvalidBodyException(
149         String.format(
150           "You do not have permissions to access the referenced DataObject with id %d.",
151           dataObjectReference.getReferencedDataObjectId()
152         )
153       );
154     }
155 
156     DataObjectReference toCreate = new DataObjectReference();
157     toCreate.setCreatedAt(dateHelper.getDate());
158     toCreate.setCreatedBy(user);
159     toCreate.setDataObject(dataObject);
160     toCreate.setName(dataObjectReference.getName());
161     toCreate.setReferencedDataObject(referenced);
162     toCreate.setRelationship(dataObjectReference.getRelationship());
163     DataObjectReference created = dataObjectReferenceDAO.createOrUpdate(toCreate);
164     created.setShepardId(created.getId());
165     created = dataObjectReferenceDAO.createOrUpdate(created);
166     Version version = versionService.attachToVersionOfVersionableEntityAndReturnVersion(
167       dataObject.getId(),
168       created.getId()
169     );
170     created.setVersion(version);
171     return created;
172   }
173 
174   /**
175    * Deletes the dataobject reference.
176    *
177    * @param collectionShepardId
178    * @param dataObjectShepardId
179    * @param dataObjectReferenceShepardId
180    * @throws InvalidPathException if collection or dataobject specified by their
181    *                              Ids are null or deleted
182    * @throws InvalidAuthException if user has no permissions to request the
183    *                              collection, which the reference is assigned to
184    * @throws InvalidBodyException If user has no permissions to access the
185    *                              referenced collection or the referenced
186    *                              collection cannot be found
187    */
188   @Override
189   public void deleteReference(long collectionShepardId, long dataObjectShepardId, long dataObjectReferenceShepardId) {
190     DataObjectReference old = getReference(
191       collectionShepardId,
192       dataObjectShepardId,
193       dataObjectReferenceShepardId,
194       null
195     );
196     collectionService.assertIsAllowedToEditCollection(collectionShepardId);
197 
198     User user = userService.getCurrentUser();
199     old.setDeleted(true);
200     old.setUpdatedAt(dateHelper.getDate());
201     old.setUpdatedBy(user);
202     dataObjectReferenceDAO.createOrUpdate(old);
203   }
204 
205   /**
206    * Returns the payload of a referenced DataObject
207    *
208    * @param collectionShepardId
209    * @param dataObjectShepardId
210    * @param dataObjectReferenceShepardId
211    * @param versionUID
212    * @return DataObject
213    * @throws InvalidPathException if collection or dataobject specified by their
214    *                              Ids are null or deleted, or if DataObject
215    *                              referenced by DataObject reference is deleted
216    * @throws InvalidAuthException if user has no permissions to request the
217    *                              collection, which the reference is assigned to
218    * @throws InvalidBodyException if the referenced DataObject cannot be found or
219    *                              is deleted or the requester do not have
220    *                              permissions to access the referenced DataObject
221    */
222   public DataObject getPayload(
223     long collectionShepardId,
224     long dataObjectShepardId,
225     long dataObjectReferenceShepardId,
226     UUID versionUID
227   ) {
228     DataObjectReference reference = getReference(
229       collectionShepardId,
230       dataObjectShepardId,
231       dataObjectReferenceShepardId,
232       versionUID
233     );
234 
235     if (reference.getReferencedDataObject() == null || reference.getReferencedDataObject().isDeleted()) {
236       String errorMsg = String.format(
237         "DataObject referenced by DataObject reference with id %s is not accessible",
238         reference.getShepardId()
239       );
240       Log.errorf(errorMsg);
241       throw new NotFoundException(errorMsg);
242     }
243 
244     try {
245       return dataObjectService.getDataObject(reference.getReferencedDataObject().getShepardId());
246     } catch (InvalidPathException e) {
247       throw new NotFoundException(
248         String.format(
249           "The referenced DataObject with id %d could not be found.",
250           reference.getReferencedDataObject().getShepardId()
251         )
252       );
253     }
254   }
255 }