KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > outerj > daisy > repository > commonimpl > CommonRepository


1 /*
2  * Copyright 2004 Outerthought bvba and Schaubroeck nv
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

16 package org.outerj.daisy.repository.commonimpl;
17
18 import org.outerj.daisy.repository.*;
19 import org.outerj.daisy.repository.acl.AclResultInfo;
20 import org.outerj.daisy.repository.acl.AclPermission;
21 import org.outerj.daisy.repository.query.QueryManager;
22 import org.outerj.daisy.repository.commonimpl.schema.CommonRepositorySchema;
23 import org.outerj.daisy.repository.commonimpl.schema.SchemaStrategy;
24 import org.outerj.daisy.repository.commonimpl.user.CommonUserManager;
25 import org.outerj.daisy.repository.commonimpl.user.UserManagementStrategy;
26 import org.outerj.daisy.repository.commonimpl.user.UserCache;
27 import org.outerj.daisy.repository.commonimpl.acl.CommonAccessManager;
28 import org.outerj.daisy.repository.commonimpl.acl.AclStrategy;
29 import org.outerj.daisy.repository.commonimpl.comment.CommonCommentManager;
30 import org.outerj.daisy.repository.commonimpl.comment.CommentStrategy;
31 import org.outerj.daisy.repository.commonimpl.variant.CommonVariantManager;
32 import org.outerj.daisy.repository.commonimpl.variant.VariantStrategy;
33 import org.outerj.daisy.repository.commonimpl.variant.VariantCache;
34
35 import java.util.List JavaDoc;
36 import java.util.ArrayList JavaDoc;
37 import java.util.Iterator JavaDoc;
38 import java.util.Map JavaDoc;
39 import java.io.InputStream JavaDoc;
40
41 public abstract class CommonRepository {
42     protected DocumentStrategy documentStrategy;
43     private CommonCollectionManager collectionManager;
44     private List JavaDoc listeners = new ArrayList JavaDoc();
45
46     private CommonRepositorySchema repositorySchema;
47     private CommonAccessManager commonAccessManager;
48     private CommonUserManager userManager;
49     private CommonCommentManager commentManager;
50     private CommonVariantManager variantManager;
51     private Map JavaDoc extensions;
52
53     public CommonRepository(DocumentStrategy documentStrategy, SchemaStrategy schemaStrategy,
54             AclStrategy aclStrategy, UserManagementStrategy userManagementStrategy, VariantStrategy variantStrategy,
55             CollectionStrategy collectionStrategy, CommentStrategy commentStrategy,
56             Map JavaDoc extensions, AuthenticatedUser systemUser) {
57         this.documentStrategy = documentStrategy;
58         this.repositorySchema = new CommonRepositorySchema(schemaStrategy, this, systemUser);
59
60         CollectionCache collectionCache = new CollectionCache(collectionStrategy, systemUser);
61         addListener(collectionCache);
62         this.collectionManager = new CommonCollectionManager(collectionStrategy, collectionCache);
63
64         UserCache userCache = new UserCache(userManagementStrategy, systemUser);
65         addListener(userCache);
66         this.userManager = new CommonUserManager(userManagementStrategy, userCache);
67
68         VariantCache variantCache = new VariantCache(variantStrategy, systemUser);
69         addListener(variantCache);
70         this.variantManager = new CommonVariantManager(variantStrategy, variantCache);
71
72         this.commonAccessManager = new CommonAccessManager(aclStrategy);
73         this.commentManager = new CommonCommentManager(commentStrategy);
74         this.extensions = extensions;
75     }
76
77     public CommonRepositorySchema getRepositorySchema() {
78         return repositorySchema;
79     }
80
81     public CommonAccessManager getAccessManager() {
82         return commonAccessManager;
83     }
84
85     public abstract QueryManager getQueryManager(AuthenticatedUser user);
86
87     public CommonCommentManager getCommentManager() {
88         return commentManager;
89     }
90
91     public CommonVariantManager getVariantManager() {
92         return variantManager;
93     }
94
95     public DocumentImpl createDocument(String JavaDoc name, long documentTypeId, long branchId, long languageId, AuthenticatedUser user) {
96         try {
97             // check that the documenttype exists
98
repositorySchema.getDocumentTypeById(documentTypeId, false, user);
99             // check the branch exists
100
variantManager.getBranch(branchId, false, user);
101             // check the language exists
102
variantManager.getLanguage(languageId, false, user);
103         } catch (RepositoryException e) {
104             throw new RuntimeException JavaDoc(e);
105         }
106         DocumentImpl newDocument = new DocumentImpl(documentStrategy, this, user, documentTypeId, branchId, languageId);
107         newDocument.setName(name);
108         return newDocument;
109     }
110
111     public DocumentImpl createDocument(String JavaDoc name, String JavaDoc documentTypeName, String JavaDoc branchName, String JavaDoc languageName, AuthenticatedUser user) {
112         long documentTypeId;
113         long branchId;
114         long languageId;
115         try {
116             documentTypeId = repositorySchema.getDocumentTypeByName(documentTypeName, false, user).getId();
117             branchId = variantManager.getBranchByName(branchName, false, user).getId();
118             languageId = variantManager.getLanguageByName(languageName, false, user).getId();
119         } catch (RepositoryException e) {
120             throw new RuntimeException JavaDoc(e);
121         }
122         DocumentImpl newDocument = new DocumentImpl(documentStrategy, this, user, documentTypeId, branchId, languageId);
123         newDocument.setName(name);
124         return newDocument;
125     }
126
127     public Document createVariant(long documentId, long startBranchId, long startLanguageId, long startVersionId, long newBranchId, long newLanguageId, boolean copyContent, AuthenticatedUser user) throws RepositoryException {
128         AvailableVariant[] availableVariants = getAvailableVariants(documentId, user).getArray();
129         for (int i = 0; i < availableVariants.length; i++) {
130             if (availableVariants[i].getBranchId() == newBranchId && availableVariants[i].getLanguageId() == newLanguageId)
131                 throw new RepositoryException("Document " + documentId + " already has the variant branch ID " + newBranchId + ", language ID " + newLanguageId);
132         }
133
134         // test that the branch and languages exist
135
variantManager.getBranch(newBranchId, false, user);
136         variantManager.getLanguage(newLanguageId, false, user);
137
138         // check that the user has write access to the start variant (otherwise everyone would be able
139
// to add new variants to whatever document, since they can modify the variant data to match the ACL rules)
140
AclResultInfo aclResultInfo = getAccessManager().getAclInfoOnLive(user, user.getId(), user.getActiveRoleIds(), documentId, startBranchId, startLanguageId);
141         if (!aclResultInfo.isAllowed(AclPermission.WRITE)) {
142             throw new RepositoryException("A new variant can only be added if you have write access to the start variant.");
143         }
144
145         if (copyContent) {
146             Document document = documentStrategy.createVariant(documentId, startBranchId, startLanguageId, startVersionId, newBranchId, newLanguageId, user);
147             return document;
148         } else {
149             Document document = getDocument(documentId, startBranchId, startLanguageId, false, user);
150             DocumentImpl newDocument = new DocumentImpl(documentStrategy, this, user, document.getDocumentTypeId(), newBranchId, newLanguageId);
151             newDocument.getIntimateAccess(documentStrategy).load(document.getId(), document.getLastModified(), document.getLastModifier(), document.getCreated(), document.getOwner(), document.isPrivate(), document.getUpdateCount());
152             newDocument.setName(document.getName());
153             DocumentVariantImpl.IntimateAccess variantInt = newDocument.getIntimateAccess(documentStrategy).getVariant().getIntimateAccess(documentStrategy);
154             variantInt.setStartFrom(startBranchId, startLanguageId);
155             return newDocument;
156         }
157     }
158
159     public Document createVariant(long documentId, String JavaDoc startBranchName, String JavaDoc startLanguageName, long startVersionId, String JavaDoc newBranchName, String JavaDoc newLanguageName, boolean copyContent, AuthenticatedUser user) throws RepositoryException {
160         long startBranchId = variantManager.getBranchByName(startBranchName, false, user).getId();
161         long startLanguageId = variantManager.getLanguageByName(startLanguageName, false, user).getId();
162         long newBranchId = variantManager.getBranchByName(newBranchName, false, user).getId();
163         long newLanguageId = variantManager.getLanguageByName(newLanguageName, false, user).getId();
164         return createVariant(documentId, startBranchId, startLanguageId, startVersionId, newBranchId, newLanguageId, copyContent, user);
165     }
166
167     public Document getDocument(long documentId, long branchId, long languageId, boolean updateable, AuthenticatedUser user) throws RepositoryException {
168         if (updateable)
169             return documentStrategy.load(user, documentId, branchId, languageId);
170         else {
171             Document document = documentStrategy.load(user, documentId, branchId, languageId);
172             DocumentImpl documentImpl = ((DocumentWrapper)document).getWrappedDocument(documentStrategy);
173             documentImpl.makeReadOnly();
174             return document;
175         }
176     }
177
178     public Document getDocument(long documentId, String JavaDoc branchName, String JavaDoc languageName, boolean updateable, AuthenticatedUser user) throws RepositoryException {
179         if (branchName == null || branchName.length() == 0)
180             throw new IllegalArgumentException JavaDoc("Null or empty branch name specified.");
181         if (languageName == null || languageName.length() == 0)
182             throw new IllegalArgumentException JavaDoc("Null or empty language name specified.");
183
184         long branchId;
185         if (Character.isDigit(branchName.charAt(0))) {
186             try {
187                 branchId = Long.parseLong(branchName);
188             } catch (NumberFormatException JavaDoc e) {
189                 throw new RepositoryException("Invalid branch name: " + branchName);
190             }
191         } else {
192             branchId = variantManager.getBranchByName(branchName, false, user).getId();
193         }
194
195         long languageId;
196         if (Character.isDigit(languageName.charAt(0))) {
197             try {
198                 languageId = Long.parseLong(languageName);
199             } catch (NumberFormatException JavaDoc e) {
200                 throw new RepositoryException("Invalid language name: " + languageName);
201             }
202         } else {
203             languageId = variantManager.getLanguageByName(languageName, false, user).getId();
204         }
205         
206         return getDocument(documentId, branchId, languageId, updateable, user);
207     }
208
209     public AvailableVariants getAvailableVariants(long documentId, AuthenticatedUser user) throws RepositoryException {
210         return new AvailableVariantsImpl(documentStrategy.getAvailableVariants(documentId, user));
211     }
212
213     public void deleteDocument(long documentId, AuthenticatedUser user) throws RepositoryException {
214         documentStrategy.deleteDocument(documentId, user);
215     }
216
217     public void deleteVariant(long documentId, long branchId, long languageId, AuthenticatedUser user) throws RepositoryException {
218         documentStrategy.deleteVariant(documentId, branchId, languageId, user);
219     }
220
221     public InputStream JavaDoc getBlob(long documentId, long branchId, long languageId, long versionId, long partTypeId, AuthenticatedUser user) throws RepositoryException {
222         return documentStrategy.getBlob(documentId, branchId, languageId, versionId, partTypeId, user);
223     }
224
225     public CommonCollectionManager getCollectionManager() {
226          return collectionManager;
227     }
228
229     public void removeListener(RepositoryListener listener) {
230         listeners.remove(listener);
231     }
232
233     public void addListener(RepositoryListener listener) {
234         listeners.add(listener);
235     }
236
237     public void fireRepositoryEvent(RepositoryEventType type, long id, long updateCount) {
238         Iterator JavaDoc listenerIt = listeners.iterator();
239         while (listenerIt.hasNext()) {
240             RepositoryListener listener = (RepositoryListener)listenerIt.next();
241             listener.repositoryEvent(type, id, updateCount);
242         }
243     }
244
245     public void fireVariantEvent(DocumentVariantEventType type, long documentId, long branchId, long languageId, long updateCount) {
246         Iterator JavaDoc listenerIt = listeners.iterator();
247         while (listenerIt.hasNext()) {
248             RepositoryListener listener = (RepositoryListener)listenerIt.next();
249             listener.variantEvent(type, documentId, branchId, languageId, updateCount);
250         }
251     }
252
253     public ExtensionProvider getExtensionProvider(String JavaDoc extensionName) {
254         return (ExtensionProvider)extensions.get(extensionName);
255     }
256
257     public CommonUserManager getUserManager() {
258         return userManager;
259     }
260
261     public String JavaDoc getClientVersion(AuthenticatedUser user) {
262         return documentStrategy.getClientVersion(user);
263     }
264
265     public String JavaDoc getServerVersion(AuthenticatedUser user) {
266         return documentStrategy.getServerVersion(user);
267     }
268 }
269
Popular Tags