private void ProcessarSmsPendente()
        {
            SmsService smsService = new SmsService();

            this._listaSmsPendente = smsService.BuscarPendentes(ParametrosAppConfig.QtdeSmsEnviadosPorVez);

            if (_listaSmsPendente.Count == 0)
            {
                return;
            }

            SmsGateway smsGateway = CreateSmsGateway();

            foreach (var sms in _listaSmsPendente)
            {
                if (!string.IsNullOrWhiteSpace(sms.IdMessageSmsGateway))
                {
                    smsGateway.GetMessage(
                        sms.IdMessageSmsGateway,
                        success: (result) =>
                    {
                        var status = result["status"].ToString();

                        if (status == "sent" || status == "manual send")
                        {
                            var smsServiceThreadSafe = new SmsService();
                            var smsAtualizavel       = smsServiceThreadSafe.BuscarPor(sms.Id);

                            smsAtualizavel.Status = StatusSms.Enviado;
                            smsAtualizavel.DataConfirmacaoEnvio = DateTime.Now;

                            smsServiceThreadSafe.Salvar(smsAtualizavel);
                        }
                        else if (status == "pending" && sms.DataEnvio < DateTime.Now.AddMinutes(-5))
                        {
                            var smsServiceThreadSafe = new SmsService();
                            var smsAtualizavel       = smsServiceThreadSafe.BuscarPor(sms.Id);

                            smsAtualizavel.Status             = StatusSms.NaoEnviado;
                            smsAtualizavel.DataEnvio          = null;
                            smsAtualizavel.DataInicioProcesso = null;

                            smsServiceThreadSafe.Salvar(smsAtualizavel);
                        }
                        else if (status == "failed")
                        {
                            LogarErroSms(sms.Id, StatusSms.Erro, (result["error"] ?? string.Empty).ToString());
                        }
                    },
                        error: (erro) =>
                    {
                        LogarErroSms(sms.Id, StatusSms.TentarNovamente, erro);
                    });
                }
            }
        }
Exemple #2
0
        private async Task SendQuickAsync(SendOtpInput input)
        {
            var smsServerUrl = await _systemConfigServices.GetValueAsync(SmsGateway.ServerUrlConfigKey);

            var smsOtpTemplate = await _systemConfigServices.GetValueAsync("SmsOtpTemplate");

            // prepare
            SmsSendRequest smsSendRequest = new SmsSendRequest();

            smsSendRequest.ServerUrl    = smsServerUrl;
            smsSendRequest.MobileNumber = input.Mobile;
            smsSendRequest.Text         = smsOtpTemplate
                                          .Replace("{otp}", input.Otp)
                                          .Replace("{time}", input.Time);
            smsSendRequest.IsUnicode = false;
            await SmsGateway.SendQuick_Send(smsSendRequest);
        }
        private void ProcessarSmsNaoEnviado()
        {
            SmsService smsService = new SmsService();

            this._listaSmsNaoEnviado = smsService.BuscarNaoEnviados(ParametrosAppConfig.QtdeSmsEnviadosPorVez);

            if (_listaSmsNaoEnviado.Count == 0)
            {
                return;
            }

            foreach (var sms in _listaSmsNaoEnviado)
            {
                sms.DataInicioProcesso = DateTime.Now;
                sms.Status             = StatusSms.Processando;
                smsService.Salvar(sms);
            }

            SmsGateway smsGateway = CreateSmsGateway();

            smsGateway.GetDevices(
                success: (devices) =>
            {
                foreach (var sms in _listaSmsNaoEnviado)
                {
                    try
                    {
                        string device = devices[0];

                        smsGateway.SendMessage(device, sms.Numero, sms.Mensagem,
                                               success: (result) =>
                        {
                            var smsServiceThreadSafe = new SmsService();
                            var smsAtualizavel       = smsServiceThreadSafe.BuscarPor(sms.Id);

                            smsAtualizavel.DataEnvio = DateTime.Now;
                            smsAtualizavel.Erro      = null;

                            if (result[0]["status"].ToString() == "pending")
                            {
                                smsAtualizavel.Status = StatusSms.Pendente;
                            }

                            smsAtualizavel.IdMessageSmsGateway = result[0]["id"].ToString();

                            smsServiceThreadSafe.Salvar(smsAtualizavel);
                        },
                                               error: (erro) =>
                        {
                            LogarErroSms(sms.Id, StatusSms.TentarNovamente, erro);
                        });

                        var newIndex = devices.IndexOf(device) + 1;

                        if (newIndex == devices.Count)
                        {
                            device = devices[0];
                        }
                        else
                        {
                            device = devices[newIndex];
                        }
                    }
                    catch (Exception ex)
                    {
                        LogarErroSms(sms.Id, StatusSms.TentarNovamente, ex.Message);
                    }
                }
            },
                error: (erro) =>
            {
                foreach (var sms in _listaSmsNaoEnviado)
                {
                    LogarErroSms(sms.Id, StatusSms.TentarNovamente, erro);
                }
            });
        }
Exemple #4
0
 public SmsService(SmsGateway smsGateway)
 {
     _smsGateway = smsGateway;
 }