Beispiel #1
0
        public Extract(HeaderExtract header, BankAccount bankAccount,
            String status, DateTime initialDate, DateTime finalDate)
        {
            Init(header, bankAccount, status);

            this.InitialDate = initialDate;
            this.FinalDate = finalDate;
        }
Beispiel #2
0
 private void Init(HeaderExtract header, BankAccount bankAccount, String status)
 {
     this.Header = header;
     this.BankAccount = bankAccount;
     this.Status = status;
     this.Transactions = new List<Transaction>();
     this.ImportingErrors = new List<string>();
 }
Beispiel #3
0
 public Extract(HeaderExtract header, BankAccount bankAccount,
     String status)
 {
     Init(header, bankAccount, status);
 }
        public Extract GenerateExtract(string ofxSourceFile)
        {
            // Translating to XML file
            var xmlFilePath = ofxSourceFile + ".xml";

            ExportToXml(ofxSourceFile, xmlFilePath);

            var         elementoSendoLido = "";
            Transaction transacaoAtual    = null;

            var header      = new HeaderExtract();
            var bankAccount = new BankAccount();
            var extract     = new Extract(header, bankAccount, "");

            // Lendo o XML efetivamente
            var xmlReader = new XmlTextReader(xmlFilePath);

            try
            {
                while (xmlReader.Read())
                {
                    if (xmlReader.NodeType == XmlNodeType.EndElement && xmlReader.Name.Equals("STMTTRN") && transacaoAtual != null)
                    {
                        extract.AddTransaction(transacaoAtual);
                        transacaoAtual = null;
                    }
                    if (xmlReader.NodeType == XmlNodeType.Element)
                    {
                        elementoSendoLido = xmlReader.Name;
                        if (xmlReader.Name.Equals("STMTTRN"))
                        {
                            transacaoAtual = new Transaction();
                        }
                    }
                    if (xmlReader.NodeType == XmlNodeType.Text)
                    {
                        switch (elementoSendoLido)
                        {
                        case "DTSERVER":
                            header.ServerDate = ConvertOfxDateToDateTime(xmlReader.Value, extract);
                            break;

                        case "LANGUAGE":
                            header.Language = xmlReader.Value;
                            break;

                        case "ORG":
                            header.BankName = xmlReader.Value;
                            break;

                        case "DTSTART":
                            extract.InitialDate = ConvertOfxDateToDateTime(xmlReader.Value, extract);
                            break;

                        case "DTEND":
                            extract.FinalDate = ConvertOfxDateToDateTime(xmlReader.Value, extract);
                            break;

                        case "BANKID":
                            bankAccount.Bank = new Bank(GetBankId(xmlReader.Value, extract), "");
                            break;

                        case "BRANCHID":
                            bankAccount.AgencyCode = xmlReader.Value;
                            break;

                        case "ACCTID":
                            bankAccount.AccountCode = xmlReader.Value;
                            break;

                        case "ACCTTYPE":
                            bankAccount.Type = xmlReader.Value;
                            break;

                        case "TRNTYPE":
                            transacaoAtual.Type = xmlReader.Value;
                            break;

                        case "DTPOSTED":
                            transacaoAtual.Date = ConvertOfxDateToDateTime(xmlReader.Value, extract);
                            break;

                        case "TRNAMT":
                            transacaoAtual.TransactionValue = GetTransactionValue(xmlReader.Value, extract);
                            break;

                        case "FITID":
                            transacaoAtual.Id = xmlReader.Value;
                            break;

                        case "CHECKNUM":
                            transacaoAtual.Checksum = Convert.ToInt64(xmlReader.Value);
                            break;

                        case "MEMO":
                            transacaoAtual.Description = string.IsNullOrEmpty(xmlReader.Value) ? string.Empty : Regex.Replace(xmlReader.Value.Trim(), "[^\\S\\n]+", " ");
                            break;
                        }
                    }
                }
            }
            catch (XmlException xe)
            {
                throw new OFXParserException($"Invalid OFX file", xe);
            }
            finally
            {
                xmlReader.Close();
            }
            return(extract);
        }
Beispiel #5
0
        public static Extract GetExtract(String ofxSourceFile, ParserSettings settings)
        {
            if (settings == null)
            {
                settings = new ParserSettings();
            }

            Boolean temCabecalho  = false;
            Boolean temDadosConta = false;

            // Translating to XML file
            ExportToXml(ofxSourceFile, ofxSourceFile + ".xml");

            // Variáveis úteis para o Parse
            String      elementoSendoLido = "";
            Transaction transacaoAtual    = null;

            // Variávies utilizadas para a leitura do XML
            HeaderExtract cabecalho = new HeaderExtract();
            BankAccount   conta     = new BankAccount();
            Extract       extrato   = new Extract(cabecalho, conta, "");

            // Lendo o XML efetivamente
            using (XmlTextReader meuXml = new XmlTextReader(ofxSourceFile + ".xml"))
            {
                try
                {
                    while (meuXml.Read())
                    {
                        if (meuXml.NodeType == XmlNodeType.EndElement)
                        {
                            switch (meuXml.Name)
                            {
                            case "STMTTRN":
                                if (transacaoAtual != null)
                                {
                                    extrato.AddTransaction(transacaoAtual);
                                    transacaoAtual = null;
                                }

                                break;
                            }
                        }

                        if (meuXml.NodeType == XmlNodeType.Element)
                        {
                            elementoSendoLido = meuXml.Name;

                            switch (elementoSendoLido)
                            {
                            case "STMTTRN":
                                transacaoAtual = new Transaction();
                                break;
                            }
                        }

                        if (meuXml.NodeType == XmlNodeType.Text)
                        {
                            switch (elementoSendoLido)
                            {
                            case "DTSERVER":
                                cabecalho.ServerDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
                                temCabecalho         = true;
                                break;

                            case "LANGUAGE":
                                cabecalho.Language = meuXml.Value;
                                temCabecalho       = true;
                                break;

                            case "ORG":
                                cabecalho.BankName = meuXml.Value;
                                temCabecalho       = true;
                                break;

                            case "DTSTART":
                                extrato.InitialDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
                                break;

                            case "DTEND":
                                extrato.FinalDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
                                break;

                            case "BANKID":
                                conta.Bank    = new Bank(GetBankId(meuXml.Value, extrato), "");
                                temDadosConta = true;
                                break;

                            case "BRANCHID":
                                conta.AgencyCode = meuXml.Value;
                                temDadosConta    = true;
                                break;

                            case "ACCTID":
                                conta.AccountCode = meuXml.Value;
                                temDadosConta     = true;
                                break;

                            case "ACCTTYPE":
                                conta.Type    = meuXml.Value;
                                temDadosConta = true;
                                break;

                            case "TRNTYPE":
                                transacaoAtual.Type = meuXml.Value;
                                break;

                            case "DTPOSTED":
                                transacaoAtual.Date = ConvertOfxDateToDateTime(meuXml.Value, extrato);
                                break;

                            case "TRNAMT":
                                transacaoAtual.TransactionValue = GetTransactionValue(meuXml.Value, extrato);
                                break;

                            case "FITID":
                                transacaoAtual.Id = meuXml.Value;
                                break;

                            case "CHECKNUM":
                                transacaoAtual.Checksum = Convert.ToInt64(meuXml.Value);
                                break;

                            case "MEMO":
                                transacaoAtual.Description = string.IsNullOrEmpty(meuXml.Value) ? "" : meuXml.Value.Trim().Replace("  ", " ");
                                break;

                            case "NAME":
                                transacaoAtual.Name = meuXml.Value;
                                break;
                            }
                        }
                    }
                }
                catch (XmlException xe)
                {
                    throw new OFXParserException("Invalid OFX file " + ofxSourceFile + " : " + xe.Message, xe);
                }
                finally
                {
                    meuXml.Close();
                    if (File.Exists(ofxSourceFile + ".xml"))
                    {
                        File.Delete(ofxSourceFile + ".xml");
                    }
                }
            }

            if ((settings.IsValidateHeader && temCabecalho == false) ||
                (settings.IsValidateAccountData && temDadosConta == false))
            {
                throw new OFXParserException("Invalid OFX file " + ofxSourceFile);
            }
            return(extrato);
        }
Beispiel #6
0
        private static Extract GetExtractByXmlExported(XmlTextReader xmlTextReader, ParserSettings settings)
        {
            if (settings == null)
            {
                settings = new ParserSettings();
            }

            // Variables used by Parser
            string      currentElement     = "";
            Transaction currentTransaction = null;

            // Variables used to read XML
            HeaderExtract header      = new HeaderExtract();
            BankAccount   bankAccount = new BankAccount();
            Extract       extract     = new Extract(header, bankAccount, "");

            bool hasHeader          = false;
            bool hasAccountInfoData = false;

            try
            {
                while (xmlTextReader.Read())
                {
                    if (xmlTextReader.NodeType == XmlNodeType.EndElement)
                    {
                        switch (xmlTextReader.Name)
                        {
                        case "STMTTRN":
                            if (currentTransaction != null)
                            {
                                extract.AddTransaction(currentTransaction);
                                currentTransaction = null;
                            }
                            break;
                        }
                    }
                    if (xmlTextReader.NodeType == XmlNodeType.Element)
                    {
                        currentElement = xmlTextReader.Name;

                        switch (currentElement)
                        {
                        case "STMTTRN":
                            currentTransaction = new Transaction();
                            break;
                        }
                    }
                    if (xmlTextReader.NodeType == XmlNodeType.Text)
                    {
                        switch (currentElement)
                        {
                        case "DTSERVER":
                            header.ServerDate = ConvertOfxDateToDateTime(xmlTextReader.Value, extract);
                            hasHeader         = true;
                            break;

                        case "LANGUAGE":
                            header.Language = xmlTextReader.Value;
                            hasHeader       = true;
                            break;

                        case "ORG":
                            header.BankName = xmlTextReader.Value;
                            hasHeader       = true;
                            break;

                        case "DTSTART":
                            extract.InitialDate = ConvertOfxDateToDateTime(xmlTextReader.Value, extract);
                            break;

                        case "DTEND":
                            extract.FinalDate = ConvertOfxDateToDateTime(xmlTextReader.Value, extract);
                            break;

                        case "BANKID":
                            bankAccount.Bank   = new Bank(GetBankId(xmlTextReader.Value, extract), "");
                            hasAccountInfoData = true;
                            break;

                        case "BRANCHID":
                            bankAccount.AgencyCode = xmlTextReader.Value;
                            hasAccountInfoData     = true;
                            break;

                        case "ACCTID":
                            bankAccount.AccountCode = xmlTextReader.Value;
                            hasAccountInfoData      = true;
                            break;

                        case "ACCTTYPE":
                            bankAccount.Type   = xmlTextReader.Value;
                            hasAccountInfoData = true;
                            break;

                        case "TRNTYPE":
                            if (currentTransaction != null)
                            {
                                currentTransaction.Type = xmlTextReader.Value;
                            }
                            break;

                        case "DTPOSTED":
                            if (currentTransaction != null)
                            {
                                currentTransaction.Date = ConvertOfxDateToDateTime(xmlTextReader.Value, extract);
                            }
                            break;

                        case "TRNAMT":
                            if (currentTransaction != null)
                            {
                                currentTransaction.TransactionValue = GetTransactionValue(xmlTextReader.Value, extract, settings);
                            }
                            break;

                        case "FITID":
                            if (currentTransaction != null)
                            {
                                currentTransaction.Id = xmlTextReader.Value;
                            }
                            break;

                        case "CHECKNUM":
                            if (currentTransaction != null)
                            {
                                currentTransaction.Checksum = Convert.ToInt64(xmlTextReader.Value);
                            }
                            break;

                        case "MEMO":
                            if (currentTransaction != null)
                            {
                                currentTransaction.Description = string.IsNullOrEmpty(xmlTextReader.Value) ? "" : xmlTextReader.Value.Trim().Replace("  ", " ");
                            }
                            break;
                        }
                    }
                }
            }
            catch (XmlException xe)
            {
                throw new OFXParserException($"Invalid OFX file! Internal message: {xe.Message}");
            }
            finally
            {
                xmlTextReader.Close();
            }

            if ((settings.IsValidateHeader && hasHeader == false) ||
                (settings.IsValidateAccountData && hasAccountInfoData == false))
            {
                throw new OFXParserException("Invalid OFX file!");
            }

            return(extract);
        }
Beispiel #7
0
        internal static Extract ParseToExtractFromFile(XmlTextReader meuXml)
        {
            var settings = new ParserSettings();

            bool temCabecalho  = false;
            bool temDadosConta = false;

            string      elementoSendoLido = string.Empty;
            Transaction transacaoAtual    = null;

            BankAccount   conta     = new BankAccount();
            HeaderExtract cabecalho = new HeaderExtract();
            Extract       extrato   = new Extract(cabecalho, conta, "");

            try
            {
                while (meuXml.Read())
                {
                    if (meuXml.NodeType == XmlNodeType.EndElement)
                    {
                        switch (meuXml.Name)
                        {
                        case "STMTTRN":
                            if (transacaoAtual != null)
                            {
                                extrato.AddTransaction(transacaoAtual);
                                transacaoAtual = null;
                            }
                            break;
                        }
                    }
                    if (meuXml.NodeType == XmlNodeType.Element)
                    {
                        elementoSendoLido = meuXml.Name;

                        switch (elementoSendoLido)
                        {
                        case "STMTTRN":
                            transacaoAtual = new Transaction();
                            break;
                        }
                    }
                    if (meuXml.NodeType == XmlNodeType.Text)
                    {
                        switch (elementoSendoLido)
                        {
                        case "DTSERVER":
                            cabecalho.ServerDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
                            temCabecalho         = true;
                            break;

                        case "LANGUAGE":
                            cabecalho.Language = meuXml.Value;
                            temCabecalho       = true;
                            break;

                        case "ORG":
                            cabecalho.BankName = meuXml.Value;
                            temCabecalho       = true;
                            break;

                        case "DTSTART":
                            extrato.InitialDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
                            break;

                        case "DTEND":
                            extrato.FinalDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
                            break;

                        case "BANKID":
                            conta.Bank    = new Bank(GetBankId(meuXml.Value, extrato), "");
                            temDadosConta = true;
                            break;

                        case "BRANCHID":
                            conta.AgencyCode = meuXml.Value;
                            temDadosConta    = true;
                            break;

                        case "ACCTID":
                            conta.AccountCode = meuXml.Value;
                            temDadosConta     = true;
                            break;

                        case "ACCTTYPE":
                            conta.AccType = meuXml.Value;
                            temDadosConta = true;
                            break;

                        case "TRNTYPE":
                            transacaoAtual.TrnType = meuXml.Value;
                            break;

                        case "DTPOSTED":
                            transacaoAtual.Date = ConvertOfxDateToDateTime(meuXml.Value, extrato);
                            break;

                        case "TRNAMT":
                            transacaoAtual.Amount = GetTransactionValue(meuXml.Value, extrato);
                            break;

                        case "FITID":
                            transacaoAtual.Id = meuXml.Value;
                            break;

                        case "CHECKNUM":
                            transacaoAtual.Checksum = Convert.ToInt64(meuXml.Value);
                            break;

                        case "MEMO":
                            transacaoAtual.Description = string.IsNullOrEmpty(meuXml.Value) ? "" : meuXml.Value.Trim().Replace("  ", " ");
                            break;
                        }
                    }
                }
            }
            catch (XmlException)
            {
                throw new FormatException("Invalid OFX file!");
            }
            finally
            {
                meuXml.Close();
            }

            if ((settings.IsValidateHeader && temCabecalho == false) ||
                (settings.IsValidateAccountData && temDadosConta == false))
            {
                throw new FormatException("Invalid OFX file!");
            }

            return(extrato);
        }