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(); }
/// <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; } }