private static void Repeat(IBusControl bus, string command, int times)
{
for (int i = 0; i < times; i++)
{
if (command == "approval")
{
bus.Publish<ReportApproval>(new ReportApprovalMessage
{
Approved = (times % 2) == 0,
ApprovalNotes = "this is the " + i + " time "
});
}
else if (command == "newref")
{
bus.Publish<NewReferral>(new NewReferralMessage
{
Name = "Mr Michael Shanks the " + i,
DateOfBirth = DateTime.Now.AddYears(-20),
NoOfAuthorisations = i
});
}
else
{
throw new Exception("Could not find command " + command);
}
}
}
static void Main(string[] args)
{
string rabbitMqAddress = "rabbitmq://localhost:5672";
string virtualHost = "/";
string rabbitMqQueue = "StayWell.SWIQ.CreateParticipant";
Uri rabbitMqRootUri = new Uri(string.Concat(rabbitMqAddress, virtualHost));
IBusControl rabbitBusControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
{
rabbit.Host(rabbitMqRootUri, settings =>
{
settings.Password("guest");
settings.Username("guest");
});
});
rabbitBusControl.Start();
Task <ISendEndpoint> sendEndpointTask = rabbitBusControl.GetSendEndpoint(new Uri(string.Concat(rabbitMqAddress, virtualHost, rabbitMqQueue)));
ISendEndpoint sendEndpoint = sendEndpointTask.Result;
do
{
Console.WriteLine("Enter message type ('command', 'event', 'rpc') (or 'quit' to exit)");
Console.Write("> ");
string type = Console.ReadLine();
if ("quit".Equals(type, StringComparison.OrdinalIgnoreCase))
{
break;
}
Console.WriteLine("Enter data");
Console.Write("> ");
string data = Console.ReadLine();
if (type.ToLower() == "command")
{
sendEndpoint.Send <ICreateParticipant>(new
{
CreationDate = DateTime.UtcNow,
Data = data
});
}
else if (type.ToLower() == "event")
{
rabbitBusControl.Publish <IParticipantUpdated>(new
{
DateUpdated = DateTime.UtcNow,
FirstName = data
});
}
else if (type.ToLower() == "rpc")
{
IRequestClient <ICreateParticipant, ICreateParticipantResponse> client =
rabbitBusControl.CreateRequestClient <ICreateParticipant, ICreateParticipantResponse>(new Uri(string.Concat(rabbitMqAddress, virtualHost, rabbitMqQueue)), TimeSpan.FromSeconds(10));
Task.Run(async() =>
{
ICreateParticipantResponse response = await client.Request(new CreateParticipant
{
CreationDate = DateTime.UtcNow,
Data = data
});
Console.WriteLine("Participant creation response: ParticipantId: {0}, Data: {1}", response.ParticipantId, response.Data);
}).Wait();
}
else
{
Console.WriteLine("Wrong message type!");
Console.Write("> ");
}
}while (true);
rabbitBusControl.Stop();
}
/// <summary>
/// Generic method used to send message to all queues on this exchange (exchange type is Fan-out)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="values"></param>
public void Publish <T>(object values) where T : class
{
senderBus.Publish <T>(values);
}
public override Task PublisAsync(object ob, Type t = null, CancellationToken?token = null)
{
t = t ?? ob.GetType();
return(Control?.Publish(ob, t, token ?? CancellationToken.None));
}
// ReSharper disable once ExcessiveIndentation
private void ReceiveCallback(IAsyncResult result)
{
ConnectionInfo connection = (ConnectionInfo)result.AsyncState;
try
{
//get a number of received bytes
int bytesRead = connection.Socket.EndReceive(result);
if (bytesRead > 0)
{
//because device sends data with portions we need summary all portions to total buffer
if (connection.IsPartialLoaded)
{
connection.TotalBuffer.AddRange(connection.Buffer.Take(bytesRead).ToList());
}
else
{
if (connection.TotalBuffer != null)
{
connection.TotalBuffer.Clear();
}
connection.TotalBuffer = connection.Buffer.Take(bytesRead).ToList();
}
//-------- Get Length of current received data ----------
string hexDataLength = string.Empty;
//Skip four zero bytes an take next four bytes with value of AVL data array length
connection.TotalBuffer.Skip(4).Take(4).ToList().ForEach(delegate(byte b) { hexDataLength += String.Format("{0:X2}", b); });
int dataLength = Convert.ToInt32(hexDataLength, 16);
//
//bytesRead = 17 when parser receive IMEI from device
//if datalength encoded in data > then total buffer then is a partial data a device will send next part
//we send confirmation and wait next portion of data
// ReSharper disable once ComplexConditionExpression
if (dataLength + 12 > connection.TotalBuffer.Count && bytesRead != 17)
{
connection.IsPartialLoaded = true;
connection.Socket.Send(new byte[] { 0x01 });
connection.Socket.BeginReceive(connection.Buffer, 0, connection.Buffer.Length, SocketFlags.None,
ReceiveCallback, connection);
return;
}
bool isDataPacket = true;
//when device send AVL data first 4 bytes is 0
string firstRourBytes = string.Empty;
connection.TotalBuffer.Take(4).ToList().ForEach(delegate(byte b) { firstRourBytes += String.Format("{0:X2}", b); });
if (Convert.ToInt32(firstRourBytes, 16) > 0)
{
isDataPacket = false;
}
// if is true then is AVL data packet
// else that a IMEI sended
if (isDataPacket)
{
if (true)
{
//all data we convert this to string in hex format only for diagnostic
StringBuilder data = new StringBuilder();
connection.TotalBuffer.ForEach(delegate(byte b) { data.AppendFormat("{0:X2}", b); });
Console.WriteLine("<" + data);
}
var decAvl = new DevicesParser();
decAvl.OnDataReceive += decAVL_OnDataReceive;
//if CRC not correct number of data returned by AVL parser = 0;
var avlData = decAvl.Decode(connection.TotalBuffer, connection.Imei);
if (!connection.IsPartialLoaded)
{
// send to device number of received data for confirmation.
if (avlData.Count > 0)
{
connection.Socket.Send(new byte[] { 0x00, 0x00, 0x00, Convert.ToByte(avlData.Count) });
LogAvlData(avlData);
var events = new TLGpsDataEvents
{
Id = Guid.NewGuid(),
Events = avlData
};
var lastGpsData = events.Events.Last();
var command = new CreateBoxCommand();
command.Imei = connection.Imei;
command.Longitude = lastGpsData.Long;
command.Latitude = lastGpsData.Lat;
command.LastValidGpsDataUtc = lastGpsData.DateTimeUtc;
command.Speed = lastGpsData.Speed;
_bus.Publish(command).ConfigureAwait(false);
Thread.Sleep(1000);
_bus.Publish(events).ConfigureAwait(false);
}
else
{
//send 0 number of data if CRC not correct for resend data from device
connection.Socket.Send(new byte[] { 0x00, 0x00, 0x00, 0x00 });
}
}
decAvl.OnDataReceive -= decAVL_OnDataReceive;
Console.WriteLine("Modem ID: " + connection.Imei + " send data");
}
else
{
//if is not data packet then is it IMEI info send from device
connection.Imei = Encoding.ASCII.GetString(connection.TotalBuffer.Skip(2).ToArray());
connection.Socket.Send(new byte[] { 0x01 });
Console.WriteLine("Modem ID: " + connection.Imei + " connected");
}
// Get next data portion from device
connection.Socket.BeginReceive(connection.Buffer, 0, connection.Buffer.Length, SocketFlags.None,
ReceiveCallback, connection);
}//if all data received then close connection
else
{
CloseConnection(connection);
}
}
catch (SocketException exc)
{
CloseConnection(connection);
Console.WriteLine("Socket exception: " + exc.SocketErrorCode);
}
catch (Exception exc)
{
CloseConnection(connection);
Console.WriteLine("Exception: " + exc);
}
}
public async Task Publish <T>(T message) where T : class
{
await _serviceBus.Publish <T>(message);
}
public async Task Publish <T>(T @event) where T : IIntegrationEvent
{
await massTransitBus.Publish(@event);
}
public Task Publish <TEvent>(TEvent @event) where TEvent : class, IUserEvent
{
return(_bus.Publish(@event, @event.GetType()));
}
public async Task QueueTaskAsync(ImgTask imgTask)
{
await _bc.Publish((object)imgTask);
}
static void Main()
{
ConfigureLogger();
// MassTransit to use Log4Net
Log4NetLogger.Use();
IBusControl busControl = CreateBus();
TaskUtil.Await(() => busControl.StartAsync());
Uri hostAddress = busControl.Address.GetHostSettings().HostAddress;
string validateQueueName = ConfigurationManager.AppSettings["ValidateActivityQueue"];
Uri validateAddress = new Uri(string.Concat(hostAddress, validateQueueName));
string retrieveQueueName = ConfigurationManager.AppSettings["RetrieveActivityQueue"];
Uri retrieveAddress = new Uri(string.Concat(hostAddress, retrieveQueueName));
try
{
for (;;)
{
Console.Write("Enter an address (quit exits): ");
string requestAddress = Console.ReadLine();
if (requestAddress == "quit")
{
break;
}
if (string.IsNullOrEmpty(requestAddress))
{
requestAddress = "http://www.microsoft.com/index.html";
}
int limit = 1;
if (requestAddress.All(x => char.IsDigit(x) || char.IsPunctuation(x)))
{
string[] values = requestAddress.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
requestAddress = values[0];
if (values.Length > 1)
{
limit = int.Parse(values[1]);
Console.WriteLine("Sending {0}", limit);
}
}
switch (requestAddress)
{
case "0":
requestAddress = "http://www.microsoft.com/index.html";
break;
case "1":
requestAddress = "http://i.imgur.com/Iroma7d.png";
break;
case "2":
requestAddress = "http://i.imgur.com/NK8eZUe.jpg";
break;
}
Uri requestUri;
try
{
requestUri = new Uri(requestAddress);
}
catch (UriFormatException)
{
Console.WriteLine("The URL entered is invalid: " + requestAddress);
continue;
}
IEnumerable <Task> tasks = Enumerable.Range(0, limit).Select(x => Task.Run(async() =>
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity("Validate", validateAddress);
builder.AddActivity("Retrieve", retrieveAddress);
builder.SetVariables(new
{
RequestId = NewId.NextGuid(),
Address = requestUri,
});
RoutingSlip routingSlip = builder.Build();
await busControl.Publish <RoutingSlipCreated>(new
{
TrackingNumber = routingSlip.TrackingNumber,
Timestamp = routingSlip.CreateTimestamp,
});
await busControl.Execute(routingSlip);
}));
Task.WaitAll(tasks.ToArray());
}
}
catch (Exception ex)
{
Console.WriteLine("Exception!!! OMG!!! {0}", ex);
Console.ReadLine();
}
finally
{
busControl.Stop();
}
}
public async Task <BodyResponse <RegisterRewardVM> > Handle(QueryRegisterRewardCommand request, CancellationToken cancellationToken)
{
//获取列表
//获取该玩家的注册时间，从注册的第二天起才能领取注册奖励
var accountResponse = await _accountClient.GetResponseExt <GetAccountBaseInfoMqCommand, BodyResponse <GetAccountBaseInfoMqResponse> >
(new GetAccountBaseInfoMqCommand(request.Id));
var accountInfo = accountResponse.Message;
if (accountInfo.StatusCode != StatusCodeDefines.Success)
{
return(new BodyResponse <RegisterRewardVM>(StatusCodeDefines.Error));
}
if ((accountInfo.Body.Flags & GetAccountBaseInfoMqResponse.SomeFlags.RegisterReward) ==
GetAccountBaseInfoMqResponse.SomeFlags.RegisterReward)
{
return(new BodyResponse <RegisterRewardVM>(StatusCodeDefines.Success,
null, new RegisterRewardVM(RegisterRewardVM.RewardState.Over, 0, _regsterConfig.DayRewards)));
}
if (_regsterConfig.DayRewards.Count == 0)
{
return(new BodyResponse <RegisterRewardVM>(StatusCodeDefines.Success,
null, new RegisterRewardVM(RegisterRewardVM.RewardState.None, 0, null)));
}
DateTime registerDate = accountInfo.Body.RegisterDate.DateOfDayBegin();
DateTime nowDate = DateTime.Now.DateOfDayBegin();
if (registerDate == nowDate)
{
return(new BodyResponse <RegisterRewardVM>(StatusCodeDefines.Success,
null, new RegisterRewardVM(RegisterRewardVM.RewardState.NotBegin, 0, _regsterConfig.DayRewards)));
}
int dayIndex = 0;
long rewardCoins = 0;
var rewardInfo = await _redis.GetUserRegiserReward(request.Id);
if (rewardInfo == null)
{
rewardInfo = await _registerRepository.GetByIdAsync(request.Id);
}
if (rewardInfo == null)
{
rewardCoins = _regsterConfig.DayRewards[dayIndex];
dayIndex = 0;
}
else
{
if (rewardInfo.DayIndex >= _regsterConfig.DayRewards.Count - 1)
{
if (dayIndex >= _regsterConfig.DayRewards.Count - 1)
{
_ = _mqBus.Publish(new FinishedRegisterRewardMqEvent(request.Id));
}
return(new BodyResponse <RegisterRewardVM>(StatusCodeDefines.Success,
null, new RegisterRewardVM(RegisterRewardVM.RewardState.Over, 0, _regsterConfig.DayRewards)));
}
else if (rewardInfo.GetDate.DateOfDayBegin() == nowDate)
{
return(new BodyResponse <RegisterRewardVM>(StatusCodeDefines.Success,
null, new RegisterRewardVM(RegisterRewardVM.RewardState.Getted, rewardInfo.DayIndex, _regsterConfig.DayRewards)));
}
else
{
dayIndex = rewardInfo.DayIndex + 1;
rewardCoins = _regsterConfig.DayRewards[dayIndex];
}
}
return(new BodyResponse <RegisterRewardVM>(StatusCodeDefines.Success, null,
new RegisterRewardVM(RegisterRewardVM.RewardState.Available, dayIndex, _regsterConfig.DayRewards)));
}
public Task NewOrderPublishSample(INewOrder msg)
{
return(_busControl.Publish(msg));
}
/// <summary>
/// 发布消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="message"></param>
public void Publish <T>(T message) where T : Event.GMP.Event
{
_bus.Publish(message);
}
public async Task Consume(ConsumeContext <IDiscordGuildDelete> context)
{
var message = context.Message;
var discordGuild = await _work.GuildRepository.SingleOrDefaultAsync(i => i.DiscordId == message.GuildId);
if (discordGuild == null)
{
return;
}
var discordChannels = discordGuild.DiscordChannels;
var discordRoles = discordGuild.DiscordRoles;
var streamSubscriptions = discordGuild.StreamSubscriptions;
foreach (var streamSubscription in streamSubscriptions)
{
try
{
await _work.SubscriptionRepository.RemoveAsync(streamSubscription.Id);
}
catch
{
Log.Error($"Unable to remove Stream Subscription {streamSubscription.User.SourceID} {streamSubscription.User.Username} in {discordGuild.DiscordId} {discordGuild.Name}");
continue;
}
}
foreach (var discordChannel in discordChannels)
{
try
{
var channelContext = new DiscordChannelDelete {
GuildId = discordGuild.DiscordId, ChannelId = discordChannel.DiscordId
};
await _bus.Publish(channelContext);
}
catch
{
Log.Error($"Unable to remove Channel {discordChannel.DiscordId} {discordChannel.Name}");
continue;
}
}
foreach (var discordRole in discordRoles)
{
try
{
var roleContext = new DiscordRoleDelete {
GuildId = discordGuild.DiscordId, RoleId = discordRole.DiscordId
};
await _bus.Publish(roleContext);
}
catch
{
Log.Error($"Unable to remove Role {discordRole.DiscordId} {discordRole.Name}");
continue;
}
}
try
{
await _work.GuildRepository.RemoveAsync(discordGuild.Id);
}
catch
{
Log.Error($"Unable to remove Guild {discordGuild.DiscordId} {discordGuild.Name}");
}
}
public static void Publish(BryzxxCreatedMessage message)
{
CreateBus.Publish(message);
}
public static void Publish(BryzxxUpdatedMessage message)
{
UpdateBus.Publish(message);
}
public async Task <bool> Publish <T>(T eventMessage) where T : EventMessage
{
await _busControl.Publish(eventMessage);
return(true);
}
public async Task Publish <TIntegrationEvent>(TIntegrationEvent IntegrationEvent) where TIntegrationEvent : IntegrationEvent
{
await _bus.Publish(IntegrationEvent);
}
public async Task Consume(ConsumeContext <IDiscordGuildAvailable> context)
{
try
{
var message = context.Message;
var guild = _client.GetGuild(message.GuildId);
if (guild == null)
{
return;
}
DiscordGuild discordGuild = new DiscordGuild()
{
DiscordId = message.GuildId, Name = message.GuildName, IconUrl = guild.IconUrl
};
await _work.GuildRepository.AddOrUpdateAsync(discordGuild, (d => d.DiscordId == message.GuildId));
discordGuild = await _work.GuildRepository.SingleOrDefaultAsync(d => d.DiscordId == message.GuildId);
#region Handle Channels
var dbChannels = await _work.ChannelRepository.FindAsync(i => i.DiscordGuild == discordGuild);
foreach (SocketGuildChannel channel in guild.TextChannels)
{
var existingChannels = dbChannels.ToList().Where(i => i.DiscordId == channel.Id && i.Name == channel.Name);
if (existingChannels.Count() > 0)
{
continue;
}
DiscordChannelUpdate channelUpdateContext = new DiscordChannelUpdate {
GuildId = guild.Id, ChannelId = channel.Id, ChannelName = channel.Name
};
await _bus.Publish(channelUpdateContext);
}
List <ulong> channelIDs = guild.TextChannels.Select(i => i.Id).Distinct().ToList();
if (dbChannels.Count() > 0)
{
foreach (var channelId in dbChannels.Select(i => i.DiscordId).Distinct().Except(channelIDs))
{
DiscordChannelDelete channelDeleteContext = new DiscordChannelDelete {
GuildId = guild.Id, ChannelId = channelId
};
await _bus.Publish(channelDeleteContext);
}
}
#endregion Handle Channels
#region Handle Roles
var dbRoles = await _work.RoleRepository.FindAsync(i => i.DiscordGuild == discordGuild);
foreach (SocketRole role in guild.Roles)
{
var existingRoles = dbRoles.ToList().Where(i => i.DiscordId == role.Id && i.Name == role.Name);
if (existingRoles.Count() > 0)
{
continue;
}
DiscordRoleUpdate roleUpdateContext = new DiscordRoleUpdate {
GuildId = guild.Id, RoleId = role.Id, RoleName = role.Name
};
await _bus.Publish(roleUpdateContext);
}
List <ulong> roleIDs = guild.Roles.Select(i => i.Id).Distinct().ToList();
if (dbRoles.Count() > 0)
{
foreach (var roleId in dbRoles.Select(i => i.DiscordId).Distinct().Except(roleIDs))
{
DiscordRoleDelete roleDeleteContext = new DiscordRoleDelete {
GuildId = guild.Id, RoleId = roleId
};
await _bus.Publish(roleDeleteContext);
}
}
#endregion Handle Roles
}
catch (Exception e)
{
Serilog.Log.Error($"{e}");
}
}
public async Task PublishEventAsync <TEvent>(TEvent @event) where TEvent : class, IEvent
{
await _busClient.Publish(@event);
}
public Task Publish <T>(T message, CancellationToken cancellationToken = default)
where T : class
{
return(_busControl.Publish(message, cancellationToken));
}
/// <summary>
/// Послать сообщение в шину
/// </summary>
/// <typeparam name="TEvent">Тип события в шине</typeparam>
/// <param name="eventModel">модель для посылки сообщения в шину</param>
public async Task Publish <TEvent>(TEvent eventModel) where TEvent : class
{
CheckForNull(eventModel);
InitBusAndThrowOnError();
await _bus.Publish(eventModel);
}
private static async void ThreadProc(object state)
{
string imei = string.Empty;
var client = ((TcpClient)state);
NetworkStream nwStream = ((TcpClient)state).GetStream();
byte[] buffer = new byte[client.ReceiveBufferSize];
try
{
var gpsResult = new List <CreateTeltonikaGps>();
while (true)
{
int bytesRead = nwStream.Read(buffer, 0, client.ReceiveBufferSize) - 2;
string dataReceived = Encoding.ASCII.GetString(buffer, 2, bytesRead);
if (imei == string.Empty)
{
imei = dataReceived;
Console.WriteLine("IMEI received : " + dataReceived);
Byte[] b = { 0x01 };
nwStream.Write(b, 0, 1);
var command = new CreateBoxCommand();
command.Imei = imei;
await _endpoint.Result.Send(command);
}
else
{
int dataNumber = Convert.ToInt32(buffer.Skip(9).Take(1).ToList()[0]);
var parser = new DevicesParser();
gpsResult.AddRange(parser.Decode(new List <byte>(buffer), imei));
var bytes = Convert.ToByte(dataNumber);
await nwStream.WriteAsync(new byte[] { 0x00, 0x0, 0x0, bytes }, 0, 4);
client.Close();
}
if (gpsResult.Count <= 0)
{
continue;
}
foreach (var gpSdata in gpsResult)
{
gpSdata.Address = await _reverseGeoCodingService.ReverseGoecode(gpSdata.Lat, gpSdata.Long);
Console.WriteLine("IMEI: " + imei + " Date: " + gpSdata.Timestamp + " latitude : " + gpSdata.Lat +
" Longitude:" + gpSdata.Long + " Speed: " + gpSdata.Speed + " Direction:" + "" +
" address " + gpSdata.Address + " milage :" + gpSdata.Mileage);
await _bus.Publish(gpSdata);
}
break;
}
}
catch (Exception)
{
// Console.WriteLine(e);
client.Close();
//throw;
}
//throw new NotImplementedException();
}
public async Task PublishMessage <TMessage>(TMessage message) where TMessage : class
{
await _serviceBus.Publish(message);
}
public static void Forward(JcbgCreatedMessage message)
{
CreateBus.Publish(message);
}
public static void Forward(JcbgUpdatedMessage message)
{
UpdateBus.Publish(message);
}
public async Task Consume(ConsumeContext <IStreamUpdate> context)
{
ILiveBotStream stream = context.Message.Stream;
ILiveBotMonitor monitor = _monitors.Where(i => i.ServiceType == stream.ServiceType).FirstOrDefault();
if (monitor == null)
{
return;
}
ILiveBotUser user = stream.User ?? await monitor.GetUserById(stream.UserId);
ILiveBotGame game = stream.Game ?? await monitor.GetGame(stream.GameId);
Expression <Func <StreamGame, bool> > templateGamePredicate = (i => i.ServiceType == stream.ServiceType && i.SourceId == "0");
var templateGame = await _work.GameRepository.SingleOrDefaultAsync(templateGamePredicate);
var streamUser = await _work.UserRepository.SingleOrDefaultAsync(i => i.ServiceType == stream.ServiceType && i.SourceID == user.Id);
var streamSubscriptions = await _work.SubscriptionRepository.FindAsync(i => i.User == streamUser);
StreamGame streamGame;
if (game.Id == "0" || string.IsNullOrEmpty(game.Id))
{
if (templateGame == null)
{
StreamGame newStreamGame = new StreamGame
{
ServiceType = stream.ServiceType,
SourceId = "0",
Name = "[Not Set]",
ThumbnailURL = ""
};
await _work.GameRepository.AddOrUpdateAsync(newStreamGame, templateGamePredicate);
templateGame = await _work.GameRepository.SingleOrDefaultAsync(templateGamePredicate);
}
streamGame = templateGame;
}
else
{
StreamGame newStreamGame = new StreamGame
{
ServiceType = stream.ServiceType,
SourceId = game.Id,
Name = game.Name,
ThumbnailURL = game.ThumbnailURL
};
await _work.GameRepository.AddOrUpdateAsync(newStreamGame, i => i.ServiceType == stream.ServiceType && i.SourceId == stream.GameId);
streamGame = await _work.GameRepository.SingleOrDefaultAsync(i => i.ServiceType == stream.ServiceType && i.SourceId == stream.GameId);
}
if (streamSubscriptions.Count() == 0)
{
return;
}
List <StreamSubscription> unsentSubscriptions = new List <StreamSubscription>();
foreach (StreamSubscription streamSubscription in streamSubscriptions)
{
if (streamSubscription.DiscordGuild == null || streamSubscription.DiscordChannel == null)
{
await _work.SubscriptionRepository.RemoveAsync(streamSubscription.Id);
continue;
}
var discordChannel = streamSubscription.DiscordChannel;
var discordRole = streamSubscription.DiscordRole;
var discordGuild = streamSubscription.DiscordGuild;
Expression <Func <StreamNotification, bool> > previousNotificationPredicate = (i =>
i.User_SourceID == streamUser.SourceID &&
i.DiscordGuild_DiscordId == discordGuild.DiscordId &&
i.DiscordChannel_DiscordId == discordChannel.DiscordId &&
i.Stream_StartTime == stream.StartTime &&
i.Stream_SourceID == stream.Id &&
i.Success == true
);
var previousNotifications = await _work.NotificationRepository.FindAsync(previousNotificationPredicate);
if (previousNotifications.Count() > 0)
{
continue;
}
unsentSubscriptions.Add(streamSubscription);
}
if (unsentSubscriptions.Count() > 0)
{
await _bus.Publish <IStreamOnline>(new { Stream = stream });
}
}
