public void Can_validate_edit(MessageDeliveryMethod messageDeliveryMethod)
{
var data = MessagingTestHelper.CreateEditMessageTemplateData(messageDeliveryMethod);
var result = MessageTemplateQueries.GetValidationResult(data);
Assert.That(result.Errors.Count, Is.EqualTo(0));
}
public void Broadcast(MessageDeliveryMethod method, long? excludedClientId)
{
NetConnection excluded = null;
if (excludedClientId.HasValue &&
connections.ContainsKey(excludedClientId.Value))
{
excluded = connections[excludedClientId.Value];
}
server.SendToAll((NetOutgoingMessage)Writer.GetMessage(), excluded, GetDeliveryMethod(method), 0);
}
public void TrySendPlayerMessage(
Guid playerId,
MessageType messageType,
MessageDeliveryMethod messageDeliveryMethod,
IPlayerMessageTemplateModel model,
bool ignoreAccountAlertSetting = false)
{
var player = _repository.Players
.Include(x => x.Brand)
.Include(x => x.Language)
.Single(x => x.Id == playerId);
var accountAlertEnabled = messageDeliveryMethod == MessageDeliveryMethod.Email
? player.AccountAlertEmail
: player.AccountAlertSms;
if (!accountAlertEnabled && !ignoreAccountAlertSetting)
{
return;
}
var messageTemplate = _repository.MessageTemplates.SingleOrDefault(x =>
x.BrandId == player.Brand.Id &&
x.LanguageCode == player.Language.Code &&
x.MessageType == messageType &&
x.MessageDeliveryMethod == messageDeliveryMethod &&
x.Status == Status.Active);
if (messageTemplate == null)
{
return;
}
model = Mapper.Map(player, model);
var parsedMessage = ParseTemplate(messageTemplate.MessageContent, model);
if (messageDeliveryMethod == MessageDeliveryMethod.Email)
{
SendEmail(
senderEmail: player.Brand.Email,
senderName: player.Brand.Name,
recipientEmail: player.Email,
recipientName: string.Format("{0} {1}", player.FirstName, player.LastName),
subject: ParseTemplate(messageTemplate.Subject, model),
body: parsedMessage);
}
else
{
SendSms(player.Brand.SmsNumber, player.PhoneNumber, parsedMessage);
}
}
public void SendMessageToAll(INetworkMessageOut message, MessageDeliveryMethod deliveryMethod, int channel)
{
if (_netPeer == null)
{
throw new NullReferenceException("NetPeer was not initialized.");
}
message.Encrypt();
var outMessage = ((NetworkMessageOutLidgren)message).GetInternalMessage();
_netPeer.SendMessage(outMessage, _netPeer.Connections, deliveryMethod.ToDeliveryMethod(), channel);
}
public void Can_fail_sending_player_message_because_player_account_setting(MessageDeliveryMethod messageDeliveryMethod)
{
var player = SetUpPlayerMessageTest(messageDeliveryMethod, false);
MessageTemplateService.TrySendPlayerMessage(
player.Id,
MessageType.PlayerRegistered,
messageDeliveryMethod,
new PlayerRegisteredModel());
var events = _eventRepository.GetEvents <NotificationSentEvent>().ToArray();
Assert.That(events, Is.Empty);
}
private Core.Messaging.Data.Player SetUpPlayerMessageTest(MessageDeliveryMethod messageDeliveryMethod, bool enableAccountAlert = true)
{
var player = _playerTestHelper.CreatePlayer();
var messagingPlayer = MessagingRepository.Players.Single(x => x.Id == player.Id);
if (messageDeliveryMethod == MessageDeliveryMethod.Email)
{
_emailNotificationWorker.Start();
messagingPlayer.AccountAlertEmail = enableAccountAlert;
}
else
{
_smsNotificationWorker.Start();
messagingPlayer.AccountAlertSms = enableAccountAlert;
}
return(messagingPlayer);
}
private void TrySendBrandMessage(
string recipientName,
string recipientContact,
string languageCode,
Guid brandId,
MessageType messageType,
MessageDeliveryMethod messageDeliveryMethod,
IBrandMessageTemplateModel model)
{
var brand = _repository.Brands.Single(x => x.Id == brandId);
var messageTemplate = _repository.MessageTemplates.SingleOrDefault(x =>
x.BrandId == brandId &&
x.LanguageCode == (languageCode ?? brand.DefaultLanguageCode) &&
x.MessageType == messageType &&
x.MessageDeliveryMethod == messageDeliveryMethod &&
x.Status == Status.Active);
if (messageTemplate == null)
{
return;
}
model.BrandName = brand.Name;
model.RecipientName = recipientName;
var parsedMessage = ParseTemplate(messageTemplate.MessageContent, model);
if (messageDeliveryMethod == MessageDeliveryMethod.Email)
{
SendEmail(
senderEmail: brand.Email,
senderName: brand.Name,
recipientEmail: recipientContact,
recipientName: recipientName,
subject: ParseTemplate(messageTemplate.Subject, model),
body: parsedMessage);
}
else
{
SendSms(brand.SmsNumber, recipientContact, parsedMessage);
}
}
public void Can_send_brand_message(MessageDeliveryMethod messageDeliveryMethod)
{
if (messageDeliveryMethod == MessageDeliveryMethod.Email)
{
_emailNotificationWorker.Start();
}
else
{
_smsNotificationWorker.Start();
}
if (messageDeliveryMethod == MessageDeliveryMethod.Email)
{
MessageTemplateService.TrySendBrandEmail(
TestDataGenerator.GetRandomString(),
TestDataGenerator.GetRandomEmail(),
Brand.Id,
MessageType.ReferFriends,
new ReferFriendsModel());
}
else
{
MessageTemplateService.TrySendBrandSms(
TestDataGenerator.GetRandomString(),
TestDataGenerator.GetRandomPhoneNumber(),
Brand.Id,
MessageType.ReferFriends,
new ReferFriendsModel());
}
var events = _eventRepository.GetEvents <NotificationSentEvent>().ToArray();
Assert.That(events.Length, Is.EqualTo(1));
var notificationType = messageDeliveryMethod == MessageDeliveryMethod.Email
? NotificationType.Email
: NotificationType.Sms;
Assert.That(events.First().Type, Is.EqualTo(notificationType));
Assert.That(events.First().Status, Is.EqualTo(NotificationStatus.Send));
}
public void Can_send_player_message(MessageDeliveryMethod messageDeliveryMethod)
{
var player = SetUpPlayerMessageTest(messageDeliveryMethod);
MessageTemplateService.TrySendPlayerMessage(
player.Id,
MessageType.PlayerRegistered,
messageDeliveryMethod,
new PlayerRegisteredModel());
var events = _eventRepository.GetEvents <NotificationSentEvent>().ToArray();
Assert.That(events.Length, Is.EqualTo(1));
var notificationType = messageDeliveryMethod == MessageDeliveryMethod.Email
? NotificationType.Email
: NotificationType.Sms;
Assert.That(events.First().Type, Is.EqualTo(notificationType));
Assert.That(events.First().Status, Is.EqualTo(NotificationStatus.Send));
}
public void SendMessageToId(long uniqueId, INetworkMessageOut message, MessageDeliveryMethod deliveryMethod, int channel)
{
if (_netPeer == null)
{
throw new NullReferenceException("NetPeer was not initialized.");
}
message.Encrypt();
var outMessage = ((NetworkMessageOutLidgren)message).GetInternalMessage();
for (int i = 0; i < _netPeer.Connections.Count; i++)
{
var connection = _netPeer.Connections[i];
if (connection.RemoteUniqueIdentifier == uniqueId)
{
_netPeer.SendMessage(outMessage, connection, deliveryMethod.ToDeliveryMethod(), channel);
break;
}
}
}
public static NetDeliveryMethod ToDeliveryMethod(this MessageDeliveryMethod deliveryMethod)
{
switch (deliveryMethod)
{
case MessageDeliveryMethod.Unreliable:
return(NetDeliveryMethod.Unreliable);
case MessageDeliveryMethod.UnreliableSequenced:
return(NetDeliveryMethod.UnreliableSequenced);
case MessageDeliveryMethod.ReliableUnordered:
return(NetDeliveryMethod.ReliableUnordered);
case MessageDeliveryMethod.ReliableSequenced:
return(NetDeliveryMethod.ReliableSequenced);
case MessageDeliveryMethod.ReliableOrdered:
return(NetDeliveryMethod.ReliableOrdered);
default:
return(NetDeliveryMethod.Unknown);
}
}
private NetDeliveryMethod GetDeliveryMethod(MessageDeliveryMethod method)
{
switch (method)
{
case MessageDeliveryMethod.Unreliable:
return NetDeliveryMethod.Unreliable;
case MessageDeliveryMethod.UnreliableSequenced:
return NetDeliveryMethod.UnreliableSequenced;
case MessageDeliveryMethod.ReliableSequenced:
return NetDeliveryMethod.ReliableSequenced;
case MessageDeliveryMethod.ReliableUnordered:
return NetDeliveryMethod.ReliableUnordered;
case MessageDeliveryMethod.ReliableOrdered:
return NetDeliveryMethod.ReliableOrdered;
default:
return NetDeliveryMethod.Unknown;
}
}
protected void SendMessageToId(long uniqueId, INetworkMessageOut message, MessageDeliveryMethod deliveryMethod, int channel)
{
NetworkImplementation?.SendMessageToId(uniqueId, message, deliveryMethod, channel);
}
public void SendMessageToIds(IEnumerable <long> uniqueIds, INetworkMessageOut message, MessageDeliveryMethod deliveryMethod, int channel)
{
if (_netPeer == null)
{
throw new NullReferenceException("NetPeer was not initialized.");
}
message.Encrypt();
var connections = new List <NetConnection>(4);
foreach (var uniqueId in uniqueIds)
{
for (int i = 0; i < _netPeer.Connections.Count; i++)
{
var connection = _netPeer.Connections[i];
if (connection.RemoteUniqueIdentifier == uniqueId)
{
connections.Add(connection);
break;
}
}
}
var outMessage = ((NetworkMessageOutLidgren)message).GetInternalMessage();
try
{
_netPeer.SendMessage(outMessage, connections, deliveryMethod.ToDeliveryMethod(), channel);
}
catch
{
// todo: throw?
}
}
private void SendMessage(MessageDeliveryMethod method = MessageDeliveryMethod.Unreliable)
{
if (!isCombined)
{
client.Send(method);
}
}
protected void SendMessageToIds(IEnumerable <long> uniqueIds, INetworkMessageOut message, MessageDeliveryMethod deliveryMethod, int channel)
{
NetworkImplementation?.SendMessageToIds(uniqueIds, message, deliveryMethod, channel);
}
public void Send(long clientId, MessageDeliveryMethod method)
{
if (connections.ContainsKey(clientId))
{
server.SendMessage((NetOutgoingMessage)Writer.GetMessage(), connections[clientId], GetDeliveryMethod(method));
}
}
protected void SendMessageToSender(INetworkMessageIn to, INetworkMessageOut message, MessageDeliveryMethod deliveryMethod, int channel)
{
NetworkImplementation?.SendMessageToSender(to, message, deliveryMethod, channel);
}
