001: /*
002: * Copyright 2004 Outerthought bvba and Schaubroeck nv
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016: package org.outerj.daisy.repository.commonimpl;
017:
018: import org.outerj.daisy.repository.*;
019: import org.outerj.daisy.repository.spi.ExtensionProvider;
020: import org.outerj.daisy.repository.namespace.NamespaceManager;
021: import org.outerj.daisy.repository.variant.VariantManager;
022: import org.outerj.daisy.repository.variant.Branch;
023: import org.outerj.daisy.repository.variant.Language;
024: import org.outerj.daisy.repository.comment.CommentManager;
025: import org.outerj.daisy.repository.query.QueryManager;
026: import org.outerj.daisy.repository.acl.AccessManager;
027: import org.outerj.daisy.repository.commonimpl.schema.RepositorySchemaImpl;
028: import org.outerj.daisy.repository.commonimpl.user.UserManagerImpl;
029: import org.outerj.daisy.repository.commonimpl.acl.AccessManagerImpl;
030: import org.outerj.daisy.repository.commonimpl.comment.CommentManagerImpl;
031: import org.outerj.daisy.repository.commonimpl.variant.VariantManagerImpl;
032: import org.outerj.daisy.repository.commonimpl.namespace.NamespaceManagerImpl;
033: import org.outerj.daisy.repository.schema.RepositorySchema;
034: import org.outerj.daisy.repository.user.UserManager;
035: import org.outerx.daisy.x10.UserInfoDocument;
036:
037: import java.io.InputStream;
038:
039: public class RepositoryImpl implements Repository {
040: private final CommonRepository delegate;
041: protected final AuthenticatedUser user;
042: private RepositorySchema repositorySchema = null;
043: private AccessManager accessManager = null;
044: private QueryManager queryManager = null;
045: private CommentManager commentManager = null;
046: private VariantManager variantManager = null;
047: private NamespaceManager namespaceManager = null;
048:
049: public RepositoryImpl(CommonRepository delegate,
050: AuthenticatedUser user) {
051: this .delegate = delegate;
052: this .user = user;
053: }
054:
055: public String getNamespace() {
056: return getNamespaceManager().getRepositoryNamespace();
057: }
058:
059: public RepositorySchema getRepositorySchema() {
060: if (repositorySchema == null)
061: this .repositorySchema = new RepositorySchemaImpl(delegate
062: .getRepositorySchema(), user);
063: return repositorySchema;
064: }
065:
066: public AccessManager getAccessManager() {
067: if (accessManager == null)
068: this .accessManager = new AccessManagerImpl(delegate
069: .getAccessManager(), delegate, user);
070: return accessManager;
071: }
072:
073: public QueryManager getQueryManager() {
074: if (queryManager == null)
075: this .queryManager = delegate.getQueryManager(user);
076: return queryManager;
077: }
078:
079: public CommentManager getCommentManager() {
080: if (commentManager == null)
081: this .commentManager = new CommentManagerImpl(delegate, user);
082: return commentManager;
083: }
084:
085: public VariantManager getVariantManager() {
086: if (variantManager == null)
087: this .variantManager = new VariantManagerImpl(delegate
088: .getVariantManager(), user);
089: return variantManager;
090: }
091:
092: public NamespaceManager getNamespaceManager() {
093: if (namespaceManager == null)
094: this .namespaceManager = new NamespaceManagerImpl(delegate
095: .getNamespaceManager(), user);
096: return namespaceManager;
097: }
098:
099: public Document createDocument(String name, long documentTypeId,
100: long branchId, long languageId) {
101: return delegate.createDocument(name, documentTypeId, branchId,
102: languageId, user);
103: }
104:
105: public Document createDocument(String name,
106: String documentTypeName, String branchName,
107: String languageName) {
108: return delegate.createDocument(name, documentTypeName,
109: branchName, languageName, user);
110: }
111:
112: public Document createDocument(String name, long documentTypeId) {
113: return createDocument(name, documentTypeId,
114: Branch.MAIN_BRANCH_ID, Language.DEFAULT_LANGUAGE_ID);
115: }
116:
117: public Document createDocument(String name, String documentTypeName) {
118: return createDocument(name, documentTypeName,
119: Branch.MAIN_BRANCH_NAME, Language.DEFAULT_LANGUAGE_NAME);
120: }
121:
122: public Document createVariant(String documentId,
123: long startBranchId, long startLanguageId,
124: long startVersionId, long newBranchId, long newLanguageId,
125: boolean copyContent) throws RepositoryException {
126: DocId docId = DocId.parseDocIdThrowNotFound(documentId,
127: delegate);
128: return delegate.createVariant(docId, startBranchId,
129: startLanguageId, startVersionId, newBranchId,
130: newLanguageId, copyContent, user);
131: }
132:
133: public Document createVariant(String documentId,
134: String startBranchName, String startLanguageName,
135: long startVersionId, String newBranchName,
136: String newLanguageName, boolean copyContent)
137: throws RepositoryException {
138: DocId docId = DocId.parseDocIdThrowNotFound(documentId,
139: delegate);
140: return delegate.createVariant(docId, startBranchName,
141: startLanguageName, startVersionId, newBranchName,
142: newLanguageName, copyContent, user);
143: }
144:
145: public Document getDocument(String documentId, long branchId,
146: long languageId, boolean updateable)
147: throws RepositoryException {
148: DocId docId = DocId.parseDocIdThrowNotFound(documentId,
149: delegate);
150: return delegate.getDocument(docId, branchId, languageId,
151: updateable, user);
152: }
153:
154: public Document getDocument(String documentId, String branchName,
155: String languageName, boolean updateable)
156: throws RepositoryException {
157: DocId docId = DocId.parseDocIdThrowNotFound(documentId,
158: delegate);
159: return delegate.getDocument(docId, branchName, languageName,
160: updateable, user);
161: }
162:
163: public Document getDocument(VariantKey key, boolean updateable)
164: throws RepositoryException {
165: if (key == null)
166: throw new IllegalArgumentException(
167: "VariantKey argument cannot be null.");
168: return this .getDocument(key.getDocumentId(), key.getBranchId(),
169: key.getLanguageId(), updateable);
170: }
171:
172: public Document getDocument(long documentId, boolean updateable)
173: throws RepositoryException {
174: DocId docId = DocId.getDocId(documentId, delegate
175: .getNamespaceManager().getRepositoryNamespace(),
176: delegate);
177: return delegate.getDocument(docId, Branch.MAIN_BRANCH_ID,
178: Language.DEFAULT_LANGUAGE_ID, updateable, user);
179: }
180:
181: public Document getDocument(String documentId, boolean updateable)
182: throws RepositoryException {
183: DocId docId = DocId.parseDocIdThrowNotFound(documentId,
184: delegate);
185: return delegate.getDocument(docId, Branch.MAIN_BRANCH_ID,
186: Language.DEFAULT_LANGUAGE_ID, updateable, user);
187: }
188:
189: public AvailableVariants getAvailableVariants(String documentId)
190: throws RepositoryException {
191: DocId docId = DocId.parseDocIdThrowNotFound(documentId,
192: delegate);
193: return delegate.getAvailableVariants(docId, user);
194: }
195:
196: public void deleteDocument(String documentId)
197: throws RepositoryException {
198: DocId docId = DocId.parseDocIdThrowNotFound(documentId,
199: delegate);
200: delegate.deleteDocument(docId, user);
201: }
202:
203: public void deleteVariant(String documentId, long branchId,
204: long languageId) throws RepositoryException {
205: DocId docId = DocId.parseDocIdThrowNotFound(documentId,
206: delegate);
207: delegate.deleteVariant(docId, branchId, languageId, user);
208: }
209:
210: public void deleteVariant(VariantKey variantKey)
211: throws RepositoryException {
212: this .deleteVariant(variantKey.getDocumentId(), variantKey
213: .getBranchId(), variantKey.getLanguageId());
214: }
215:
216: public InputStream getPartData(String documentId, long branchId,
217: long languageId, long versionId, long partTypeId)
218: throws RepositoryException {
219: DocId docId = DocId.parseDocIdThrowNotFound(documentId,
220: delegate);
221: return delegate.getBlob(docId, branchId, languageId, versionId,
222: partTypeId, user);
223: }
224:
225: public InputStream getPartData(String documentId, long versionId,
226: long partTypeId) throws RepositoryException {
227: return getPartData(documentId, Branch.MAIN_BRANCH_ID,
228: Language.DEFAULT_LANGUAGE_ID, versionId, partTypeId);
229: }
230:
231: public CollectionManager getCollectionManager() {
232: return new CollectionManagerImpl(delegate
233: .getCollectionManager(), user);
234: }
235:
236: public long getUserId() {
237: return user.getId();
238: }
239:
240: public long[] getActiveRoleIds() {
241: return user.getActiveRoleIds();
242: }
243:
244: public boolean isInRole(long roleId) {
245: return user.isInRole(roleId);
246: }
247:
248: public boolean isInRole(String roleName) {
249: long roleId;
250: try {
251: roleId = getUserManager().getRole(roleName, false).getId();
252: } catch (RepositoryException e) {
253: throw new RuntimeException(e);
254: }
255: return user.isInRole(roleId);
256: }
257:
258: public String getUserDisplayName() {
259: try {
260: return getUserManager().getUserDisplayName(user.getId());
261: } catch (Exception e) {
262: throw new RuntimeException(e);
263: }
264: }
265:
266: public String getUserLogin() {
267: return user.getLogin();
268: }
269:
270: public String[] getActiveRolesDisplayNames() {
271: try {
272: UserManager userManager = getUserManager();
273: long[] activeRoleIds = user.getActiveRoleIds();
274: String[] roleNames = new String[activeRoleIds.length];
275: for (int i = 0; i < activeRoleIds.length; i++)
276: roleNames[i] = userManager
277: .getRoleDisplayName(activeRoleIds[i]);
278: return roleNames;
279: } catch (Exception e) {
280: throw new RuntimeException(e);
281: }
282: }
283:
284: public long[] getAvailableRoles() {
285: return user.getAvailableRoleIds();
286: }
287:
288: public void switchRole(long roleId) {
289: user.setActiveRoleIds(new long[] { roleId });
290: }
291:
292: public void setActiveRoleIds(long[] roleIds) {
293: user.setActiveRoleIds(roleIds);
294: }
295:
296: public UserInfoDocument getUserInfoAsXml() {
297: return user.getXml();
298: }
299:
300: // To enable subclasses to access the user
301: protected AuthenticatedUser getUser() {
302: return user;
303: }
304:
305: protected CommonRepository getCommonRepository() {
306: return delegate;
307: }
308:
309: public UserManager getUserManager() {
310: return new UserManagerImpl(delegate.getUserManager(), user);
311: }
312:
313: public void addListener(RepositoryListener listener) {
314: if (listener == null)
315: throw new NullPointerException(
316: "Listener should not be null.");
317:
318: delegate.addListener(listener);
319: }
320:
321: public void removeListener(RepositoryListener listener) {
322: if (listener == null)
323: throw new NullPointerException(
324: "Listener should not be null.");
325:
326: delegate.removeListener(listener);
327: }
328:
329: public Object getExtension(String name) {
330: if (name == null)
331: throw new NullPointerException(
332: "Extension name should not be null.");
333:
334: ExtensionProvider extensionProvider = delegate
335: .getExtensionProvider(name);
336: if (extensionProvider == null)
337: throw new RuntimeException("Extension named \"" + name
338: + "\" is not available.");
339:
340: return extensionProvider.createExtension(this );
341: }
342:
343: public boolean hasExtension(String name) {
344: ExtensionProvider extensionProvider = delegate
345: .getExtensionProvider(name);
346: return extensionProvider != null;
347: }
348:
349: public Object clone() {
350: return new RepositoryImpl(delegate, user);
351: }
352:
353: public String getClientVersion() {
354: return delegate.getClientVersion(user);
355: }
356:
357: public String getServerVersion() {
358: return delegate.getServerVersion(user);
359: }
360:
361: public String normalizeDocumentId(String documentId) {
362: return delegate.normalizeDocumentId(documentId);
363: }
364: }
|