예제 #1
0
        public BL_Boleta GeraBoleta(BL_Cotista Cotista, BL_FIQ Fundo, decimal VALOR, DateTime DataSol, string OP, string CONTA, long CAUTELA = 0)
        {
            DateTime Solicitacao = DataSol;

            if (CAUTELA != 0 && Fundo.LOCKUP != 0)
            {
                BL_Saldo Cautela = new BL_Saldo().CautelasPorCODCOTeCODFUND(Cotista.CODCOT, Fundo.CODFUND).FirstOrDefault(x => x.CAUTELA == CAUTELA);
                Solicitacao = Solicitacao > Cautela.DTLANCT.AddDays(Fundo.LOCKUP) ? Solicitacao : Cautela.DTLANCT.AddDays(Fundo.LOCKUP);
            }
            DateTime Cotizacao = new BL_Boleta().CalculaCotizacao(Solicitacao, OP, Fundo.CODFUND);
            DateTime Impacto   = OP == "AP" ? DataSol : new BL_Boleta().CalculaLiquidacao(Cotizacao, OP, Fundo.CODFUND);

            BL_Boleta Boleta = new BL_Boleta
            {
                CODCOT    = Cotista.CODCOT,
                CODFUND   = Fundo.CODFUND,
                CPFCNPJ   = Cotista.CPFCNPJ,
                NOME      = Cotista.NOME,
                FUNDO     = Fundo.NOME,
                OPERACAO  = OP,
                STATUS    = "Pendente",
                VALOR     = VALOR,
                CONTA     = CONTA,
                COTIZACAO = Cotizacao,
                IMPACTO   = Impacto,
                CAUTELA   = CAUTELA
            };

            return(Boleta);
        }
예제 #2
0
        public List <BL_Boleta> BoletaPorCautela(BL_Cotista Cotista, BL_FIQ Fundo, decimal VALOR, DateTime DataSol, string OP, string CONTA)
        {
            List <BL_Boleta> Ans      = new List <BL_Boleta>();
            List <BL_Saldo>  Cautelas = new BL_Saldo().CautelasPorCODCOTeCODFUND(Cotista.CODCOT, Fundo.CODFUND);

            DateTime        MaisRecente       = Cautelas.Select(x => x.DTLANCT).Max();
            DateTime        Cotizacao         = CalculaCotizacao(DataSol, OP, Fundo.CODFUND);
            List <BL_Saldo> CautelasLiberadas = Cautelas.Where(x => Cotizacao.Subtract(x.DTLANCT).Days >= 630 + 90).ToList();

            CautelasLiberadas = CautelasLiberadas.OrderByDescending(x => x.VLCOTAP).ToList();
            while (VALOR != 0 && CautelasLiberadas.Count > 0) //resgata das cautelas liberadas em ordem de menor rentabilidade
            {
                BL_Saldo  Cautela = CautelasLiberadas[0];
                BL_Boleta Boleta;
                decimal   Valor; string Operacao;
                if (VALOR >= Cautela.QNTCOTAS)
                {
                    Valor = Cautela.QNTCOTAS; Operacao = "RT";
                }
                else
                {
                    Valor = VALOR; Operacao = "RC";
                }
                Boleta = GeraBoleta(Cotista, Fundo, Valor, DataSol, Operacao, CONTA, Cautela.CAUTELA);
                Ans.Add(Boleta);
                VALOR -= Valor;
                CautelasLiberadas.Remove(Cautela);
            }
            if (VALOR > 0) //resgata das cautelas travadas em ordem de data de aplicação
            {
                List <BL_Saldo> CautelasTravadas = Cautelas.Where(x => Cotizacao.Subtract(x.DTLANCT).Days < Fundo.LOCKUP + Fundo.CONVRESG).ToList();
                CautelasTravadas = CautelasTravadas.OrderBy(x => x.DTLANCT).ToList();
                while (VALOR != 0 && CautelasTravadas.Count > 0)
                {
                    BL_Saldo  Cautela = CautelasTravadas[0];
                    BL_Boleta Boleta;
                    decimal   Valor; string Operacao;
                    if (VALOR >= Cautela.QNTCOTAS)
                    {
                        Valor = Cautela.QNTCOTAS; Operacao = "RT";
                    }
                    else
                    {
                        Valor = VALOR; Operacao = "RC";
                    }
                    Boleta = GeraBoleta(Cotista, Fundo, Valor, Cautela.DTLANCT.AddDays(Fundo.LOCKUP), Operacao, CONTA, Cautela.CAUTELA);
                    Ans.Add(Boleta);
                    VALOR -= Valor;
                    CautelasTravadas.Remove(Cautela);
                }
            }

            return(Ans);
        }
예제 #3
0
        //Métodos de Dados
        #region
        public void AtualizarDados(string Usuario, string Senha)
        {
            string Extract(string s, string tag)
            {
                var startTag   = "<" + tag + ">";
                int startIndex = s.IndexOf(startTag) + startTag.Length;
                int endIndex   = s.IndexOf("</" + tag + ">", startIndex);

                if (endIndex - startIndex < 0)
                {
                    return("");
                }
                else
                {
                    return(s.Substring(startIndex, endIndex - startIndex));
                }
            }

            List <long> Fundos = new BL_FIQ().Dados().Select(x => x.CODFUND).ToList();

            Fundos.AddRange(new BL_Master().Dados().Select(X => X.CODFUND));

            string[] linhas;
            linhas = new DownloadArquivoServiceService().saldosCotaFechamentoD0XMLNoZIP(Usuario, Senha, "991259").Split(Convert.ToChar("\n"));

            //Deletar();
            List <BL_Saldo> Saldos = new BL_Saldo().DadosCompletos();

            for (int i = 0; i < linhas.Length; i++)
            {
                if (linhas[i].Contains("</CDFDO>"))
                {
                    BL_Saldo Saldo;
                    long     CAUTELA_Aux      = Convert.ToInt64(Extract(linhas[i + 9], "CDAPL"));
                    string   CODAUX           = Extract(linhas[i + 2], "AGENCIA") + Extract(linhas[i + 3], "CDCTA") + Extract(linhas[i + 4], "DAC10");
                    long     CODCOT_Aux       = Convert.ToInt64(CODAUX);
                    long     CODFUND_Aux      = Convert.ToInt64(Extract(linhas[i], "CDFDO"));
                    decimal  QNTCOTAS_Aux     = Convert.ToDecimal(Extract(linhas[i + 14], "QTCOTPAT")) / 100000;
                    string   TIPOREGISTRO_Aux = Extract(linhas[i + 8], "IDTIPREG") == "20" ? "Simples" : "Total";
                    //DateTime DATACOTA_Aux = DateTime.ParseExact(Extract(linhas[i + 16], "DTACOTA"), "yyyyMMdd", CultureInfo.InvariantCulture);
                    //decimal COTA_Aux = Convert.ToDecimal(Extract(linhas[i + 17], "VLRCOT")) / 10000000;

                    if (CAUTELA_Aux != 0)
                    {
                        Saldo = Saldos.FirstOrDefault(x => x.CAUTELA == CAUTELA_Aux);
                    }
                    else
                    {
                        Saldo = Saldos.FirstOrDefault(x => x.CODCOT == CODCOT_Aux && x.CODFUND == CODFUND_Aux && x.TIPOREGISTRO == "Total");
                    }
                    if (Saldo == null) //Inserir nova linha
                    {
                        DateTime DTLANCT_Aux;
                        if (TIPOREGISTRO_Aux == "Simples")
                        {
                            DTLANCT_Aux = DateTime.ParseExact(Extract(linhas[i + 6], "DTLANCT"), "yyyyMMdd", CultureInfo.InvariantCulture);
                        }
                        else
                        {
                            DTLANCT_Aux = new DateTime(1753, 1, 1);
                        }
                        decimal VLCOTAP_Aux = Convert.ToDecimal(Extract(linhas[i + 11], "VLCOTAP")) / 10000000;
                        Inserir(CODCOT_Aux, CODFUND_Aux, DTLANCT_Aux, VLCOTAP_Aux, TIPOREGISTRO_Aux, CAUTELA_Aux, QNTCOTAS_Aux);
                        continue;
                    }
                    if (TIPOREGISTRO_Aux == "Simples" && (CODCOT_Aux != Saldo.CODCOT || CODFUND_Aux != Saldo.CODFUND || QNTCOTAS_Aux != Saldo.QNTCOTAS))
                    {
                        EditarSimples(CODCOT_Aux, CODFUND_Aux, TIPOREGISTRO_Aux, CAUTELA_Aux, QNTCOTAS_Aux);
                    }
                    if (TIPOREGISTRO_Aux == "Total" && (QNTCOTAS_Aux != Saldo.QNTCOTAS))
                    {
                        EditarTotal(CODCOT_Aux, CODFUND_Aux, QNTCOTAS_Aux);
                    }
                    Saldos.Remove(Saldo);
                }
            }

            foreach (BL_Saldo Resto in Saldos)
            {
                if (Resto.TIPOREGISTRO == "Simples")
                {
                    DeletarSimples(Resto.CAUTELA);
                }
                else if (Resto.TIPOREGISTRO == "Total")
                {
                    DeletarTotal(Resto.CODCOT, Resto.CODFUND);
                }
            }
            linhas = null;
        }
예제 #4
0
        //Métodos da Classe
        #region
        public bool ValidaBoleta(BL_Cotista Cotista, BL_FIQ Fundo, string OPERACAO, decimal VALOR, DateTime SOLICITACAO, long CAUTELA, ref string Status)
        {
            Status = "Liberado";
            BL_Saldo Saldo = new BL_Saldo().DadosPorCODCOTeCODFUND(Cotista.CODCOT, Fundo.CODFUND);

            if (OPERACAO == "AP") //Aplicação
            {                     //Aplicação inicial mínima
                if (Saldo.QNTCOTAS == 0 && VALOR < Fundo.VALORAPLAMIN)
                {
                    Status = $"O valor solicitado é inferior à aplicação inicial mínima permitida de {Fundo.VALORAPLAMIN}!";
                } //Aplicação adicional mínima
                else if (VALOR < Fundo.VALORAPLMINADI)
                {
                    Status = $"O valor solicitado é inferior à aplicação adicional mínima permitida de {Fundo.VALORAPLMINADI}!";
                } //Janela do Raptor
                DateTime Cotizacao    = CalculaCotizacao(SOLICITACAO, OPERACAO, Fundo.CODFUND);
                DateTime JanelaRaptor = new BL_Feriados().AddWorkDays(Cotizacao, -1);
                if (SOLICITACAO != JanelaRaptor)
                {
                    Status = $"Operação não permitida hoje! A próxima janela de aplicação do Raptor será dia {JanelaRaptor}.";
                }
            }
            else //Resgates
            {
                BL_Cota UltimaCota = new BL_Cota().UltimaCota(Fundo.CODFUND);
                if (OPERACAO == "R")
                {
                    if (Fundo.LOCKUP != 0)
                    {
                        Status = "Não é possível resgatar por financeiro em fundos com lockup!";
                    }
                    else if (VALOR < Fundo.VALORMINRES)
                    {
                        Status = $"O valor solicitado é inferior ao resgate mínimo permitido de {Fundo.VALORMINRES}!";
                    }
                    else if (Saldo.QNTCOTAS * UltimaCota.COTA - VALOR < Fundo.Valorsaldominimo)
                    {
                        Status = $"O saldo restante será inferior ao mínimo permitido de {Fundo.Valorsaldominimo}!";
                    }
                }
                else
                {
                    if (VALOR * UltimaCota.COTA < Fundo.VALORMINRES)
                    {
                        Status = $"O valor solicitado é inferior ao resgate mínimo permitido de {Fundo.VALORMINRES}!";
                    }
                    else if (OPERACAO == "RC" && (Saldo.QNTCOTAS - VALOR) * UltimaCota.COTA < Fundo.Valorsaldominimo)
                    {
                        Status = $"O saldo restante será inferior ao mínimo permitido de {Fundo.Valorsaldominimo}!";
                    }
                }
                if (CAUTELA != 0) //Resgate por cautela
                {
                    if (OPERACAO == "R")
                    {
                        Status = "Não é possível realizar resgates financeiros por cautela!";
                    }
                    else if (VALOR > Saldo.QNTCOTAS)
                    {
                        Status = "O valor solicitado é maior que a quantidade de cotas disponível na cautela!";
                    }
                }
            }

            if (Status == "Liberado")
            {
                return(true);
            }
            return(false);
        }