commit 1b07cf9a32f5dcea926d8c11a3fa4947ea7461c2 Author: chochos Date: Fri Nov 26 00:30:40 2010 +0000 This is the mavenized version of the project, and it's the one I'll be working with from now on. git-svn-id: https://j8583.svn.sourceforge.net/svnroot/j8583/j8583@52 db60a039-f72e-0410-b1d2-baa000846441 diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..898a61f --- /dev/null +++ b/pom.xml @@ -0,0 +1,122 @@ + + + 4.0.0 + com.solab + j8583 + 1.3.4 + jar + j8583 + Java implementation of the ISO 8583 protocol, focused on making the creation, edition and reading of ISO8583 messages as simple and flexible as possible. + http://j8583.sourceforge.net/ + + + GNU Lesser General Public License, version 2.1 + http://www.gnu.org/licenses/lgpl-2.1.html + repo + + + + scm:svn:https://j8583.svn.sourceforge.net/svnroot/j8583 + scm:svn:https://j8583.svn.sourceforge.net/svnroot/j8583 + http://j8583.svn.sourceforge.net/viewvc/j8583/ + + + UTF-8 + + + + org.slf4j + slf4j-api + 1.6.1 + + + junit + junit + 4.8.2 + jar + test + + + + Java Mexico + http://javamexico.org + + + + chochos + Enrique Zamudio Lopez + http://javamexico.org/blogs/ezamudio + + architect + developer + + + chochosmx + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 2.3.2 + + 1.6 + 1.6 + + + + org.apache.maven.plugins + maven-eclipse-plugin + 2.8 + + true + true + + + + org.apache.maven.plugins + maven-gpg-plugin + 1.1 + + + sign-artifacts + verify + + sign + + + + + + org.apache.maven.plugins + maven-site-plugin + 2.0.1 + + en,es + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.7 + + + http://download.oracle.com/javase/6/docs/api/ + http://static.springsource.org/spring/docs/3.0.x/javadoc-api/ + http://slf4j.org/apidocs/ + http://jml.blathersource.org/javadocs/ + http://dustin.github.com/java-memcached-client/apidocs/ + + + + + + + + j8583.sf.net + scp://chochos,j8583@shell.sourceforge.net:/home/groups/j/j8/j8583/htdocs + + + diff --git a/src/main/java/com/solab/iso8583/CustomField.java b/src/main/java/com/solab/iso8583/CustomField.java new file mode 100644 index 0000000..c9de1df --- /dev/null +++ b/src/main/java/com/solab/iso8583/CustomField.java @@ -0,0 +1,31 @@ +/* +j8583 A Java implementation of the ISO8583 protocol +Copyright (C) 2007 Enrique Zamudio Lopez + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA +*/ +package com.solab.iso8583; + +/** Defines the behavior for a custom field value encoder/decoder + * + * @author Enrique Zamudio + */ +public interface CustomField { + + public T decodeField(String value); + + public String encodeField(T value); + +} diff --git a/src/main/java/com/solab/iso8583/IsoMessage.java b/src/main/java/com/solab/iso8583/IsoMessage.java new file mode 100644 index 0000000..0a6cf5a --- /dev/null +++ b/src/main/java/com/solab/iso8583/IsoMessage.java @@ -0,0 +1,373 @@ +/* +j8583 A Java implementation of the ISO8583 protocol +Copyright (C) 2007 Enrique Zamudio Lopez + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA +*/ +package com.solab.iso8583; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.BitSet; +import java.util.Collections; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +/** Represents an ISO8583 message. This is the core class of the framework. + * Contains the bitmap which is modified as fields are added/removed. + * This class makes no assumptions as to what types belong in each field, + * nor what fields should each different message type have; that is left + * for the developer, since the different ISO8583 implementations can vary + * greatly. + * + * @author Enrique Zamudio + */ +public class IsoMessage { + + static final byte[] HEX = new byte[]{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; + + /** The message type. */ + private int type; + /** Indicates if the message is binary-coded. */ + private boolean binary; + /** This is where the values are stored. */ + private Map> fields = new ConcurrentHashMap>(); + /** Stores the optional ISO header. */ + private String isoHeader; + private int etx = -1; + /** Flag to enforce secondary bitmap even if empty. */ + private boolean forceb2; + + /** Creates a new empty message with no values set. */ + public IsoMessage() { + } + + /** Creates a new message with the specified ISO header. This will be prepended to the message. */ + IsoMessage(String header) { + isoHeader = header; + } + + /** If set, this flag will cause the secondary bitmap to be written even if it's not needed. */ + public void setForceSecondaryBitmap(boolean flag) { + forceb2 = flag; + } + public boolean getForceSecondaryBitmap() { + return forceb2; + } + + /** Sets the string to be sent as ISO header, that is, after the length header but before the message type. + * This is useful in case an application needs some custom data in the ISO header of each message (very rare). */ + public void setIsoHeader(String value) { + isoHeader = value; + } + /** Returns the ISO header that this message was created with. */ + public String getIsoHeader() { + return isoHeader; + } + + /** Sets the ISO message type. Common values are 0x200, 0x210, 0x400, 0x410, 0x800, 0x810. */ + public void setType(int value) { + type = value; + } + /** Returns the ISO message type. */ + public int getType() { + return type; + } + + /** Indicates whether the message should be binary. Default is false. */ + public void setBinary(boolean flag) { + binary = flag; + } + /** Returns true if the message is binary coded; default is false. */ + public boolean isBinary() { + return binary; + } + + /** Sets the ETX character, which is sent at the end of the message as a terminator. + * Default is -1, which means no terminator is sent. */ + public void setEtx(int value) { + etx = value; + } + + /** Returns the stored value in the field, without converting or formatting it. + * @param field The field number. 1 is the secondary bitmap and is not returned as such; + * real fields go from 2 to 128. */ + public Object getObjectValue(int field) { + IsoValue v = fields.get(field); + if (v == null) { + return null; + } + return v.getValue(); + } + + /** Returns the IsoValue for the specified field. First real field is 2. */ + public IsoValue getField(int field) { + return fields.get(field); + } + + /** Stored the field in the specified index. The first field is the secondary bitmap and has index 1, + * so the first valid value for index must be 2. */ + public void setField(int index, IsoValue field) { + if (index < 2 || index > 128) { + throw new IndexOutOfBoundsException("Field index must be between 2 and 128"); + } + if (field == null) { + fields.remove(index); + } else { + fields.put(index, field); + } + } + + /** Sets the specified value in the specified field, creating an IsoValue internally. + * @param index The field number (2 to 128) + * @param value The value to be stored. + * @param t The ISO type. + * @param length The length of the field, used for ALPHA and NUMERIC values only, ignored + * with any other type. */ + public void setValue(int index, Object value, IsoType t, int length) { + setValue(index, value, null, t, length); + } + + /** Sets the specified value in the specified field, creating an IsoValue internally. + * @param index The field number (2 to 128) + * @param value The value to be stored. + * @param encoder An optional CustomField to encode/decode the value. + * @param t The ISO type. + * @param length The length of the field, used for ALPHA and NUMERIC values only, ignored + * with any other type. */ + @SuppressWarnings("unchecked") + public void setValue(int index, Object value, CustomField encoder, IsoType t, int length) { + if (index < 2 || index > 128) { + throw new IndexOutOfBoundsException("Field index must be between 2 and 128"); + } + if (value == null) { + fields.remove(index); + } else { + IsoValue v = null; + if (t.needsLength()) { + v = new IsoValue(t, value, length, encoder); + } else { + v = new IsoValue(t, value, encoder); + } + fields.put(index, v); + } + } + + /** Returns true is the message has a value in the specified field. + * @param idx The field number. */ + public boolean hasField(int idx) { + return fields.get(idx) != null; + } + + /** Writes a message to a stream, after writing the specified number of bytes indicating + * the message's length. The message will first be written to an internal memory stream + * which will then be dumped into the specified stream. This method flushes the stream + * after the write. There are at most three write operations to the stream: one for the + * length header, one for the message, and the last one with for the ETX. + * @param outs The stream to write the message to. + * @param lengthBytes The size of the message length header. Valid ranges are 0 to 4. + * @throws IllegalArgumentException if the specified length header is more than 4 bytes. + * @throws IOException if there is a problem writing to the stream. */ + public void write(OutputStream outs, int lengthBytes) throws IOException { + if (lengthBytes > 4) { + throw new IllegalArgumentException("The length header can have at most 4 bytes"); + } + byte[] data = writeInternal(); + + if (lengthBytes > 0) { + int l = data.length; + if (etx > -1) { + l++; + } + byte[] buf = new byte[lengthBytes]; + int pos = 0; + if (lengthBytes == 4) { + buf[0] = (byte)((l & 0xff000000) >> 24); + pos++; + } + if (lengthBytes > 2) { + buf[pos] = (byte)((l & 0xff0000) >> 16); + pos++; + } + if (lengthBytes > 1) { + buf[pos] = (byte)((l & 0xff00) >> 8); + pos++; + } + buf[pos] = (byte)(l & 0xff); + outs.write(buf); + } + outs.write(data); + //ETX + if (etx > -1) { + outs.write(etx); + } + outs.flush(); + } + + /** Creates and returns a ByteBuffer with the data of the message, including the length header. + * The returned buffer is already flipped, so it is ready to be written to a Channel. */ + public ByteBuffer writeToBuffer(int lengthBytes) { + if (lengthBytes > 4) { + throw new IllegalArgumentException("The length header can have at most 4 bytes"); + } + + byte[] data = writeInternal(); + ByteBuffer buf = ByteBuffer.allocate(lengthBytes + data.length + (etx > -1 ? 1 : 0)); + if (lengthBytes > 0) { + int l = data.length; + if (etx > -1) { + l++; + } + byte[] bbuf = new byte[lengthBytes]; + int pos = 0; + if (lengthBytes == 4) { + bbuf[0] = (byte)((l & 0xff000000) >> 24); + pos++; + } + if (lengthBytes > 2) { + bbuf[pos] = (byte)((l & 0xff0000) >> 16); + pos++; + } + if (lengthBytes > 1) { + bbuf[pos] = (byte)((l & 0xff00) >> 8); + pos++; + } + bbuf[pos] = (byte)(l & 0xff); + buf.put(bbuf); + } + buf.put(data); + //ETX + if (etx > -1) { + buf.put((byte)etx); + } + buf.flip(); + return buf; + } + + /** This calls writeInternal(), allowing applications to get the byte buffer containing the + * message data, without the length header. */ + public byte[] writeData() { + return writeInternal(); + } + + /** Writes the message to a memory buffer and returns it. The message does not include + * the ETX character or the header length. */ + protected byte[] writeInternal() { + ByteArrayOutputStream bout = new ByteArrayOutputStream(); + if (isoHeader != null) { + try { + bout.write(isoHeader.getBytes()); + } catch (IOException ex) { + //should never happen, writing to a ByteArrayOutputStream + } + } + //Message Type + if (binary) { + bout.write((type & 0xff00) >> 8); + bout.write(type & 0xff); + } else { + try { + bout.write(String.format("%04x", type).getBytes()); + } catch (IOException ex) { + //should never happen, writing to a ByteArrayOutputStream + } + } + + //Bitmap + ArrayList keys = new ArrayList(); + keys.addAll(fields.keySet()); + Collections.sort(keys); + BitSet bs = new BitSet(forceb2 ? 128 : 64); + for (Integer i : keys) { + bs.set(i - 1); + } + if (forceb2) { + bs.set(0); + } else if (bs.length() > 64) { + //Extend to 128 if needed + BitSet b2 = new BitSet(128); + b2.or(bs); + bs = b2; + bs.set(0); + } + //Write bitmap to stream + if (binary) { + int pos = 128; + int b = 0; + for (int i = 0; i < bs.size(); i++) { + if (bs.get(i)) { + b |= pos; + } + pos >>= 1; + if (pos == 0) { + bout.write(b); + pos = 128; + b = 0; + } + } + } else { + int pos = 0; + int lim = bs.size() / 4; + for (int i = 0; i < lim; i++) { + int nibble = 0; + if (bs.get(pos++)) + nibble |= 8; + if (bs.get(pos++)) + nibble |= 4; + if (bs.get(pos++)) + nibble |= 2; + if (bs.get(pos++)) + nibble |= 1; + bout.write(HEX[nibble]); + } + } + + //Fields + for (Integer i : keys) { + IsoValue v = fields.get(i); + try { + v.write(bout, binary); + } catch (IOException ex) { + //should never happen, writing to a ByteArrayOutputStream + } + } + return bout.toByteArray(); + } + + //These are for Groovy compat + /** Sets the specified value in the specified field, just like {@link #setField(int, IsoValue)}. */ + public void putAt(int i, IsoValue v) { + setField(i, v); + } + /** Returns the IsoValue in the specified field, just like {@link #getField(int)}. */ + public IsoValue getAt(int i) { + return getField(i); + } + + /** Copies the specified fields from the other message into the recipient. If a specified field is + * not present in the source message it is simply ignored. */ + public void copyFieldsFrom(IsoMessage src, int...idx) { + for (int i : idx) { + IsoValue v = src.getField(i); + if (v != null) { + setValue(i, v.getValue(), v.getType(), v.getLength()); + } + } + } + +} diff --git a/src/main/java/com/solab/iso8583/IsoType.java b/src/main/java/com/solab/iso8583/IsoType.java new file mode 100644 index 0000000..133d5ff --- /dev/null +++ b/src/main/java/com/solab/iso8583/IsoType.java @@ -0,0 +1,179 @@ +/* +j8583 A Java implementation of the ISO8583 protocol +Copyright (C) 2007 Enrique Zamudio Lopez + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA +*/ +package com.solab.iso8583; + +import java.math.BigDecimal; +import java.text.DecimalFormat; +import java.text.SimpleDateFormat; +import java.util.Date; + +/** Defines the possible values types that can be used in the fields. + * Some types required the length of the value to be specified (NUMERIC + * and ALPHA). Other types have a fixed length, like dates and times. + * Other types do not require a length to be specified, like LLVAR + * and LLLVAR. + * + * @author Enrique Zamudio + */ +public enum IsoType { + + /** A fixed-length numeric value. It is zero-filled to the left. */ + NUMERIC(true, 0), + /** A fixed-length alphanumeric value. It is filled with spaces to the right. */ + ALPHA(true, 0), + /** A variable length alphanumeric value with a 2-digit header length. */ + LLVAR(false, 0), + /** A variable length alphanumeric value with a 3-digit header length. */ + LLLVAR(false, 0), + /** A date in format MMddHHmmss */ + DATE10(false, 10), + /** A date in format MMdd */ + DATE4(false, 4), + /** A date in format yyMM */ + DATE_EXP(false, 4), + /** Time of day in format HHmmss */ + TIME(false, 6), + /** An amount, expressed in cents with a fixed length of 12. */ + AMOUNT(false, 12); + + private boolean needsLen; + private int length; + + IsoType(boolean flag, int l) { + needsLen = flag; + length = l; + } + + /** Returns true if the type needs a specified length. */ + public boolean needsLength() { + return needsLen; + } + + /** Returns the length of the type if it's always fixed, or 0 if it's variable. */ + public int getLength() { + return length; + } + + /** Formats a Date if the receiver is DATE10, DATE4, DATE_EXP or TIME; throws an exception + * otherwise. */ + public String format(Date value) { + if (this == DATE10) { + return new SimpleDateFormat("MMddHHmmss").format(value); + } else if (this == DATE4) { + return new SimpleDateFormat("MMdd").format(value); + } else if (this == DATE_EXP) { + return new SimpleDateFormat("yyMM").format(value); + } else if (this == TIME) { + return new SimpleDateFormat("HHmmss").format(value); + } + throw new IllegalArgumentException("Cannot format date as " + this); + } + + /** Formats the string to the given length (length is only useful if type is ALPHA). */ + public String format(String value, int length) { + if (this == ALPHA) { + if (value == null) { + value = ""; + } + if (value.length() > length) { + return value.substring(0, length); + } + char[] c = new char[length]; + System.arraycopy(value.toCharArray(), 0, c, 0, value.length()); + for (int i = value.length(); i < c.length; i++) { + c[i] = ' '; + } + return new String(c); + } else if (this == LLVAR || this == LLLVAR) { + return value; + } else if (this == NUMERIC) { + char[] c = new char[length]; + char[] x = value.toCharArray(); + if (x.length > length) { + throw new IllegalArgumentException("Numeric value is larger than intended length: " + value + " LEN " + length); + } + int lim = c.length - x.length; + for (int i = 0; i < lim; i++) { + c[i] = '0'; + } + System.arraycopy(x, 0, c, lim, x.length); + return new String(c); + } + throw new IllegalArgumentException("Cannot format String as " + this); + } + + /** Formats the integer value as a NUMERIC, an AMOUNT, or a String. */ + public String format(long value, int length) { + if (this == NUMERIC) { + char[] c = new char[length]; + char[] x = Long.toString(value).toCharArray(); + if (x.length > length) { + throw new IllegalArgumentException("Numeric value is larger than intended length: " + value + " LEN " + length); + } + int lim = c.length - x.length; + for (int i = 0; i < lim; i++) { + c[i] = '0'; + } + System.arraycopy(x, 0, c, lim, x.length); + return new String(c); + } else if (this == ALPHA || this == LLVAR || this == LLLVAR) { + return format(Long.toString(value), length); + } else if (this == AMOUNT) { + String v = Long.toString(value); + char[] digits = new char[12]; + for (int i = 0; i < 12; i++) { + digits[i] = '0'; + } + //No hay decimales asi que dejamos los dos ultimos digitos como 0 + System.arraycopy(v.toCharArray(), 0, digits, 10 - v.length(), v.length()); + return new String(digits); + } + throw new IllegalArgumentException("Cannot format number as " + this); + } + + /** Formats the BigDecimal as an AMOUNT, NUMERIC, or a String. */ + public String format(BigDecimal value, int length) { + if (this == AMOUNT) { + String v = new DecimalFormat(value.signum() >= 0 ? "0000000000.00" : "000000000.00").format(value); + return String.format("%s%s", v.substring(0, 10), v.substring(11)); + } else if (this == NUMERIC) { + return format(value.longValue(), length); + } else if (this == ALPHA || this == LLVAR || this == LLLVAR) { + return format(value.toString(), length); + } + throw new IllegalArgumentException("Cannot format BigDecimal as " + this); + } + + public IsoValue