示例#1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="reader"></param>
        /// <returns></returns>
        private ISOFieldPackager LoadISOFieldPackager(XmlReader reader)
        {
            ISOFieldDefinition fieldDefinition = new ISOFieldDefinition();

            ISOFieldPackager fieldPackager = new ISOFieldPackager(_logger);

            // Search for the attribute name on this current node.

            string attribute = reader["number"];

            if (attribute != null)
            {
                fieldPackager.SetFieldNumber(Int32.Parse(attribute));
            }

            attribute = reader["name"];

            if (attribute != null)
            {
                fieldDefinition.name = attribute;
            }

            attribute = reader["length"];

            if (attribute != null)
            {
                fieldDefinition.length = Int32.Parse(attribute);
            }

            attribute = reader["lengthlength"];

            if (attribute != null)
            {
                fieldDefinition.lengthLength = Int32.Parse(attribute);
            }

            attribute = reader["lengthformat"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "FIXED":
                    fieldDefinition.lengthFormat = ISOFieldLengthFormat.FIXED;
                    break;

                case "VAR":
                    fieldDefinition.lengthFormat = ISOFieldLengthFormat.VAR;
                    break;
                }
            }

            attribute = reader["lengthcoding"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "ASCII":
                    fieldDefinition.lengthCoding = ISOFieldCoding.ASCII;
                    break;

                case "BCD":
                    fieldDefinition.lengthCoding = ISOFieldCoding.BCD;
                    break;

                case "BCDU":
                    fieldDefinition.lengthCoding = ISOFieldCoding.BCDU;
                    break;

                case "EBCDIC":
                    fieldDefinition.lengthCoding = ISOFieldCoding.EBCDIC;
                    break;

                case "BIN":
                    fieldDefinition.lengthCoding = ISOFieldCoding.BIN;
                    break;
                }
            }

            attribute = reader["lengthpadding"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "LEFT":
                    fieldDefinition.lengthPadding = ISOFieldPadding.LEFT;
                    break;

                case "RIGHT":
                    fieldDefinition.lengthPadding = ISOFieldPadding.RIGHT;
                    break;

                case "NONE":
                    fieldDefinition.lengthPadding = ISOFieldPadding.NONE;
                    break;
                }
            }

            attribute = reader["contentformat"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "A":
                    fieldDefinition.content = ISOFieldContent.A;
                    break;

                case "AN":
                    fieldDefinition.content = ISOFieldContent.AN;
                    break;

                case "ANS":
                    fieldDefinition.content = ISOFieldContent.ANS;
                    break;

                case "AS":
                    fieldDefinition.content = ISOFieldContent.AS;
                    break;

                case "N":
                    fieldDefinition.content = ISOFieldContent.N;
                    break;

                case "NS":
                    fieldDefinition.content = ISOFieldContent.NS;
                    break;

                case "HD":
                    fieldDefinition.content = ISOFieldContent.HD;
                    break;

                case "TRACK2":
                    fieldDefinition.content = ISOFieldContent.Z;
                    break;

                case "Z":
                    fieldDefinition.content = ISOFieldContent.Z;
                    break;
                }
            }

            attribute = reader["contentcoding"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "ASCII":
                    fieldDefinition.contentCoding = ISOFieldCoding.ASCII;
                    break;

                case "BCD":
                    fieldDefinition.contentCoding = ISOFieldCoding.BCD;
                    // Always N the content since nothing else is possible
                    fieldDefinition.content = ISOFieldContent.N;
                    break;

                case "BCDU":
                    fieldDefinition.contentCoding = ISOFieldCoding.BCDU;
                    // Always N the content since nothing else is possible
                    fieldDefinition.content = ISOFieldContent.N;
                    break;

                case "EBCDIC":
                    fieldDefinition.contentCoding = ISOFieldCoding.EBCDIC;
                    break;

                case "BIN":
                    // Always HD the content since nothing else is possible
                    fieldDefinition.content       = ISOFieldContent.HD;
                    fieldDefinition.contentCoding = ISOFieldCoding.BIN;
                    break;

                case "Z":
                    fieldDefinition.contentCoding = ISOFieldCoding.Z;
                    break;
                }
            }

            attribute = reader["contentpaddingcharacter"];
            if (!string.IsNullOrEmpty(attribute))
            {
                if (fieldDefinition.contentCoding == ISOFieldCoding.ASCII || fieldDefinition.contentCoding == ISOFieldCoding.ASCII)
                {
                    //save as ascii character
                    fieldDefinition.contentPaddingCharacter = (byte)attribute[0];
                }
                else
                {
                    //padding character should be a hex digit 0-F
                    //save the numeric value of it
                    fieldDefinition.contentPaddingCharacter = Convert.ToByte(attribute, 16);
                }
            }
            attribute = reader["contentpadding"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "LEFT":
                    fieldDefinition.contentPadding = ISOFieldPadding.LEFT;
                    break;

                case "RIGHT":
                    fieldDefinition.contentPadding = ISOFieldPadding.RIGHT;
                    break;

                case "NONE":
                    fieldDefinition.contentPadding = ISOFieldPadding.NONE;
                    break;
                }
            }

            attribute = reader["desc"];

            if (attribute != null)
            {
                fieldDefinition.description = attribute;
            }

            fieldPackager.SetFieldDefinition(fieldDefinition);
            return(fieldPackager);
        }
示例#2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="fieldNumber"></param>
        /// <returns></returns>
        private ISOFieldBitmapSubFieldsPackager LoadISOMessageSubFieldsPackager(XmlReader reader, int fieldNumber)
        {
            ISOFieldBitmapSubFieldsPackager msgFieldPackager = new ISOFieldBitmapSubFieldsPackager(_logger, fieldNumber, m_totalFields);

            if (reader.ReadToDescendant("isofield"))
            {
                do
                {
                    int fldNumber = int.Parse(reader["number"]);

                    string packager       = reader["packager"];
                    string storageclass   = reader["storageclass"];
                    string iscomposite    = reader["composite"];
                    string isointerpreter = reader["interpreter"];

                    if (_logger.IsEnabled(LogLevel.Trace))
                    {
                        _logger.LogTrace("Field Number: " + fldNumber.ToString().PadLeft(3, '0') + " Name: " + reader["name"] + " Description: " + reader["desc"]);
                    }

                    switch (packager)
                    {
                    case "ISOFieldBitmapSubFieldsPackager":

                        int totalFields = Int32.Parse(reader["totalfields"]);

                        totalFields += 1;

                        if (_logger.IsEnabled(LogLevel.Trace))
                        {
                            _logger.LogTrace("Field Number: " + fldNumber.ToString().PadLeft(3, '0') + " is of [[[<--ISOMessageFieldsPackager-->]]], SubFields follow:");
                        }

                        ISOFieldPackager fPackager = LoadISOFieldPackager(reader);

                        ISOFieldBitmapSubFieldsPackager newMsgFieldPackager = LoadISOMessageSubFieldsPackager(reader, fldNumber);

                        newMsgFieldPackager.SetISOFieldDefinition(fPackager.GetISOFieldDefinition());

                        newMsgFieldPackager.SetStorageClass(Type.GetType("ISO8583Net.Field.ISOFieldBitmapSubFields"));

                        msgFieldPackager.Add(newMsgFieldPackager, newMsgFieldPackager.GetFieldNumber());

                        newMsgFieldPackager.totalFields = totalFields;

                        break;

                    default:

                        ISOFieldPackager fieldPackager = LoadISOFieldPackager(reader);

                        if (storageclass == null)
                        {
                            fieldPackager.SetStorageClass(Type.GetType("ISO8583Net.Field.ISOField"));
                        }
                        else
                        {
                            fieldPackager.SetStorageClass(Type.GetType("ISO8583Net." + storageclass));
                        }

                        if (iscomposite == null || iscomposite == "N" || iscomposite == "n" || iscomposite == "No" || iscomposite == "no")
                        {
                            fieldPackager.SetComposite(false);
                        }
                        else
                        {
                            fieldPackager.SetComposite(true);
                        }

                        switch (isointerpreter)
                        {
                        //case "ISOEMVTagInterpreter":
                        //    fieldPackager.SetISOInterpreter(new ISOEMVTagInterpreter(Logger));
                        //    break;

                        case "ISOIndexedValueInterpreter":
                            ISOIndexedValueInterpreter isoIndexedValueInterpreter = LoadISOIndexedValueInterpreter(reader);
                            fieldPackager.SetISOInterpreter(isoIndexedValueInterpreter);
                            break;
                        }

                        msgFieldPackager.Add(fieldPackager, fieldPackager.GetFieldNumber());

                        break;
                    }
                } while (reader.ReadToNextSibling("isofield"));
            }
            return(msgFieldPackager);
        }
示例#3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="reader"></param>
        /// <returns></returns>
        private ISOFieldPackager LoadISOFieldPackager(XmlReader reader)
        {
            ISOFieldDefinition fieldDefinition = new ISOFieldDefinition();

            ISOFieldPackager fieldPackager = new ISOFieldPackager(Logger);

            // Search for the attribute name on this current node.

            string attribute = reader["number"];

            if (attribute != null)
            {
                fieldPackager.SetFieldNumber(Int32.Parse(attribute));
            }

            attribute = reader["name"];

            if (attribute != null)
            {
                fieldDefinition.name = attribute;
            }

            attribute = reader["length"];

            if (attribute != null)
            {
                fieldDefinition.length = Int32.Parse(attribute);
            }

            attribute = reader["lengthlength"];

            if (attribute != null)
            {
                fieldDefinition.lengthLength = Int32.Parse(attribute);
            }

            attribute = reader["lengthformat"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "FIXED":
                    fieldDefinition.lengthFormat = ISOFieldLengthFormat.FIXED;
                    break;

                case "VAR":
                    fieldDefinition.lengthFormat = ISOFieldLengthFormat.VAR;
                    break;
                }
            }

            attribute = reader["lengthcoding"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "ASCII":
                    fieldDefinition.lengthCoding = ISOFieldCoding.ASCII;
                    break;

                case "BCD":
                    fieldDefinition.lengthCoding = ISOFieldCoding.BCD;
                    break;

                case "BCDU":
                    fieldDefinition.lengthCoding = ISOFieldCoding.BCDU;
                    break;

                case "EBCDIC":
                    fieldDefinition.lengthCoding = ISOFieldCoding.EBCDIC;
                    break;

                case "BIN":
                    fieldDefinition.lengthCoding = ISOFieldCoding.BIN;
                    break;
                }
            }

            attribute = reader["lengthpadding"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "LEFT":
                    fieldDefinition.lengthPadding = ISOFieldPadding.LEFT;
                    break;

                case "RIGHT":
                    fieldDefinition.lengthPadding = ISOFieldPadding.RIGHT;
                    break;

                case "NONE":
                    fieldDefinition.lengthPadding = ISOFieldPadding.NONE;
                    break;
                }
            }

            attribute = reader["contentformat"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "A":
                    fieldDefinition.content = ISOFieldContent.A;
                    break;

                case "AN":
                    fieldDefinition.content = ISOFieldContent.AN;
                    break;

                case "ANS":
                    fieldDefinition.content = ISOFieldContent.ANS;
                    break;

                case "AS":
                    fieldDefinition.content = ISOFieldContent.AS;
                    break;

                case "N":
                    fieldDefinition.content = ISOFieldContent.N;
                    break;

                case "NS":
                    fieldDefinition.content = ISOFieldContent.NS;
                    break;

                case "HD":
                    fieldDefinition.content = ISOFieldContent.HD;
                    break;

                case "TRACK2":
                    fieldDefinition.content = ISOFieldContent.Z;
                    break;

                case "Z":
                    fieldDefinition.content = ISOFieldContent.Z;
                    break;
                }
            }

            attribute = reader["contentcoding"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "ASCII":
                    fieldDefinition.contentCoding = ISOFieldCoding.ASCII;
                    break;

                case "BCD":
                    fieldDefinition.contentCoding = ISOFieldCoding.BCD;
                    // Always N the content since nothing else is possible
                    fieldDefinition.content = ISOFieldContent.N;
                    break;

                case "BCDU":
                    fieldDefinition.contentCoding = ISOFieldCoding.BCDU;
                    // Always N the content since nothing else is possible
                    fieldDefinition.content = ISOFieldContent.N;
                    break;

                case "EBCDIC":
                    fieldDefinition.contentCoding = ISOFieldCoding.EBCDIC;
                    break;

                case "BIN":
                    // Always HD the content since nothing else is possible
                    fieldDefinition.content       = ISOFieldContent.HD;
                    fieldDefinition.contentCoding = ISOFieldCoding.BIN;
                    break;

                case "Z":
                    fieldDefinition.contentCoding = ISOFieldCoding.Z;
                    break;
                }
            }

            attribute = reader["contentpadding"];

            if (attribute != null)
            {
                switch (attribute)
                {
                case "LEFT":
                    fieldDefinition.contentPadding = ISOFieldPadding.LEFT;
                    break;

                case "RIGHT":
                    fieldDefinition.contentPadding = ISOFieldPadding.RIGHT;
                    break;

                case "NONE":
                    fieldDefinition.contentPadding = ISOFieldPadding.NONE;
                    break;
                }
            }

            attribute = reader["desc"];

            if (attribute != null)
            {
                fieldDefinition.description = attribute;
            }

            fieldPackager.SetFieldDefinition(fieldDefinition);
            return(fieldPackager);
        }