record.java

Sequoia ERP是一个真正的企业级开源ERP解决方案。它提供的模块包括：电子商务应用(e-commerce), POS系统(point of sales),知识管理,存货与仓库管理

        else if (fieldType.equals("LEInteger"))
            set(name, new Integer(readLEInt(value.getBytes())));
        else if (fieldType.equals("LELong"))
            set(name, new Long(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
            NumberFormat nf = NumberFormat.getNumberInstance();
            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
            StringBuffer strBuf = new StringBuffer(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);

        StringBuffer lineBuf = new StringBuffer();

        for (int f = 0; f < modelRecord.fields.size(); f++) {
            ModelField modelField = (ModelField) modelRecord.fields.get(f);
            String data = this.getFixedString(modelField.name);

            // if field is null (not set) then assume we want to pad the field
            char PAD_CHAR = ' ';

            if (data == null) {
                StringBuffer sb = new StringBuffer("");

                for (int i = 0; i < modelField.length; i++)
                    sb.append(PAD_CHAR);
                data = new String(sb);
            }

            // 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)
                lineBuf.append(modelDataFile.delimiter);
        }
        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
            StringBuffer zeros = new StringBuffer();
            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 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
     */
    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
     */
    public static Record createRecord(ModelRecord modelRecord, Map 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
     */
    public static Record createRecord(String line, int lineNum, ModelRecord modelRecord) throws DataFileException {
        Record record = new Record(modelRecord);

        for (int i = 0; i < modelRecord.fields.size(); i++) {
            ModelField modelField = (ModelField) modelRecord.fields.get(i);
            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
     */
    public static Record createDelimitedRecord(String line, int lineNum, ModelRecord modelRecord, char delimiter) throws DataFileException {
        Record record = new Record(modelRecord);

        StringTokenizer st = new StringTokenizer(line, "" + delimiter, true);
        for (int i = 0; i < modelRecord.fields.size(); i++) {
            ModelField modelField = (ModelField) modelRecord.fields.get(i);
            String strVal = null;

            if (modelField.expression) {
                if (modelField.refField != null && modelField.refField.length() > 0) {
                    strVal = record.getString(modelField.refField);
                }
                if (strVal == null) {
                    strVal = (String)modelField.defaultValue;
                }
            } else {
                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);
                }
            }
            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;
    }

}