Esempio n. 1
0
        private void _processTxt(TOArqTxt toTxt)
        {
            try
            {
                ColdFilesSplitter splitter = new ColdFilesSplitter();
                bool bSplit = false;

                switch (toTxt.Config.Type)
                {
                case TypeWatcher.COLD_BTC:
                    bSplit = splitter.SplitArquivoBTC(toTxt);
                    break;

                case TypeWatcher.COLD_LIQ:
                    bSplit = splitter.SplitArquivoLiquidacoes(toTxt);
                    break;

                case TypeWatcher.COLD_POS_CLI:
                    bSplit = splitter.SplitArquivoPosicaoCliente(toTxt);
                    break;

                case TypeWatcher.COLD_CUST:
                    bSplit = splitter.SplitArquivoCustodia(toTxt);
                    break;

                case TypeWatcher.COLD_MARG:
                    bSplit = splitter.SplitArquivoMargem(toTxt);
                    break;

                case TypeWatcher.COLD_GART:
                    bSplit = splitter.SplitArquivoGarantias(toTxt);
                    break;

                case TypeWatcher.COLD_TERMO:
                    bSplit = splitter.SplitArquivoTermo(toTxt);
                    break;

                case TypeWatcher.COLD_DIVIDENDO:
                    bSplit = splitter.SplitArquivoDividendo(toTxt);
                    break;

                default: break;
                }

                if (!bSplit)
                {
                    logger.Warn("*** Erro ao fragmentar arquivo: " + toTxt.FileName);
                    logger.Warn("Config.ClientIdCheck ...: " + toTxt.Config.ClientIdCheck);
                    logger.Warn("Config.Exchange ........: " + toTxt.Config.Exchange);
                    logger.Warn("Config.ExtensionFilter..: " + toTxt.Config.ExtensionFilter);
                    logger.Warn("Config.FileType.........: " + toTxt.Config.FileType);
                    logger.Warn("Config.NameType ........: " + toTxt.Config.NameType);
                    logger.Warn("Config.PathBkp .........: " + toTxt.Config.PathBkp);
                    logger.Warn("Config.PathProcessed ...: " + toTxt.Config.PathProcessed);
                    logger.Warn("Config.PathWatcher .....: " + toTxt.Config.PathWatcher);
                    logger.Warn("Config.SubjectEmail ....: " + toTxt.Config.SubjectEmail);
                    logger.Warn("Config.TemplateFile ....: " + toTxt.Config.TemplateFile);
                    logger.Warn("Config.TimeToRefresh ...: " + toTxt.Config.TimeToRefresh);
                    logger.Warn("Config.Type ............: " + toTxt.Config.Type);
                    logger.Warn("*** End of report *** ");
                }
            }
            catch (Exception ex)
            {
                logger.Error("Problemas no processamento do arquivo txt: " + ex.Message, ex);
            }
        }
Esempio n. 2
0
        /*
         *
         * public static IEnumerable<string> ExtractText2(this CObject cObject)
         * {
         *  if (cObject is COperator)
         *  {
         *      var cOperator = cObject as COperator;
         *      if (cOperator.OpCode.Name == OpCodeName.Tj.ToString() ||
         *          cOperator.OpCode.Name == OpCodeName.TJ.ToString())
         *      {
         *          foreach (var cOperand in cOperator.Operands)
         *              foreach (var txt in ExtractText2(cOperand))
         *                  yield return txt;
         *      }
         *  }
         *  else if (cObject is CSequence)
         *  {
         *      var cSequence = cObject as CSequence;
         *      foreach (var element in cSequence)
         *          foreach (var txt in ExtractText2(element))
         *              yield return txt;
         *  }
         *  else if (cObject is CString)
         *  {
         *      var cString = cObject as CString;
         *      yield return cString.Value;
         *  }
         * }
         */

        /// <summary>
        /// processa o arquivo da brasilplural
        /// o layout eh semelhante ao gradual, com menores diferencas no inicio das linhas
        /// </summary>
        public bool ParseCustodia(string arqentrada, bool converteconta = false)
        {
            try
            {
                ColdFilesSplitter splitter = new ColdFilesSplitter();

                logger.Info("Parsing [" + arqentrada + "]");

                string[] allLines      = File.ReadAllLines(arqentrada);
                bool     cabecalholido = false;

                string cabecalho      = "";
                string clienteBRP     = "";
                string clienteGradual = "";
                string cliente        = "";
                string clienteOrig    = "";
                string oldcliente     = "";
                string oldpapel       = "";
                string carteira       = "";

                char ffChar    = Convert.ToChar(0xff);
                char zerocChar = Convert.ToChar(0x0c);

                DBClientesCOLD db = new DBClientesCOLD();
                Dictionary <int, STClienteRelatCold> listaClientesCold = db.ObterListaClientesCOLD();
                Dictionary <int, bool> cabecalhoGrupo = new Dictionary <int, bool>();
                STCustodiaCliente      custodia       = null;

                for (int i = 0; i < allLines.Length; i++)
                {
                    string line = allLines[i].Replace('\r', ' ').Replace('\n', ' ').Replace(ffChar, ' ').Replace(zerocChar, ' ');

                    int xxx = line.IndexOf("***  C B L C  -  COMPANHIA BRASILEIRA DE LIQUIDACAO E CUSTODIA  ***");
                    if (xxx > 0 && !cabecalholido)
                    {
                        string data = line.Substring(3, 8).Trim();

                        //TODO: bater as datas
                    }

                    // Ignorar todas as linhas referentes a cabecalho
                    if (cabecalholido)
                    {
                        if (line.IndexOf("C B L C") > 0 ||
                            line.IndexOf("S I S T E M A") > 0 ||
                            line.IndexOf("POSICAO CONSOLIDADA") > 0 ||
                            line.IndexOf("SOCIEDADE CORRETORA") > 0 ||
                            line.IndexOf("SALDOS  NA  CUSTODIA") > 0 ||
                            line.IndexOf("BLOQUEIOS P/") > 0 ||
                            line.IndexOf("CUSTODIA  ----II----    DEPOSITO") > 0 ||
                            line.IndexOf("DIREITOS  DE") > 0 ||
                            line.IndexOf("SALDOS REGISTRADO") > 0 ||
                            line.IndexOf("QUANTIDADE  DE  CLIENTES") > 0 ||
                            line.IndexOf("T O T A L") > 0)
                        {
                            continue;
                        }
                    }


                    // Do the fuc*** job
                    if (!String.IsNullOrEmpty(line))
                    {
                        int idxClient = line.IndexOf("CLIENTE:");
                        if (idxClient >= 0)
                        {
                            cabecalholido = true;
                            //int idxFimCliente = line.IndexOf("XXXXXXXXXXXXXXXXX");

                            clienteOrig = line.Substring(idxClient + 9, 11);
                            cliente     = splitter.StripDigitAndThousand(clienteOrig.Trim());

                            if (converteconta)
                            {
                                logger.Info("Processando cliente Gradual [" + cliente + "]");
                            }
                            else
                            {
                                logger.Info("Processando cliente BRP [" + cliente + "]");
                            }

                            if (!String.IsNullOrEmpty(oldcliente) && !cliente.Equals(oldcliente))
                            {
                                oldcliente = cliente;

                                if (converteconta)
                                {
                                    clienteBRP     = splitter.BuscarClienteBRP(cliente);
                                    clienteGradual = cliente;
                                }
                                else
                                {
                                    clienteBRP     = cliente;
                                    clienteGradual = splitter.BuscarClienteGradual(cliente);
                                }
                            }

                            if (String.IsNullOrEmpty(oldcliente))
                            {
                                oldcliente = cliente;

                                if (converteconta)
                                {
                                    clienteBRP     = splitter.BuscarClienteBRP(cliente);
                                    clienteGradual = cliente;
                                }
                                else
                                {
                                    clienteBRP     = cliente;
                                    clienteGradual = splitter.BuscarClienteGradual(cliente);
                                }
                            }

                            continue;
                        }

                        if (!cabecalholido)
                        {
                            cabecalho += line + "\r\n";
                            continue;
                        }


                        int icarteira = line.IndexOf("CARTEIRA...:");
                        if (icarteira > 0)
                        {
                            carteira = line.Substring(icarteira + 13).Trim();
                            continue;
                        }


                        // Aqui é a linha do papel/ativo
                        line = line.TrimEnd().PadRight(150);

                        // Se a linha comecar com espaco, remove
                        if (line[0] == ' ')
                        {
                            line.Remove(0, 1);
                        }

                        string papel = line.Substring(0, 12).Trim();
                        string isin  = line.Substring(13, 12).Trim();
                        string dis   = line.Substring(26, 3).Trim();
                        string esp1  = line.Substring(30, 3).Trim();
                        string esp2  = line.Substring(34, 3).Trim();
                        string esp3  = line.Substring(38, 3).Trim();
                        string sit   = line.Substring(41, 11).Trim();

                        string cust    = line.Substring(54, 23).Trim().Replace(".", "");
                        string depst   = line.Substring(79, 23).Trim().Replace(".", "");
                        string credito = line.Substring(105, 21).Trim().Replace(".", "");
                        string debito  = line.Substring(128, 21).Trim().Replace(".", "");

                        if (!String.IsNullOrEmpty(papel))
                        {
                            if (!String.IsNullOrEmpty(oldpapel) && !papel.Equals(oldpapel))
                            {
                                // Busca as entradas ja existentes
                                // para esse cliente, para fazer a soma
                                STCustodiaCliente itemEncontrado = null;
                                foreach (STCustodiaCliente item in dctCustodia[custodia.CodBolsa])
                                {
                                    if (item.Carteira.Equals(custodia.Carteira) &&
                                        item.Papel.Equals(custodia.Papel))
                                    {
                                        int iContaGradual = Convert.ToInt32(clienteGradual);
                                        if (!dctRelatorioMerge.ContainsKey(iContaGradual))
                                        {
                                            dctRelatorioMerge.Add(iContaGradual, new List <STRelatMergeCustodia>());
                                        }

                                        List <STRelatMergeCustodia> relatorio = dctRelatorioMerge[iContaGradual];
                                        STRelatMergeCustodia        itemRelat = relatorio.Find(x => (x.Carteira.Equals(custodia.Carteira) && x.Papel.Equals(custodia.Papel)));

                                        if (itemRelat == null)
                                        {
                                            itemRelat             = new STRelatMergeCustodia();
                                            itemRelat.Papel       = custodia.Papel;
                                            itemRelat.Carteira    = custodia.Carteira;
                                            itemRelat.CodConta    = iContaGradual;
                                            itemRelat.CodContaBRP = Convert.ToInt32(clienteBRP);

                                            relatorio.Add(itemRelat);
                                        }

                                        item.SaldoCustodia    += custodia.SaldoCustodia;
                                        item.BloqueioDeposito += custodia.BloqueioDeposito;

                                        foreach (KeyValuePair <string, STLancamentoPrevisto> custoPrev in custodia.Lancamentos)
                                        {
                                            if (item.Lancamentos.ContainsKey(custoPrev.Key))
                                            {
                                                item.Lancamentos[custoPrev.Key].LctoPrevCredito += custoPrev.Value.LctoPrevCredito;
                                                item.Lancamentos[custoPrev.Key].LctoPrevDebito  += custoPrev.Value.LctoPrevDebito;
                                            }
                                            else
                                            {
                                                item.Lancamentos.Add(custoPrev.Key, custoPrev.Value);
                                            }
                                        }


                                        //if (converteconta)
                                        //{
                                        //    itemRelat.BloqueioDepositoGRD = custodia.BloqueioDeposito;
                                        //    itemRelat.LctoPrevCreditoGRD = custodia.LctoPrevCredito;
                                        //    itemRelat.LctoPrevDebitoGRD = custodia.LctoPrevDebito;
                                        //    itemRelat.SaldoCustodiaGRD = custodia.SaldoCustodia;
                                        //}
                                        //else
                                        //{
                                        //    itemRelat.BloqueioDepositoBRP = custodia.BloqueioDeposito;
                                        //    itemRelat.LctoPrevCreditoBRP = custodia.LctoPrevCredito;
                                        //    itemRelat.LctoPrevDebitoBRP = custodia.LctoPrevDebito;
                                        //    itemRelat.SaldoCustodiaBRP = custodia.SaldoCustodia;
                                        //}


                                        itemEncontrado = item;

                                        break;
                                    }

                                    if (itemEncontrado == null)
                                    {
                                        // Se nao achou carteira + papel, acrescenta
                                        dctCustodia[custodia.CodBolsa].Add(custodia);
                                    }
                                }
                            }

                            // Inicializa nova entrada de custodia
                            custodia          = new STCustodiaCliente();
                            custodia.Papel    = papel;
                            custodia.Carteira = carteira;
                            custodia.CodBolsa = Convert.ToInt32(clienteBRP);
                            custodia.Situacao = sit;
                            custodia.ISIN     = string.Format("{0} {1} {2} {3} {4}",
                                                              isin.PadRight(12),
                                                              dis.PadRight(3),
                                                              esp1.PadRight(3),
                                                              esp2.PadRight(3),
                                                              esp3.PadRight(3));

                            if (!String.IsNullOrEmpty(cust))
                            {
                                custodia.SaldoCustodia = Convert.ToInt64(cust);
                            }
                            if (!String.IsNullOrEmpty(depst))
                            {
                                custodia.BloqueioDeposito = Convert.ToInt64(depst);
                            }

                            if (!dctCustodia.ContainsKey(custodia.CodBolsa))
                            {
                                dctCustodia.Add(custodia.CodBolsa, new List <STCustodiaCliente>());
                            }

                            oldpapel = papel;
                        }
                        else
                        {
                            string dataprevisao = sit;

                            logger.DebugFormat("Parsing Account [{0}] Carteira [{1}] Papel [{2}] Previsao [{3}] Cred [{4}] Deb [{5}]",
                                               clienteBRP,
                                               carteira,
                                               papel,
                                               dataprevisao,
                                               credito,
                                               debito);

                            STLancamentoPrevisto lcto = new STLancamentoPrevisto();
                            lcto.DataPrevisao = dataprevisao;

                            if (!String.IsNullOrEmpty(credito))
                            {
                                lcto.LctoPrevCredito = Convert.ToInt64(credito);
                            }
                            if (!String.IsNullOrEmpty(debito))
                            {
                                lcto.LctoPrevDebito = Convert.ToInt64(debito);
                            }

                            custodia.Lancamentos.Add(dataprevisao, lcto);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error("ParseCustodia: " + ex.Message, ex);
                return(false);
            }
            return(true);
        }