예제 #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="reader"></param>
        /// <returns></returns>
        private ISOIndexedValueInterpreter LoadISOIndexedValueInterpreter(XmlReader reader)
        {
            ISOIndexedValueInterpreter isoIndexedValueInterpreter = new ISOIndexedValueInterpreter(_logger);

            if (reader.ReadToDescendant("interpreter"))
            {
                do
                {
                    string index  = reader["index"];
                    string length = reader["length"];
                    string desc   = reader["desc"];

                    if (reader.ReadToDescendant("value"))
                    {
                        isoIndexedValueInterpreter.AddIndexLength(Int32.Parse(index), Int32.Parse(length));

                        Dictionary <string, string> dic = new Dictionary <string, string>();

                        dic.Add("", desc);

                        do
                        {
                            string value = reader["value"];
                            desc = reader["desc"];

                            dic.Add(value, desc);
                        } while (reader.ReadToNextSibling("value"));

                        isoIndexedValueInterpreter.AddIndexValueDescriptionDic(Int32.Parse(index), dic);
                    }
                } while (reader.ReadToNextSibling("interpreter"));
            }

            return(isoIndexedValueInterpreter);
        }
예제 #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);
        }