コード例 #1
0
 public void Put(ContaConjuntaDto contaConjunta)
 {
     ExecuteProcedure(Procedures.SP_UpdContaConjunta);
     AddParameter("Id", contaConjunta.Id);
     AddParameter("IndicadorAprovado", contaConjunta.IndicadorAprovado);
     ExecuteNonQuery();
 }
コード例 #2
0
 public void Post(ContaConjuntaDto contaConjunta)
 {
     ExecuteProcedure(Procedures.SP_InsContaConjunta);
     AddParameter("IdConta", contaConjunta.IdConta);
     AddParameter("IdUsuarioEnvio", contaConjunta.IdUsuarioEnvio);
     AddParameter("IdUsuarioConvidado", contaConjunta.IdUsuarioConvidado);
     ExecuteNonQuery();
 }
コード例 #3
0
        public void Put(ContaConjuntaDto contaConjunta)
        {
            _contaConjuntaRepository.OpenTransaction();

            _contaConjuntaRepository.Put(contaConjunta);

            var conta = _contaFinanceiraRepository.Get(contaConjunta.IdConta);

            var msg = $"{(contaConjunta.IndicadorAprovado == "A" ? "Aceitou" : "Recusou")} seu convite para compartilhar a conta {conta.Nome.ToUpper()}";

            // IdTipo - 2: Aceitação de convite para conta conjunta. 3: Recuso de convite para conta conjunta
            var idTipoNotificacao = (short)(contaConjunta.IndicadorAprovado == "A" ? 2 : 3);

            _notificacaoRepository.Post(new NotificacaoDto
            {
                IdTipo           = idTipoNotificacao,
                IdUsuarioEnvio   = contaConjunta.IdUsuarioConvidado,
                IdUsuarioDestino = contaConjunta.IdUsuarioEnvio,
                Mensagem         = msg,
                ParametrosUrl    = null // Não implementado nessa versão do sistema
            });

            var usuarioEnvio = _usuarioRepository.Get(contaConjunta.IdUsuarioEnvio);

            msg = $"{(contaConjunta.IndicadorAprovado == "A" ? "Aceitou" : "Recusou")} o convite do {usuarioEnvio.Nome} para compartilhar a conta {conta.Nome.ToUpper()}";

            // Cadastra notificações para todos os usuarios (caso seja conta conjunta)
            _notificacaoService.Post(contaConjunta.IdUsuarioConvidado, contaConjunta.IdConta, idTipoNotificacao, msg, new List <int> {
                contaConjunta.IdUsuarioEnvio
            });

            // caso o usuario RECUSE o convite para conta conjunta
            if (contaConjunta.IndicadorAprovado != "A")
            {
                _contaConjuntaRepository.CommitTransaction();
                return;
            }

            // caso o usuario ACEITE o convite para conta conjunta

            var categoriasConta         = _lancamentoCategoriaRepository.GetCategoriasConta(contaConjunta.IdConta).ToList();
            var categoriasContaConjunta = _contaConjuntaRepository.GetCategoria(contaConjunta.IdConta).ToList();

            // insere as categorias que estão faltando ir para a tabela de categorias da conta conjunta
            foreach (var categoria in categoriasConta.Where(x => categoriasContaConjunta.All(y => y.Id != x.Id)))
            {
                _contaConjuntaRepository.PostCategoria(contaConjunta.IdConta, categoria.Id);
            }

            // exclui as categorias que estão na tabela de "contas conjuntas categorias" que não estão sendo utilizadas
            foreach (var categoriaContaConjunta in categoriasContaConjunta.Where(x => categoriasConta.All(y => y.Id != x.Id)))
            {
                _contaConjuntaRepository.DeleteCategoria(contaConjunta.IdConta, categoriaContaConjunta.Id);
            }

            _contaConjuntaRepository.CommitTransaction();
        }
コード例 #4
0
        public ActionResult Post(ContaConjuntaDto contaConjunta)
        {
            contaConjunta.IdUsuarioEnvio = UsuarioLogado.Id;
            var response = _contaConjuntaAppService.Post(contaConjunta);

            return(response.IsSuccessStatusCode
                ? Ok("Convite enviado com sucesso! Assim que o usuário aceitar, a conta será compartilhada")
                : Error(response));
        }
コード例 #5
0
        public ActionResult Put(ContaConjuntaDto contaConjunta)
        {
            contaConjunta.IdUsuarioConvidado = UsuarioLogado.Id;
            var response = _contaConjuntaAppService.Put(contaConjunta);

            return(response.IsSuccessStatusCode
                ? Ok($"Convite {(contaConjunta.IndicadorAprovado == "A" ? "Aprovado" : "Recusado")} com sucesso")
                : Error(response));
        }
コード例 #6
0
        public IHttpActionResult Put(ContaConjuntaDto contaConjunta)
        {
            _contaConjuntaService.Put(contaConjunta);
            if (!_notification.Any)
            {
                return(Ok());
            }

            return(Content(HttpStatusCode.BadRequest, _notification.Get));
        }
コード例 #7
0
 public ContaConjuntaViewModel(ContaConjuntaDto dto)
 {
     Id                    = dto.Id;
     IdConta               = dto.IdConta;
     DataAnalise           = dto.DataAnalise.HasValue ? $"{dto.DataAnalise:d}" : "";
     DataCadastro          = dto.DataCadastro.ToShortDateString();
     IdUsuarioEnvio        = dto.IdUsuarioEnvio;
     NomeUsuarioEnvio      = dto.NomeUsuarioEnvio;
     IdUsuarioConvidado    = dto.IdUsuarioConvidado;
     NomeUsuarioConvidado  = dto.NomeUsuarioConvidado;
     EmailUsuarioConvidado = dto.EmailUsuarioConvidado;
     IndicadorAprovado     = dto.IndicadorAprovado;
     EmailUsuarioEnvio     = dto.EmailUsuarioEnvio;
     NomeConta             = dto.NomeConta;
 }
コード例 #8
0
        public void Post(ContaConjuntaDto contaConjunta)
        {
            var usuarioConvidado = _usuarioRepository.Get(null, contaConjunta.EmailUsuarioConvidado);

            if (usuarioConvidado == null)
            {
                _notification.Add("Não foi encontrado nenhum usuário com o e-mail informado.");
                return;
            }

            if (usuarioConvidado.Id == contaConjunta.IdUsuarioEnvio)
            {
                _notification.Add("O e-mail informado não pode ser o mesmo do usuário desta conta");
                return;
            }

            if (_contaConjuntaRepository.Get(null, contaConjunta.IdConta).Any(x => x.IdUsuarioConvidado == usuarioConvidado.Id && contaConjunta.IndicadorAprovado == "A"))
            {
                _notification.Add("O usuário já esta vinculado com esta conta");
                return;
            }

            contaConjunta.IdUsuarioConvidado = usuarioConvidado.Id;

            _contaConjuntaRepository.OpenTransaction();

            _contaConjuntaRepository.Post(contaConjunta);

            var conta = _contaFinanceiraRepository.Get(contaConjunta.IdConta);

            _notificacaoRepository.Post(new NotificacaoDto
            {
                IdTipo           = 1, // Convite para conta conjunta
                IdUsuarioEnvio   = contaConjunta.IdUsuarioEnvio,
                IdUsuarioDestino = contaConjunta.IdUsuarioConvidado,
                Mensagem         = $"Deseja compartilhar sua conta {conta.Nome.ToUpper()} com você",
                ParametrosUrl    = null // Não implementado nessa versão do sistema
            });

            // Cadastra notificações para todos os usuarios (caso seja conta conjunta)
            var msg = $"Enviou um convite para compartilhar a conta {conta.Nome.ToUpper()} com o usuário {usuarioConvidado.Nome}";

            _notificacaoService.Post(contaConjunta.IdUsuarioEnvio, conta.Id, 1, msg, new List <int> {
                contaConjunta.IdUsuarioConvidado
            });                                                                                                                           // 1: Convite para conta conjunta

            _contaConjuntaRepository.CommitTransaction();
        }
コード例 #9
0
 public ContaConjuntaViewModel(ContaConjuntaDto dto, string indicadorProprietarioConta, int idUsuarioLogado)
 {
     Id                       = dto.Id;
     IdConta                  = dto.IdConta;
     DataAnalise              = dto.DataAnalise.HasValue ? $"{dto.DataAnalise:G}" : "";
     DataCadastro             = $"{dto.DataCadastro:G}";
     IdUsuarioEnvio           = dto.IdUsuarioEnvio;
     NomeUsuarioEnvio         = dto.NomeUsuarioEnvio;
     IdUsuarioConvidado       = dto.IdUsuarioConvidado;
     NomeUsuarioConvidado     = dto.NomeUsuarioConvidado;
     EmailUsuarioConvidado    = dto.EmailUsuarioConvidado;
     IndicadorAprovado        = dto.IndicadorAprovado;
     EmailUsuarioEnvio        = dto.EmailUsuarioEnvio;
     NomeConta                = dto.NomeConta;
     PodeRemoverContaConjunta = indicadorProprietarioConta == "S" || idUsuarioLogado == IdUsuarioConvidado;
 }
コード例 #10
0
 public HttpResponseMessage Put(ContaConjuntaDto contaConjunta)
 {
     return(PutRequest("Put", contaConjunta));
 }