Esempio n. 1
0
 /// <summary>
 /// Creates a new instance that knows how to parse a value of the given
 /// type and the given length (the length is necessary for ALPHA and NUMERIC
 /// values only).
 /// </summary>
 /// <param name="t">The ISO8583 type.</param>
 /// <param name="len">The length of the value to parse (for ALPHA and NUMERIC values).</param>
 /// <param name="req">Define mandatory xml item</param>
 public FieldParseInfo(IsoType t, Int32 len, Boolean req, TypeElement st, Dictionary <Int32, FieldParseInfo> sub, ConfigParser.Base b)
 {
     type     = t;
     length   = len;
     required = req;
     subDataElements_Fields = sub;
     typeElement            = st;
     this.b = b;
 }
Esempio n. 2
0
        /// <summary>
        /// Parse and store the data in its respective subelement/subfield
        /// </summary>
        /// <param name="configBase"></param>
        /// <param name="subDataElements_Fields"></param>
        /// <param name="val"></param>
        /// <param name="encoder"></param>
        /// <param name="pos"></param>
        /// <returns></returns>
        internal IsoValue parseDataElement_Field(CaseBusiness.ISO.EncodingType encoding, ConfigParser.Base configBase, Dictionary <Int32, FieldParseInfo> subDataElements_Fields, IsoValue val, Encoding encoder, ref Int32 pos)
        {
            Byte[] bufSub = null;

            if (configBase == ConfigParser.Base.B64)
            {
                bufSub = Convert.FromBase64String(val.OriginalValue);
            }
            else
            {
                bufSub = Encoding.ASCII.GetBytes(val.OriginalValue);
            }

            Int32 posLeitura       = 0;
            Int32 multFieldHex     = 1; //variavel para controle de campos do tipo Binary (recebido no formato Hex)
            Int32 multHex          = 1; //variavel para controle de campos do tipo Binary (recebido no formato Hex)
            Int32 DE_FieldsChecked = 0;

            for (Int32 i = 0; DE_FieldsChecked < subDataElements_Fields.Count; i++)
            {
                Int32 posSub = 0;
                KeyValuePair <Int32, FieldParseInfo> subData = subDataElements_Fields.ElementAt(i);

                if (val.SubData.Keys.Contains(subData.Key))
                {
                    continue;
                }

                if (posLeitura > 0)
                {
                    posSub = posLeitura;
                }

                if (subData.Value.TypeElement == TypeElement.SubElement)
                {
                    #region SubElement

                    Int32 numSubElementArray = 0;

                    if (configBase == ConfigParser.Base.Hexadecimal) //Quando campo Binario, й tratado como campo Hexadecimal, logo a extraзгo de bytes й dobrada
                    {
                        multFieldHex       = 2;
                        multHex            = 2;
                        numSubElementArray = Convert.ToInt32(Encoding.ASCII.GetString(bufSub, posSub, subData.Value.SubElementIDLength * multFieldHex), 16);
                    }
                    else
                    {
                        multFieldHex       = 1;
                        multHex            = 1;
                        numSubElementArray = Convert.ToInt32(Encoding.ASCII.GetString(bufSub, posSub, subData.Value.SubElementIDLength));
                    }

                    if (numSubElementArray == subData.Key)
                    {
                        posSub += subData.Value.SubElementIDLength * multFieldHex;


                        Int32 tamSubElement = (configBase == ConfigParser.Base.Hexadecimal ? Convert.ToInt32(Encoding.ASCII.GetString(bufSub, posSub, subData.Value.LengthOfLengthSubElement * multFieldHex), 16) : Convert.ToInt32(Encoding.ASCII.GetString(bufSub, posSub, subData.Value.LengthOfLengthSubElement * multFieldHex))) * multHex;
                        posSub += subData.Value.LengthOfLengthSubElement * multFieldHex;
                        String   value  = "";
                        IsoValue valSub = null;
                        //Byte[] bufSubSub = null;

                        if (configBase == ConfigParser.Base.B64)
                        {
                            value = Convert.ToBase64String(bufSub, posSub, tamSubElement);
                            //bufSubSub = Encoding.ASCII.GetBytes(valSub.OriginalValue);
                        }
                        else
                        {
                            value = Encoding.ASCII.GetString(bufSub, posSub, tamSubElement);
                            // bufSubSub = Encoding.ASCII.GetBytes(valSub.OriginalValue);
                        }

                        valSub = new IsoValue(subData.Value.Type, configBase, value, value.Length, value, "", subData.Value.TypeElement, subData.Value.SubElementIDLength, subData.Value.LengthOfLengthSubElement);

                        if (subData.Value.SubDataElements_Fields == null || subData.Value.SubDataElements_Fields.Count == 0)
                        {
                            val.SubData.Add(subData.Key, valSub);
                        }
                        else  //Quando: subData.Value.SubDataElements_Fields.Count > 0
                        {
                            val.SubData.Add(subData.Key, parseDataElement_Field(encoding, configBase, subData.Value.SubDataElements_Fields, valSub, encoder, ref pos));
                        }

                        posSub    += tamSubElement;
                        posLeitura = posSub;
                        DE_FieldsChecked++;
                        i = -1;
                    }
                    else if (i == (subDataElements_Fields.Count - 1))
                    {
                        DE_FieldsChecked++;
                        i = -1;
                    }

                    #endregion SubElement
                }
                else
                {
                    #region SubField
                    if (posSub < bufSub.Length)
                    {
                        IsoValue valSub = subData.Value.Parse(encoding, bufSub, posSub, encoder, true);

                        if (subData.Value.SubDataElements_Fields == null || subData.Value.SubDataElements_Fields.Count == 0)
                        {
                            if (valSub.OriginalValue != null)
                            {
                                val.SubData.Add(subData.Key, valSub);
                                posSub     += valSub.Length;
                                posLeitura += valSub.Length;

                                if (valSub.Type == IsoType.LLVAR)
                                {
                                    pos += 2;
                                }
                                else if (valSub.Type == IsoType.LLLVAR)
                                {
                                    pos += 3;
                                }
                            }
                            else
                            {
                                return(null);
                            }
                        }
                        else
                        {
                            val.SubData.Add(subData.Key, parseDataElement_Field(encoding, configBase, subData.Value.SubDataElements_Fields, valSub, encoder, ref pos));
                        }
                    }

                    DE_FieldsChecked++;
                    #endregion
                }

                if (posSub >= val.Length)
                {
                    break;
                }
            }

            val.CompletelyParsed = true;
            return(val);
        }