| /******************************************************************************* |
| * 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.io.Serializable; |
| import java.text.NumberFormat; |
| import java.text.ParseException; |
| import java.text.SimpleDateFormat; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.NoSuchElementException; |
| import java.util.StringTokenizer; |
| |
| import org.apache.ofbiz.base.crypto.HashCrypt; |
| import org.apache.ofbiz.base.util.UtilValidate; |
| import org.apache.ofbiz.common.login.LoginServices; |
| |
| /** |
| * Record |
| */ |
| @SuppressWarnings("serial") |
| public class Record implements Serializable { |
| |
| /** Contains a map with field data by name */ |
| protected Map<String, Object> fields; |
| |
| /** Contains the name of the record definition */ |
| protected String recordName; |
| |
| /** Contains the definition for the record */ |
| protected transient ModelRecord modelRecord; |
| |
| protected Record parentRecord = null; |
| protected List<Record> childRecords = new ArrayList<Record>(); |
| |
| /** Creates new Record */ |
| protected Record(ModelRecord modelRecord) { |
| if (modelRecord == null) |
| throw new IllegalArgumentException("Cannont create a Record with a null modelRecord parameter"); |
| this.recordName = modelRecord.name; |
| this.modelRecord = modelRecord; |
| this.fields = new HashMap<String, Object>(); |
| } |
| |
| /** Creates new Record from existing Map */ |
| protected Record(ModelRecord modelRecord, Map<String, Object> fields) { |
| if (modelRecord == null) |
| throw new IllegalArgumentException("Cannont create a Record with a null modelRecord parameter"); |
| this.recordName = modelRecord.name; |
| this.modelRecord = modelRecord; |
| this.fields = (fields == null ? new HashMap<String, Object>() : new HashMap<String, Object>(fields)); |
| } |
| |
| public String getRecordName() { |
| return recordName; |
| } |
| |
| public ModelRecord getModelRecord() { |
| if (modelRecord == null) { |
| throw new IllegalStateException("[Record.getModelRecord] could not find modelRecord for recordName " + recordName); |
| } |
| return modelRecord; |
| } |
| |
| public Object get(String name) { |
| if (getModelRecord().getModelField(name) == null) { |
| throw new IllegalArgumentException("[Record.get] \"" + name + "\" is not a field of " + recordName); |
| // Debug.logWarning("[GenericRecord.get] \"" + name + "\" is not a field of " + recordName + ", but getting anyway...", module); |
| } |
| return fields.get(name); |
| } |
| |
| public String getString(String name) { |
| Object object = get(name); |
| |
| if (object == null) |
| return null; |
| if (object instanceof java.lang.String) |
| return (String) object; |
| else |
| return object.toString(); |
| } |
| |
| public String getStringAndEmpty(String name) { |
| Object object = get(name); |
| |
| if (object == null) |
| return ""; |
| if (object instanceof java.lang.String) |
| return (String) object; |
| else |
| return object.toString(); |
| } |
| |
| public java.sql.Timestamp getTimestamp(String name) { |
| return (java.sql.Timestamp) get(name); |
| } |
| |
| public java.sql.Time getTime(String name) { |
| return (java.sql.Time) get(name); |
| } |
| |
| public java.sql.Date getDate(String name) { |
| return (java.sql.Date) get(name); |
| } |
| |
| public Integer getInteger(String name) { |
| return (Integer) get(name); |
| } |
| |
| public Long getLong(String name) { |
| return (Long) get(name); |
| } |
| |
| public Float getFloat(String name) { |
| return (Float) get(name); |
| } |
| |
| public Double getDouble(String name) { |
| return (Double) get(name); |
| } |
| |
| /** Sets the named field to the passed value, even if the value is null |
| * @param name The field name to set |
| * @param value The value to set |
| */ |
| public void set(String name, Object value) { |
| set(name, value, true); |
| } |
| |
| /** Sets the named field to the passed value. If value is null, it is only |
| * set if the setIfNull parameter is true. |
| * @param name The field name to set |
| * @param value The value to set |
| * @param setIfNull Specifies whether or not to set the value if it is null |
| */ |
| public synchronized void set(String name, Object value, boolean setIfNull) { |
| if (getModelRecord().getModelField(name) == null) { |
| throw new IllegalArgumentException("[Record.set] \"" + name + "\" is not a field of " + recordName); |
| // Debug.logWarning("[GenericRecord.set] \"" + name + "\" is not a field of " + recordName + ", but setting anyway...", module); |
| } |
| if (value != null || setIfNull) { |
| if (value instanceof Boolean) { |
| value = ((Boolean) value).booleanValue() ? "Y" : "N"; |
| } |
| fields.put(name, value); |
| } |
| } |
| |
| /** |
| * little endian reader for 2 byte short. |
| */ |
| public final short readLEShort(byte[] byteArray) { |
| return (short)( |
| (byteArray[1]&0xff) << 8 | |
| (byteArray[0]&0xff)); |
| |
| } |
| |
| /** |
| * little endian reader for 4 byte int. |
| */ |
| public final int readLEInt(byte []byteArray) { |
| return |
| (byteArray[3]) << 24 | |
| (byteArray[2]&0xff) << 16 | |
| (byteArray[1]&0xff) << 8 | |
| (byteArray[0]&0xff); |
| } |
| |
| /** |
| * little endian reader for 8 byte long. |
| */ |
| public final long readLELong(byte []byteArray) { |
| return |
| (long)(byteArray[7]) << 56 | /* long cast needed or shift done modulo 32 */ |
| (long)(byteArray[6]&0xff) << 48 | |
| (long)(byteArray[5]&0xff) << 40 | |
| (long)(byteArray[4]&0xff) << 32 | |
| (long)(byteArray[3]&0xff) << 24 | |
| (long)(byteArray[2]&0xff) << 16 | |
| (long)(byteArray[1]&0xff) << 8 | |
| (byteArray[0]&0xff); |
| } |
| |
| /** Sets the named field to the passed value, converting the value from a String to the current type using <code>Type.valueOf()</code> |
| * @param name The field name to set |
| * @param value The String value to convert and set |
| */ |
| public void setString(String name, String value) throws ParseException { |
| if (name == null || value == null || value.equals("")) |
| return; |
| ModelField field = getModelRecord().getModelField(name); |
| |
| if (field == null) |
| set(name, value); // this will get an error in the set() method... |
| |
| // if the string is all spaces ignore |
| boolean nonSpace = false; |
| |
| for (int i = 0; i < value.length(); i++) { |
| if (value.charAt(i) != ' ') { |
| nonSpace = true; |
| break; |
| } |
| } |
| if (!nonSpace) |
| return; |
| |
| // if (Debug.verboseOn()) Debug.logVerbose("Value: " + value, module); |
| |
| String fieldType = field.type; |
| |
| // first the custom types that need to be parsed |
| if (fieldType.equals("CustomTimestamp")) { |
| // this custom type will take a string a parse according to date formatting |
| // string then put the result in a java.sql.Timestamp |
| // a common timestamp format for flat files is with no separators: yyyyMMddHHmmss |
| SimpleDateFormat sdf = new SimpleDateFormat(field.format); |
| java.util.Date tempDate = sdf.parse(value); |
| java.sql.Timestamp timestamp = new java.sql.Timestamp(tempDate.getTime()); |
| |
| set(name, timestamp); |
| } else if (fieldType.equals("CustomDate")) { |
| // a common date only format for flat files is with no separators: yyyyMMdd or MMddyyyy |
| SimpleDateFormat sdf = new SimpleDateFormat(field.format); |
| java.util.Date tempDate = sdf.parse(value); |
| java.sql.Date date = new java.sql.Date(tempDate.getTime()); |
| |
| set(name, date); |
| } else if (fieldType.equals("CustomTime")) { |
| // a common time only format for flat files is with no separators: HHmmss |
| SimpleDateFormat sdf = new SimpleDateFormat(field.format); |
| java.util.Date tempDate = sdf.parse(value); |
| java.sql.Time time = new java.sql.Time(tempDate.getTime()); |
| |
| set(name, time); |
| } else if (fieldType.equals("FixedPointDouble")) { |
| // this custom type will parse a fixed point number according to the number |
| // of decimal places in the formatting string then place it in a Double |
| NumberFormat nf = NumberFormat.getNumberInstance(); |
| Number tempNum = nf.parse(value); |
| double number = tempNum.doubleValue(); |
| double decimalPlaces = Double.parseDouble(field.format); |
| double divisor = Math.pow(10.0, decimalPlaces); |
| |
| number = number / divisor; |
| set(name, Double.valueOf(number)); |
| } // standard types |
| else if (fieldType.equals("java.lang.String") || fieldType.equals("String")) |
| if (field.format.equals("EncryptedString")) { |
| String hashType = LoginServices.getHashType(); |
| set(name, HashCrypt.digestHash(hashType, value.getBytes())); |
| } else { |
| set(name, value); |
| } |
| else if (fieldType.equals("NullTerminatedString")) { |
| int terminate = value.indexOf(0x0); |
| set(name, terminate>0?value.substring(0,terminate):value); |
| } else if (fieldType.equals("java.sql.Timestamp") || fieldType.equals("Timestamp")) |
| set(name, java.sql.Timestamp.valueOf(value)); |
| else if (fieldType.equals("java.sql.Time") || fieldType.equals("Time")) |
| set(name, java.sql.Time.valueOf(value)); |
| else if (fieldType.equals("java.sql.Date") || fieldType.equals("Date")) |
| set(name, java.sql.Date.valueOf(value)); |
| else if (fieldType.equals("java.lang.Integer") || fieldType.equals("Integer")) |
| set(name, Integer.valueOf(value)); |
| else if (fieldType.equals("java.lang.Long") || fieldType.equals("Long")) |
| set(name, Long.valueOf(value)); |
| else if (fieldType.equals("java.lang.Float") || fieldType.equals("Float")) |
| set(name, Float.valueOf(value)); |
| else if (fieldType.equals("java.lang.Double") || fieldType.equals("Double")) |
| set(name, Double.valueOf(value)); |
| else if (fieldType.equals("LEShort")) |
| set(name, Short.valueOf(readLEShort(value.getBytes()))); |
| else if (fieldType.equals("LEInteger")) |
| set(name, Integer.valueOf(readLEInt(value.getBytes()))); |
| else if (fieldType.equals("LELong")) |
| set(name, Long.valueOf(readLELong(value.getBytes()))); |
| else { |
| throw new IllegalArgumentException("Field type " + fieldType + " not currently supported. Sorry."); |
| } |
| } |
| |
| public String getFixedString(String name) { |
| if (name == null) |
| return null; |
| if (getModelRecord() == null) |
| throw new IllegalArgumentException("Could not find modelrecord for field named \"" + name + "\""); |
| ModelField field = getModelRecord().getModelField(name); |
| |
| if (field == null) |
| throw new IllegalArgumentException("Could not find model for field named \"" + name + "\""); |
| |
| Object value = get(name); |
| |
| if (value == null) { |
| return null; |
| } |
| |
| String fieldType = field.type; |
| String str = null; |
| |
| // first the custom types that need to be parsed |
| if (fieldType.equals("CustomTimestamp")) { |
| // a common timestamp format for flat files is with no separators: yyyyMMddHHmmss |
| SimpleDateFormat sdf = new SimpleDateFormat(field.format); |
| java.sql.Timestamp timestamp = (java.sql.Timestamp) value; |
| |
| str = sdf.format(new Date(timestamp.getTime())); |
| } else if (fieldType.equals("CustomDate")) { |
| // a common date only format for flat files is with no separators: yyyyMMdd or MMddyyyy |
| SimpleDateFormat sdf = new SimpleDateFormat(field.format); |
| java.sql.Date date = (java.sql.Date) value; |
| |
| str = sdf.format(new Date(date.getTime())); |
| } else if (fieldType.equals("CustomTime")) { |
| // a common time only format for flat files is with no separators: HHmmss |
| SimpleDateFormat sdf = new SimpleDateFormat(field.format); |
| java.sql.Time time = (java.sql.Time) value; |
| |
| str = sdf.format(new Date(time.getTime())); |
| } else if (fieldType.equals("FixedPointDouble")) { |
| // this custom type will parse a fixed point number according to the number |
| // of decimal places in the formatting string then place it in a Double |
| double decimalPlaces = Double.parseDouble(field.format); |
| double multiplier = Math.pow(10.0, decimalPlaces); |
| double dnum = multiplier * ((Double) value).doubleValue(); |
| long number = Math.round(dnum); |
| |
| str = padFrontZeros(Long.toString(number), field.length); |
| // if (Debug.infoOn()) Debug.logInfo("[Record.getFixedString] FixedPointDouble: multiplier=" + multiplier + ", value=" + value + ", dnum=" + dnum + ", number=" + number + ", str=" + str, module); |
| } // standard types |
| else if (fieldType.equals("java.lang.String") || fieldType.equals("String")) |
| str = value.toString(); |
| else if (fieldType.equals("java.sql.Timestamp") || fieldType.equals("Timestamp")) |
| str = value.toString(); |
| else if (fieldType.equals("java.sql.Time") || fieldType.equals("Time")) |
| str = value.toString(); |
| else if (fieldType.equals("java.sql.Date") || fieldType.equals("Date")) |
| str = value.toString(); |
| // for all numbers, pad front with zeros if field length is specified |
| else if (fieldType.equals("java.lang.Integer") || fieldType.equals("Integer")) |
| str = padFrontZeros(value.toString(), field.length); |
| else if (fieldType.equals("java.lang.Long") || fieldType.equals("Long")) |
| str = padFrontZeros(value.toString(), field.length); |
| else if (fieldType.equals("java.lang.Float") || fieldType.equals("Float")) |
| str = padFrontZeros(value.toString(), field.length); |
| else if (fieldType.equals("java.lang.Double") || fieldType.equals("Double")) |
| str = padFrontZeros(value.toString(), field.length); |
| else { |
| throw new IllegalArgumentException("Field type " + fieldType + " not currently supported. Sorry."); |
| } |
| |
| if (str != null && field.length > 0 && str.length() < field.length) { |
| // pad the end with spaces |
| StringBuilder strBuf = new StringBuilder(str); |
| |
| while (strBuf.length() < field.length) |
| strBuf.append(' '); |
| str = strBuf.toString(); |
| } |
| return str; |
| } |
| |
| public String writeLineString(ModelDataFile modelDataFile) throws DataFileException { |
| ModelRecord modelRecord = getModelRecord(); |
| boolean isFixedRecord = ModelDataFile.SEP_FIXED_RECORD.equals(modelDataFile.separatorStyle); |
| boolean isFixedLength = ModelDataFile.SEP_FIXED_LENGTH.equals(modelDataFile.separatorStyle); |
| boolean isDelimited = ModelDataFile.SEP_DELIMITED.equals(modelDataFile.separatorStyle); |
| |
| StringBuilder lineBuf = new StringBuilder(); |
| |
| for (ModelField modelField: modelRecord.fields) { |
| String data = this.getFixedString(modelField.name); |
| |
| if (isDelimited && null != modelDataFile.textDelimiter) { |
| lineBuf.append(modelDataFile.textDelimiter); |
| } |
| |
| // if field is null (not set) then assume we want to pad the field |
| char PAD_CHAR = ' '; |
| |
| if (data == null) { |
| StringBuilder sb = new StringBuilder(""); |
| |
| for (int i = 0; i < modelField.length; i++) |
| sb.append(PAD_CHAR); |
| data = sb.toString(); |
| } |
| |
| // Pad the record |
| if (isFixedRecord) { |
| while (modelField.position > lineBuf.length()) |
| lineBuf.append(" "); |
| } |
| // if (Debug.infoOn()) Debug.logInfo("Field: " + modelField.name + " Position: " + modelField.position + " BufLen: " + lineBuf.length(), module); |
| |
| // if (Debug.infoOn()) Debug.logInfo("Got data \"" + data + "\" for field " + modelField.name + " in record " + modelRecord.name, module); |
| if (modelField.length > 0 && data.length() != modelField.length) |
| throw new DataFileException("Got field length " + data.length() + " but expected field length is " + modelField.length + " for field \"" + |
| modelField.name + "\" of record \"" + modelRecord.name + "\" data is: \"" + data + "\""); |
| |
| lineBuf.append(data); |
| if (isDelimited) { |
| if (null != modelDataFile.textDelimiter) { |
| lineBuf.append(modelDataFile.textDelimiter); |
| } |
| lineBuf.append(modelDataFile.delimiter); |
| } |
| } |
| |
| if (isDelimited) { |
| // just remove the last delimiter to finish clean, otherwise shows as extra column |
| lineBuf.setLength(lineBuf.length() - 1); |
| } |
| |
| if ((isFixedRecord || isFixedLength) && modelDataFile.recordLength > 0 && lineBuf.length() != modelDataFile.recordLength) |
| throw new DataFileException("Got record length " + lineBuf.length() + " but expected record length is " + modelDataFile.recordLength + |
| " for record \"" + modelRecord.name + "\" data line is: \"" + lineBuf + "\""); |
| |
| // for convenience, insert the type-code in where it is looked for, if exists |
| if (modelRecord.tcPosition > 0 && modelRecord.typeCode.length() > 0) { |
| lineBuf.replace(modelRecord.tcPosition, modelRecord.tcPosition + modelRecord.tcLength, modelRecord.typeCode); |
| } |
| |
| if (isFixedLength || isDelimited) |
| lineBuf.append('\n'); |
| |
| return lineBuf.toString(); |
| } |
| |
| String padFrontZeros(String str, int totalLength) { |
| if (totalLength > 0 && str.length() < totalLength) { |
| // pad the front with zeros |
| StringBuilder zeros = new StringBuilder(); |
| int numZeros = totalLength - str.length(); |
| |
| for (int i = 0; i < numZeros; i++) |
| zeros.append('0'); |
| zeros.append(str); |
| return zeros.toString(); |
| } else |
| return str; |
| } |
| |
| public Record getParentRecord() { |
| return parentRecord; |
| } |
| |
| public List<Record> getChildRecords() { |
| return childRecords; |
| } |
| |
| public void addChildRecord(Record record) { |
| childRecords.add(record); |
| } |
| |
| /** Creates new Record |
| * @param modelRecord |
| * @throws DataFileException Exception thown for various errors, generally has a nested exception |
| * @return return the Record Object created |
| */ |
| public static Record createRecord(ModelRecord modelRecord) throws DataFileException { |
| Record record = new Record(modelRecord); |
| |
| return record; |
| } |
| |
| /** Creates new Record from existing fields Map |
| * @param modelRecord |
| * @param fields |
| * @throws DataFileException Exception thown for various errors, generally has a nested exception |
| * @return return the Record Object created |
| */ |
| public static Record createRecord(ModelRecord modelRecord, Map<String, Object> fields) throws DataFileException { |
| Record record = new Record(modelRecord, fields); |
| |
| return record; |
| } |
| |
| /** |
| * @param line |
| * @param lineNum |
| * @param modelRecord |
| * @throws DataFileException Exception thown for various errors, generally has a nested exception |
| * @return return the Record Object created |
| */ |
| public static Record createRecord(String line, int lineNum, ModelRecord modelRecord) throws DataFileException { |
| Record record = new Record(modelRecord); |
| |
| for (ModelField modelField: modelRecord.fields) { |
| String strVal = null; |
| |
| |
| try { |
| strVal = line.substring(modelField.position, modelField.position + modelField.length); |
| } catch (IndexOutOfBoundsException ioobe) { |
| throw new DataFileException("Field " + modelField.name + " from " + modelField.position + |
| " for " + modelField.length + " chars could not be read from a line (" + lineNum + ") with only " + |
| line.length() + " chars.", ioobe); |
| } |
| try { |
| record.setString(modelField.name, strVal); |
| } catch (java.text.ParseException e) { |
| throw new DataFileException("Could not parse field " + modelField.name + ", format string \"" + modelField.format + "\" with value " + strVal + |
| " on line " + lineNum, e); |
| } catch (java.lang.NumberFormatException e) { |
| throw new DataFileException("Number not valid for field " + modelField.name + ", format string \"" + modelField.format + "\" with value " + |
| strVal + " on line " + lineNum, e); |
| } |
| } |
| return record; |
| } |
| |
| /** |
| * @param line |
| * @param lineNum |
| * @param modelRecord |
| * @param delimiter |
| * @throws DataFileException Exception thown for various errors, generally has a nested exception |
| * @return return a Record Object |
| */ |
| public static Record createDelimitedRecord(String line, int lineNum, ModelRecord modelRecord, char delimiter, String textDelimiter) throws DataFileException { |
| Record record = new Record(modelRecord); |
| |
| StringTokenizer st = null; |
| if (line.endsWith(String.valueOf(delimiter))) { |
| st = new StringTokenizer(line + " ", "" + delimiter, true); |
| } |
| else { |
| st = new StringTokenizer(line, "" + delimiter, true); |
| } |
| for (ModelField modelField: modelRecord.fields) { |
| String strVal = null; |
| |
| if (modelField.expression) { |
| if (UtilValidate.isNotEmpty(modelField.refField)) { |
| strVal = record.getString(modelField.refField); |
| } |
| if (strVal == null) { |
| strVal = (String)modelField.defaultValue; |
| } |
| } else { |
| //some input lines may be less than the header model. |
| if (st.hasMoreTokens()) { |
| try { |
| strVal = st.nextToken(); |
| if (strVal.equals("" + delimiter)) { |
| strVal = null; |
| } else if (st.hasMoreTokens()) { |
| st.nextToken(); |
| } |
| } catch (NoSuchElementException nsee) { |
| throw new DataFileException("Field " + modelField.name + " could not be read from a line (" + lineNum + ") with only " + |
| line.length() + " chars.", nsee); |
| } |
| } |
| else { //if input line is less than the header model then pad with null |
| strVal = null; |
| } |
| } |
| try { |
| if (textDelimiter != null && strVal != null && (strVal.startsWith(textDelimiter) && (!strVal.endsWith(textDelimiter) || strVal.length()==1))) { |
| strVal = strVal.concat(""+delimiter); |
| while (!strVal.endsWith(textDelimiter)) { |
| strVal = strVal.concat(st.nextToken()); |
| } |
| st.nextToken(); |
| } |
| if (textDelimiter != null && strVal != null && (strVal.startsWith(textDelimiter) && strVal.endsWith(textDelimiter))) { |
| strVal = strVal.substring(textDelimiter.length(), strVal.length() - textDelimiter.length()); |
| } |
| record.setString(modelField.name, strVal); |
| } catch (java.text.ParseException e) { |
| throw new DataFileException("Could not parse field " + modelField.name + ", format string \"" + modelField.format + "\" with value " + strVal + |
| " on line " + lineNum, e); |
| } catch (java.lang.NumberFormatException e) { |
| throw new DataFileException("Number not valid for field " + modelField.name + ", format string \"" + modelField.format + "\" with value " + |
| strVal + " on line " + lineNum, e); |
| } |
| } |
| return record; |
| } |
| |
| } |
| |
