001: /*********************************************************************************
002: * The contents of this file are subject to the OpenI Public License Version 1.0
003: * ("License"); You may not use this file except in compliance with the
004: * License. You may obtain a copy of the License at
005: * http://www.openi.org/docs/LICENSE.txt
006: *
007: * Software distributed under the License is distributed on an "AS IS" basis,
008: * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
009: * the specific language governing rights and limitations under the License.
010: *
011: * The Original Code is: OpenI Open Source
012: *
013: * The Initial Developer of the Original Code is Loyalty Matrix, Inc.
014: * Portions created by Loyalty Matrix, Inc. are
015: * Copyright (C) 2005 Loyalty Matrix, Inc.; All Rights Reserved.
016: *
017: *
018: ********************************************************************************/package org.openi.feeds.client;
019:
020: import java.io.File;
021: import java.util.ArrayList;
022: import java.util.HashMap;
023: import java.util.Iterator;
024: import java.util.List;
025: import java.util.Map;
026:
027: import org.apache.log4j.Logger;
028: import org.openi.feeds.FeedsMetaData;
029: import org.openi.feeds.FeedsUtil;
030: import org.openi.feeds.MetaDataReader;
031: import org.openi.feeds.ParseException;
032: import org.openi.project.DirectoryLister;
033: import org.openi.project.ProjectContext;
034: import org.openi.util.FileItem;
035: import org.openi.util.Folder;
036: import org.openi.util.FolderVisitor;
037:
038: /**
039: * @author Dipendra Pokhrel <br>
040: *
041: * FeedsMetaData local client facade
042: *
043: */
044: class FeedsServiceLocalClient implements FeedsService {
045: private static Logger logger = Logger
046: .getLogger(FeedsServiceLocalClient.class);
047:
048: ProjectContext projectContext;
049:
050: FeedsServiceLocalClient(ProjectContext projectContext) {
051: this .projectContext = projectContext;
052: }
053:
054: public Folder listFolders(String extensions)
055: throws FeedsServiceException {
056: try {
057: return getLocalFolderList(extensions);
058: } catch (Exception e) {
059: throw new FeedsServiceException(e);
060: }
061: }
062:
063: public Folder listFolders(String dir, boolean foldersOnly,
064: String pattern) throws FeedsServiceException {
065: throw new FeedsServiceException(
066: new UnsupportedOperationException(
067: "Method is not implemented"));
068: }
069:
070: public List listMetaData(String path) throws FeedsServiceException {
071: try {
072: return getLocalFeedsMetaDataList(path);
073: } catch (Exception e) {
074: throw new FeedsServiceException(e);
075: }
076: }
077:
078: public FeedsMetaData parse(String path, FeedsMetaData metaData)
079: throws FeedsServiceException {
080: File file = new File(projectContext
081: .resolvePathWithProjectDir(path));
082: if (file.exists() && file.isFile()) {
083: if (metaData == null) {
084: throw new FeedsServiceException(
085: new IllegalArgumentException("metaData is null"));
086: }
087: try {
088: MetaDataReader.readMetaData(file, metaData, true);
089: metaData.getAttributes().put("path", path);
090: } catch (ParseException e) {
091: throw new FeedsServiceException(
092: "An error occured while parsing feed :'" + path
093: + "'", e);
094: }
095: try {
096: FeedsUtil.persistMetaData(file.getAbsolutePath(),
097: metaData);
098: } catch (Exception e) {
099: throw new FeedsServiceException(
100: "An error occured while persisting feed metadata:'"
101: + path + "'", e);
102: }
103: } else {
104: throw new FeedsServiceException("'" + path + "' is invalid");
105: }
106: return metaData;
107: }
108:
109: public FeedsMetaData reparse(String path)
110: throws FeedsServiceException {
111: String feedPath = projectContext
112: .resolvePathWithProjectDir(path);
113: FeedsMetaData metadata = null;
114: try {
115: metadata = FeedsUtil.restoreMetaData(feedPath);
116: } catch (Exception e) {
117: throw new FeedsServiceException(
118: "An error occured while restring metadata:'"
119: + feedPath + "'", e);
120: }
121: return parse(path, metadata);
122: }
123:
124: private List getLocalFeedsMetaDataList(String path)
125: throws Exception {
126: List metaDatas = new ArrayList();
127: List modules = projectContext.getProjectModules(true, true);
128: Folder folder;
129: folder = DirectoryLister.buildFolderList(projectContext
130: .getProjectDirectory(), modules, false);
131:
132: FeedsMetaDataVisitor visitor = new FeedsMetaDataVisitor(path);
133: folder.accept(visitor);
134:
135: int projectDirPathLen = new File(projectContext
136: .getProjectDirectory()).getCanonicalPath().length();
137:
138: for (Iterator iter = visitor.getMetaDataList().iterator(); iter
139: .hasNext();) {
140: String metaDataFilePath = (String) iter.next();
141: try {
142: File metaDataFile = new File(projectContext
143: .resolvePathWithProjectDir(metaDataFilePath));
144: metaDataFilePath = metaDataFile.getCanonicalPath();
145: } catch (Throwable t) {
146: logger.error("path error!! feed :" + metaDataFilePath,
147: t);
148: continue;
149: }
150: //override path since path can be invalid if file has been moved
151: if (metaDataFilePath.endsWith(".metadata"))
152: metaDataFilePath = metaDataFilePath.substring(0,
153: metaDataFilePath.length()
154: - ".metadata".length());
155: FeedsMetaData metaData = null;
156: try {
157: metaData = FeedsUtil.restoreMetaData(metaDataFilePath);
158: } catch (Throwable t) {
159: logger.error("error occured while restoring MetaData :"
160: + metaDataFilePath, t);
161: continue;
162: }
163: String relativePath = metaDataFilePath
164: .substring(projectDirPathLen);
165: Map attr = metaData.getAttributes();
166: if (attr == null) {
167: attr = new HashMap();
168: metaData.setAttributes(attr);
169: }
170: attr.put("path", relativePath.replace('\\', '/'));
171:
172: metaDatas.add(metaData);
173: }
174:
175: return metaDatas;
176: }
177:
178: private Folder getLocalFolderList(String extensions)
179: throws Exception {
180: List modules = projectContext.getProjectModules(true, true);
181: Folder folder;
182: folder = DirectoryLister.buildFolderList(projectContext
183: .getProjectDirectory(), modules, false);
184: filterFolder(folder, extensions);
185: return folder;
186: }
187:
188: private void filterFolder(Folder folder, String extensions) {
189: if (folder == null || folder.getChildren() == null
190: && folder.getChildren().size() == 0)
191: return;
192:
193: List deleted = new ArrayList();
194: for (Iterator iter = folder.getChildren().iterator(); iter
195: .hasNext();) {
196: Object item = iter.next();
197: if (item instanceof FileItem) {
198: FileItem fitem = (FileItem) item;
199: String url = fitem.getPath().replace('\\', '/');
200: fitem.setPath(url);
201: if (!isFileSupported(fitem.getPath(), extensions)) {
202: deleted.add(fitem);
203: }
204:
205: } else if (item instanceof Folder) {
206: Folder fdr = (Folder) item;
207: if (fdr.getChildren() == null
208: || fdr.getChildren().size() == 0)
209: deleted.add(item);
210: else
211: filterFolder((Folder) item, extensions);
212: }
213: }
214:
215: for (Iterator iter = deleted.iterator(); iter.hasNext();) {
216: folder.getChildren().remove(iter.next());
217: }
218: }
219:
220: private boolean isFileSupported(String name, String extensions) {
221: if (name.lastIndexOf(".") == -1)
222: return false;
223: String ext = name.substring(name.lastIndexOf("."));
224: return extensions.indexOf(ext.toLowerCase()) != -1 ? true
225: : false;
226: }
227:
228: class FeedsMetaDataVisitor implements FolderVisitor {
229: List metaDataList = new ArrayList();
230: String root;
231:
232: FeedsMetaDataVisitor(String root) {
233: this .root = root;
234: if ("".equals(this .root))
235: this .root = null;
236: if (this .root != null) {
237: this .root = this .root.replace('\\', '/');
238: if (!this .root.startsWith("/"))
239: this .root = "/" + this .root;
240: }
241: }
242:
243: public void visit(Folder folder) {
244: // TODO Auto-generated method stub
245:
246: }
247:
248: public void visit(FileItem file) {
249: if (file.getPath().endsWith(".metadata")) {
250: if (root != null) {
251: String url = file.getPath().replace('\\', '/');
252: if (!url.startsWith(root))
253: return;
254: }
255: metaDataList.add(file.getPath().replace('\\', '/'));
256: }
257:
258: }
259:
260: public List getMetaDataList() {
261: return this.metaDataList;
262: }
263: }
264:
265: }
|