KickJava   Java API By Example, From Geeks To Geeks.

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


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.variant.VariantManager;
20 import org.outerj.daisy.repository.variant.Branch;
21 import org.outerj.daisy.repository.variant.Language;
22 import org.outerj.daisy.repository.comment.CommentManager;
23 import org.outerj.daisy.repository.query.QueryManager;
24 import org.outerj.daisy.repository.acl.AccessManager;
25 import org.outerj.daisy.repository.commonimpl.schema.RepositorySchemaImpl;
26 import org.outerj.daisy.repository.commonimpl.user.UserManagerImpl;
27 import org.outerj.daisy.repository.commonimpl.acl.AccessManagerImpl;
28 import org.outerj.daisy.repository.commonimpl.comment.CommentManagerImpl;
29 import org.outerj.daisy.repository.commonimpl.variant.VariantManagerImpl;
30 import org.outerj.daisy.repository.schema.RepositorySchema;
31 import org.outerj.daisy.repository.user.UserManager;
32 import org.outerx.daisy.x10.UserInfoDocument;
33
34 import java.io.InputStream JavaDoc;
35
36 public class RepositoryImpl implements Repository {
37     private final CommonRepository delegate;
38     protected final AuthenticatedUser user;
39     private RepositorySchema repositorySchema = null;
40     private AccessManager accessManager = null;
41     private QueryManager queryManager = null;
42     private CommentManager commentManager = null;
43     private VariantManager variantManager = null;
44
45     public RepositoryImpl(CommonRepository delegate, AuthenticatedUser user) {
46         this.delegate = delegate;
47         this.user = user;
48     }
49
50     public RepositorySchema getRepositorySchema() {
51         if (repositorySchema == null)
52             this.repositorySchema = new RepositorySchemaImpl(delegate.getRepositorySchema(), user);
53         return repositorySchema;
54     }
55
56     public AccessManager getAccessManager() {
57         if (accessManager == null)
58             this.accessManager = new AccessManagerImpl(delegate.getAccessManager(), user);
59         return accessManager;
60     }
61
62     public QueryManager getQueryManager() {
63         if (queryManager == null)
64             this.queryManager = delegate.getQueryManager(user);
65         return queryManager;
66     }
67
68     public CommentManager getCommentManager() {
69         if (commentManager == null)
70             this.commentManager = new CommentManagerImpl(delegate.getCommentManager(), user);
71         return commentManager;
72     }
73
74     public VariantManager getVariantManager() {
75         if (variantManager == null)
76             this.variantManager = new VariantManagerImpl(delegate.getVariantManager(), user);
77         return variantManager;
78     }
79
80     public Document createDocument(String JavaDoc name, long documentTypeId, long branchId, long languageId) {
81         return delegate.createDocument(name, documentTypeId, branchId, languageId, user);
82     }
83
84     public Document createDocument(String JavaDoc name, String JavaDoc documentTypeName, String JavaDoc branchName, String JavaDoc languageName) {
85         return delegate.createDocument(name, documentTypeName, branchName, languageName, user);
86     }
87
88     public Document createDocument(String JavaDoc name, long documentTypeId) {
89         return createDocument(name, documentTypeId, Branch.MAIN_BRANCH_ID, Language.DEFAULT_LANGUAGE_ID);
90     }
91
92     public Document createDocument(String JavaDoc name, String JavaDoc documentTypeName) {
93         return createDocument(name, documentTypeName, Branch.MAIN_BRANCH_NAME, Language.DEFAULT_LANGUAGE_NAME);
94     }
95
96     public Document createVariant(long documentId, long startBranchId, long startLanguageId, long startVersionId, long newBranchId, long newLanguageId, boolean copyContent) throws RepositoryException {
97         return delegate.createVariant(documentId, startBranchId, startLanguageId, startVersionId, newBranchId, newLanguageId, copyContent, user);
98     }
99
100     public Document createVariant(long documentId, String JavaDoc startBranchName, String JavaDoc startLanguageName, long startVersionId, String JavaDoc newBranchName, String JavaDoc newLanguageName, boolean copyContent) throws RepositoryException {
101         return delegate.createVariant(documentId, startBranchName, startLanguageName, startVersionId, newBranchName, newLanguageName, copyContent, user);
102     }
103
104     public Document getDocument(long documentId, long branchId, long languageId, boolean updateable) throws RepositoryException {
105         return delegate.getDocument(documentId, branchId, languageId, updateable, user);
106     }
107
108     public Document getDocument(long documentId, String JavaDoc branchName, String JavaDoc languageName, boolean updateable) throws RepositoryException {
109         return delegate.getDocument(documentId, branchName, languageName, updateable, user);
110     }
111
112     public Document getDocument(VariantKey key, boolean updateable) throws RepositoryException {
113         if (key == null)
114             throw new IllegalArgumentException JavaDoc("VariantKey argument cannot be null.");
115         return this.getDocument(key.getDocumentId(), key.getBranchId(), key.getLanguageId(), updateable);
116     }
117
118     public Document getDocument(long documentId, boolean updateable) throws RepositoryException {
119         return getDocument(documentId, Branch.MAIN_BRANCH_ID, Language.DEFAULT_LANGUAGE_ID, updateable);
120     }
121
122     public AvailableVariants getAvailableVariants(long documentId) throws RepositoryException {
123         return delegate.getAvailableVariants(documentId, user);
124     }
125
126     public void deleteDocument(long documentId) throws RepositoryException {
127         delegate.deleteDocument(documentId, user);
128     }
129
130     public void deleteVariant(long documentId, long branchId, long languageId) throws RepositoryException {
131         delegate.deleteVariant(documentId, branchId, languageId, user);
132     }
133
134     public void deleteVariant(VariantKey variantKey) throws RepositoryException {
135         this.deleteVariant(variantKey.getDocumentId(), variantKey.getBranchId(), variantKey.getLanguageId());
136     }
137
138     public InputStream JavaDoc getPartData(long documentId, long branchId, long languageId, long versionId, long partTypeId) throws RepositoryException {
139         return delegate.getBlob(documentId, branchId, languageId, versionId, partTypeId, user);
140     }
141
142     public InputStream JavaDoc getPartData(long documentId, long versionId, long partTypeId) throws RepositoryException {
143         return getPartData(documentId, Branch.MAIN_BRANCH_ID, Language.DEFAULT_LANGUAGE_ID, versionId, partTypeId);
144     }
145
146     public CollectionManager getCollectionManager() {
147         return new CollectionManagerImpl(delegate.getCollectionManager(), user);
148     }
149
150     public long getUserId() {
151         return user.getId();
152     }
153
154     public long[] getActiveRoleIds() {
155         return user.getActiveRoleIds();
156     }
157
158     public boolean isInRole(long roleId) {
159         return user.isInRole(roleId);
160     }
161
162     public boolean isInRole(String JavaDoc roleName) {
163         long roleId = 0;
164         try {
165             roleId = getUserManager().getRole(roleName, false).getId();
166         } catch (RepositoryException e) {
167             throw new RuntimeException JavaDoc(e);
168         }
169         return user.isInRole(roleId);
170     }
171
172     public String JavaDoc getUserDisplayName() {
173         try {
174             return getUserManager().getUserDisplayName(user.getId());
175         } catch (Exception JavaDoc e) {
176             throw new RuntimeException JavaDoc(e);
177         }
178     }
179
180     public String JavaDoc getUserLogin() {
181         return user.getLogin();
182     }
183
184     public String JavaDoc[] getActiveRolesDisplayNames() {
185         try {
186             UserManager userManager = getUserManager();
187             long[] activeRoleIds = user.getActiveRoleIds();
188             String JavaDoc[] roleNames = new String JavaDoc[activeRoleIds.length];
189             for (int i = 0; i < activeRoleIds.length; i++)
190                 roleNames[i] = userManager.getRoleDisplayName(activeRoleIds[i]);
191             return roleNames;
192         } catch (Exception JavaDoc e) {
193             throw new RuntimeException JavaDoc(e);
194         }
195     }
196
197     public long[] getAvailableRoles() {
198         return user.getAvailableRoleIds();
199     }
200
201     public void switchRole(long roleId) {
202         user.setActiveRoleIds(new long[] { roleId });
203     }
204
205     public void setActiveRoleIds(long[] roleIds) {
206         user.setActiveRoleIds(roleIds);
207     }
208
209     public UserInfoDocument getUserInfoAsXml() {
210         return user.getXml();
211     }
212
213     // To enable subclasses to access the user
214
protected AuthenticatedUser getUser() {
215         return user;
216     }
217
218     protected CommonRepository getCommonRepository() {
219         return delegate;
220     }
221
222     public UserManager getUserManager() {
223         return new UserManagerImpl(delegate.getUserManager(), user);
224     }
225
226     public void addListener(RepositoryListener listener) {
227         if (listener == null)
228             throw new NullPointerException JavaDoc("Listener should not be null.");
229
230         delegate.addListener(listener);
231     }
232
233     public void removeListener(RepositoryListener listener) {
234         if (listener == null)
235             throw new NullPointerException JavaDoc("Listener should not be null.");
236
237         delegate.removeListener(listener);
238     }
239
240     public Object JavaDoc getExtension(String JavaDoc name) {
241         if (name == null)
242             throw new NullPointerException JavaDoc("Extension name should not be null.");
243
244         ExtensionProvider extensionProvider = delegate.getExtensionProvider(name);
245         if (extensionProvider == null)
246             throw new RuntimeException JavaDoc("Extension named \"" + name + "\" is not available.");
247
248         return extensionProvider.createExtension(this);
249     }
250
251     public Object JavaDoc clone() {
252         return new RepositoryImpl(delegate, user);
253     }
254
255     public String JavaDoc getClientVersion() {
256         return delegate.getClientVersion(user);
257     }
258
259     public String JavaDoc getServerVersion() {
260         return delegate.getServerVersion(user);
261     }
262 }
263
Popular Tags