1 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 ; 36 import java.util.ArrayList ; 37 import java.util.Iterator ; 38 import java.util.Map ; 39 import java.io.InputStream ; 40 41 public abstract class CommonRepository { 42 protected DocumentStrategy documentStrategy; 43 private CommonCollectionManager collectionManager; 44 private List listeners = new ArrayList (); 45 46 private CommonRepositorySchema repositorySchema; 47 private CommonAccessManager commonAccessManager; 48 private CommonUserManager userManager; 49 private CommonCommentManager commentManager; 50 private CommonVariantManager variantManager; 51 private Map extensions; 52 53 public CommonRepository(DocumentStrategy documentStrategy, SchemaStrategy schemaStrategy, 54 AclStrategy aclStrategy, UserManagementStrategy userManagementStrategy, VariantStrategy variantStrategy, 55 CollectionStrategy collectionStrategy, CommentStrategy commentStrategy, 56 Map 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 name, long documentTypeId, long branchId, long languageId, AuthenticatedUser user) { 96 try { 97 repositorySchema.getDocumentTypeById(documentTypeId, false, user); 99 variantManager.getBranch(branchId, false, user); 101 variantManager.getLanguage(languageId, false, user); 103 } catch (RepositoryException e) { 104 throw new RuntimeException (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 name, String documentTypeName, String branchName, String 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 (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 variantManager.getBranch(newBranchId, false, user); 136 variantManager.getLanguage(newLanguageId, false, user); 137 138 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 startBranchName, String startLanguageName, long startVersionId, String newBranchName, String 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 branchName, String languageName, boolean updateable, AuthenticatedUser user) throws RepositoryException { 179 if (branchName == null || branchName.length() == 0) 180 throw new IllegalArgumentException ("Null or empty branch name specified."); 181 if (languageName == null || languageName.length() == 0) 182 throw new IllegalArgumentException ("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 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 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 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 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 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 extensionName) { 254 return (ExtensionProvider)extensions.get(extensionName); 255 } 256 257 public CommonUserManager getUserManager() { 258 return userManager; 259 } 260 261 public String getClientVersion(AuthenticatedUser user) { 262 return documentStrategy.getClientVersion(user); 263 } 264 265 public String getServerVersion(AuthenticatedUser user) { 266 return documentStrategy.getServerVersion(user); 267 } 268 } 269 | Popular Tags |