| /******************************************************************************* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| *******************************************************************************/ |
| package org.ofbiz.datafile; |
| |
| |
| import java.io.IOException; |
| import java.net.URL; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Map; |
| |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| import org.ofbiz.base.util.Debug; |
| import org.ofbiz.base.util.UtilTimer; |
| import org.ofbiz.base.util.UtilValidate; |
| import org.ofbiz.base.util.UtilXml; |
| import org.ofbiz.base.util.cache.UtilCache; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.SAXException; |
| |
| |
| /** |
| * Flat File definition reader |
| */ |
| |
| public class ModelDataFileReader { |
| |
| public static final String module = ModelDataFileReader.class.getName(); |
| |
| public static UtilCache<URL, ModelDataFileReader> readers = UtilCache.createUtilCache("ModelDataFile", 0, 0); |
| |
| public URL readerURL = null; |
| public Map<String, ModelDataFile> modelDataFiles = null; |
| |
| public static ModelDataFileReader getModelDataFileReader(URL readerURL) { |
| ModelDataFileReader reader = null; |
| |
| reader = readers.get(readerURL); |
| if (reader == null) { // don't want to block here |
| synchronized (ModelDataFileReader.class) { |
| // must check if null again as one of the blocked threads can still enter |
| reader = readers.get(readerURL); |
| if (reader == null) { |
| if (Debug.infoOn()) Debug.logInfo("[ModelDataFileReader.getModelDataFileReader] : creating reader.", module); |
| reader = new ModelDataFileReader(readerURL); |
| readers.put(readerURL, reader); |
| } |
| } |
| } |
| if (reader != null && UtilValidate.isEmpty(reader.modelDataFiles)) { |
| readers.remove(readerURL); |
| return null; |
| } |
| if (Debug.infoOn()) Debug.logInfo("[ModelDataFileReader.getModelDataFileReader] : returning reader.", module); |
| return reader; |
| } |
| |
| public ModelDataFileReader(URL readerURL) { |
| this.readerURL = readerURL; |
| |
| // preload models... |
| getModelDataFiles(); |
| } |
| |
| public Map<String, ModelDataFile> getModelDataFiles() { |
| if (modelDataFiles == null) { // don't want to block here |
| synchronized (ModelDataFileReader.class) { |
| // must check if null again as one of the blocked threads can still enter |
| if (modelDataFiles == null) { // now it's safe |
| modelDataFiles = new HashMap<String, ModelDataFile>(); |
| |
| UtilTimer utilTimer = new UtilTimer(); |
| |
| utilTimer.timerString("Before getDocument in file " + readerURL); |
| Document document = getDocument(readerURL); |
| |
| if (document == null) { |
| modelDataFiles = null; |
| return null; |
| } |
| |
| utilTimer.timerString("Before getDocumentElement in file " + readerURL); |
| Element docElement = document.getDocumentElement(); |
| |
| if (docElement == null) { |
| modelDataFiles = null; |
| return null; |
| } |
| docElement.normalize(); |
| Node curChild = docElement.getFirstChild(); |
| |
| int i = 0; |
| |
| if (curChild != null) { |
| utilTimer.timerString("Before start of dataFile loop in file " + readerURL); |
| do { |
| if (curChild.getNodeType() == Node.ELEMENT_NODE && "data-file".equals(curChild.getNodeName())) { |
| i++; |
| Element curDataFile = (Element) curChild; |
| String dataFileName = UtilXml.checkEmpty(curDataFile.getAttribute("name")); |
| |
| // check to see if dataFile with same name has already been read |
| if (modelDataFiles.containsKey(dataFileName)) { |
| Debug.logWarning("WARNING: DataFile " + dataFileName + |
| " is defined more than once, most recent will over-write previous definition(s)", module); |
| } |
| |
| // utilTimer.timerString(" After dataFileName -- " + i + " --"); |
| ModelDataFile dataFile = createModelDataFile(curDataFile); |
| |
| // utilTimer.timerString(" After createModelDataFile -- " + i + " --"); |
| if (dataFile != null) { |
| modelDataFiles.put(dataFileName, dataFile); |
| // utilTimer.timerString(" After modelDataFiles.put -- " + i + " --"); |
| if (Debug.infoOn()) Debug.logInfo("-- getModelDataFile: #" + i + " Loaded dataFile: " + dataFileName, module); |
| } else |
| Debug.logWarning("-- -- SERVICE ERROR:getModelDataFile: Could not create dataFile for dataFileName: " + dataFileName, module); |
| |
| } |
| } while ((curChild = curChild.getNextSibling()) != null); |
| } else { |
| Debug.logWarning("No child nodes found.", module); |
| } |
| utilTimer.timerString("Finished file " + readerURL + " - Total Flat File Defs: " + i + " FINISHED"); |
| } |
| } |
| } |
| return modelDataFiles; |
| } |
| |
| /** Gets an DataFile object based on a definition from the specified XML DataFile descriptor file. |
| * @param dataFileName The dataFileName of the DataFile definition to use. |
| * @return An DataFile object describing the specified dataFile of the specified descriptor file. |
| */ |
| public ModelDataFile getModelDataFile(String dataFileName) { |
| Map<String, ModelDataFile> ec = getModelDataFiles(); |
| |
| if (ec != null) { |
| return ec.get(dataFileName); |
| } else { |
| return null; |
| } |
| } |
| |
| /** Creates a Iterator with the dataFileName of each DataFile defined in the specified XML DataFile Descriptor file. |
| * @return A Iterator of dataFileName Strings |
| */ |
| public Iterator<String> getDataFileNamesIterator() { |
| Collection<String> collection = getDataFileNames(); |
| |
| if (collection != null) { |
| return collection.iterator(); |
| } else { |
| return null; |
| } |
| } |
| |
| /** Creates a Collection with the dataFileName of each DataFile defined in the specified XML DataFile Descriptor file. |
| * @return A Collection of dataFileName Strings |
| */ |
| public Collection<String> getDataFileNames() { |
| Map<String, ModelDataFile> ec = getModelDataFiles(); |
| |
| return ec.keySet(); |
| } |
| |
| protected ModelDataFile createModelDataFile(Element dataFileElement) { |
| ModelDataFile dataFile = new ModelDataFile(); |
| String tempStr; |
| |
| dataFile.name = UtilXml.checkEmpty(dataFileElement.getAttribute("name")); |
| dataFile.typeCode = UtilXml.checkEmpty(dataFileElement.getAttribute("type-code")); |
| dataFile.sender = UtilXml.checkEmpty(dataFileElement.getAttribute("sender")); |
| dataFile.receiver = UtilXml.checkEmpty(dataFileElement.getAttribute("receiver")); |
| |
| tempStr = UtilXml.checkEmpty(dataFileElement.getAttribute("record-length")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| dataFile.recordLength = Integer.parseInt(tempStr); |
| } |
| tempStr = UtilXml.checkEmpty(dataFileElement.getAttribute("delimiter")); |
| if (tempStr != null && tempStr.length() == 1) { |
| dataFile.delimiter = tempStr.charAt(0); |
| } |
| |
| tempStr = UtilXml.checkEmpty(dataFileElement.getAttribute("text-delimiter")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| dataFile.textDelimiter = tempStr; |
| } |
| |
| dataFile.separatorStyle = UtilXml.checkEmpty(dataFileElement.getAttribute("separator-style")); |
| dataFile.description = UtilXml.checkEmpty(dataFileElement.getAttribute("description")); |
| |
| NodeList rList = dataFileElement.getElementsByTagName("record"); |
| |
| for (int i = 0; i < rList.getLength(); i++) { |
| Element recordElement = (Element) rList.item(i); |
| ModelRecord modelRecord = createModelRecord(recordElement); |
| |
| if (modelRecord != null) { |
| dataFile.records.add(modelRecord); |
| } else { |
| Debug.logWarning("[ModelDataFileReader.createModelDataFile] Weird, modelRecord was null", module); |
| } |
| } |
| |
| for (ModelRecord modelRecord: dataFile.records) { |
| |
| if (modelRecord.parentName.length() > 0) { |
| ModelRecord parentRecord = dataFile.getModelRecord(modelRecord.parentName); |
| |
| if (parentRecord != null) { |
| parentRecord.childRecords.add(modelRecord); |
| modelRecord.parentRecord = parentRecord; |
| } else { |
| Debug.logError("[ModelDataFileReader.createModelDataFile] ERROR: Could not find parentRecord with name " + modelRecord.parentName, module); |
| } |
| } |
| } |
| |
| return dataFile; |
| } |
| |
| protected ModelRecord createModelRecord(Element recordElement) { |
| ModelRecord record = new ModelRecord(); |
| String tempStr; |
| |
| record.name = UtilXml.checkEmpty(recordElement.getAttribute("name")); |
| record.typeCode = UtilXml.checkEmpty(recordElement.getAttribute("type-code")); |
| |
| record.tcMin = UtilXml.checkEmpty(recordElement.getAttribute("tc-min")); |
| if (record.tcMin.length() > 0) record.tcMinNum = Long.parseLong(record.tcMin); |
| record.tcMax = UtilXml.checkEmpty(recordElement.getAttribute("tc-max")); |
| if (record.tcMax.length() > 0) record.tcMaxNum = Long.parseLong(record.tcMax); |
| |
| tempStr = UtilXml.checkEmpty(recordElement.getAttribute("tc-isnum")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| record.tcIsNum = Boolean.parseBoolean(tempStr); |
| } |
| |
| tempStr = UtilXml.checkEmpty(recordElement.getAttribute("tc-position")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| record.tcPosition = Integer.parseInt(tempStr); |
| } |
| tempStr = UtilXml.checkEmpty(recordElement.getAttribute("tc-length")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| record.tcLength = Integer.parseInt(tempStr); |
| } |
| |
| record.description = UtilXml.checkEmpty(recordElement.getAttribute("description")); |
| record.parentName = UtilXml.checkEmpty(recordElement.getAttribute("parent-name")); |
| record.limit = UtilXml.checkEmpty(recordElement.getAttribute("limit")); |
| |
| NodeList fList = recordElement.getElementsByTagName("field"); |
| int priorEnd = -1; |
| |
| for (int i = 0; i < fList.getLength(); i++) { |
| Element fieldElement = (Element) fList.item(i); |
| ModelField modelField = createModelField(fieldElement); |
| |
| // if the position is not specified, assume the start position based on last entry |
| if ((i > 0) && (modelField.position == -1)) { |
| modelField.position = priorEnd; |
| } |
| priorEnd = modelField.position + modelField.length; |
| |
| if (modelField != null) { |
| record.fields.add(modelField); |
| } else { |
| Debug.logWarning("[ModelDataFileReader.createModelRecord] Weird, modelField was null", module); |
| } |
| } |
| |
| return record; |
| } |
| |
| protected ModelField createModelField(Element fieldElement) { |
| ModelField field = new ModelField(); |
| String tempStr; |
| |
| field.name = UtilXml.checkEmpty(fieldElement.getAttribute("name")); |
| |
| tempStr = UtilXml.checkEmpty(fieldElement.getAttribute("position")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| field.position = Integer.parseInt(tempStr); |
| } |
| tempStr = UtilXml.checkEmpty(fieldElement.getAttribute("length")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| field.length = Integer.parseInt(tempStr); |
| } |
| |
| field.type = UtilXml.checkEmpty(fieldElement.getAttribute("type")); |
| field.format = UtilXml.checkEmpty(fieldElement.getAttribute("format")); |
| field.validExp = UtilXml.checkEmpty(fieldElement.getAttribute("valid-exp")); |
| field.description = UtilXml.checkEmpty(fieldElement.getAttribute("description")); |
| field.defaultValue = UtilXml.checkEmpty(fieldElement.getAttribute("default-value")); |
| field.refField = UtilXml.checkEmpty(fieldElement.getAttribute("ref-field")); |
| |
| tempStr = UtilXml.checkEmpty(fieldElement.getAttribute("prim-key")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| field.isPk = Boolean.parseBoolean(tempStr); |
| } |
| |
| tempStr = UtilXml.checkEmpty(fieldElement.getAttribute("ignored")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| field.ignored = Boolean.parseBoolean(tempStr); |
| } |
| |
| tempStr = UtilXml.checkEmpty(fieldElement.getAttribute("expression")); |
| if (UtilValidate.isNotEmpty(tempStr)) { |
| field.expression = Boolean.parseBoolean(tempStr); |
| } |
| |
| return field; |
| } |
| |
| protected Document getDocument(URL url) { |
| if (url == null) |
| return null; |
| Document document = null; |
| |
| try { |
| document = UtilXml.readXmlDocument(url); |
| } catch (SAXException sxe) { |
| // Error generated during parsing) |
| Exception x = sxe; |
| |
| if (sxe.getException() != null) { |
| x = sxe.getException(); |
| } |
| x.printStackTrace(); |
| } catch (ParserConfigurationException pce) { |
| // Parser with specified options can't be built |
| pce.printStackTrace(); |
| } catch (IOException ioe) { |
| ioe.printStackTrace(); |
| } |
| |
| return document; |
| } |
| } |
| |
