public static async Task <(string id, Exception error)> send(ISmsMessage message)
{
if (_impl != null)
{
return(await _impl.send(message));
}
return(default, new NotImplementedException());
public async Task <bool> Send(ISmsMessage smsItem)
{
if (smsItem.Retries > MaximumRetries)
{
return(false);
}
if (smsItem.IsNew)
{
await Database.Save(smsItem);
}
try
{
await Dispatcher.Dispatch(smsItem);
await Database.Update(smsItem, o => o.DateSent = LocalTime.Now);
return(true);
}
catch (Exception ex)
{
await SendError.Raise(new SmsSendingEventArgs(smsItem) { Error = ex });
Log.Error(ex, "Can not send the SMS queue item.");
await RecordFailedAttempt(smsItem);
return(false);
}
}
public VerificationCodeAppService(IMailManager emailSender, IRepository <MessageHistory> messageHistoryRepository, ISmsMessage smsMessage)
{
_emailSender = emailSender;
LocalizationSourceName = AppConsts.LocalizationSourceName;
_messageHistoryRepository = messageHistoryRepository;
_smsMessage = smsMessage;
}
public void SendSMS()
{
ISmsMessage message = ((Skype)Activator.CreateInstance(System.Type.GetTypeFromCLSID(new Guid("830690FC-BF2F-47A6-AC2D-330BCB402664")))).CreateSms(TSmsMessageType.smsMessageTypeOutgoing, this.PhoneNumber);
message.Body = this.SMS_Message;
message.Send();
SRG.srespeech.SpeakAsync("Message sent");
}
public async Task <ISendSmsResponse> SendAsync(ISmsMessage smsMessage)
{
Log.Info("Sending an SMS");
Log.Debug("SMS options: " + LogSerialiser.Serialise(options.SmsOptions));
var response = await client.SendRequestAsync(new SendSmsRequest(smsMessage, options));
return(new SendSmsResponse(JsonConvert.DeserializeObject <SendSmsResponseEntry>(response.RawResponse), response.RawResponse,
response.StatusCode, response.Successful));
}
/// <summary>
/// Records an unsuccessful attempt to send this SMS.
/// </summary>
public async Task RecordFailedAttempt(ISmsMessage sms)
{
if (!sms.IsNew)
{
await Database.Update(sms, s => s.Retries++);
}
// Also update this local instance:
sms.Retries++;
}
public Task Dispatch(ISmsMessage sms)
{
var client = new Client(Config.GetOrThrow("Sms:TextMagic:Username"), Config.GetOrThrow("Sms:TextMagic:Key"));
var result = client.SendMessage(sms.Text, sms.To);
if (!result.Success)
{
throw new Exception("Failed to send message because : " + result.ClientException.Message);
}
return(Task.CompletedTask);
}
public async Task SendAsync(ISmsMessage smsMessage, CancellationToken cancellationToken = default)
{
var smsClient = new SmsClient(_options.ConnectionString);
var response = await smsClient.SendAsync(
from : _options.FromNumber,
to : smsMessage.PhoneNumber,
message : smsMessage.Message,
cancellationToken : cancellationToken);
if (!string.IsNullOrWhiteSpace(response?.Value?.MessageId))
{
}
}
public async Task SendAsync(ISmsMessage smsMessage, CancellationToken cancellationToken = default)
{
TwilioClient.Init(_options.AccountSId, _options.AuthToken);
var message = await MessageResource.CreateAsync(
body : smsMessage.Message,
from : new PhoneNumber(_options.FromNumber),
to : new PhoneNumber(smsMessage.PhoneNumber));
if (!string.IsNullOrWhiteSpace(message.Sid))
{
}
}
public Sms(ISendSmsRequestReceived @event, ISmsMessage smsMessage)
{
Subject = smsMessage.Subject;
Body = smsMessage.Body;
Phone = smsMessage.Receiver;
Credit = smsMessage.Credit;
Status = SmsStatus.Pending;
Id = smsMessage.Id;
StudentOpticalFormId = smsMessage.StudentOpticalFormId;
ExamId = smsMessage.ExamId;
UserId = @event.UserId;
CreatedOnDateTimeUtc = @event.CreatedOnUTC;
UserSubjectId = @event.UserSubjectId;
}
public SendSmsRequest(ISmsMessage smsMessage, IMailjetOptions options)
{
if (smsMessage == null)
{
throw new ArgumentNullException(nameof(smsMessage));
}
this.options = options ?? throw new ArgumentNullException(nameof(options));
if (options.SmsOptions.SmsApiVersion != SmsApiVersion.V4)
{
throw new UnsupportedApiVersionException();
}
AuthenticationHeaderValue = new AuthenticationHeaderValue("Bearer", options.Token);
SetRequestBody(smsMessage);
HttpMethod = new HttpMethod("POST");
Path = "v4/sms-send";
}
public static SmsMessage Create(ISmsMessage src)
{
if (src == null)
{
return(null);
}
return(new SmsMessage
{
Id = src.Id,
MessageId = src.MessageId,
Phone = src.Phone,
Message = src.Message,
Provider = src.Provider,
CountryCode = src.CountryCode,
Created = src.Created
});
}
public async Task Dispatch(ISmsMessage sms)
{
var senderId = sms.SenderName ?? Configuration.GetValue <string>("Aws:Sns:SenderId");
var originationNumber = Configuration.GetValue <string>("Aws:Sns:OriginationNumber");
var messageAttributes = new Dictionary <string, MessageAttributeValue>
{
{
"AWS.SNS.SMS.SMSType",
new MessageAttributeValue {
DataType = "String", StringValue = "Transactional"
}
},
};
if (!string.IsNullOrWhiteSpace(senderId))
{
messageAttributes.Add(
"AWS.SNS.SMS.SenderID",
new MessageAttributeValue {
DataType = "String", StringValue = senderId
}
);
}
if (!string.IsNullOrWhiteSpace(originationNumber))
{
messageAttributes.Add(
"AWS.MM.SMS.OriginationNumber",
new MessageAttributeValue {
DataType = "String", StringValue = originationNumber
}
);
}
var pubRequest = new PublishRequest
{
Message = sms.Text,
PhoneNumber = sms.To,
MessageAttributes = messageAttributes,
};
await Client.PublishAsync(pubRequest);
}
internal static SmsMessageEntity Create(ISmsMessage message)
{
string id = string.IsNullOrEmpty(message.Id)
? Guid.NewGuid().ToString()
: message.Id;
return(new SmsMessageEntity
{
PartitionKey = GeneratePartitionKey(message.Created == DateTime.MinValue ? DateTime.UtcNow : message.Created),
RowKey = GenerateRowKey(id),
Id = id,
CountryCode = message.CountryCode,
Message = message.Message,
MessageId = message.MessageId,
Phone = message.Phone,
Provider = message.Provider,
Created = DateTime.UtcNow
});
}
public ISmsSendResult SendSms(ISmsMessage smsMessage)
{
if (smsMessage == null)
{
throw new ArgumentNullException(nameof(smsMessage));
}
if (!ValidateMobilePhoneNumberLength(smsMessage.MobilePhoneNumber))
{
return(new SmsBlissSentResult(SmsSentStatus.InvalidMobilePhone)
{
Description = "Сообщение не было отправлено, не корректная длина номера телефона"
});
}
string phone = smsMessage.MobilePhoneNumber;
Message message = new Message(smsMessage.LocalId, phone, smsMessage.MessageText);
var response = smsBlissClient.SendMessages(new[] { message }, showBillingDetails: true);
NotifyBalanceChangeOnSendSuccessfully(response);
return(ConvertToISmsSendResult(response));
}
public Task Dispatch(ISmsMessage sms)
{
return(Task.CompletedTask);
}
// Handle a request to read a message.
private async void Read_Click(object sender, RoutedEventArgs e)
{
// If this is the first request, get the default SMS device. If this
// is the first SMS device access, the user will be prompted to grant
// access permission for this application.
if (device == null)
{
try
{
rootPage.NotifyUser("Getting default SMS device ...", NotifyType.StatusMessage);
device = await SmsDevice.GetDefaultAsync();
}
catch (Exception ex)
{
rootPage.NotifyUser("Failed to find SMS device\n" + ex.Message, NotifyType.ErrorMessage);
return;
}
}
// Clear message display.
DateText.Text = "";
ReadFromText.Text = "";
ReadMessageText.Text = "";
try
{
// Parse the message ID - must be number between 1 and maximum message count.
uint id;
if (uint.TryParse(ReadIdText.Text, out id) &&
(id >= 1) && (id <= device.MessageStore.MaxMessages))
{
rootPage.NotifyUser("Reading message ...", NotifyType.StatusMessage);
// Get the selected message from message store asynchronously.
ISmsMessage msg = await device.MessageStore.GetMessageAsync(id);
// See if this is a text message by querying for the text message interface.
ISmsTextMessage textMsg = msg as ISmsTextMessage;
if (textMsg == null)
{
// If it is a binary message then try to convert it to a text message.
if (msg is SmsBinaryMessage)
{
textMsg = SmsTextMessage.FromBinaryMessage(msg as SmsBinaryMessage);
}
}
// Display the text message information.
if (textMsg != null)
{
DateText.Text = textMsg.Timestamp.DateTime.ToString();
ReadFromText.Text = textMsg.From;
ReadMessageText.Text = textMsg.Body;
rootPage.NotifyUser("Message read.", NotifyType.StatusMessage);
}
}
else
{
rootPage.NotifyUser("Invalid ID number entered.", NotifyType.ErrorMessage);
}
}
catch (Exception ex)
{
rootPage.NotifyUser(ex.Message, NotifyType.ErrorMessage);
// On failure, release the device. If the user revoked access or the device
// is removed, a new device object must be obtained.
device = null;
}
}
public Task SendAsync(ISmsMessage smsMessage, CancellationToken cancellationToken = default)
{
return(Task.CompletedTask);
}
public SmsSendingEventArgs(ISmsMessage item) => Item = item;
public Task Dispatch(ISmsMessage sms)
{
// send sms
}
public Task <ISmsSendResult> SendSmsAsync(ISmsMessage message)
{
throw new NotSupportedException(); // Нет использований в нашем проекте TODO: дописать при рефакторинге библиотеки
}
public ISmsSendResult SendSms(ISmsMessage message)
{
var response = smsRuProvider.Send(configuration.SmsNumberFrom, message.MobilePhoneNumber, message.MessageText, message.ScheduleTime);
if (!string.IsNullOrEmpty(response))
{
var lines = response.Split('\n');
var enumStatus = Enum.Parse(typeof(ResponseOnSendRequest), lines[0]);
SmsSendResult smsSendResponse;
switch (enumStatus)
{
case ResponseOnSendRequest.MessageAccepted:
smsSendResponse = new SmsSendResult(SmsSentStatus.Accepted);
var balanceLine = lines.FirstOrDefault(x => x.StartsWith(balanceStringPrefix));
var culture = CultureInfo.CreateSpecificCulture("ru-RU");
culture.NumberFormat.NumberDecimalSeparator = ".";
if (balanceLine != null && decimal.TryParse(balanceLine.Substring(balanceStringPrefix.Length), NumberStyles.AllowDecimalPoint, culture.NumberFormat, out decimal newBalance))
{
OnBalanceChange?.Invoke(this, new SmsBalanceEventArgs(BalanceType.CurrencyBalance, newBalance));
}
else
{
logger.Warn("Не удалось получить баланс в ответном сообщении");
}
break;
case ResponseOnSendRequest.BadRecipient:
case ResponseOnSendRequest.BlacklistedRecepient:
case ResponseOnSendRequest.CantSendToThisNumber:
case ResponseOnSendRequest.DayMessageLimitToNumber:
smsSendResponse = new SmsSendResult(SmsSentStatus.InvalidMobilePhone);
break;
case ResponseOnSendRequest.MessageTextNotSpecified:
smsSendResponse = new SmsSendResult(SmsSentStatus.TextIsEmpty);
break;
case ResponseOnSendRequest.BadSender:
smsSendResponse = new SmsSendResult(SmsSentStatus.SenderAddressInvalid);
break;
case ResponseOnSendRequest.OutOfMoney:
smsSendResponse = new SmsSendResult(SmsSentStatus.NotEnoughBalance);
break;
default:
smsSendResponse = new SmsSendResult(SmsSentStatus.UnknownError);
break;
}
return(smsSendResponse);
}
else
{
throw new Exception("Не получен ответ от сервера");
}
}
/// <summary>
/// Updates the DateSent field of this item and then soft deletes it.
/// </summary>
public Task MarkSent(ISmsMessage sms)
{
return(Database.EnlistOrCreateTransaction(() => Database.Update(sms, o => o.DateSent = LocalTime.Now)));
}
public async Task <(string id, Exception error)> send(ISmsMessage message)
{
return(getNextMessageId(), default);
public Task Dispatch(ISmsMessage sms) => Task.CompletedTask;
