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

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