public static int GrabarNotificacion(List <string> numerosMovil, string tipoMensaje, string cuerpoMensaje)
{
try
{
foreach (var numeroMovil in numerosMovil)
{
SmsQueue notificacionSms = new SmsQueue()
{
NumeroMovil = numeroMovil,
TipoMensaje = tipoMensaje,
CuerpoMensaje = cuerpoMensaje,
FechaCreacion = DateTime.Now,
Procesado = false,
ResultadoProceso = string.Empty,
ErrorProceso = false
};
_db.SmsQueues.Add(notificacionSms);
_db.SaveChanges();
}
return(1);
}
catch (Exception e)
{
return(0);
}
}
//Wird z.Z. nicht aktiv angefragt
#endregion
#region SMS versenden
/// <summary>
/// Erstellt und übergibt eine SMS an das GSM-Modem zum senden. Triggert die Sendungsnachverfolgung.
/// </summary>
/// <param name="phone">Telefonnummer an die diese SMS gesendet werden soll (als Zahl mit Ländervorwahl).</param>
/// <param name="content">Inhalt der SMS</param>
/// <param name="logSentId">Eindeutige ID für Sendungsnachverfolgung durch Aufrufer. Wird automatisch vergeben, wenn keine Angabe.</param>
public void SmsSend(ulong phone, string content, int logSentId = 0)
{
List <Sms> results = SmsQueue.FindAll(x => x.Phone == phone && x.Content == content);
if (results.Count == 0)
{
//Inhalt vorbereiten
const string ctrlz = "\u001a";
content = content.Replace("\r\n", " ");
if (content.Length > 160)
{
content = content.Substring(0, 160);
}
if (logSentId < 1)
{
logSentId = DateTime.Now.Millisecond;
}
Sms sms = new Sms
{
LogSentId = logSentId,
Phone = phone,
Content = content,
SendTrys = 1
};
//Sendungsnachverfolgung
SmsQueue.Add(sms);
SetRetrySendSmsTimer();
//Senden
AddAtCommand("AT+CMGS=\"+" + phone + "\"\r");
AddAtCommand(content + ctrlz);
}
}
public async Task <bool> Delete(SmsQueue SmsQueue)
{
if (await ValidateId(SmsQueue))
{
}
return(SmsQueue.IsValidated);
}
/// <summary>
/// Antwort auf CMGS=[...]
/// Nachricht wurde gesendet. Liest internen Index für Statusreport aus
/// </summary>
/// <param name="input"></param>
private void ParseSmsTrackingIdFromSendResponse(string input)
{
if (input == null) return;
/* z.B.
+CMGS: 67
OK
*/
Regex r = new Regex(@"\+CMGS: (\d+)");
Match m = r.Match(input);
while (m.Success)
{
if (byte.TryParse(m.Groups[1].Value, out byte trackingId))
{
Console.WriteLine("Tracking-ID für gesendet SMS:" + trackingId);
Sms firstNew = SmsQueue.FindAll(x => x.TrackingId == 0).FirstOrDefault();
if (firstNew == null) continue;
int i = SmsQueue.IndexOf(firstNew);
SmsQueue[i].TrackingId = trackingId;
//firstNew.TrackingId = trackingId;
OnRaiseSmsSentEvent(SmsQueue[i]);
}
DebugTracking();
m = m.NextMatch();
}
}
public async Task AddAsync(string mobile, string templetTag, dynamic data)
{
if (string.IsNullOrEmpty(mobile))
{
throw new KuArgNullException("未设置手机号！");
}
if (string.IsNullOrEmpty(templetTag))
{
throw new KuArgNullException("未设置短信模板！");
}
Sms sms = new Sms
{
Id = ID.NewID(),
CreateTime = DateTime.Now,
IsDeleted = false,
Data = JsonConvert.SerializeObject(data),
Mobile = mobile
};
using (var dapper = DapperFactory.Create())
{
var templet = await dapper.QueryOneAsync <SmsTemplet>(new { Tag = templetTag, IsDeleted = false, IsEnable = true });
if (templet == null)
{
throw new KuDataNotFoundException("无法取得短信模板数据！");
}
var content = templet.Templet;
if (data != null)
{
foreach (var item in JsonConvert.DeserializeObject <Dictionary <string, string> >(sms.Data))
{
content = content.Replace("${" + item.Key + "}", item.Value);
}
}
sms.SmsTempletId = templet.Id;
sms.Content = content + $"【{templet.Signature}】";
//创建队列
var queue = new SmsQueue
{
Id = ID.NewID(),
CreateTime = DateTime.Now,
IsDeleted = false,
Status = EmSmsQueueStatus.WaitSend,
SmsId = sms.Id,
ExpireTime = templet.ExpireMinute == 0 ? DateTime.Now.AddDays(1) : DateTime.Now.AddMinutes(templet.ExpireMinute)
};
using (var trans = dapper.BeginTrans())
{
await dapper.InsertAsync(sms);
await dapper.InsertAsync(queue);
trans.Commit();
}
}
}
public SmsPollingJob(IOptions <JobsOptions> options, SmsQueue queue, InstanceInfoProvider instanceInfo, ApplicationRepositoryLite repo, ILogger <SmsJob> logger)
{
_options = options.Value;
_queue = queue;
_instanceInfo = instanceInfo;
_repo = repo;
_logger = logger;
}
public SmsJob(IOptions <JobsOptions> options, SmsQueue queue, ISmsSender smsSender, ILogger <SmsJob> logger, ApplicationRepositoryLite repo)
{
_options = options.Value;
_queue = queue;
_smsSender = smsSender;
_logger = logger;
_repo = repo;
}
public ExternalNotificationsService(ApplicationRepositoryLite repo, IOptions <JobsOptions> options, EmailQueue emailQueue, SmsQueue smsQueue, PushNotificationQueue pushQueue)
{
_repo = repo;
_options = options.Value;
_emailQueue = emailQueue;
_smsQueue = smsQueue;
_pushQueue = pushQueue;
}
public SmsJob(IOptions <NotificationsOptions> options, SmsQueue queue, ISmsSender smsSender, ILogger <SmsJob> logger, IApplicationRepositoryFactory repoFactory)
{
_options = options.Value;
_queue = queue;
_smsSender = smsSender;
_logger = logger;
_repoFactory = repoFactory;
}
public async Task <bool> Delete(SmsQueue SmsQueue)
{
await DataContext.SmsQueue.Where(x => x.Id == SmsQueue.Id).UpdateFromQueryAsync(x => new SmsQueueDAO {
DeletedAt = StaticParams.DateTimeNow
});
return(true);
}
public async Task <bool> RemindAsync(string tenant, ReminderMessage message)
{
await Task.Delay(0).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(message.Contact.MobileNumbers))
{
return(false);
}
int alarm = message.Event.Alarm ?? 0;
if (alarm == 0)
{
return(false);
}
string timezone = message.Contact.TimeZone.Or(message.Event.TimeZone);
string template = Configs.GetNotificationEmailTemplate(tenant);
string eventDate = TimeZoneInfo.ConvertTime(DateTime.UtcNow.AddMinutes(alarm), TimeZoneInfo.FindSystemTimeZoneById(timezone)).Date.ToString("D");
string startTime = TimeZoneInfo.ConvertTime(message.Event.StartsAt, TimeZoneInfo.FindSystemTimeZoneById(timezone)).ToString("t");
string endTime = TimeZoneInfo.ConvertTime(message.Event.EndsOn, TimeZoneInfo.FindSystemTimeZoneById(timezone)).ToString("t");
template = template.Replace("{Name}", message.Event.Name);
template = template.Replace("{StartTime}", startTime);
template = template.Replace("{EndTime}", endTime);
template = template.Replace("{Date}", eventDate);
template = template.Replace("{Location}", message.Event.Location);
template = template.Replace("{Note}", message.Event.Note);
var processor = SmsProcessor.GetDefault(tenant);
if (processor == null)
{
return(false);
}
var textMessage = new SmsQueue
{
AddedOn = DateTimeOffset.UtcNow,
SendOn = DateTimeOffset.UtcNow,
SendTo = message.Contact.MobileNumbers,
FromName = processor.Config.FromName,
FromNumber = processor.Config.FromNumber,
Subject = string.Format(I18N.CalendarNotificationEmailSubject, message.Event.Name, startTime),
Message = template
};
var manager = new SmsQueueManager(tenant, textMessage);
await manager.AddAsync().ConfigureAwait(false);
await manager.ProcessQueueAsync(processor).ConfigureAwait(false);
return(true);
}
public async Task <SmsQueue> Get(long Id)
{
SmsQueue SmsQueue = await UOW.SmsQueueRepository.Get(Id);
if (SmsQueue == null)
{
return(null);
}
return(SmsQueue);
}
/// <summary>
/// Saves an sms queue object in the db
/// </summary>
/// <param name="smsQueue">Sms</param>
/// <returns>True if successfull</returns>
public bool Save(SmsQueue smsQueue)
{
return(sqlService.OpenConnection((connection) =>
{
var affectedRows = connection.Execute($"INSERT INTO {TableName} (Id, Number, Body, Status, ProviderResponse, SentTime) "
+ " ON EXISTING UPDATE VALUES (:Id, :Number, :Body, :Status, :ProviderResponse, :SentTime)", smsQueue);
return affectedRows > 0;
}));
}
/// <summary>
/// 新增
/// </summary>
public async Task AddAsync(SmsDto dto)
{
Sms model = Mapper.Map <Sms>(dto);
if (string.IsNullOrEmpty(model.Mobile))
{
throw new VinoArgNullException("未设置手机号！");
}
using (var dapper = DapperFactory.Create())
{
var templet = await dapper.QueryOneAsync <SmsTemplet>(new { Id = model.SmsTempletId });
if (templet == null || templet.IsDeleted)
{
throw new VinoDataNotFoundException("无法取得短信模板数据！");
}
if (!templet.IsEnable)
{
throw new VinoDataNotFoundException("短信模板已禁用！");
}
var content = templet.Templet;
foreach (var item in dto.Data)
{
content = content.Replace("${" + item.Key + "}", item.Value);
}
model.Content = content + $"【{templet.Signature}】";
model.Id = ID.NewID();
model.CreateTime = DateTime.Now;
model.IsDeleted = false;
//创建队列
var queue = new SmsQueue
{
Id = ID.NewID(),
CreateTime = DateTime.Now,
IsDeleted = false,
Status = EmSmsQueueStatus.WaitSend,
SmsId = model.Id,
ExpireTime = templet.ExpireMinute == 0 ? DateTime.Now.AddDays(1) : DateTime.Now.AddMinutes(templet.ExpireMinute)
};
using (var trans = dapper.BeginTrans())
{
await dapper.InsertAsync(model);
await dapper.InsertAsync(queue);
trans.Commit();
}
}
}
/// <summary>
/// Lese Statusreport-SMS, lösche bei erfolgreichem Senden SMS aus Sendungsverfolgung
/// </summary>
/// <param name="input"></param>
private void ParseStatusReport(string input)
{
if (input == null) return;
try
{
//+CMGL: < index > , < stat > , < fo > , < mr > , [ < ra > ], [ < tora > ], < scts > , < dt > , < st >
//[... ]
//OK
//<st> 0-31 erfolgreich versandt; 32-63 versucht weiter zu senden: 64-127 Sendeversuch abgebrochen
//z.B.: +CMGL: 1,"REC READ",6,34,,,"20/11/06,16:08:45+04","20/11/06,16:08:50+04",0
//Regex r = new Regex(@"\+CMGL: (\d+),""(.+)"",(\d+),(\d+),,,""(.+)"",""(.+)"",(\d+)\r\n");
Regex r = new Regex(@"\+CMGL: (\d+),""(.+)"",(\d+),(\d+),,,""(.+)"",""(.+)"",(\d+)");
Match m = r.Match(input);
if(m.Length > 0)
{
DebugTracking();
}
while (m.Success)
{
byte.TryParse(m.Groups[1].Value, out byte index);
string status = m.Groups[2].Value;
byte trackingId = byte.Parse(m.Groups[4].Value);
Console.WriteLine("Status-report für SMS-Index {0} erhalten.", trackingId);
byte trackingStatus = byte.Parse(m.Groups[7].Value);
if (status != "REC UNREAD" && status != "REC READ") continue; //nur empfangene Nachrichten
Sms confirmedSms = SmsQueue.FindAll(x => x.TrackingId == trackingId).FirstOrDefault();
if (confirmedSms != null)
{
confirmedSms.SendStatus = trackingStatus;
OnRaiseSmsStatusreportEvent(confirmedSms);
if (confirmedSms.SendStatus < 32) //SMS erfolgreich versendet
{
SmsQueue.Remove(confirmedSms);
}
}
SmsToDelete.Add(index); //Diesen Statusreport löschen
m = m.NextMatch();
}
}
catch (Exception ex)
{
throw ex;
}
}
public static async Task <bool> SendAsync(string tenant, SmsViewModel model, LoginView meta)
{
var processor = SmsProcessor.GetDefault(tenant);
if (processor == null)
{
return(false);
}
foreach (var contactId in model.Contacts)
{
var contact = await DAL.Contacts.GetContactAsync(tenant, model.UserId, contactId).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(contact?.MobileNumbers) || !contact.MobileNumbers.Split(',').Any())
{
continue;
}
//Only select the first cell number
string cellNumber = contact.MobileNumbers.Split(',').Select(x => x.Trim()).FirstOrDefault();
if (string.IsNullOrWhiteSpace(cellNumber))
{
continue;
}
string message = model.Message;
message = MessageParser.ParseMessage(message, contact);
var sms = new SmsQueue
{
AddedOn = DateTimeOffset.UtcNow,
SendOn = DateTimeOffset.UtcNow,
SendTo = cellNumber,
FromName = processor.Config.FromName.Or(meta.OfficeName),
FromNumber = processor.Config.FromNumber.Or(meta.Phone),
Subject = model.Subject,
Message = message
};
await new SmsQueueManager(tenant, sms).AddAsync().ConfigureAwait(false);
}
var queue = new SmsQueueManager
{
Database = tenant
};
await queue.ProcessQueueAsync(processor).ConfigureAwait(false);
return(true);
}
public SmsPollingJob(
IOptions <NotificationsOptions> options,
SmsQueue queue,
InstanceInfoProvider instanceInfo,
IApplicationRepositoryFactory repoFactory,
ILogger <SmsPollingJob> logger)
{
_options = options.Value;
_queue = queue;
_instanceInfo = instanceInfo;
_repoFactory = repoFactory;
_logger = logger;
}
public CustomerLead_SmsQueueDTO(SmsQueue SmsQueue)
{
this.Id = SmsQueue.Id;
this.Phone = SmsQueue.Phone;
this.SmsCode = SmsQueue.SmsCode;
this.SmsTitle = SmsQueue.SmsTitle;
this.SentDate = SmsQueue.SentDate;
this.SmsContent = SmsQueue.SmsContent;
this.SentByAppUserId = SmsQueue.SentByAppUserId;
this.SmsQueueStatusId = SmsQueue.SmsQueueStatusId;
this.SentByAppUser = SmsQueue.SentByAppUser == null ? null : new CustomerLead_AppUserDTO(SmsQueue.SentByAppUser);
this.SmsQueueStatus = SmsQueue.SmsQueueStatus == null ? null : new CustomerLead_SmsQueueStatusDTO(SmsQueue.SmsQueueStatus);
this.CreatedAt = SmsQueue.CreatedAt;
this.UpdatedAt = SmsQueue.UpdatedAt;
this.Errors = SmsQueue.Errors;
}
public static SmsMessage GetMessage(SmsConfig config, SmsQueue mail)
{
var message = new SmsMessage
{
FromName = mail.FromName,
FromIdentifier = mail.FromNumber,
Subject = mail.Subject,
SendTo = mail.SendTo,
Message = mail.Message,
Type = Type.Outward,
EventDateUtc = DateTimeOffset.UtcNow,
Status = Status.Unknown
};
return(message);
}
public async Task <SmsQueue> Get(long Id)
{
SmsQueue SmsQueue = await DataContext.SmsQueue.AsNoTracking()
.Where(x => x.Id == Id).Select(x => new SmsQueue()
{
CreatedAt = x.CreatedAt,
UpdatedAt = x.UpdatedAt,
Id = x.Id,
Phone = x.Phone,
SmsCode = x.SmsCode,
SmsTitle = x.SmsTitle,
SmsContent = x.SmsContent,
SmsQueueStatusId = x.SmsQueueStatusId,
SentByAppUserId = x.SentByAppUserId,
SmsQueueStatus = x.SmsQueueStatus == null ? null : new SmsQueueStatus
{
Id = x.SmsQueueStatus.Id,
Code = x.SmsQueueStatus.Code,
Name = x.SmsQueueStatus.Name,
},
SentByAppUser = x.SentByAppUser == null ? null : new AppUser
{
Id = x.SentByAppUser.Id,
Username = x.SentByAppUser.Username,
DisplayName = x.SentByAppUser.DisplayName,
Address = x.SentByAppUser.Address,
Email = x.SentByAppUser.Email,
Phone = x.SentByAppUser.Phone,
SexId = x.SentByAppUser.SexId,
Birthday = x.SentByAppUser.Birthday,
Avatar = x.SentByAppUser.Avatar,
Department = x.SentByAppUser.Department,
OrganizationId = x.SentByAppUser.OrganizationId,
Longitude = x.SentByAppUser.Longitude,
Latitude = x.SentByAppUser.Latitude,
StatusId = x.SentByAppUser.StatusId,
},
}).FirstOrDefaultAsync();
if (SmsQueue == null)
{
return(null);
}
return(SmsQueue);
}
public NotificationsQueue(
IApplicationRepositoryFactory repoFactory,
IOptions <NotificationsOptions> options,
EmailQueue emailQueue,
SmsQueue smsQueue,
PushNotificationQueue pushQueue,
IEmailSender emailSender,
ISmsSender smsSender,
IBlobService blobService)
{
_options = options.Value;
_repoFactory = repoFactory;
_emailQueue = emailQueue;
_smsQueue = smsQueue;
_pushQueue = pushQueue;
_emailSender = emailSender;
_smsSender = smsSender;
_blobService = blobService;
}
public async Task <bool> ValidateId(SmsQueue SmsQueue)
{
SmsQueueFilter SmsQueueFilter = new SmsQueueFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = SmsQueue.Id
},
Selects = SmsQueueSelect.Id
};
int count = await UOW.SmsQueueRepository.Count(SmsQueueFilter);
if (count == 0)
{
SmsQueue.AddError(nameof(SmsQueueValidator), nameof(SmsQueue.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public ReturnObject CreateSmsQueueAsync(SmsQueue model)
{
try
{
var sendSmsRepository = _vakaxaIdRepositoryFactory.GetSendSmsRepository(_connectionDb);
// save to DB
var result = sendSmsRepository.Insert(model);
return(result);
}
catch (Exception e)
{
_logger.Error(e);
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = e.ToString()
});
}
}
public ReturnObject CreateSmsQueueAsync(SmsQueue model)
{
try
{
using (var sendSmslRepository = _vakapayRepositoryFactory.GetSendSmsRepository(_connectionDb))
{
return(sendSmslRepository.Insert(model));
}
// save to DB
}
catch (Exception e)
{
_logger.Error(e);
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = e.ToString()
});
}
}
public async Task <bool> Update(SmsQueue SmsQueue)
{
SmsQueueDAO SmsQueueDAO = DataContext.SmsQueue.Where(x => x.Id == SmsQueue.Id).FirstOrDefault();
if (SmsQueueDAO == null)
{
return(false);
}
SmsQueueDAO.Id = SmsQueue.Id;
SmsQueueDAO.Phone = SmsQueue.Phone;
SmsQueueDAO.SmsCode = SmsQueue.SmsCode;
SmsQueueDAO.SmsTitle = SmsQueue.SmsTitle;
SmsQueueDAO.SmsContent = SmsQueue.SmsContent;
SmsQueueDAO.SmsQueueStatusId = SmsQueue.SmsQueueStatusId;
SmsQueueDAO.UpdatedAt = StaticParams.DateTimeNow;
await DataContext.SaveChangesAsync();
await SaveReference(SmsQueue);
return(true);
}
public async Task <SmsQueue> Update(SmsQueue SmsQueue)
{
if (!await SmsQueueValidator.Update(SmsQueue))
{
return(SmsQueue);
}
try
{
var oldData = await UOW.SmsQueueRepository.Get(SmsQueue.Id);
await UOW.Begin();
await UOW.SmsQueueRepository.Update(SmsQueue);
await UOW.Commit();
SmsQueue = await UOW.SmsQueueRepository.Get(SmsQueue.Id);
await Logging.CreateAuditLog(SmsQueue, oldData, nameof(SmsQueueService));
return(SmsQueue);
}
catch (Exception ex)
{
await UOW.Rollback();
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(SmsQueueService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(SmsQueueService));
throw new MessageException(ex.InnerException);
}
}
}
// Send code when do action
public ReturnObject SendSms(User user, string code)
{
try
{
var sendSmsRepository = new SendSmsBusiness.SendSmsBusiness(_vakapayRepositoryFactory, false);
var newSms = new SmsQueue
{
Status = Status.STATUS_PENDING,
To = user.PhoneNumber,
TextSend = "VaKaXaPay security code is: " + code,
};
var resultSms = sendSmsRepository.CreateSmsQueueAsync(newSms);
if (resultSms.Status == Status.STATUS_ERROR)
{
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = "Fail insert to sendSms " + resultSms.Message
});
}
return(new ReturnObject
{
Status = Status.STATUS_SUCCESS,
Message = "Success"
});
}
catch (Exception e)
{
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = e.Message
});
}
}
public async Task <bool> Create(SmsQueue SmsQueue)
{
SmsQueueDAO SmsQueueDAO = new SmsQueueDAO();
SmsQueueDAO.Id = SmsQueue.Id;
SmsQueueDAO.Phone = SmsQueue.Phone;
SmsQueueDAO.SmsCode = SmsQueue.SmsCode;
SmsQueueDAO.SmsTitle = SmsQueue.SmsTitle;
SmsQueueDAO.SmsContent = SmsQueue.SmsContent;
SmsQueueDAO.SmsQueueStatusId = SmsQueue.SmsQueueStatusId;
SmsQueueDAO.SentDate = StaticParams.DateTimeNow;
SmsQueueDAO.SentByAppUserId = SmsQueue.SentByAppUserId;
SmsQueueDAO.CreatedAt = StaticParams.DateTimeNow;
SmsQueueDAO.UpdatedAt = StaticParams.DateTimeNow;
DataContext.SmsQueue.Add(SmsQueueDAO);
await DataContext.SaveChangesAsync();
SmsQueue.Id = SmsQueueDAO.Id;
await SaveReference(SmsQueue);
return(true);
}
/// <summary>
/// Sends an sms using a provider (lox24 is default)
/// </summary>
/// <param name="number">Phone number</param>
/// <param name="body">Sms text</param>
/// <returns>True if successfull</returns>
public bool SendSms(SmsQueue smsQueue)
{
var result = smsProvider.SendSms(smsQueue.Number, smsQueue.Body);
if (result == null)
{
return(false);
}
var resultLox24 = result as Lox24Result;
if (resultLox24 != null)
{
if (resultLox24.StatusCode == Lox24ResultStatus.SmsSuccess ||
resultLox24.StatusCode == Lox24ResultStatus.SuccessfulQuery ||
resultLox24.StatusCode == Lox24ResultStatus.CommandExecuted)
{
smsQueue.SentTime = DateTime.Now;
smsQueue.Status = SmsStatus.Sent;
smsQueue.ProviderResponse = resultLox24.ResultText;
Save(smsQueue);
return(true);
}
else
{
smsQueue.Status = SmsStatus.Failed;
smsQueue.ProviderResponse = resultLox24.ResultText;
Save(smsQueue);
return(false);
}
}
return(false);
}
private void SendMessages(string loco, DateTime date)
{
try
{
var dbSms = new UserContext();
var receivers = new string[] { "*****@*****.**",
"*****@*****.**",
"*****@*****.**" };
// "*****@*****.**",
// "*****@*****.**",
// "*****@*****.**",
// "*****@*****.**",
// "*****@*****.**",
// "*****@*****.**",
// "*****@*****.**"
//};
foreach (var user in receivers)
{
SmsQueue smsQueue = new SmsQueue();
smsQueue.Hist = DateTime.Now;
smsQueue.Message = string.Format("Log da Locomotiva Helper {0} recebido no sistema! http://172.20.15.22/hd/LogHelperDinamico ", loco);
smsQueue.Sender = "*****@*****.**";
smsQueue.Receiver = user;
smsQueue.Subject = string.Format("Download Remoto do Helper Dinâmico - Log da {0} recebido com sucesso!", loco);
smsQueue.AppInfo = "5500";
dbSms.SmsQueue.Add(smsQueue);
}
dbSms.SaveChanges();
dbSms.Dispose();
}
catch (Exception e)
{
DebugLog.Logar(e.Message);
DebugLog.Logar(e.StackTrace);
}
}
