Esempio n. 1
0
        public async Task <IComandoResultado> ManipuladorAsync(MatriculaItemComando comando)
        {
            //check Matricula Existe
            if (await _repositorio.CheckMatriculaItemTempExisteAsync(comando))
            {
                AddNotification("Item", $"Item já informado");
            }

            //Aplicar regra desconto
            var desconto          = Convert.ToInt32((await _configuracao.ObterPorChaveAsync("DescontoCurso")).Valor);
            var turmas            = (await _repositorio.ObterMatriculaItensTempPor(new Guid(comando.IdMatriculaGuid))).ToList();
            var idTurmaMaiorValor = 0;

            if (turmas != null && turmas.Count() > 0)
            {
                turmas.Add(new ItemMatriculaQueryResultado
                {
                    Desconto           = false,
                    IdMatriculaGuid    = comando.IdMatriculaGuid,
                    IdTurma            = comando.IdTurma,
                    Valor              = comando.Valor,
                    ValorDesconto      = 0,
                    ValorCalculado     = comando.Valor,
                    ValorTotalDesconto = comando.Valor
                });
                idTurmaMaiorValor = turmas.MaxBy(t => t.Valor).FirstOrDefault().IdTurma;

                foreach (var item in turmas)
                {
                    if (item.IdTurma != idTurmaMaiorValor)
                    {
                        item.ValorCalculado = ValorCalculado(item.Valor, desconto);
                        item.ValorDesconto  = desconto;
                        item.Desconto       = true;
                    }
                    else
                    {
                        item.ValorCalculado = item.Valor;
                        item.ValorDesconto  = 0;
                        item.Desconto       = false;
                    }
                }
            }
            else
            {
                turmas = new List <ItemMatriculaQueryResultado>();
                turmas.Add(new ItemMatriculaQueryResultado
                {
                    Desconto           = false,
                    IdMatriculaGuid    = comando.IdMatriculaGuid,
                    IdTurma            = comando.IdTurma,
                    Valor              = comando.Valor,
                    ValorDesconto      = 0,
                    ValorCalculado     = comando.Valor,
                    ValorTotalDesconto = comando.Valor
                });
            }
            //Validar Comando
            comando.Valido();
            AddNotifications(comando.Notifications);
            if (Invalid)
            {
                return(new ComandoResultado(false, "Por favor, corrija os campos abaixo", Notifications));
            }


            //Persistir Item    temp
            foreach (var item in turmas)
            {
                await _repositorio.RegistrarItemMatriculaTemp(new MatriculaItemTemp(
                                                                  item.IdMatriculaGuid,
                                                                  item.IdTurma,
                                                                  item.Valor,
                                                                  item.Desconto,
                                                                  item.ValorDesconto,
                                                                  item.ValorCalculado
                                                                  ));
            }


            //Obter lista de retorno
            var itens         = (await _repositorio.ObterMatriculaItensTempPor(new Guid(comando.IdMatriculaGuid))).ToList();
            var totalGeral    = itens.Sum(t => t.Valor);
            var totalDesconto = itens.Sum(t => t.ValorCalculado);

            // Retornar o resultado para tela
            return(new ComandoResultado(true, "Item incluido com sucesso", new
            {
                itens,
                totalGeral,
                totalDesconto
            }));
        }
        public async Task <IComandoResultado> ManipuladorAsync(EditMatriculaComando comando)
        {
            //Recuperar Matricula
            var matricula = await _repositorioMatricula.ObterPor(new Guid(comando.IdMatriculaGuid));

            if (!matricula.Status)
            {
                AddNotification("Matricula", "Matricula ja esta inativada. Operação não realizada.");
            }

            //Validar Comando
            comando.Valido();

            //Recuperar itens matricula modificado
            var turmasTemp = (await _repositorio.ObterMatriculaItensTempPor(new Guid(comando.IdMatriculaGuid))).ToList();

            //Verificar total trumas > 0
            if (turmasTemp.Count <= 0)
            {
                AddNotification("Item", $"Informe Pelo Menos Uma Turma");
            }

            //Recupera itens matricula
            var turmas = (await _repositorio.ObterMatriculaItensPor(new Guid(comando.IdMatriculaGuid))).ToList();

            //Obter as turmas excluidas para inativar o aluno
            var turmasExclusao = ObterDiferencaLista(turmas, turmasTemp);

            AddNotifications(comando.Notifications);
            if (Invalid)
            {
                return(new ComandoResultado(false, "Por favor, corrija os campos abaixo", Notifications));
            }

            if (comando.StatusMatricula)
            {
                //Deletar turmas
                var deletado = await _repositorioMatricula.DeletarItemMatricula(matricula.IdMatricula, 0);

                //Excluir aluno da turma
                if (deletado > 0 && turmasExclusao.Count > 0)
                {
                    foreach (var item in turmasExclusao)
                    {
                        await _repositorioTurma.DeletarAlunoAsync(matricula.IdAluno, item.IdTurma);
                    }
                }

                //Persistir Item
                foreach (var item in turmasTemp)
                {
                    await _repositorio.RegistrarItemMatricula(new MatriculaItem(
                                                                  matricula.IdMatricula,
                                                                  item.IdTurma,
                                                                  item.Valor,
                                                                  item.Desconto,
                                                                  item.ValorDesconto,
                                                                  item.ValorCalculado
                                                                  ));

                    //Enturmar Aluno
                    await _repositorioAluno.SalvarTurmaAsync(new TurmaAluno(item.IdTurma, matricula.IdAluno));
                }

                var novoValorMensalidade = turmasTemp.Sum(x => x.ValorCalculado);

                //Atualiza Mensalidade
                await _repositorioMensalidade.AtualizarValorAsync(matricula.IdMatricula, novoValorMensalidade);
            }
            else if (!comando.StatusMatricula)
            {
                //Inativar matricula
                if (await _repositorioMatricula.InativarAsync(matricula.IdMatricula) > 0)
                {
                    //Inativar Turma
                    foreach (var item in turmas)
                    {
                        await _repositorioTurma.DeletarAlunoAsync(matricula.IdAluno, item.IdTurma);
                    }

                    //Inativar Pagamentos Pendente
                }
            }

            return(new ComandoResultado(true, "Item Atualizado com Sucesso", new
            {
                Id = matricula.IdMatricula,
                Nome = "Atualizado",
                Status = true
            }));
        }
        public async Task <IComandoResultado> ManipuladorAsync(DelMatriculaItemComando comando)
        {
            //Validar Comando
            AddNotifications(comando.Notifications);
            if (Invalid)
            {
                return(new ComandoResultado(false, "Por favor, corrija os campos abaixo", Notifications));
            }
            //persistir dados
            //Deletar Tem item matricula
            var deletado = await _repositorio.DeletarItemMatriculaTemp(comando.IdMatricula, comando.IdTurma);

            //Atualizar Lista
            var turmas = (await _repositorio.ObterMatriculaItensTempPor(new Guid(comando.IdMatricula))).ToList();

            //Aplicar regra desconto
            var desconto          = Convert.ToInt32((await _configuracao.ObterPorChaveAsync("DescontoCurso")).Valor);
            var idTurmaMaiorValor = 0;

            if (turmas != null && turmas.Count() > 0)
            {
                idTurmaMaiorValor = turmas.MaxBy(t => t.Valor).FirstOrDefault().IdTurma;

                foreach (var item in turmas)
                {
                    if (item.IdTurma != idTurmaMaiorValor)
                    {
                        item.ValorCalculado = ValorCalculado(item.Valor, desconto);
                        item.ValorDesconto  = desconto;
                        item.Desconto       = true;
                    }
                    else
                    {
                        item.ValorCalculado = item.Valor;
                        item.ValorDesconto  = 0;
                        item.Desconto       = false;
                    }
                }
            }

            //Atualizar Item    temp
            foreach (var item in turmas)
            {
                await _repositorio.AtualizaItemMatriculaTemp(new MatriculaItemTemp(
                                                                 item.IdMatriculaGuid,
                                                                 item.IdTurma,
                                                                 item.Valor,
                                                                 item.Desconto,
                                                                 item.ValorDesconto,
                                                                 item.ValorCalculado
                                                                 ));
            }



            //Obter lista de retorno
            var itens         = turmas;
            var totalGeral    = itens.Sum(t => t.Valor);
            var totalDesconto = itens.Sum(t => t.ValorCalculado);

            // Retornar o resultado para tela
            return(new ComandoResultado(true, "Item excluído com sucesso", new
            {
                itens,
                totalGeral,
                totalDesconto
            }));
        }
Esempio n. 4
0
        public async Task <IComandoResultado> ManipuladorAsync(MatricularComando comando)
        {
            //Obter itens matricula
            var turmas = (await _repositorio.ObterMatriculaItensTempPor(new Guid(comando.IdMatriculaGuid))).ToList();

            if (turmas.Count() <= 0)
            {
                AddNotification("Turmas", $"Informe pelo menos uma turma");
            }
            comando.ValorContrato = turmas.Sum(x => x.ValorCalculado);
            //Criar Entidade
            var matricula = new Matricula(comando.Id, comando.IdAluno, comando.TotalParcelas,
                                          comando.DataContrato, comando.PercentualDesconto, comando.ValorDesconto, comando.ValorMatricula,
                                          comando.ValorContrato, comando.DiaVencimento, comando.DataIncialPagamento, ChaveRegistro.Gerar(), comando.Ano, comando.MesInicioPagamento);

            //check Matricula Existe
            if (await _repositorio.CheckMatriculaExisteAsync(matricula))
            {
                AddNotification("Matricula", $"Aluno informado ja possui matricula ativa para o ano de {comando.Ano} ");
            }

            //Validar Comando
            comando.Valido();
            AddNotifications(comando.Notifications);
            if (Invalid)
            {
                return(new ComandoResultado(false, "Por favor, corrija os campos abaixo", Notifications));
            }

            //Persistir Dados
            var id = await _repositorio.MatricularAsync(matricula);

            //Persistir Item
            foreach (var item in turmas)
            {
                await _repositorio.RegistrarItemMatricula(new MatriculaItem(
                                                              id,
                                                              item.IdTurma,
                                                              item.Valor,
                                                              item.Desconto,
                                                              item.ValorDesconto,
                                                              item.ValorCalculado
                                                              ));

                //Enturmar Aluno
                await _repositorioAluno.SalvarTurmaAsync(new TurmaAluno(item.IdTurma, matricula.IdAluno));
            }
            //Deletar Tem item matricula
            await _repositorio.DeletarItemMatriculaTemp(comando.IdMatriculaGuid, 0);

            //Persistir Boletos
            await _repositorio.GerarMensalidade(new Mensalidade(0, matricula.IdAluno, id, matricula.TotalParcelas, Convert.ToDecimal(matricula.ValorContrato), matricula.ValorDesconto, matricula.DataIncialPagamento, 2));

            //Persistir Boleto Matricula
            await _repositorio.GerarMensalidade(new Mensalidade(0, matricula.IdAluno, id, 1, Convert.ToDecimal(matricula.ValorMaricula), matricula.ValorDesconto, matricula.DataIncialPagamento, 1));

            // Retornar o resultado para tela
            return(new ComandoResultado(true, "Matricula realizada com sucesso", new
            {
                Id = id,
                Nome = "Matriculado",
                Status = true
            }));
        }