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.clientimpl.schema;
017:
018: import java.util.ArrayList;
019: import java.util.Collection;
020: import java.util.List;
021: import java.util.Locale;
022:
023: import org.apache.commons.httpclient.HttpMethod;
024: import org.apache.commons.httpclient.NameValuePair;
025: import org.apache.commons.httpclient.methods.GetMethod;
026: import org.apache.commons.httpclient.methods.PostMethod;
027: import org.apache.commons.httpclient.methods.DeleteMethod;
028: import org.apache.commons.httpclient.methods.InputStreamRequestEntity;
029: import org.outerj.daisy.repository.*;
030: import org.outerj.daisy.repository.clientimpl.RemoteRepositoryManager;
031: import org.outerj.daisy.repository.clientimpl.infrastructure.AbstractRemoteStrategy;
032: import org.outerj.daisy.repository.clientimpl.infrastructure.DaisyHttpClient;
033: import org.outerj.daisy.repository.commonimpl.AuthenticatedUser;
034: import org.outerj.daisy.repository.commonimpl.LinkExtractorInfoImpl;
035: import org.outerj.daisy.repository.commonimpl.LinkExtractorInfosImpl;
036: import org.outerj.daisy.repository.commonimpl.schema.DocumentTypeImpl;
037: import org.outerj.daisy.repository.commonimpl.schema.FieldTypeImpl;
038: import org.outerj.daisy.repository.commonimpl.schema.PartTypeImpl;
039: import org.outerj.daisy.repository.commonimpl.schema.SchemaStrategy;
040: import org.outerj.daisy.repository.schema.RepositorySchemaEventType;
041: import org.outerx.daisy.x10.*;
042:
043: public class RemoteSchemaStrategy extends AbstractRemoteStrategy
044: implements SchemaStrategy {
045: public RemoteSchemaStrategy(RemoteRepositoryManager.Context context) {
046: super (context);
047: }
048:
049: public DocumentTypeImpl getDocumentTypeById(long id,
050: AuthenticatedUser user) throws RepositoryException {
051: DaisyHttpClient httpClient = getClient(user);
052: HttpMethod method = new GetMethod(
053: "/repository/schema/documentType/" + id);
054:
055: DocumentTypeDocument documentTypeDocument = (DocumentTypeDocument) httpClient
056: .executeMethod(method, DocumentTypeDocument.class, true);
057: DocumentTypeDocument.DocumentType documentTypeXml = documentTypeDocument
058: .getDocumentType();
059: DocumentTypeImpl documentType = instantiateDocumentTypeFromXml(
060: documentTypeXml, user);
061: return documentType;
062: }
063:
064: public DocumentTypeImpl getDocumentTypeByName(String name,
065: AuthenticatedUser user) throws RepositoryException {
066: DaisyHttpClient httpClient = getClient(user);
067: String encodedName = encodeNameForUseInPath("document type",
068: name);
069: HttpMethod method = new GetMethod(
070: "/repository/schema/documentTypeByName/" + encodedName);
071:
072: DocumentTypeDocument documentTypeDocument = (DocumentTypeDocument) httpClient
073: .executeMethod(method, DocumentTypeDocument.class, true);
074: DocumentTypeDocument.DocumentType documentTypeXml = documentTypeDocument
075: .getDocumentType();
076: DocumentTypeImpl documentType = instantiateDocumentTypeFromXml(
077: documentTypeXml, user);
078: return documentType;
079: }
080:
081: public void store(DocumentTypeImpl documentType)
082: throws RepositoryException {
083: DocumentTypeImpl.IntimateAccess documentTypeInt = documentType
084: .getIntimateAccess(this );
085: DaisyHttpClient httpClient = getClient(documentTypeInt
086: .getCurrentModifier());
087:
088: String url = "/repository";
089: boolean isNew = documentType.getId() == -1;
090: if (isNew)
091: url += "/schema/documentType";
092: else
093: url += "/schema/documentType/" + documentType.getId();
094:
095: PostMethod method = new PostMethod(url);
096: method.setRequestEntity(new InputStreamRequestEntity(
097: documentType.getXml().newInputStream()));
098:
099: DocumentTypeDocument documentTypeDocument = (DocumentTypeDocument) httpClient
100: .executeMethod(method, DocumentTypeDocument.class, true);
101: DocumentTypeDocument.DocumentType documentTypeXml = documentTypeDocument
102: .getDocumentType();
103: documentTypeInt.setId(documentTypeXml.getId());
104: documentTypeInt.setLastModified(documentTypeXml
105: .getLastModified().getTime());
106: documentTypeInt.setLastModifier(documentTypeXml
107: .getLastModifier());
108: documentTypeInt
109: .setUpdateCount(documentTypeXml.getUpdateCount());
110:
111: if (isNew)
112: context
113: .getCommonRepositorySchema()
114: .fireSchemaEvent(
115: RepositorySchemaEventType.DOCUMENT_TYPE_CREATED,
116: documentType.getId(),
117: documentType.getUpdateCount());
118: else
119: context
120: .getCommonRepositorySchema()
121: .fireSchemaEvent(
122: RepositorySchemaEventType.DOCUMENT_TYPE_UPDATED,
123: documentType.getId(),
124: documentType.getUpdateCount());
125: }
126:
127: public void deleteDocumentType(long documentTypeId,
128: AuthenticatedUser user) throws RepositoryException {
129: DaisyHttpClient httpClient = getClient(user);
130:
131: String url = "/repository/schema/documentType/"
132: + documentTypeId;
133:
134: DeleteMethod method = new DeleteMethod(url);
135: httpClient.executeMethod(method, null, true);
136: context.getCommonRepositorySchema().fireSchemaEvent(
137: RepositorySchemaEventType.DOCUMENT_TYPE_DELETED,
138: documentTypeId, -1);
139: }
140:
141: public Collection<DocumentTypeImpl> getAllDocumentTypes(
142: AuthenticatedUser user) throws RepositoryException {
143: DaisyHttpClient httpClient = getClient(user);
144: HttpMethod method = new GetMethod(
145: "/repository/schema/documentType");
146:
147: DocumentTypesDocument documentTypesDocument = (DocumentTypesDocument) httpClient
148: .executeMethod(method, DocumentTypesDocument.class,
149: true);
150: DocumentTypesDocument.DocumentTypes documentTypesElement = documentTypesDocument
151: .getDocumentTypes();
152:
153: List<DocumentTypeDocument.DocumentType> documentTypesXml = documentTypesElement
154: .getDocumentTypeList();
155: List<DocumentTypeImpl> documentTypes = new ArrayList<DocumentTypeImpl>(
156: documentTypesXml.size());
157: for (DocumentTypeDocument.DocumentType documentTypeXml : documentTypesXml) {
158: DocumentTypeImpl documentType = instantiateDocumentTypeFromXml(
159: documentTypeXml, user);
160: documentTypes.add(documentType);
161: }
162: return documentTypes;
163: }
164:
165: private DocumentTypeImpl instantiateDocumentTypeFromXml(
166: DocumentTypeDocument.DocumentType documentTypeXml,
167: AuthenticatedUser user) {
168: DocumentTypeImpl documentType = new DocumentTypeImpl(
169: documentTypeXml.getName(), this , context
170: .getCommonRepository(), user);
171: DocumentTypeImpl.IntimateAccess documentTypeInt = documentType
172: .getIntimateAccess(this );
173: documentType.setAllFromXml(documentTypeXml);
174: documentTypeInt.setLastModified(documentTypeXml
175: .getLastModified().getTime());
176: documentTypeInt.setLastModifier(documentTypeXml
177: .getLastModifier());
178: documentTypeInt.setId(documentTypeXml.getId());
179: documentTypeInt
180: .setUpdateCount(documentTypeXml.getUpdateCount());
181: return documentType;
182: }
183:
184: public PartTypeImpl getPartTypeById(long id, AuthenticatedUser user)
185: throws RepositoryException {
186: DaisyHttpClient httpClient = getClient(user);
187: HttpMethod method = new GetMethod(
188: "/repository/schema/partType/" + id);
189:
190: PartTypeDocument partTypeDocument = (PartTypeDocument) httpClient
191: .executeMethod(method, PartTypeDocument.class, true);
192: PartTypeDocument.PartType partTypeXml = partTypeDocument
193: .getPartType();
194: PartTypeImpl partType = instantiatePartTypeFromXml(partTypeXml,
195: user);
196: return partType;
197: }
198:
199: public PartTypeImpl getPartTypeByName(String name,
200: AuthenticatedUser user) throws RepositoryException {
201: DaisyHttpClient httpClient = getClient(user);
202: String encodedName = encodeNameForUseInPath("part type", name);
203: HttpMethod method = new GetMethod(
204: "/repository/schema/partTypeByName/" + encodedName);
205:
206: PartTypeDocument partTypeDocument = (PartTypeDocument) httpClient
207: .executeMethod(method, PartTypeDocument.class, true);
208: PartTypeDocument.PartType partTypeXml = partTypeDocument
209: .getPartType();
210: PartTypeImpl partType = instantiatePartTypeFromXml(partTypeXml,
211: user);
212: return partType;
213: }
214:
215: public void store(PartTypeImpl partType) throws RepositoryException {
216: PartTypeImpl.IntimateAccess partTypeInt = partType
217: .getIntimateAccess(this );
218: DaisyHttpClient httpClient = getClient(partTypeInt
219: .getCurrentModifier());
220:
221: String url = "/repository";
222: boolean isNew = partType.getId() == -1;
223: if (isNew)
224: url += "/schema/partType";
225: else
226: url += "/schema/partType/" + partType.getId();
227:
228: PostMethod method = new PostMethod(url);
229: method.setRequestEntity(new InputStreamRequestEntity(partType
230: .getXml().newInputStream()));
231:
232: PartTypeDocument partTypeDocument = (PartTypeDocument) httpClient
233: .executeMethod(method, PartTypeDocument.class, true);
234: PartTypeDocument.PartType partTypeXml = partTypeDocument
235: .getPartType();
236: partTypeInt.setId(partTypeXml.getId());
237: partTypeInt.setLastModified(partTypeXml.getLastModified()
238: .getTime());
239: partTypeInt.setLastModifier(partTypeXml.getLastModifier());
240: partTypeInt.setUpdateCount(partTypeXml.getUpdateCount());
241:
242: if (isNew)
243: context.getCommonRepositorySchema().fireSchemaEvent(
244: RepositorySchemaEventType.PART_TYPE_CREATED,
245: partType.getId(), partType.getUpdateCount());
246: else
247: context.getCommonRepositorySchema().fireSchemaEvent(
248: RepositorySchemaEventType.PART_TYPE_UPDATED,
249: partType.getId(), partType.getUpdateCount());
250: }
251:
252: public void deletePartType(long partTypeId, AuthenticatedUser user)
253: throws RepositoryException {
254: DaisyHttpClient httpClient = getClient(user);
255:
256: String url = "/repository/schema/partType/" + partTypeId;
257:
258: DeleteMethod method = new DeleteMethod(url);
259:
260: httpClient.executeMethod(method, null, true);
261: context.getCommonRepositorySchema().fireSchemaEvent(
262: RepositorySchemaEventType.PART_TYPE_DELETED,
263: partTypeId, -1);
264: }
265:
266: public Collection<PartTypeImpl> getAllPartTypes(
267: AuthenticatedUser user) throws RepositoryException {
268: DaisyHttpClient httpClient = getClient(user);
269: HttpMethod method = new GetMethod("/repository/schema/partType");
270:
271: PartTypesDocument partTypesDocument = (PartTypesDocument) httpClient
272: .executeMethod(method, PartTypesDocument.class, true);
273: PartTypesDocument.PartTypes partTypesElement = partTypesDocument
274: .getPartTypes();
275: List<PartTypeDocument.PartType> partTypesXml = partTypesElement
276: .getPartTypeList();
277: List<PartTypeImpl> partTypes = new ArrayList<PartTypeImpl>(
278: partTypesXml.size());
279: for (PartTypeDocument.PartType partTypeXml : partTypesXml) {
280: PartTypeImpl partType = instantiatePartTypeFromXml(
281: partTypeXml, user);
282: partTypes.add(partType);
283: }
284: return partTypes;
285: }
286:
287: private PartTypeImpl instantiatePartTypeFromXml(
288: PartTypeDocument.PartType partTypeXml,
289: AuthenticatedUser user) {
290: PartTypeImpl partType = new PartTypeImpl(partTypeXml.getName(),
291: partTypeXml.getMimeTypes(), this , user);
292: PartTypeImpl.IntimateAccess partTypeInt = partType
293: .getIntimateAccess(this );
294: partType.setAllFromXml(partTypeXml);
295: partTypeInt.setId(partTypeXml.getId());
296: partTypeInt.setLastModified(partTypeXml.getLastModified()
297: .getTime());
298: partTypeInt.setLastModifier(partTypeXml.getLastModifier());
299: partTypeInt.setUpdateCount(partTypeXml.getUpdateCount());
300: return partType;
301: }
302:
303: public FieldTypeImpl getFieldTypeById(long id,
304: AuthenticatedUser user) throws RepositoryException {
305: DaisyHttpClient httpClient = getClient(user);
306: HttpMethod method = new GetMethod(
307: "/repository/schema/fieldType/" + id);
308:
309: FieldTypeDocument fieldTypeDocument = (FieldTypeDocument) httpClient
310: .executeMethod(method, FieldTypeDocument.class, true);
311: FieldTypeDocument.FieldType fieldTypeXml = fieldTypeDocument
312: .getFieldType();
313: FieldTypeImpl fieldType = instantiateFieldTypeFromXml(
314: fieldTypeXml, user);
315: return fieldType;
316: }
317:
318: public FieldTypeImpl getFieldTypeByName(String name,
319: AuthenticatedUser user) throws RepositoryException {
320: DaisyHttpClient httpClient = getClient(user);
321: String encodedName = encodeNameForUseInPath("field type", name);
322: HttpMethod method = new GetMethod(
323: "/repository/schema/fieldTypeByName/" + encodedName);
324:
325: FieldTypeDocument fieldTypeDocument = (FieldTypeDocument) httpClient
326: .executeMethod(method, FieldTypeDocument.class, true);
327: FieldTypeDocument.FieldType fieldTypeXml = fieldTypeDocument
328: .getFieldType();
329: FieldTypeImpl fieldType = instantiateFieldTypeFromXml(
330: fieldTypeXml, user);
331: return fieldType;
332: }
333:
334: public void store(FieldTypeImpl fieldType)
335: throws RepositoryException {
336: FieldTypeImpl.IntimateAccess fieldTypeInt = fieldType
337: .getIntimateAccess(this );
338: DaisyHttpClient httpClient = getClient(fieldTypeInt
339: .getCurrentModifier());
340:
341: String url = "/repository";
342: boolean isNew = fieldType.getId() == -1;
343: if (isNew)
344: url += "/schema/fieldType";
345: else
346: url += "/schema/fieldType/" + fieldType.getId();
347:
348: PostMethod method = new PostMethod(url);
349: method.setRequestEntity(new InputStreamRequestEntity(fieldType
350: .getXml().newInputStream()));
351:
352: FieldTypeDocument fieldTypeDocument = (FieldTypeDocument) httpClient
353: .executeMethod(method, FieldTypeDocument.class, true);
354: FieldTypeDocument.FieldType fieldTypeXml = fieldTypeDocument
355: .getFieldType();
356: fieldTypeInt.setId(fieldTypeXml.getId());
357: fieldTypeInt.setLastModified(fieldTypeXml.getLastModified()
358: .getTime());
359: fieldTypeInt.setLastModifier(fieldTypeXml.getLastModifier());
360: fieldTypeInt.setUpdateCount(fieldTypeXml.getUpdateCount());
361:
362: if (isNew)
363: context.getCommonRepositorySchema().fireSchemaEvent(
364: RepositorySchemaEventType.FIELD_TYPE_CREATED,
365: fieldType.getId(), fieldType.getUpdateCount());
366: else
367: context.getCommonRepositorySchema().fireSchemaEvent(
368: RepositorySchemaEventType.FIELD_TYPE_UPDATED,
369: fieldType.getId(), fieldType.getUpdateCount());
370: }
371:
372: public void deleteFieldType(long fieldTypeId, AuthenticatedUser user)
373: throws RepositoryException {
374: DaisyHttpClient httpClient = getClient(user);
375:
376: String url = "/repository/schema/fieldType/" + fieldTypeId;
377:
378: DeleteMethod method = new DeleteMethod(url);
379: httpClient.executeMethod(method, null, true);
380: context.getCommonRepositorySchema().fireSchemaEvent(
381: RepositorySchemaEventType.FIELD_TYPE_DELETED,
382: fieldTypeId, -1);
383: }
384:
385: public Collection<FieldTypeImpl> getAllFieldTypes(
386: AuthenticatedUser user) throws RepositoryException {
387: DaisyHttpClient httpClient = getClient(user);
388: HttpMethod method = new GetMethod(
389: "/repository/schema/fieldType");
390:
391: FieldTypesDocument fieldTypesDocument = (FieldTypesDocument) httpClient
392: .executeMethod(method, FieldTypesDocument.class, true);
393: FieldTypesDocument.FieldTypes fieldTypesElement = fieldTypesDocument
394: .getFieldTypes();
395: List<FieldTypeDocument.FieldType> fieldTypesXml = fieldTypesElement
396: .getFieldTypeList();
397: List<FieldTypeImpl> fieldTypes = new ArrayList<FieldTypeImpl>(
398: fieldTypesXml.size());
399: for (FieldTypeDocument.FieldType fieldTypeXml : fieldTypesXml) {
400: FieldTypeImpl partType = instantiateFieldTypeFromXml(
401: fieldTypeXml, user);
402: fieldTypes.add(partType);
403: }
404: return fieldTypes;
405: }
406:
407: private FieldTypeImpl instantiateFieldTypeFromXml(
408: FieldTypeDocument.FieldType fieldTypeXml,
409: AuthenticatedUser user) {
410: FieldTypeImpl fieldType = new FieldTypeImpl(fieldTypeXml
411: .getName(), ValueType.fromString(fieldTypeXml
412: .getValueType()), fieldTypeXml.getMultiValue(),
413: fieldTypeXml.getHierarchical(), this , user);
414: FieldTypeImpl.IntimateAccess fieldTypeInt = fieldType
415: .getIntimateAccess(this );
416: fieldType.setAllFromXml(fieldTypeXml);
417: fieldTypeInt.setId(fieldTypeXml.getId());
418: fieldTypeInt.setLastModified(fieldTypeXml.getLastModified()
419: .getTime());
420: fieldTypeInt.setLastModifier(fieldTypeXml.getLastModifier());
421: fieldTypeInt.setUpdateCount(fieldTypeXml.getUpdateCount());
422: return fieldType;
423: }
424:
425: public LinkExtractorInfos getLinkExtractors(AuthenticatedUser user)
426: throws RepositoryException {
427: DaisyHttpClient httpClient = getClient(user);
428: HttpMethod method = new GetMethod("/repository/linkExtractors");
429:
430: LinkExtractorsDocument linkExtractorsDocument = (LinkExtractorsDocument) httpClient
431: .executeMethod(method, LinkExtractorsDocument.class,
432: true);
433: List<LinkExtractorDocument.LinkExtractor> linkExtractorsXml = linkExtractorsDocument
434: .getLinkExtractors().getLinkExtractorList();
435: LinkExtractorInfo[] linkExtractorInfos = new LinkExtractorInfo[linkExtractorsXml
436: .size()];
437: for (int i = 0; i < linkExtractorsXml.size(); i++) {
438: linkExtractorInfos[i] = new LinkExtractorInfoImpl(
439: linkExtractorsXml.get(i).getName(),
440: linkExtractorsXml.get(i).getDescription());
441: }
442: return new LinkExtractorInfosImpl(linkExtractorInfos);
443: }
444:
445: public ExpSelectionListDocument getExpandedSelectionListData(
446: long fieldTypeId, long branchId, long languageId,
447: Locale locale, AuthenticatedUser user)
448: throws RepositoryException {
449: DaisyHttpClient httpClient = getClient(user);
450: HttpMethod method = new GetMethod(
451: "/repository/schema/fieldType/" + fieldTypeId
452: + "/selectionListData");
453:
454: List<NameValuePair> queryString = new ArrayList<NameValuePair>();
455: if (branchId != -1)
456: queryString.add(new NameValuePair("branch", String
457: .valueOf(branchId)));
458: if (languageId != -1)
459: queryString.add(new NameValuePair("language", String
460: .valueOf(languageId)));
461: queryString.add(new NameValuePair("locale", LocaleHelper
462: .getString(locale)));
463:
464: method
465: .setQueryString(queryString
466: .toArray(new NameValuePair[0]));
467:
468: return (ExpSelectionListDocument) httpClient.executeMethod(
469: method, ExpSelectionListDocument.class, true);
470: }
471: }
|