public void CarregarLogSmsAgenda()
        {
            try
            {
                LogSmsAgenda logSmsAgenda = new LogSmsAgenda();
                logSmsAgenda = new LogSmsAgendaRepository().Details(new LogSmsAgenda()
                {
                    LogSmsAgendaID = LogSmsAgendaID
                });

                this.txtLogSmsAgendaID.Text = logSmsAgenda.LogSmsAgendaID.Value.ToString();

                Boolean smsEnviado = logSmsAgenda.SMSEnviado.Value;
                this.txtSMSEnviado.Text = smsEnviado ? "Sim" : "Não";
                this.txtSMSEnviado.Attributes["style"] = String.Format("color:{0} !important;", smsEnviado ? "green" : "red");
                this.txtSMSEnviado.CssClass            = String.Format("{0} {1}", this.txtSMSEnviado.CssClass, (smsEnviado ? "w3-pale-green" : "w3-pale-red"));
                this.txtSMSEnviado.Font.Bold           = true;

                this.txtSMSDataProcessamento.Text = logSmsAgenda.SMSDataProcessamento.Value.ToString("yyyy-MM-dd");
                this.txtSMSHoraProcessamento.Text = logSmsAgenda.SMSDataProcessamento.Value.ToString("HH:mm:ss");
                this.txtSMSMessageID.Text         = (logSmsAgenda.SMSMessageID != "NULL") ? logSmsAgenda.SMSMessageID : String.Empty;
                this.txtObservacao.Text           = logSmsAgenda.Observacao;

                this.CarregarAgenda(logSmsAgenda.Agenda);
            }
            catch (Exception e)
            {
                Log.Create(e);
                Email.Send("Agendamento de congelação - falha na aplicação", e);
                this.msgDialog.Show("Erro", "Ocorreu uma falha ao carregar o log de SMS de agenda.", UserControl.Message.Type.Error);
            }
        }
Ejemplo n.º 2
0
        private void CarregarLogSmsAgenda()
        {
            try
            {
                LogSmsAgenda logSmsAgenda = new LogSmsAgenda();
                logSmsAgenda.SMSMessageID = this.txtSMSMessageID.Text.Length > 0 ? this.txtSMSMessageID.Text : null;

                if (this.rbtTodos.Checked)
                {
                    logSmsAgenda.SMSEnviado = null;
                }
                else if (this.rbtEnviado.Checked)
                {
                    logSmsAgenda.SMSEnviado = true;
                }
                else
                {
                    logSmsAgenda.SMSEnviado = false;
                }

                DateTime?dataInicial = null;
                DateTime?dataFinal   = null;

                if (!String.IsNullOrEmpty(this.txtDataInicial.Text))
                {
                    dataInicial = Convert.ToDateTime(this.txtDataInicial.Text);
                }

                if (!String.IsNullOrEmpty(this.txtDataFinal.Text))
                {
                    dataFinal = Convert.ToDateTime(this.txtDataFinal.Text);
                    TimeSpan hora = new TimeSpan(23, 59, 59);
                    dataFinal = dataFinal.Value.Add(hora);
                }

                List <LogSmsAgenda> logs = new LogSmsAgendaRepository().Retreave(logSmsAgenda, dataInicial, dataFinal);

                VsLogSmsAgendas = logs;
                this.gvLogSmsAgenda.DataSource = logs;
                this.gvLogSmsAgenda.DataBind();
                this.lblTotalRegistros.Text     = logs.Count.ToString();
                this.infoTotalRegistros.Visible = true;
            }
            catch (Exception e)
            {
                Log.Create(e);
                Email.Send("Agendamento de congelação - falha na aplicação", e);
                this.msgDialog.Show("Erro", "Ocorreu uma falha ao carregar os registros de log's de SMS das agendas.", UserControl.Message.Type.Error);
            }
        }
Ejemplo n.º 3
0
        private void EnviarSMS(Agenda agenda, ConfiguracaoNotificacaoAgenda configuracao, String mensagemSMS)
        {
            if (ConfigurationManager.AppSettings["ENVIAR_SMS"] != null)
            {
                String numeroTelefone = String.Format("{0}{1}", CodigoE164, agenda.MedicoExecucaoAgenda.Celular);

                if (Convert.ToBoolean(ConfigurationManager.AppSettings["ENVIAR_SMS"]))
                {
                    String MessageId = TwilioServices.SendSMS(numeroTelefone, mensagemSMS);
                    ConsoleLogMessage("SMS enviado", ConsoleMessageType.SUCCESS);

                    LogSmsAgenda logSmsAgenda = new LogSmsAgenda();
                    logSmsAgenda.Agenda               = agenda;
                    logSmsAgenda.SMSEnviado           = true;
                    logSmsAgenda.SMSDataProcessamento = DateTime.Now;
                    logSmsAgenda.SMSMessageID         = MessageId;
                    logSmsAgenda.Observacao           =
                        String.Format
                        (
                            "Origem SERVIÇO: mensagem destinado ao nº {0} como lembrete ({1} {2} antes), enviada com sucesso ao servidor de serviço SMS."
                            , numeroTelefone
                            , configuracao.Tempo
                            , configuracao.UnidadeTempoAgenda.Unidade
                        );
                    new LogSmsAgendaRepository().Create(logSmsAgenda);
                    ConsoleLogMessage("Log gravado", ConsoleMessageType.SUCCESS);
                }
                else
                {
                    ConsoleLogMessage("SMS não foi enviado.", ConsoleMessageType.WARNING);
                    LogSmsAgenda logSmsAgenda = new LogSmsAgenda();
                    logSmsAgenda.Agenda               = agenda;
                    logSmsAgenda.SMSEnviado           = false;
                    logSmsAgenda.SMSDataProcessamento = DateTime.Now;
                    logSmsAgenda.SMSMessageID         = null;
                    logSmsAgenda.Observacao           =
                        String.Format
                        (
                            "Origem SERVIÇO: mensagem destinado ao nº {0} como lembrete ({1} {2} antes) não foi enviada, o serviço de envio de SMS está desabilitado. Utilize a chave ENVIAR_SMS do app.config da aplicação."
                            , numeroTelefone
                            , configuracao.Tempo
                            , configuracao.UnidadeTempoAgenda.Unidade
                        );
                    new LogSmsAgendaRepository().Create(logSmsAgenda);
                    ConsoleLogMessage("Log gravado", ConsoleMessageType.SUCCESS);
                }
            }
        }
        protected void gvLogSmsAgenda_RowDataBound(object sender, GridViewRowEventArgs e)
        {
            if (e.Row.RowType == DataControlRowType.DataRow)
            {
                LogSmsAgenda logSmsAgenda = (LogSmsAgenda)e.Row.DataItem;

                Literal litSMSEnviado        = (Literal)e.Row.FindControl("litSMSEnviado");
                Literal litDataProcessamento = (Literal)e.Row.FindControl("litDataProcessamento");
                Literal litSMSMessageID      = (Literal)e.Row.FindControl("litSMSMessageID");

                Boolean smsEnviado = logSmsAgenda.SMSEnviado.Value;
                litSMSEnviado.Text        = "<span style='font-weight:bold;color:" + (smsEnviado ? "green" : "red") + ";'>" + (smsEnviado ? "Sim" : "Não") + "</span>";
                litDataProcessamento.Text = logSmsAgenda.SMSDataProcessamento.Value.ToString("dd/MM/yyyy HH:mm:ss");
                litSMSMessageID.Text      =
                    logSmsAgenda.SMSMessageID.Length > 0
                    ?
                    String.Format("<a class='w3-text-blue' href='https://www.twilio.com/console/sms/logs/{0}' target='_blank'>{0}</a>", logSmsAgenda.SMSMessageID)
                    :
                    String.Empty;
            }
        }
Ejemplo n.º 5
0
        private void Salvar(HttpContext context)
        {
            Model.Entities.Agenda agenda = new Model.Entities.Agenda();

            JavaScriptSerializer serializer = new JavaScriptSerializer();
            ReturnJSON <Model.Entities.Agenda> returnJSON = new ReturnJSON <Model.Entities.Agenda>();
            String retorno = null;

            try
            {
                String json = new StreamReader(context.Request.InputStream).ReadToEnd();
                agenda = (Model.Entities.Agenda)serializer.Deserialize <Model.Entities.Agenda>(json);

                // Recupera novamente o EstadoAgenda, pois no client/browser só foi possível enviar o seu ID.
                agenda.EstadoAgenda =
                    new EstadoAgendaRepository()
                    .Details(new EstadoAgenda()
                {
                    EstadoAgendaID = agenda.EstadoAgenda.EstadoAgendaID
                });

                // Recupera novamente o MedicoExecucaoAgenda, pois no client/browser só foi possível enviar o seu ID.
                agenda.MedicoExecucaoAgenda =
                    new MedicoExecucaoAgendaRepository()
                    .Details(new MedicoExecucaoAgenda()
                {
                    MedicoExecucaoAgendaID = agenda.MedicoExecucaoAgenda.MedicoExecucaoAgendaID
                });

                if (!agenda.DataHoraEhNoiteOuFimSemana(agenda.DataHoraEvento.Value))
                {
                    returnJSON.Message    = "O agendamento da congelação <b>não</b> pode ser realizado após as 19:00 e aos finais de semana.";
                    returnJSON.ReturnCode = Enum.GetName(typeof(ReturnType), ReturnType.WARNING);
                    retorno = serializer.Serialize(returnJSON);
                    context.Response.ContentType     = "text/json";
                    context.Response.ContentEncoding = Encoding.UTF8;
                    context.Response.Write(retorno);
                    return;
                }

                // É novo registro? Verifica se não está sendo gravado uma nova agenda com data retroativa.
                if (agenda.AgendaID.HasValue && agenda.AgendaID.Value == 0)
                {
                    if (agenda.DataHoraEhRetroativa(agenda.DataHoraEvento.Value))
                    {
                        returnJSON.Message    = "Não é permitido agendar uma congelação com data/hora retroativa.";
                        returnJSON.ReturnCode = Enum.GetName(typeof(ReturnType), ReturnType.WARNING);
                        retorno = serializer.Serialize(returnJSON);
                        context.Response.ContentType     = "text/json";
                        context.Response.ContentEncoding = Encoding.UTF8;
                        context.Response.Write(retorno);
                        return;
                    }
                }

                String assuntoSMS = String.Empty;

                // Registro em edição?
                if (agenda.AgendaID.HasValue && agenda.AgendaID.Value > 0)
                {
                    assuntoSMS = "Atualização de agendamento de congelação";

                    if (agenda.EstadoAgenda.Estado.Equals("Confirmado"))
                    {
                        // Consulta a existência de lembrestes configurados para a agenda.
                        List <NotificacaoAgenda> notificacoesExistentes = new NotificacaoAgendaRepository()
                                                                          .Retreave(new NotificacaoAgenda()
                        {
                            Agenda = agenda
                        });

                        // Se não houver nenhum lembrete, cria com base nas configurações existentes (recorrência de notificação).
                        if (notificacoesExistentes.Count == 0)
                        {
                            List <ConfiguracaoNotificacaoAgenda> configuracaoNotificacaoAgendas
                                = new ConfiguracaoNotificacaoAgendaRepository()
                                  .Retreave(new ConfiguracaoNotificacaoAgenda());

                            foreach (ConfiguracaoNotificacaoAgenda configuracao in configuracaoNotificacaoAgendas)
                            {
                                DateTime inicioNotificacao = agenda.DataHoraEvento.Value;

                                // Verifica a unidade de tempo da configuração para determinar a data/hora inicial da notificação.
                                switch (configuracao.UnidadeTempoAgenda.Unidade)
                                {
                                case "Minutos":
                                    inicioNotificacao = inicioNotificacao.AddMinutes(-Convert.ToDouble(configuracao.Tempo));
                                    break;

                                case "Horas":
                                    inicioNotificacao = inicioNotificacao.AddHours(-Convert.ToDouble(configuracao.Tempo));
                                    break;

                                case "Dias":
                                    inicioNotificacao = inicioNotificacao.AddDays(-Convert.ToDouble(configuracao.Tempo));
                                    break;

                                case "Semanas":
                                    inicioNotificacao = inicioNotificacao.AddDays(-Convert.ToDouble(configuracao.Tempo) * 7);
                                    break;

                                default:
                                    break;
                                }

                                /*
                                 * Verifica se a data/hora do momento está dentro do intervalo:
                                 * data/hora de início da notificação e a data/hora evento (fim) da agenda.
                                 * Como é uma nova agenda ou alteração de agenda, se a data/hora evento estiver
                                 * dentro do tempo de intervalo de notificação, a notificãção não será criada.
                                 */
                                if (DateTime.Now >= inicioNotificacao && DateTime.Now <= agenda.DataHoraEvento.Value)
                                {
                                    // Evita criar o registro no banco.
                                    continue;
                                }

                                NotificacaoAgenda notificacaoAgenda = new NotificacaoAgenda();
                                notificacaoAgenda.Agenda = agenda;
                                notificacaoAgenda.ConfiguracaoNotificacaoAgenda = configuracao;
                                new NotificacaoAgendaRepository().Create(notificacaoAgenda);
                            }
                        }
                        // Se não, se já existir o lembrete (por que a mesma agenda foi cancelada e confirmada posteriormente)
                        //, mantém ativado.
                        else
                        {
                            NotificacaoAgenda notificacaoAgenda = new NotificacaoAgenda();
                            notificacaoAgenda.Agenda    = agenda;
                            notificacaoAgenda.Utilizado = false;
                            notificacaoAgenda.Ativo     = true;
                            new NotificacaoAgendaRepository().ReativarNotificacao(notificacaoAgenda);
                        }
                    }
                    else if (agenda.EstadoAgenda.Estado.Equals("Cancelado") ||
                             agenda.EstadoAgenda.Estado.Equals("Agendado") ||
                             agenda.EstadoAgenda.Estado.Equals("Finalizado")
                             )
                    {
                        NotificacaoAgenda notificacaoAgenda = new NotificacaoAgenda();
                        notificacaoAgenda.Agenda = agenda;
                        new NotificacaoAgendaRepository().Delete(notificacaoAgenda);
                    }

                    new AgendaRepository().Update(agenda);
                }
                // Ou é novo registro?
                else
                {
                    agenda.AgendaID = new AgendaRepository().CreateWithReturnID(agenda);
                    assuntoSMS      = "Novo agendamento de congelação";

                    // Se a nova agenda é para o mesmo dia, evidencia no assunto do SMS.
                    if (agenda.DataHoraEvento.Value.Day == DateTime.Now.Day &&
                        agenda.DataHoraEvento.Value.Month == DateTime.Now.Month &&
                        agenda.DataHoraEvento.Value.Year == DateTime.Now.Year)
                    {
                        assuntoSMS = "*** Atenção *** Uma nova congelação foi marcada hoje.";
                    }
                }

                String mensagemSMS = Model.SMS.FormataMensagemSMS(agenda, assuntoSMS);

                if (ConfigurationManager.AppSettings["ENVIAR_SMS"] != null)
                {
                    String numeroTelefone = String.Format("{0}{1}", CodigoE164, agenda.MedicoExecucaoAgenda.Celular);

                    if (Convert.ToBoolean(ConfigurationManager.AppSettings["ENVIAR_SMS"]))
                    {
                        String MessageId = TwilioServices.SendSMS(numeroTelefone, mensagemSMS);

                        LogSmsAgenda logSmsAgenda = new LogSmsAgenda();
                        logSmsAgenda.Agenda               = agenda;
                        logSmsAgenda.SMSEnviado           = true;
                        logSmsAgenda.SMSDataProcessamento = DateTime.Now;
                        logSmsAgenda.SMSMessageID         = MessageId;
                        logSmsAgenda.Observacao           =
                            String.Format
                            (
                                "Origem SITE: mensagem destinado ao nº {0} enviada com sucesso ao servidor de serviço SMS."
                                , numeroTelefone
                            );
                        new LogSmsAgendaRepository().Create(logSmsAgenda);
                    }
                    else
                    {
                        LogSmsAgenda logSmsAgenda = new LogSmsAgenda();
                        logSmsAgenda.Agenda               = agenda;
                        logSmsAgenda.SMSEnviado           = false;
                        logSmsAgenda.SMSDataProcessamento = DateTime.Now;
                        logSmsAgenda.SMSMessageID         = null;
                        logSmsAgenda.Observacao           =
                            String.Format
                            (
                                "Origem SITE: mensagem destinado ao nº {0} não foi enviada, o serviço de envio de SMS está desabilitado. Utilize a chave ENVIAR_SMS do web.config da aplicação."
                                , numeroTelefone
                            );
                        new LogSmsAgendaRepository().Create(logSmsAgenda);
                    }
                }

                returnJSON.Message          = "Registro salvo com sucesso.";
                returnJSON.ReturnCode       = Enum.GetName(typeof(ReturnType), ReturnType.SUCCESS);
                context.Response.StatusCode = 201;
            }
            catch (SqlException e)
            {
                Log.Create(e);
                Email.Send("Agendamento de congelação - falha na aplicação", e);
                returnJSON.Message          = "Não foi possível salvar o registro.";
                returnJSON.ReturnCode       = Enum.GetName(typeof(ReturnType), ReturnType.ERROR);
                context.Response.StatusCode = 500;
            }
            catch (Exception e)
            {
                LogSmsAgenda logSmsAgenda = new LogSmsAgenda();
                logSmsAgenda.Agenda               = agenda;
                logSmsAgenda.SMSEnviado           = false;
                logSmsAgenda.SMSDataProcessamento = DateTime.Now;
                logSmsAgenda.Observacao           =
                    String.Format
                    (
                        "Ocorreu uma falha ao enviar o SMS para o nº {0}. Detalhes: {1}"
                        , String.Format("{0}{1}", CodigoE164, agenda.MedicoExecucaoAgenda.Celular)
                        , e.Message
                    );
                new LogSmsAgendaRepository().Create(logSmsAgenda);

                Log.Create(e);
                Email.Send("Agendamento de congelação - falha na aplicação", e);

                returnJSON.Message          = "Não foi possível enviar o SMS.";
                returnJSON.ReturnCode       = Enum.GetName(typeof(ReturnType), ReturnType.ERROR);
                context.Response.StatusCode = 500;
            }

            retorno = serializer.Serialize(returnJSON);
            context.Response.ContentType     = "text/json";
            context.Response.ContentEncoding = Encoding.UTF8;
            context.Response.Write(retorno);
        }