source: VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/VirtualCollectionRegistry.java @ 221

Last change on this file since 221 was 221, checked in by oschonef, 14 years ago
  • also validate merged virtual collection
  • Property svn:eol-style set to native
File size: 12.5 KB
Line 
1package eu.clarin.cmdi.virtualcollectionregistry;
2
3import java.security.Principal;
4import java.util.Collections;
5import java.util.HashSet;
6import java.util.List;
7import java.util.Map;
8import java.util.concurrent.atomic.AtomicBoolean;
9import java.util.logging.Level;
10import java.util.logging.Logger;
11
12import javax.persistence.EntityManager;
13import javax.persistence.NoResultException;
14import javax.persistence.TypedQuery;
15
16import eu.clarin.cmdi.virtualcollectionregistry.model.Handle;
17import eu.clarin.cmdi.virtualcollectionregistry.model.Resource;
18import eu.clarin.cmdi.virtualcollectionregistry.model.ResourceMetadata;
19import eu.clarin.cmdi.virtualcollectionregistry.model.User;
20import eu.clarin.cmdi.virtualcollectionregistry.model.VirtualCollection;
21import eu.clarin.cmdi.virtualcollectionregistry.model.VirtualCollectionList;
22import eu.clarin.cmdi.virtualcollectionregistry.model.VirtualCollectionValidator;
23import eu.clarin.cmdi.virtualcollectionregistry.query.ParsedQuery;
24import eu.clarin.cmdi.virtualcollectionregistry.query.QueryException;
25
26public class VirtualCollectionRegistry {
27        private static final Logger logger = Logger
28                        .getLogger(VirtualCollectionRegistry.class.getName());
29        private static VirtualCollectionRegistry s_instance =
30                new VirtualCollectionRegistry();
31        private AtomicBoolean intialized = new AtomicBoolean(false);
32        private DataStore datastore = null;
33        private VirtualCollectionRegistryMarshaller marshaller = null;
34       
35        private VirtualCollectionRegistry() {
36                super();
37        }
38
39        public static void initalize(Map<String, String> config)
40                        throws VirtualCollectionRegistryException {
41                s_instance.doInitalize(config);
42        }
43
44        private void doInitalize(Map<String, String> config)
45                        throws VirtualCollectionRegistryException {
46                if (intialized.get()) {
47                        throw new VirtualCollectionRegistryException("already initialized");
48                }
49                logger.fine("initialize ...");
50                if (config == null) {
51                        config = Collections.emptyMap();
52                }
53                for (String key : config.keySet()) {
54                        logger.fine("XXX: " + key + " = \"" + config.get(key) + "\"");
55                }
56                datastore  = new DataStore(config);
57                marshaller = new VirtualCollectionRegistryMarshaller();
58                intialized.set(true);
59        }
60
61        public void destroy() throws VirtualCollectionRegistryException {
62                if (datastore != null) {
63                        datastore.destroy();
64                }
65        }
66
67        public static VirtualCollectionRegistry instance() {
68                if (!s_instance.intialized.get()) {
69                        throw new InternalError("virtual collection registry failed " +
70                                        "to initialize correctly");
71                }
72                return s_instance;
73        }
74
75        public DataStore getDataStore() {
76                return datastore;
77        }
78
79        public VirtualCollectionRegistryMarshaller getMarshaller() {
80                return marshaller;
81        }
82
83        public long createVirtualCollection(Principal principal,
84                        VirtualCollection vc) throws VirtualCollectionRegistryException {
85                if (principal == null) {
86                        throw new NullPointerException("principal == null");
87                }
88                if (vc == null) {
89                        throw new NullPointerException("vc == null");
90                }
91
92                VirtualCollectionValidator validator =
93                        new VirtualCollectionValidator();
94                validator.validate(vc);
95
96                try {
97                        EntityManager em = datastore.getEntityManager();
98                        em.getTransaction().begin();
99
100                        // fetch user, if user does not exist create new
101                        User user = fetchUser(em, principal);
102                        if (user == null) {
103                                user = new User(principal.getName());
104                                em.persist(user);
105                        }
106
107                        // store virtual collection
108                        vc.setOwner(user);
109                        vc.setPid(Handle.createPid());
110                        for (Resource resource : vc.getResources()) {
111                                if (resource instanceof ResourceMetadata) {
112                                        ResourceMetadata md = (ResourceMetadata) resource;
113                                        md.setPid(Handle.createPid());
114                                }
115                        }
116                        em.persist(vc);                 
117                        em.getTransaction().commit();
118
119                        // XXX: for test PID service
120                        em.getTransaction().begin();
121                        em.persist(new Handle(vc.getPid(), Handle.Type.COLLECTION, vc.getId()));
122                        for (Resource resource : vc.getResources()) {
123                                if (resource instanceof ResourceMetadata) {
124                                        ResourceMetadata md = (ResourceMetadata) resource;
125                                        em.persist(new Handle(md.getPid(), Handle.Type.METADATA,
126                                                                                        md.getId()));
127                                }
128                        }
129                        em.getTransaction().commit();
130                        return vc.getId();
131                } catch (Exception e) {
132                        logger.log(Level.SEVERE,
133                                           "error while creating virtual collection", e);
134                        throw new VirtualCollectionRegistryException(
135                                        "error while creating virtual collection", e);
136                }
137        }
138
139        public long updateVirtualCollection(Principal principal, long id,
140                        VirtualCollection vc) throws VirtualCollectionRegistryException {
141                if (principal == null) {
142                        throw new NullPointerException("principal == null");
143                }
144                if (id <= 0) {
145                        throw new IllegalArgumentException("id <= 0");
146                }
147                if (vc == null) {
148                        throw new NullPointerException("vc == null");
149                }
150               
151                VirtualCollectionValidator validator =
152                        new VirtualCollectionValidator();
153                validator.validate(vc);
154
155                try {
156                        EntityManager em = datastore.getEntityManager();
157                        em.getTransaction().begin();
158                        VirtualCollection c = em.find(VirtualCollection.class, new Long(id));
159                        if (c == null) {
160                                throw new VirtualCollectionNotFoundException(id);
161                        }
162                        if (!c.getOwner().equalsPrincipal(principal)) {
163                                throw new VirtualCollectionRegistryPermissionException(
164                                                "permission denied for user \"" +
165                                                principal.getName() + "\"");
166                        }
167                        c.updateFrom(vc);
168                        validator.validate(c);
169
170                        HashSet<String> newPids = new HashSet<String>();
171                        for (Resource resource : c.getResources()) {
172                                if (resource instanceof ResourceMetadata) {
173                                        ResourceMetadata md = (ResourceMetadata) resource;
174                                        if (md.getPid() == null) {
175                                                String pid = Handle.createPid();
176                                                md.setPid(pid);
177                                                newPids.add(pid);
178                                        }
179                                }
180                        }
181                        em.getTransaction().commit();
182                        em.getTransaction().begin();
183                        for (Resource resource : c.getResources()) {
184                                if (resource instanceof ResourceMetadata) {
185                                        ResourceMetadata md = (ResourceMetadata) resource;
186                                        if (newPids.contains(md.getPid())) {
187                                                em.persist(new Handle(md.getPid(),
188                                                                Handle.Type.METADATA, md.getId()));
189                                        }
190                                }
191                        }
192                        em.getTransaction().commit();
193                        return vc.getId();
194                } catch (VirtualCollectionRegistryException e) {
195                        throw e;
196                } catch (Exception e) {
197                        logger.log(Level.SEVERE,
198                       "error while updating virtual collection", e);
199                        throw new VirtualCollectionRegistryException(
200                                        "error while updating virtual collection", e);
201                }
202        }
203
204        public long deleteVirtualCollection(Principal principal, long id)
205                        throws VirtualCollectionRegistryException {
206                if (principal == null) {
207                        throw new NullPointerException("principal == null");
208                }
209                if (id <= 0) {
210                        throw new IllegalArgumentException("id <= 0");
211                }
212
213                try {
214                        EntityManager em = datastore.getEntityManager();
215                        em.getTransaction().begin();
216                        VirtualCollection vc = em.find(VirtualCollection.class, new Long(id));
217                        if (vc == null) {
218                                throw new VirtualCollectionNotFoundException(id);
219                        }
220                        if (!vc.getOwner().equalsPrincipal(principal)) {
221                                throw new VirtualCollectionRegistryPermissionException(
222                                                "permission denied for user \"" +
223                                                principal.getName() + "\"");
224                        }
225                        em.remove(vc);
226                        em.getTransaction().commit();
227                        return vc.getId();
228                } catch (VirtualCollectionRegistryException e) {
229                        throw e;
230                } catch (Exception e) {
231                        logger.log(Level.SEVERE,
232                                           "error while deleting virtual collection", e);
233                        throw new VirtualCollectionRegistryException(
234                                        "error while deleting virtual collection", e);
235                }
236        }
237
238        public VirtualCollection retrieveVirtualCollection(long id)
239                        throws VirtualCollectionRegistryException {
240                if (id <= 0) {
241                        throw new IllegalArgumentException("id <= 0");
242                }
243
244                try {
245                        EntityManager em = datastore.getEntityManager();
246                        em.getTransaction().begin();
247                        VirtualCollection vc = em.find(VirtualCollection.class,
248                                        new Long(id));
249                        em.getTransaction().commit();
250                        if (vc == null) {
251                                throw new VirtualCollectionNotFoundException(id);
252                        }
253                        return vc;
254                } catch (VirtualCollectionRegistryException e) {
255                        throw e;
256                } catch (Exception e) {
257                        logger.log(Level.SEVERE,
258                                           "error while retrieving virtual collection", e);
259                        throw new VirtualCollectionRegistryException(
260                                        "error while retrieving virtual collection", e);
261                }
262        }
263
264        public ResourceMetadata retrieveMetadataResource(long id)
265                        throws VirtualCollectionRegistryException {
266                if (id <= 0) {
267                        throw new IllegalArgumentException("id <= 0");
268                }
269
270                try {
271                        EntityManager em = datastore.getEntityManager();
272                        em.getTransaction().begin();
273                        ResourceMetadata md = em.find(ResourceMetadata.class, new Long(id));
274                        em.getTransaction().commit();
275                        if (md == null) {
276                                throw new VirtualCollectionMetadataNotFoundException(id);
277                        }
278                        return md;
279                } catch (VirtualCollectionRegistryException e) {
280                        throw e;
281                } catch (Exception e) {
282                        logger.log(Level.SEVERE,
283                                           "error while retrieving metadata resource", e);
284                        throw new VirtualCollectionRegistryException(
285                                        "error while retrieving metadata resource", e);
286                }
287                       
288        }
289
290        public VirtualCollectionList getVirtualCollections(String query,
291                        int offset, int count) throws VirtualCollectionRegistryException {
292                EntityManager em = datastore.getEntityManager();
293                try {
294                        em.getTransaction().begin();
295
296                        // setup queries
297                        TypedQuery<Long>              cq = null;
298                        TypedQuery<VirtualCollection>  q = null;
299                        if (query != null) {
300                                ParsedQuery parsedQuery = ParsedQuery.parseQuery(em, query);
301                                cq = parsedQuery.getCountQuery(null);
302                                q = parsedQuery.getQuery(null);
303                        } else {
304                                cq = em.createNamedQuery("VirtualCollection.countAll",
305                                                Long.class);
306                                q = em.createNamedQuery("VirtualCollection.findAll",
307                                                VirtualCollection.class);
308                        }
309
310                        // commence query ...
311                        List<VirtualCollection> results = null;
312                        long totalCount = cq.getSingleResult();
313
314                        // optimization; don't query, if we won't get any results
315                        if ( totalCount > 0) {
316                                if (offset > 0) {
317                                        q.setFirstResult(offset);
318                                }
319                                if (count > 0) {
320                                        q.setMaxResults(count);
321                                }
322                                results = q.getResultList();
323                        }
324                        return new VirtualCollectionList(results, offset, (int) totalCount);
325                } catch (QueryException e) {
326                        throw new VirtualCollectionRegistryUsageException(
327                                "query invalid", e);
328                } catch (Exception e) {
329                        logger.log(Level.SEVERE,
330                                           "error while enumerating virtual collections", e);
331                        throw new VirtualCollectionRegistryException(
332                                        "error while enumerating virtual collections", e);
333                } finally {
334                        em.getTransaction().commit();
335                }
336        }
337
338        public VirtualCollectionList getVirtualCollections(Principal principal,
339                        String query, int offset, int count)
340                        throws VirtualCollectionRegistryException {
341                if (principal == null) {
342                        throw new NullPointerException("principal == null");
343                }
344                EntityManager em = datastore.getEntityManager();
345                try {
346                        em.getTransaction().begin();
347
348                        // fetch user
349                        User user = fetchUser(em, principal);
350                        if (user == null) {
351                                throw new VirtualCollectionRegistryPermissionException("user " +
352                                                principal.getName() + " does not exist");
353                        }
354
355                        // setup queries
356                        TypedQuery<Long>              cq = null;
357                        TypedQuery<VirtualCollection>  q = null;
358                        if (query != null) {
359                                ParsedQuery parsedQuery = ParsedQuery.parseQuery(em, query);
360                                cq = parsedQuery.getCountQuery(user);
361                                q = parsedQuery.getQuery(user);
362                        } else {
363                                cq = em.createNamedQuery("VirtualCollection.countByOwner", Long.class);
364                                cq.setParameter("owner", user);
365                                q = em.createNamedQuery("VirtualCollection.findByOwner",
366                                                VirtualCollection.class);
367                                q.setParameter("owner", user);
368                        }
369
370                        // commence query ...
371                        List<VirtualCollection> results = null;
372                        long totalCount = cq.getSingleResult();
373
374                        // optimization; don't query, if we won't get any results
375                        if (totalCount > 0) {
376                                if (offset > 0) {
377                                        q.setFirstResult(offset);
378                                }
379                                if (count > 0) {
380                                        q.setMaxResults(count);
381                                }
382                                results = q.getResultList();
383                        }
384                        return new VirtualCollectionList(results, offset, (int) totalCount);
385                } catch (QueryException e) {
386                        throw new VirtualCollectionRegistryUsageException(
387                                "query invalid", e);
388                } catch (VirtualCollectionRegistryException e) {
389                        throw e;
390                } catch (Exception e) {
391                        logger.log(Level.SEVERE,
392                                           "error while enumerating virtual collections", e);
393                        throw new VirtualCollectionRegistryException(
394                                        "error while enumerating virtual collections", e);
395                } finally {
396                        em.getTransaction().commit();
397                }
398        }
399
400        private static User fetchUser(EntityManager em, Principal principal) {
401                User user = null;
402                try {
403                        TypedQuery<User> q =
404                                em.createNamedQuery("User.findByName", User.class);
405                        q.setParameter("name", principal.getName());
406                        user = q.getSingleResult();
407                } catch (NoResultException e) {
408                        /* IGNORE */
409                }
410                return user;
411        }
412
413} // class VirtualCollectionRegistry
Note: See TracBrowser for help on using the repository browser.