/// <summary>
/// (重)发送入园凭证短信 基础数据验证
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public DataValidResult ValidDataForMessageSendRequest(MessageSendRequest request)
{
var orderInfo = request.Body.OrderInfo;
var result = new DataValidResult {
Status = false
};
if (string.IsNullOrEmpty(orderInfo.OrderId))
{
result.Code = "117001";
result.Message = "(重)发送入园凭证短信异常，订单id不能为空";
return(result);
}
if (string.IsNullOrEmpty(orderInfo.phoneNumber))
{
result.Code = "117002";
result.Message = "(重)发送入园凭证短信异常，重发手机号码不能为空";
return(result);
}
if (!RegexValidation.IsCellPhone(orderInfo.phoneNumber))
{
result.Code = "117003";
result.Message = "(重)发送入园凭证短信异常，重发手机号码异常";
return(result);
}
result.Status = true;
return(result);
}
public async Task <MessageSendResponse> SendMulticast(MessageSendRequest request)
{
var message = new MulticastMessage()
{
Notification = new Notification()
{
Title = request.NotificationTitle,
Body = request.NotificationBody,
},
Tokens = request.Tokens,
};
var response = await _firebaseService.SendMulticastAsync(message);
var returnResponse = new MessageSendResponse()
{
Responses = response.Responses.Select(x => new ResponseItem
{
IsSuccess = x.IsSuccess,
MessageId = x.MessageId,
Exception = x.IsSuccess ? null : new ExceptionItem
{
Message = x.Exception.Message,
MessagingErrorCode = x.Exception.MessagingErrorCode.HasValue ? (int)x.Exception.MessagingErrorCode : 0
}
}),
FailureCount = response.FailureCount,
SuccessCount = response.SuccessCount
};
return(returnResponse);
}
/// <summary>
/// 发送短信
/// </summary>
/// <param name="body"></param>
/// <returns></returns>
public static MessageSendResponse SendMessage(MessageSendBody body)
{
var request = new MessageSendRequest
{
Head = new HeadRequest
{
InvokeTime = DateTime.Now.ToString("yyyy-MM-dd"),
InvokeUser = key,
ProtocolVersion = "V1"
},
Body = body
};
string url = apiUrl + "message/send";
var result = dooPost(request, url).Result;
if (!string.IsNullOrEmpty(result.Data))
{
return(Base64Helper.Base64EncodeToObject <MessageSendResponse>(result.Data));
}
return(new MessageSendResponse {
Head = new HeadResponse {
Describe = "数据格式不正确"
}
});
}
public async Task <IActionResult> MessageSend(MessageSendRequest request)
{
var response = await mediator.Send(request);
logger.LogResponse($"User #{HttpContext.GetCurrentUserId()} sent message to friend #{request.RecipientId}", response.Error);
return(response.IsSucceeded ? (IActionResult)Ok(response) : BadRequest(response));
}
private void SendMessage(MessageSendRequest postData)
{
RestRequestEx request = new RestRequestEx(
$"users/xuid({Config.XboxUserId})/outbox", Method.POST);
request.AddHeaders(Headers);
request.AddJsonBody(postData, JsonNamingStrategy.CamelCase);
IRestResponse response = HttpClient.Execute(request);
}
private async Task SendMessageAsync(MessageSendRequest postData)
{
var request = new HttpRequestMessage(HttpMethod.Post,
$"users/xuid({Config.XboxUserId})/outbox");
request.Headers.Add(Headers);
request.Content = new JsonContent(postData, JsonNamingStrategy.CamelCase);
var response = await HttpClient.SendAsync(request);
}
private PageResult SendMessage(MessageSendRequest request, Tbl_OTABusiness business)
{
MessageSendOrderInfo orderInfo = request.Body.OrderInfo;
MessageSendResponse result = new MessageSendResponse
{
Head = HeadResult.V1
};
var validResult = _orderService.ValidDataForMessageSendRequest(request);
if (!validResult.Status)
{
result.Head.Code = validResult.Code;
result.Head.Describe = validResult.Message;
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
var tbl_Order = _orderService.Get(orderInfo.OrderId);
if (tbl_Order == null)
{
result.Head.Code = "117004";
result.Head.Describe = "(重)发送入园凭证短信异常，订单不存在";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
var tbl_OrderDetails = _orderDetailService.GetList(tbl_Order.OrderNo);
if (tbl_OrderDetails.FirstOrDefault(a => a.EticektSendQuantity >= 5) != null)
{
result.Head.Code = "117006";
result.Head.Describe = "(重)发送入园凭证短信异常，发送次数不能超过5次";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
try
{
var sendResult = _smsService.Send(tbl_OrderDetails, tbl_Order.Mobile);
if (sendResult.Status)
{
result.Body = new MessageSendResponseBody
{
Message = "OK"
};
result.Head.Code = "000000";
result.Head.Describe = "成功";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
result.Head.Code = "117005";
result.Head.Describe = "(重)发送入园凭证短信异常，发送失败";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
catch (Exception ex)
{
result.Head.Code = "117005";
result.Head.Describe = "(重)发送入园凭证短信异常，发送失败";
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
}
public MessageSendResponse Notice(MessageSendRequest request)
{
var apiurl = string.Format(Urls.MessageSend, RequestHelper.GetAccessToken());
var rtn = RequestHelper.Post <MessageSendResponse>(apiurl, request);
if (rtn.ErrCode != ErrCodeEnum.OK)
{
throw new ApiException(ApiCodeEnum.Error, rtn.ErrMsg);
}
return(rtn);
}
private void OnMessageSend(NetConnection <NetSession> sender, MessageSendRequest message)
{
sender.Session.Response.messageSendResponse = new MessageSendResponse();
Result res = sender.Session.Character.messageManager.OnMessageSend(sender, message);
Log.Info($@"OnMessageSend Type:{message.Type}
From:{message.messageInfo.FromInfo.Id} To:{message.ToId}
Result:{res}
Msg{sender.Session.Response.messageSendResponse.Errormsg}");
sender.Session.Response.messageSendResponse.Type = message.Type;
sender.Session.Response.messageSendResponse.Result = res;
sender.SendResponse();
}
public void CreateMessageSendRequest()
{
string expectedXuid = TestData["MessageSendMessageXuidRequest.json"];
string expectedGamertag = TestData["MessageSendMessageGtRequest.json"];
ulong[] xuids = new ulong[] { 2580478784034343, 2535771801919068, 2508565379774180 };
string[] gamertags = new string[] { "Gamertag1", "Gamertag2" };
MessageSendRequest requestXuid = new MessageSendRequest("TestString", xuids);
MessageSendRequest requestGt = new MessageSendRequest("TestString", gamertags);
string bodyXuid = NewtonsoftJsonSerializer.Create(JsonNamingStrategy.CamelCase)
.Serialize(requestXuid);
string bodyGt = NewtonsoftJsonSerializer.Create(JsonNamingStrategy.CamelCase)
.Serialize(requestGt);
Assert.AreEqual(expectedXuid, bodyXuid);
Assert.AreEqual(expectedGamertag, bodyGt);
}
/// <summary>
/// 发送短信
/// </summary>
/// <param name="body"></param>
/// <returns></returns>
public MessageSendResponse SendMessage(MessageSendBody body)
{
var request = new MessageSendRequest
{
Head = RequestHead(),
Body = body
};
string url = _website + "message/send";
var result = PostService(request, url);
if (!string.IsNullOrEmpty(result.Data))
{
return(Base64Helper.Base64EncodeToObject <MessageSendResponse>(result.Data));
}
return(new MessageSendResponse
{
Head = new HeadResponse
{
Code = "900001",
Describe = "数据格式不正确"
}
});
}
public void SendMessage(string messageText, ulong[] xuids)
{
MessageSendRequest postData = new MessageSendRequest(messageText, xuids);
SendMessage(postData);
}
public async Task <ServiceProviderResponse> OtpPushAsync(string account, OtpPushDescription description, ServiceProviderRequest request, string requestId, CancellationToken cancellationToken)
{
var channel = OtpChannelHelper.Format(description.Channel);
var smsProvider = ProviderManager.GetSmsServiceProvider();
// Check if templete type is 2
var smsGetRequest = new ServiceProviderRequest
{
HttpMethod = "GET",
Path = "templates/" + description.TemplateName,
Content = string.Empty,
Headers = request.Headers,
QueryNameValuePairs = request.QueryNameValuePairs,
};
var subscriptionId = await RequestHelper.GetSubscriptionId(account);
try
{
var result = await smsProvider.OnRequestAsync(smsGetRequest);
var projson = JObject.Parse(result.Content);
JToken tpltype;
if (projson.TryGetValue("tplType", out tpltype) && ((int)tpltype != 2))
{
throw new ArgumentException($"Invalid template type.");
}
// generate otpCode
var code = GetOtpCode((int)description.CodeLength);
// prepare messageSendRequest for sending request to sms provider
MessageSendRequest messageSendRequest = new MessageSendRequest()
{
Targets = new List <string>()
{
description.PhoneNumber
},
MessageBody = new MessageTemplateBody()
{
TemplateName = description.TemplateName,
TemplateParameters = new PropertyCollection <string>()
}
};
messageSendRequest.MessageBody.TemplateParameters.Add("otpcode", code);
var content = JsonConvert.SerializeObject(messageSendRequest);
// create request for sms provider
var smsRequest = new ServiceProviderRequest
{
HttpMethod = "POST",
Path = "messages",
Content = content,
Headers = request.Headers,
QueryNameValuePairs = request.QueryNameValuePairs
};
// send push request to sms provider
result = await smsProvider.OnRequestAsync(smsRequest);
if (result.StatusCode != HttpStatusCode.OK)
{
return(result);
}
// Create otp record in db
var otpcode = await this.otpStore.CreateorUpdateOtpCodeAsync(account, description.PhoneNumber, code, (int)description.ExpireTime);
// Create otp check history in otp storage table
await this.otpStorage.CreateOtpCodeHistoryRecord(account, description.PhoneNumber, ActionType.Start.ToString(), DateTime.UtcNow);
this.metricManager.LogOtpSendSuccess(1, account, subscriptionId, description.Channel);
OtpProviderEventSource.Current.Info(requestId, this, nameof(this.OtpPushAsync), OperationStates.Succeeded, $"account: {account}, channel: {channel}, phoneNumber: {description.PhoneNumber}");
return(new ServiceProviderResponse
{
StatusCode = HttpStatusCode.OK,
JsonContent = new OtpStartOperationResult
{
ExpireTime = (int)description.ExpireTime
}
});
}
catch (Exception ex)
{
this.metricManager.LogOtpSendFailed(1, account, subscriptionId, description.Channel);
while (ex is AggregateException)
{
ex = ex.InnerException;
}
OtpProviderEventSource.Current.ErrorException(requestId, this, nameof(this.OtpPushAsync), OperationStates.Failed, $"Failed to send OTP code for account: {account}, channel: {channel}, phoneNumber: {description.PhoneNumber}", ex);
if ((ex is ArgumentException) || (ex is QuotaExceededException))
{
throw ex;
}
throw new Exception(string.Format($"Failed to send OTP code for account: {account}, channel: {channel}, phoneNumber: {description.PhoneNumber}"));
}
}
public ActionResult <RequestResult> SendMessage([FromServices] ITokens tokens, [FromServices] IConfiguration config, [FromServices] MessageData messageData, MessageSendRequest messageSendRequest)
{
var result = new RequestResult();
const string firebaseFuncName = "SendMessage";
var client = new RestClient(config["FirebaseLink"]);
var androidToken = tokens.AndroidToken;
var req = new RestRequest(firebaseFuncName, Method.POST);
var message = messageSendRequest.Message;
var recipients = messageSendRequest.Recipients;
var messageID = messageSendRequest.MessageID;
foreach (var conversation in messageData.Conversations.Where(conversation => conversation.ConversationID == messageSendRequest.ConversationID))
{
conversation.MostRecent = message;
}
Message newMsg = new Message();
newMsg.ConversationID = messageSendRequest.ConversationID;
newMsg.sentSuccessfully = false;
newMsg.Sender = "";
newMsg.IsSender = true;
newMsg.TimeStamp = DateTime.Now;
newMsg.MessageBody = message;
// GUID stuff
messageData.UnsentMessageGuids[messageID] = newMsg;
if (messageData.ConversationToMessages.TryGetValue(messageSendRequest.ConversationID, out var msgList))
{
messageData.ConversationToMessages[messageSendRequest.ConversationID].Add(newMsg);
}
else
{
messageData.ConversationToMessages[messageSendRequest.ConversationID] = new List <Message>();
messageData.ConversationToMessages[messageSendRequest.ConversationID].Add(newMsg);
}
var dict = new Dictionary <string, object>()
{
{ "Token", androidToken },
{ "Message", message },
{ "Recipients", JsonConvert.SerializeObject(recipients) },
{ "MessageID", messageID }
};
req.AddParameter("application/json; charset=utf-8", JsonConvert.SerializeObject(dict), ParameterType.RequestBody);
req.RequestFormat = DataFormat.Json;
var response = client.Execute(req);
if (response.StatusCode == HttpStatusCode.OK)
{
result.ResultMessage = "Successfully sent SendMessage request to firebase";
result.Status = ResultStatus.Success;
return(Ok(result));
}
else
{
result.ErrorMessage = response.ErrorMessage;
result.Status = ResultStatus.Failure;
return(BadRequest(result));
}
}
private async Task <MessagePack> BuildInputMessageAsync(Account account, MessageSendRequest request, string requestId)
{
// Validate extended code
this.ValidateExtendedCode(request.ExtendedCode);
// Get template
var template = await this.store.GetTemplateAsync(account.EngagementAccount, request.MessageBody.TemplateName);
Validator.IsTrue <ArgumentException>(template != null && template.State == ResourceState.Active, nameof(template), "Template does not exist or is not active");
// Validate account settings
this.ValidateAccountSettings(account, template);
// Get signature
var signature = await this.store.GetSignatureAsync(account.EngagementAccount, template.Signature);
Validator.IsTrue <ArgumentException>(signature != null && signature.State == ResourceState.Active, nameof(signature), "Signature does not exist or is not active");
// Get message body
var messageBody = this.ValidateTemplateParameters(template, request.MessageBody.TemplateParameters);
messageBody = string.Format(SmsConstant.SmsBodyFormat, signature.Value, messageBody);
// Get credential assignement
var channelType = SmsConstant.MessageSendChannelMappings[template.Category];
var assignment = await this.credentialManager.GetCredentialAssignmentByAccountAsync(account.EngagementAccount, channelType);
Validator.IsTrue <ApplicationException>(assignment != null, nameof(assignment), "No active credential assignment for account {0}", account.EngagementAccount);
// Get credential and metadata
var credential = await this.credentialManager.GetConnectorCredentialByIdAsync(assignment.ConnectorIdentifier);
Validator.IsTrue <ApplicationException>(credential != null, nameof(credential), "Invalid credential for account {0}", account.EngagementAccount);
var metadata = await this.credentialManager.GetMetadata(assignment.ConnectorIdentifier.ConnectorName);
// Extended code consists of three segments
var extendedCodes = new List <string>
{
assignment.ExtendedCode,
signature.ExtendedCode,
request.ExtendedCode
};
var extension = new SmsMessageInfoExtension();
extension.ChannelType = SmsConstant.MessageSendChannelMappings[template.Category];
extension.MessageCategory = template.Category;
extension.ExtendedCodes = extendedCodes;
var message = new InputMessage();
message.MessageInfo = new MessageInfo();
message.MessageInfo.EngagementAccount = account.EngagementAccount;
message.MessageInfo.MessageId = Guid.NewGuid();
message.MessageInfo.MessageBody = messageBody;
message.MessageInfo.SendTime = DateTime.UtcNow;
message.MessageInfo.TrackingId = requestId;
message.MessageInfo.ExtensionData = extension.ToString();
message.Targets = request.Targets.AsReadOnly();
message.ConnectorCredential = credential.ToDataContract(metadata);
return(new MessagePack
{
InputMessage = message,
Extension = extension,
Signature = signature
});
}
public async Task <ServiceProviderResponse> SendMessageAsync(
[FromHeader(Constant.OperationTrackingIdHeader)] string requestId,
[FromHeader] string account,
[FromBody] MessageSendRequest request)
{
Account currentAccount = null;
try
{
SmsProviderEventSource.Current.Info(requestId, this, nameof(this.SendMessageAsync), OperationStates.Received, $"Request is received");
currentAccount = await this.ValidateAccount(account);
Validator.ArgumentNotNull(request, nameof(request));
Validator.ArgumentNotNull(request.MessageBody, nameof(request.MessageBody));
Validator.ArgumentNotNullOrEmpty(request.MessageBody.TemplateName, request.MessageBody.TemplateName);
request.Targets = this.ValidatePhoneNumbers(request.Targets);
var pack = await this.BuildInputMessageAsync(currentAccount, request, requestId);
var message = pack.InputMessage;
SmsProviderEventSource.Current.Info(requestId, this, nameof(this.SendMessageAsync), OperationStates.Starting, $"Message is ready. messageId={message.MessageInfo.MessageId}");
var signatureQuotaName = string.Format(Constant.SmsSignatureMAUNamingTemplate, pack.Signature.Value);
SmsProviderEventSource.Current.Info(requestId, this, nameof(this.SendMessageAsync), OperationStates.Empty, $"If quota is enabled, request {request.Targets.Count} for account {account}. Otherwise, ignore");
await QuotaCheckClient.AcquireQuotaAsync(account, SmsConstant.SmsQuotaName, request.Targets.Count);
await QuotaCheckClient.AcquireQuotaAsync(account, signatureQuotaName, request.Targets.Count);
try
{
await this.reportManager.OnMessageSentAsync(account, message, pack.Extension);
SmsProviderEventSource.Current.Info(requestId, this, nameof(this.SendMessageAsync), OperationStates.Starting, $"Report is updated. messageId={message.MessageInfo.MessageId}");
await this.DispatchMessageAsync(message, pack.Extension, requestId);
SmsProviderEventSource.Current.Info(requestId, this, nameof(this.SendMessageAsync), OperationStates.Starting, $"Message is dispatched. messageId={message.MessageInfo.MessageId}");
this.metricManager.LogSendSuccess(1, account, currentAccount.SubscriptionId ?? string.Empty, pack.Extension.MessageCategory);
this.metricManager.LogSendTotal(BillingHelper.GetTotalSegments(message.MessageInfo.MessageBody), account, currentAccount.SubscriptionId ?? string.Empty, pack.Extension.MessageCategory);
var response = new MessageSendResponse
{
MessageId = message.MessageInfo.MessageId,
SendTime = message.MessageInfo.SendTime
};
return(ServiceProviderResponse.CreateJsonResponse(HttpStatusCode.OK, response));
}
catch
{
SmsProviderEventSource.Current.Info(requestId, this, nameof(this.SendMessageAsync), OperationStates.Empty, $"If quota is enabled, release {request.Targets.Count} for account {account}. Otherwise, ignore");
await QuotaCheckClient.ReleaseQuotaAsync(account, SmsConstant.SmsQuotaName, request.Targets.Count);
await QuotaCheckClient.ReleaseQuotaAsync(account, signatureQuotaName, request.Targets.Count);
this.metricManager.LogSendFailed(1, account, currentAccount.SubscriptionId ?? string.Empty, pack.Extension.MessageCategory);
throw;
}
}
catch
{
this.metricManager.LogSendFailed(1, account, currentAccount?.SubscriptionId ?? string.Empty, null);
throw;
}
}
public async Task SendMessageAsync(string messageText, string[] gamertags)
{
MessageSendRequest postData = new MessageSendRequest(messageText, gamertags);
await SendMessageAsync(postData);
}
public ApiResult <BaseResponse> Execute(MessageSendRequest request)
{
return(Execute <MessageSendRequest, BaseResponse>("/cgi/message/send", request));
}
public async Task SendMessageAsync(string messageText, ulong[] xuids)
{
MessageSendRequest postData = new MessageSendRequest(messageText, xuids);
await SendMessageAsync(postData);
}
public void SendMessage(string messageText, string[] gamertags)
{
MessageSendRequest postData = new MessageSendRequest(messageText, gamertags);
SendMessage(postData);
}
