public async Task NotificarCriacaoCapsula(CapsulaDoTempo capsula)

        {
            try
            {
                if (!string.IsNullOrEmpty(capsula.Email))
                {
                    MailMessage e = new MailMessage()
                    {
                        From = new MailAddress(conta, "Cápsula do Tempo")
                    };
                    e.To.Add(new MailAddress(capsula.Email));

                    e.Subject    = "Cápsula do Tempo - Cápsula criada";
                    e.Body       = capsula.Id + " " + System.Net.WebUtility.UrlEncode(capsula.ChaveCapsula);
                    e.IsBodyHtml = true;

                    using (SmtpClient smtp = new SmtpClient(dominio, porta))
                    {
                        smtp.Credentials = new NetworkCredential(conta, senha);
                        smtp.EnableSsl   = true;
                        await smtp.SendMailAsync(e);
                    }
                }
            }
            catch (Exception ex)
            {
                // não posso parar o processo porque não foi possivel notificar
            }
        }
        public async Task <ResultadoCriacaoCapsula> CriarCapsula(string id, CapsulaDoTempo capsula)
        {
            capsula.Id           = id;
            capsula.DataCriacao  = DateTime.UtcNow;
            capsula.DataAbertura = capsula.DataAbertura.ToUniversalTime();

            string msgErro;

            if (!capsula.ValidarCriacao(out msgErro))
            {
                return(new ResultadoCriacaoCapsula()
                {
                    ResultadoCriacao = ResultadoCriacao.NaoCriada, Mensagem = msgErro
                });
            }

            if (!string.IsNullOrEmpty(capsula.Email))
            {
                capsula.ChaveCapsula = cryptoService.Criptografar(capsula.Id, capsula.Email);
            }

            var c = await repositorio.RecuperarCapsula(capsula.Id);

            if (c == null)
            {
                await repositorio.CriarCapsula(capsula);

                await notificacao.NotificarCriacaoCapsula(capsula);

                return(new ResultadoCriacaoCapsula()
                {
                    ResultadoCriacao = ResultadoCriacao.Criada
                });
            }
            else if (c.Estado == EstadoCapsula.Expirada)
            {
                await repositorio.ExcluirCapsula(capsula.Id);

                await repositorio.CriarCapsula(capsula);

                await notificacao.NotificarCriacaoCapsula(capsula);

                return(new ResultadoCriacaoCapsula()
                {
                    ResultadoCriacao = ResultadoCriacao.Criada
                });
            }
            else
            {
                return(new ResultadoCriacaoCapsula()
                {
                    ResultadoCriacao = ResultadoCriacao.CapsulaJaExistente
                });
            }
        }
        public async Task <ResultadoAlteracao> AlterarCapsulaDoTempo(string id, CapsulaDoTempo capsula)
        {
            var c = await repositorio.RecuperarCapsula(id);

            if (c == null)
            {
                return(ResultadoAlteracao.CapsulaNaoEncontrada);
            }
            else
            {
                if (!c.Editavel)
                {
                    return(ResultadoAlteracao.CapsulaNaoPermiteEdicao);
                }
                else if (c.ChaveCapsula == capsula.ChaveCapsula)
                {
                    c.DataAbertura = capsula.DataAbertura;
                    c.Duracao      = capsula.Duracao;
                    c.Imagem       = capsula.Imagem;
                    c.Mensagem     = capsula.Mensagem;

                    string retornoValidacao;
                    if (!c.ValidarCriacao(out retornoValidacao))
                    {
                        return(ResultadoAlteracao.CapsulaNaoValidada);
                    }

                    await repositorio.AtualizarCapsula(c);

                    return(ResultadoAlteracao.Alterada);
                }
                else
                {
                    return(ResultadoAlteracao.ChaveInvalida);
                }
            }
        }
Example #4
0
 public async Task CriarCapsula(CapsulaDoTempo capsula)
 {
     listaCapsulaDoTempo.Add(capsula);
 }
Example #5
0
 public async Task AtualizarCapsula(CapsulaDoTempo capsula)
 {
     listaCapsulaDoTempo.RemoveAll(a => a.Id == capsula.Id);
     listaCapsulaDoTempo.Add(capsula);
 }
 public async Task AtualizarCapsula(CapsulaDoTempo capsula)
 {
     await capsulas.FindOneAndReplaceAsync(Builders <CapsulaDoTempo> .Filter.Eq(a => a.Id, capsula.Id), capsula);
 }
 public async Task CriarCapsula(CapsulaDoTempo capsula)
 {
     await capsulas.InsertOneAsync(capsula);
 }