/*******************************************************************************
* 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.apache.ofbiz.datafile;
import java.net.URL;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.base.util.UtilXml;
import org.apache.ofbiz.base.util.cache.UtilCache;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
/**
* Flat File definition reader
*/
public final class ModelDataFileReader {
public static final String module = ModelDataFileReader.class.getName();
private static final UtilCache<URL, ModelDataFileReader> readers = UtilCache.createUtilCache("ModelDataFile", true);
public static ModelDataFileReader getModelDataFileReader(URL readerURL) throws DataFileException {
ModelDataFileReader reader = readers.get(readerURL);
if (reader == null) {
if (Debug.infoOn())
Debug.logInfo("[ModelDataFileReader.getModelDataFileReader] : creating reader for " + readerURL, module);
reader = new ModelDataFileReader(readerURL);
readers.putIfAbsent(readerURL, reader);
}
if (Debug.infoOn())
Debug.logInfo("[ModelDataFileReader.getModelDataFileReader] : returning reader for " + readerURL, module);
return reader;
}
private final URL readerURL;
private final Map<String, ModelDataFile> modelDataFiles;
public ModelDataFileReader(URL readerURL) throws DataFileException {
this.readerURL = readerURL;
this.modelDataFiles = Collections.unmodifiableMap(createModelDataFiles());
}
private 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;
}
private Map<String, ModelDataFile> createModelDataFiles() throws DataFileException {
Document document = null;
Element docElement = null;
try {
document = UtilXml.readXmlDocument(this.readerURL);
} catch (Exception e) {
Debug.logWarning(e, "Error while reading " + this.readerURL + ": ", module);
throw new DataFileException("Error while reading " + this.readerURL, e);
}
if (document != null) {
docElement = document.getDocumentElement();
}
if (docElement == null) {
Debug.logWarning("Document element not found in " + this.readerURL, module);
throw new DataFileException("Document element not found in " + this.readerURL);
}
docElement.normalize();
List<? extends Element> dataFileElements = UtilXml.childElementList(docElement, "data-file");
if (dataFileElements.size() == 0) {
Debug.logWarning("No <data-file> elements found in " + this.readerURL, module);
throw new DataFileException("No <data-file> elements found in " + this.readerURL);
}
Map<String, ModelDataFile> result = new HashMap<String, ModelDataFile>();
for (Element curDataFile : dataFileElements) {
String dataFileName = UtilXml.checkEmpty(curDataFile.getAttribute("name"));
if (result.containsKey(dataFileName)) {
Debug.logWarning("DataFile " + dataFileName + " is defined more than once, most recent will over-write previous definition(s)", module);
}
ModelDataFile dataFile = createModelDataFile(curDataFile);
if (dataFile != null) {
result.put(dataFileName, dataFile);
if (Debug.verboseOn()) {
Debug.logVerbose("Loaded dataFile: " + dataFileName, module);
}
} else {
Debug.logWarning("Could not create dataFile for dataFileName " + dataFileName, module);
throw new DataFileException("Could not create dataFile for " + dataFileName + " defined in " + this.readerURL);
}
}
return result;
}
private 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;
}
private 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;
record.fields.add(modelField);
}
return record;
}
/**
* 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() {
return this.modelDataFiles.keySet();
}
/**
* 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() {
return this.modelDataFiles.keySet().iterator();
}
/**
* 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) {
return this.modelDataFiles.get(dataFileName);
}
public Map<String, ModelDataFile> getModelDataFiles() {
return this.modelDataFiles;
}
}