public override int Decode(ISOComponent component, byte[] data, int offset)
{
int length;
BitArray bitmap = Utils.Hex2BitArray(data, offset, (Length << 3));
component.Value = bitmap;
// check if we have secondary bitmap
if (bitmap.Get(1))
{
length = 128;
}
else
{
length = 64;
}
// check if we have extended bitmap (more than 128 fields)
if (Length > 16 && bitmap.Get(65))
{
length = 192;
}
return(length >> 2);
}
/// <summary>
///
/// </summary>
/// <param name="isoField"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
public override void UnPack(ISOComponent isoField, byte[] packedBytes, ref int index)
{
// reserve enough bytes to store the length !! ASUMES FOR NOW THAT IS ALWAYS BINARY !!
switch (m_isoFieldDefinition.lengthCoding)
{
case ISOFieldCoding.BIN:
index += m_isoFieldDefinition.lengthLength / 2; // 2 HEXADECIMAL DIGITS represent 1 byte
break;
case ISOFieldCoding.ASCII:
case ISOFieldCoding.EBCDIC:
index += m_isoFieldDefinition.lengthLength; // 1 ASCII Character is 1 byte
break;
case ISOFieldCoding.BCD:
break;
default:
break;
}
ISOComponent[] isoFields = ((ISOFieldBitmapSubFields)(isoField)).GetFields();
isoFields[0] = new ISOFieldBitmap(Logger, m_fieldPackagerList[0], m_fieldPackagerList[0].GetFieldNumber());
m_fieldPackagerList[0].UnPack(isoFields[0], packedBytes, ref index);
var bitmap = isoFields[0] as ISOFieldBitmap;
int[] setFields = bitmap.GetSetFields();
for (int k = 0; k < setFields.Length; k++)
{
int fieldNumber = setFields[k];
if (fieldNumber != 0)
{
isoFields[fieldNumber] = new ISOField(Logger, m_fieldPackagerList[fieldNumber], m_fieldPackagerList[fieldNumber].GetFieldNumber());
m_fieldPackagerList[fieldNumber].UnPack(isoFields[fieldNumber], packedBytes, ref index);
}
}
//int totFields = bitmap.GetLengthInBits();
//for (int fieldNumber = 1; fieldNumber <= totFields; fieldNumber++)
//{
// if (bitmap.BitIsSet(fieldNumber))
// {
// isoFields[fieldNumber] = new ISOField(Logger, m_fieldPackagerList[fieldNumber], m_fieldPackagerList[fieldNumber].GetFieldNumber());
// m_fieldPackagerList[fieldNumber].UnPack(isoFields[fieldNumber], packedBytes, ref index);
// }
//}
}
/// <summary>
///
/// </summary>
/// <param name="isoMessageFields"></param>
/// <param name="packedBytes"></param>
/// <param name="i"></param>
public override void Pack(ISOComponent isoMessageFields, byte[] packedBytes, ref int i)
{
//bool allMandatoryExist = true;
ISOComponent[] isoFields = ((ISOMessageFields)(isoMessageFields)).GetFields();
m_fieldPackagerList[0].Pack(isoFields[0], packedBytes, ref i); // pack the message type to the byteArray for transmission
m_fieldPackagerList[1].Pack(isoFields[1], packedBytes, ref i); // pack the Bitmap to the byteArray for transmission
var bitmap = isoFields[1] as ISOFieldBitmap;
int[] setFields = bitmap.GetSetFields(); //Get all the set fields
for (int k = 0; k < setFields.Length; k++)
{
int fieldNumber = setFields[k];
if (fieldNumber >= 2 && (fieldNumber != 65 && fieldNumber != 129)) // special bit fields indicating existance of second and tird bitmap (VISA BASE I Specifications)
{
m_fieldPackagerList[fieldNumber].Pack(isoFields[fieldNumber], packedBytes, ref i);
}
}
//int totFields = bitmap.GetLengthInBits(); // get max number of fields that this message can have
//for (int fieldNumber = 2; fieldNumber <= totFields; fieldNumber++)
//{
// if (fieldNumber != 65 && fieldNumber != 129) // special bit fields indicating existance of second and tird bitmap (VISA BASE I Specifications)
// {
// if (bitmap.BitIsSet(fieldNumber))
// {
// // the mandatory field is present so package it
// m_fieldPackagerList[fieldNumber].Pack(isoFields[fieldNumber], packedBytes, ref i);
// }
// }
//}
}
public abstract byte[] Encode(ISOComponent component);
public abstract int Decode(ISOComponent component, byte[] data, int offset);
/// <summary>
/// Packs all subfields of field
/// </summary>
/// <param name="isoMessageFields"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
/// <remarks>
/// The way the length is handled is completely wrong, needs to be coded correctly
/// </remarks>
public override void Pack(ISOComponent isoMessageFields, byte[] packedBytes, ref int index)
{
ISOComponent[] isoFields = ((ISOFieldBitmapSubFields)(isoMessageFields)).GetFields();
// remember where to copy the length - once we know it
int indexStarts = index;
// based on coding of length decide how many bytes to move on packedBytes
int advanceNumOfBytes = 0;
// reserve enough bytes to store the length !! ASUMES FOR NOW THAT IS ALWAYS BINARY !!
switch (m_isoFieldDefinition.lengthCoding)
{
case ISOFieldCoding.BIN:
advanceNumOfBytes = (m_isoFieldDefinition.lengthLength / 2);
break;
case ISOFieldCoding.ASCII:
case ISOFieldCoding.EBCDIC:
advanceNumOfBytes = m_isoFieldDefinition.lengthLength;
break;
case ISOFieldCoding.BCD:
//!!! Special handling to handle BCD Length cause we need padding !!!!
break;
default:
break;
}
index += advanceNumOfBytes; // (m_isoFieldDefinition.lengthLength / 2);
m_fieldPackagerList[0].Pack(isoFields[0], packedBytes, ref index);
// bitmap was packed so get the total length in bits to determine up to what field number it expands
var bitmap = isoFields[0] as ISOFieldBitmap;
int[] setFields = bitmap.GetSetFields();
for (int k = 0; k < setFields.Length; k++)
{
int fieldNumber = setFields[k];
if (fieldNumber != 0)
{
m_fieldPackagerList[fieldNumber].Pack(isoFields[fieldNumber], packedBytes, ref index);
}
}
//int totFields = bitmap.GetLengthInBits();
//for (int fieldNumber = 1; fieldNumber <= totFields; fieldNumber++)
//{
// if (bitmap.BitIsSet(fieldNumber))
// {
// m_fieldPackagerList[fieldNumber].Pack(isoFields[fieldNumber], packedBytes, ref index);
// }
//}
//!!! Hack always assumes length is in binary format !!!!
//int bytesCopied = (i - (indexStarts - (m_isoFieldDefinition.m_lengthLength/2))); // bytes used for length not inclusive in length indicator
//!!! Assumes length is excluding the length indicator !!NEED TO INTRODUCE PARAM!!
ISOUtils.Int2Bytes(index - (indexStarts - advanceNumOfBytes), packedBytes, ref indexStarts, m_isoFieldDefinition.lengthLength);
}
/// <summary>
///
/// </summary>
/// <param name="isoField"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
public override void UnPack(ISOComponent isoField, byte[] packedBytes, ref int index)
{
throw new NotImplementedException();
}
public abstract int Decode(ISOComponent component, byte[] data, int offset);
/// <summary>
///
/// </summary>
/// <param name="isoField"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
public override void UnPack(ISOComponent isoField, ReadOnlySpan <byte> packedBytes, ref int index)
{
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("Trying to Unpack Field [" + m_number.ToString().PadLeft(3, '0') + "]");
int lengthToRead = m_isoFieldDefinition.length; // in type units
// handle length type, size and coding
if (m_isoFieldDefinition.lengthFormat == ISOFieldLengthFormat.FIXED)
{
// Do nothing, there is no length indicator
lengthToRead = m_isoFieldDefinition.length; // in type units
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("ISOField [" + m_number.ToString().PadLeft(3, '0') + "] is of FIXED length format");
}
else if (m_isoFieldDefinition.lengthFormat == ISOFieldLengthFormat.VAR)
{
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("ISOField [" + m_number.ToString().PadLeft(3, '0') + "] is of VARIABLE length format");
if (m_isoFieldDefinition.lengthCoding == ISOFieldCoding.BCD)
{
// adjust legnthToRead
lengthToRead = ISOUtils.BytesBcd2Int(packedBytes, ref index, m_isoFieldDefinition.lengthLength);
}
else if (m_isoFieldDefinition.lengthCoding == ISOFieldCoding.ASCII)
{
// adjust legnthToRead
}
else if (m_isoFieldDefinition.lengthCoding == ISOFieldCoding.BIN)
{
// adjust legnthToRead
lengthToRead = ISOUtils.Bytes2Int(packedBytes, ref index, m_isoFieldDefinition.lengthLength); // !!! hmmm this value is not bytes, it depends on content coding !!
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("Length of VARIABLE Field [" + m_number.ToString().PadLeft(3, '0') + "] is [" + lengthToRead + "]");
}
else if (m_isoFieldDefinition.lengthCoding == ISOFieldCoding.EBCDIC)
{
// adjust legnthToRead
}
else
{
//if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Unknown length coding for Field [" + m_number.ToString().PadLeft(3, '0') + "]");
}
}
else
{
//if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Error Unpacking field [" + m_number + "]. Field Length Format is Invalid!");
}
// handle content coding
if (!this.IsComposite()) //this.GetStorageClass() != "ISO8583Net.ISOMessageSubFields")
{
if (m_isoFieldDefinition.contentCoding == ISOFieldCoding.BCD)
{
isoField.value = (ISOUtils.Bcd2Ascii(packedBytes, ref index, m_isoFieldDefinition.contentPadding, lengthToRead));
// Logger.LogInformation("Field [" + m_number + "] [" + isoField.GetValue() + "]");
}
else if (m_isoFieldDefinition.contentCoding == ISOFieldCoding.ASCII)
{
isoField.value = (ISOUtils.Bytes2Ascii(packedBytes, ref index, lengthToRead));
//if (Logger.IsEnabled(LogLevel.Information)) Logger.LogInformation("Field [" + m_number + "] [" + isoField.GetValue() + "]");
}
else if (m_isoFieldDefinition.contentCoding == ISOFieldCoding.BIN)
{
// handle the ISOMessage Bitmap differently than other Bitmaps
if (m_isoFieldDefinition.lengthFormat == ISOFieldLengthFormat.FIXED && m_storeClass == "ISO8583Net.Field.ISOFieldBitmap")
{
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("ISO field [" + m_number + "] is ISOFieldBitmap and is FIXED Length but special handling needed based on 2nd and 3rd Bitmap Indicator.");
// no length to read, the Set method of Bitmap will identify if 2nd and 3rd bitmap is set so it will know how many byets to read
((ISOFieldBitmap)isoField).Set(packedBytes, ref index);
}
else
{
isoField.value = (ISOUtils.Bytes2Hex(packedBytes, ref index, lengthToRead / 2)); // Number of hex digits so convert to number of bytes
}
}
else if (m_isoFieldDefinition.contentCoding == ISOFieldCoding.EBCDIC)
{
isoField.value = (ISOUtils.Ebcdic2Ascii(packedBytes, ref index, lengthToRead));
//if (Logger.IsEnabled(LogLevel.Information)) Logger.LogInformation("Field [" + m_number + "] [" + isoField.GetValue() + "]");
}
else
{
//if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Unknown content coding for Field [" + m_number.ToString().PadLeft(3, '0') + "]. Fallback to ASCII UnPack");
}
}
}
/// <summary>
///
/// </summary>
/// <param name="isoField"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
public override void UnPack(ISOComponent isoField, ReadOnlySpan <byte> packedBytes, ref int index)
{
m_msgFieldsPackager.UnPack(isoField, packedBytes, ref index);
}
/// <summary>
///
/// </summary>
/// <param name="isoMessage"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
public override void Pack(ISOComponent isoMessage, byte[] packedBytes, ref int index)
{
m_msgFieldsPackager.Pack(isoMessage, packedBytes, ref index);
}
public override byte[] Encode(ISOComponent component)
{
byte[] b = Utils.BitArray2Byte((BitArray)component.Value);
return(ASCIIEncoding.ASCII.GetBytes(Utils.HexString(b)));
}
/// <summary>
///
/// </summary>
/// <param name="isoField"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
public override void UnPack(ISOComponent isoField, byte[] packedBytes, ref int index)
{
m_msgFieldsPackager.UnPack(isoField, packedBytes, ref index);
}
/// <summary> /// /// </summary> /// <param name="isoField"></param> /// <param name="packedBytes"></param> /// <param name="index"></param> public abstract void UnPack(ISOComponent isoField, ReadOnlySpan <byte> packedBytes, ref int index);
/// <summary> /// /// </summary> /// <param name="isoField"></param> /// <param name="packedBytes"></param> /// <param name="index"></param> public abstract void Pack(ISOComponent isoField, byte[] packedBytes, ref int index);
/// <summary>
///
/// </summary>
/// <param name="isoField"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
public void PackLengh(ISOComponent isoField, byte[] packedBytes, ref int index)
{
}
/// <summary>
///
/// </summary>
/// <param name="isoField"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
public override void Pack(ISOComponent isoField, byte[] packedBytes, ref int index)
{
string isoFieldValue;
//add the length indicator
if (m_isoFieldDefinition.lengthFormat == ISOFieldLengthFormat.VAR)
{
isoFieldValue = isoField.value;
// variable length format, check how many units of m_isoFieldDefinition.m_lengthCoding we should use
switch (m_isoFieldDefinition.lengthCoding)
{
case ISOFieldCoding.BIN:
// convert HexDigits to bytes - lengthlength = number of hexadecimal digits
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("ISOField [" + m_number + "] is of variable length and of BINARY format with lengthIndicator=[" + m_isoFieldDefinition.m_lengthLength + "] bytes");
ISOUtils.Int2Bytes(isoFieldValue.Length, packedBytes, ref index, m_isoFieldDefinition.lengthLength);
break;
case ISOFieldCoding.ASCII:
// convert ascii char to the corresponding byte value - lengthlength = number of ascii characters
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("ISOField [" + m_number + "] is of variable length and of ASCII format with lengthIndicator=[" + m_isoFieldDefinition.m_lengthLength + "] ascii characters");
break;
case ISOFieldCoding.EBCDIC:
// convert EBCDIC char to the corresponding byte value - lengthlength = number of ebdic characters
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("ISOField [" + m_number + "] is of variable length and of EBCDIC format with lengthIndicator=[" + m_isoFieldDefinition.m_lengthLength + "] ebdic charachters");
break;
case ISOFieldCoding.BCD:
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("ISOField [" + m_number + "] is of variable length and of BCD format with lengthIndicator=[" + m_isoFieldDefinition.m_lengthLength + "] BCD Nibles");
// convert bcd digits to byte values - lengthlength = number of bcd nipples (1 byte has 2 nibbles and padding should be used)
ISOUtils.Bcd2Bytes(isoFieldValue.Length, packedBytes, ref index, m_isoFieldDefinition.lengthLength);
break;
default:
//if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Error packaging field [" + m_number + "]. Length Coding Type is Invalid!");
break;
}
}
//FIXED
else
{
//Check that the length is correct or pad accordingly
int expectedLength = m_isoFieldDefinition.length;
char paddingChar = (char)m_isoFieldDefinition.contentPaddingCharacter;
if (m_isoFieldDefinition.content == ISOFieldContent.HD)
{
isoFieldValue = isoField.value;
}
else
{
if (m_isoFieldDefinition.contentCoding == ISOFieldCoding.ASCII || m_isoFieldDefinition.contentCoding == ISOFieldCoding.EBCDIC)
{
//Length is defined in bytes
if (paddingChar == 0)
{
paddingChar = ' ';
}
}
if (isoField.value.Length < expectedLength)
{
if (m_isoFieldDefinition.contentPadding == ISOFieldPadding.LEFT)
{
isoFieldValue = isoField.value.PadLeft(expectedLength, paddingChar);
}
else
{
isoFieldValue = isoField.value.PadRight(expectedLength, paddingChar);
}
}
else
{
isoFieldValue = isoField.value;
}
}
}
// handle content coding
// if is of type ISOMessageFields then dont try pack the content as is invalid
if (!this.IsComposite()) //this.GetStorageClass() != "ISO8583Net.ISOMessageSubFields")
{
////!!!! NOT EFFICIENT - WE KNOW THE TYPE GET VALUES IN BYTES WHERE YOU CAN !!!!!!/////
switch (m_isoFieldDefinition.contentCoding)
{
case ISOFieldCoding.BCD:
ISOUtils.Ascii2Bcd(isoFieldValue, packedBytes, ref index, m_isoFieldDefinition.contentPadding, m_isoFieldDefinition.contentPaddingCharacter);
break;
case ISOFieldCoding.ASCII:
ISOUtils.Ascii2Bytes(isoFieldValue, packedBytes, ref index);
break;
case ISOFieldCoding.BIN:
ISOUtils.Hex2Bytes(isoFieldValue, packedBytes, ref index);
break;
case ISOFieldCoding.EBCDIC:
ISOUtils.Ascii2Ebcdic(isoFieldValue, packedBytes, ref index);
break;
//case ISOFieldCoding.Z:
// break;
//case ISOFieldCoding.BCDU:
// break;
default:
// Logger.LogCritical("Unknown content coding for Field [" + m_number.ToString().PadLeft(3, '0') + "]. Fallback to ASCII Packager");
ISOUtils.Ascii2Bytes(isoField.value, packedBytes, ref index);
break;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="isoField"></param>
/// <param name="packedBytes"></param>
/// <param name="index"></param>
public override void UnPack(ISOComponent isoField, byte[] packedBytes, ref int index)
{
bool allMandatoryExist = true;
ISOComponent[] isoFields = ((ISOMessageFields)(isoField)).GetFields();
// Unpack the message type from the byteArray for transmission
isoFields[0] = new ISOField(Logger, m_fieldPackagerList[0], m_fieldPackagerList[0].GetFieldNumber());
m_fieldPackagerList[0].UnPack(isoFields[0], packedBytes, ref index);
string msgType = isoFields[0].value;
// Unpack the Bitmap from the byteArray for transmission
isoFields[1] = new ISOFieldBitmap(Logger, m_fieldPackagerList[1], m_fieldPackagerList[1].GetFieldNumber());
m_fieldPackagerList[1].UnPack(isoFields[1], packedBytes, ref index);
var bitmap = isoFields[1] as ISOFieldBitmap;
int[] setFields = bitmap.GetSetFields();
for (int k = 0; k < setFields.Length; k++)
{
// special bit fields indicating existance of third and fourth bitmap should not try to pack them
int fieldNumber = setFields[k];
if (fieldNumber >= 2 && fieldNumber != 65 && fieldNumber != 129)
{
if (m_fieldPackagerList[fieldNumber].IsComposite())
{
isoFields[fieldNumber] = new ISOFieldBitmapSubFields(Logger, (ISOFieldBitmapSubFieldsPackager)m_fieldPackagerList[fieldNumber], m_fieldPackagerList[fieldNumber].GetFieldNumber());
}
else
{
isoFields[fieldNumber] = new ISOField(Logger, m_fieldPackagerList[fieldNumber], m_fieldPackagerList[fieldNumber].GetFieldNumber());
}
m_fieldPackagerList[fieldNumber].UnPack(isoFields[fieldNumber], packedBytes, ref index);
}
}
//int totFields = bitmap.GetLengthInBits();
//for (int fieldNumber = 2; fieldNumber <= totFields; fieldNumber++)
//{
// // special bit fields indicating existance of third and fourth bitmap should not try to pack them
// if (fieldNumber != 65 && fieldNumber != 129)
// {
// // check if current field number is present on message bitmap
// if (bitmap.BitIsSet(fieldNumber))
// {
// if (m_fieldPackagerList[fieldNumber].IsComposite())
// {
// //if (m_fieldPackagerList[fieldNumber].GetStorageClass() == "ISO8583Net.ISOMessageSubFields")
// //{
// isoFields[fieldNumber] = new ISOFieldBitmapSubFields(Logger, (ISOFieldBitmapSubFieldsPackager)m_fieldPackagerList[fieldNumber], m_fieldPackagerList[fieldNumber].GetFieldNumber());
// //}
// }
// else
// {
// isoFields[fieldNumber] = new ISOField(Logger, m_fieldPackagerList[fieldNumber], m_fieldPackagerList[fieldNumber].GetFieldNumber());
// }
// m_fieldPackagerList[fieldNumber].UnPack(isoFields[fieldNumber], packedBytes, ref index);
// }
// }
//}
}
/// <summary>
///
/// </summary>
/// <param name="isoField"></param>
public void Validate(ISOComponent isoField)
{
// Check field length limitation
// Validate content based on Definition AN, N, ASCII, HEX (if BIN) etc
// if FIXED check that user provided exact data
// if VAR check that is not exceeding max definition
this.Trace();
// Validate the packager
// ---------------------
//
// Notes on Field Encoding
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// 01. Field Encoding BCD implies field value format = N and should be padded if not ODD (LEFT or RIGHT)
// 02. Field Encoding ASCII implies each char is [a..z][A..Z][0..9] and value length should always be ODD number
// 03. Field Encoding BIN implies each char is [0..9][A..F]
// 04. Field Encoding EBCDIC implies each char is an EBCDIC char
// 05. Field Encoding Z implies that field contains [0..9]0x0D[0..9]
//
// Notes on Field Format
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// 06. Field Format A implies field value contains only [A..Z] [a..z]
// 07. Field Format AN implies field value contains only [A..Z] [a..z] [0..9]
// 08. Field Format ANS implies field value contains only [A..Z] [a..z] [0..9] [!"£$%^&*()_+-=[]{}#';~@:/.,?><\|`¬]
// 09. Field Format AS implies field value contains only [A..Z] [a..z] [!"£$%^&*()_+-=[]{}#';~@:/.,?><\|`¬]
// 10. Field Format N implies field value contains only [0..9]
// 11. Field Format NS implies field value contains only [0..9] [!"£$%^&*()_+-=[]{}#';~@:/.,?><\|`¬]
// 12. Field Format Z implies field value contains only [0..9] [0x0D]
// 13. Field Format HD implies field value contains only [0..9] [A..F] Hexadecimal Digits
//
// Notes on Length Type
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// 13. Length Type FIXED implies that field length is always of length equals to field length definition
// 14. Length Type LVAR implies that field length is using 1 byte to indicate the length of value to follow and has MAX value equal to what is in field length definition or no more than 255
// 15. Length Type LLVAR implies that field length is using 2 bytes to indicate the length of value to follow and has MAX value equal to what is in field length definition or no more than 65535
//
// Notes on Length Encoding
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// 16. Length Encoding BCD implies field value format = N and should be padded if not ODD (LEFT or RIGHT)
// 17. Length Encoding BIN implies each char is [0..9][A..F] and value length should always be ODD number
// 18. Length Encoding ASCII implies each char is [0..9] since is length
// 19. Length Encoding EBCDIC implies each char is a valid EBCDIC char and is [0..9]
// 20. Length Encoding Z NOT POSSIBLE TO USE AS LENGTH ENCODING
//
// Notes on Lengths
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// 21. When Encoding is BCD Length is expressed in nipples (1/2 bytes) For Example: field 002 card number len = 19 means 19 Nipple means field value can be up to 19 decimal digits
// 22. When Encoding is BIN Length is expressed in hexadecimal digits For Example: field 064 Mac len = 16 means 8 Bytes which means a valid hexadecimal sequence of length 16 0123456789ABCDEF
// 23. When Encoding is ASCII Length is expressed in characters For Example: if len=16 it means 16 ASCII characters (8bytes)
// 24. When Encoding is EBCDIC Length is expressed in characters For Example: if len=16 it means 16 EBCDIC characters (8bytes)
// 25. When Encoding is Z Length is expressed in niples (1/2Bytes) plus 1 byte for HEXADECIMAL 0x0D those 0x0D is accounted for two nibbles
string fldValue = isoField.value;
string fldNumber = m_number.ToString().PadLeft(3, '0');
// validate the content of field value based on field format
switch (m_isoFieldDefinition.content)
{
case ISOFieldContent.A:
// check if is only [A..Z][a..z]
break;
case ISOFieldContent.AN:
// check if is only [A..Z][a..z][0..1]
break;
case ISOFieldContent.ANS:
// check if is only [A..Z] [a..z] [0..9] [!"£$%^&*()_+-=[]{}#';~@:/.,?><\|`¬]
break;
case ISOFieldContent.AS:
// check if is only [A..Z] [a..z] [!"£$%^&*()_+-=[]{}#';~@:/.,?><\|`¬]
break;
case ISOFieldContent.N:
// check if is only [0..9]
break;
case ISOFieldContent.NS:
// check if is only [0..9] [!"£$%^&*()_+-=[]{}#';~@:/.,?><\|`¬]
break;
case ISOFieldContent.HD:
// check is only [0..9] [A..F] Hexadecimal Digits
break;
}
// validate the field value based on field content coding
switch (m_isoFieldDefinition.contentCoding)
{
case ISOFieldCoding.EBCDIC:
if (ISOUtils.IsAscii(fldValue))
{
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Field [" + fldNumber + "] contains only EBCDIC characters [OK]");
}
}
else
{
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Field [" + fldNumber + "] contains non EBCDIC characters [NOT-OK]");
}
}
break;
case ISOFieldCoding.ASCII:
if (ISOUtils.IsAscii(fldValue))
{
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Field [" + fldNumber + "] contains only ASCII characters [OK]");
}
}
else
{
//if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Field [" + fldNumber + "] contains non ASCII characters [NOT-OK]");
}
break;
case ISOFieldCoding.BCDU:
case ISOFieldCoding.BCD:
if (ISOUtils.IsDigits(fldValue))
{
// if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("Field [" + fldNumber + "] contains only decimal digits [OK]");
}
else
{
//if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Field [" + fldNumber + "] contains non decimal digits [NOT-OK]");
}
break;
case ISOFieldCoding.BIN:
if (ISOUtils.IsHexDigits(fldValue))
{
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("Field [" + fldNumber + "] contains only hexadecimal digits [OK]");
}
else
{
// if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Field [" + fldNumber + "] contains non hexadecimal digits [NOT-OK]");
}
break;
case ISOFieldCoding.Z:
break;
}
// validate length of field value based on length field coding
switch (m_isoFieldDefinition.lengthCoding)
{
case ISOFieldCoding.ASCII:
break;
case ISOFieldCoding.BCD:
break;
case ISOFieldCoding.BCDU:
break;
case ISOFieldCoding.BIN:
break;
case ISOFieldCoding.EBCDIC:
break;
case ISOFieldCoding.Z:
break;
}
// validate length based on length format
switch (m_isoFieldDefinition.lengthFormat)
{
// All checks are based on value length and definition length since length is always ecxpressed in units of coding used
// For example, ASCII=number of chars, BIN=number of hex digits, BCD=number of nibbles etc
case ISOFieldLengthFormat.FIXED:
if ((fldValue.Length == m_isoFieldDefinition.length) && this.m_number != 1)
{
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("Field [" + fldNumber + "] Value has Length[" + fldValue.Length + "] = Definition Length=[" + m_isoFieldDefinition.m_length +"] [OK]");
}
else if ((fldValue.Length > m_isoFieldDefinition.length) && this.m_number != 1)
{
//if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Field [" + fldNumber + "] Value has Length[" + fldValue.Length + "] > Definition Length=[" + m_isoFieldDefinition.m_length + "] [NOT-OK] [TRIM & PACK POSSIBLE]");
}
else if ((fldValue.Length < m_isoFieldDefinition.length) && this.m_number != 1)
{
//if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Field [" + fldNumber + "] Value has Length[" + fldValue.Length + "] < Definition Length=[" + m_isoFieldDefinition.m_length + "] [NOT-OK] [PACK IMPOSSIBLE]");
}
break;
case ISOFieldLengthFormat.VAR:
if ((fldValue.Length <= m_isoFieldDefinition.length) && this.m_number != 1)
{
//if (Logger.IsEnabled(LogLevel.Debug)) Logger.LogDebug("Field [" + fldNumber + "] Value has Length[" + fldValue.Length + "] <= Definition Length=[" + m_isoFieldDefinition.m_length + "] [OK]");
}
else if ((fldValue.Length > m_isoFieldDefinition.length) && this.m_number != 1)
{
//if (Logger.IsEnabled(LogLevel.Critical)) Logger.LogCritical("Field [" + fldNumber + "] value length[" + fldValue.Length + "] > definition length[" + m_isoFieldDefinition.m_length + "] [NOT-OK] [TRIM & PACK POSSIBLE");
}
break;
}
}
public abstract byte[] Encode(ISOComponent component);
