public abstract void OnBroadcastMessageReceived(BroadcastMessage message);
private void EmulateCalls()
{
var randomizer = new Random();
do
{
var randomValue = randomizer.Next(1, 5000);
if (randomValue % 2 == 0)
{
var broadcast = new BroadcastMessage($"{nameof(BroadcastMessage)} message at [{DateTime.Now.ToString("HH:mm:ss")}]");
_manager.SendToAll(broadcast);
}
else
{
var personal = new PersonalMessage($"{nameof(PersonalMessage)} message at [{DateTime.Now.ToString("HH:mm:ss")}]");
var clients = _manager.GetClients().ToArray();
if (clients.Any())
{
var clientRandom = new Random();
var clientId = clients[clientRandom.Next(0, clients.Length)];
_manager.Send(clientId, personal);
}
}
int timeout = 5000 + randomValue;
Thread.Sleep(timeout);
} while (true);
}
public async Task SendBroadcastMessage()
{
IEnumerable <User> users = await _userRepository.GetAll();
IEnumerable <string> viberUserIds = users.Where(w => w.IsViber).Select(x => x.ClientId).ToList();
int lastVersion = await _dataVersionRepository.GetLastVersion();
BroadcastMessage broadcastMessage = new BroadcastMessage("oFKwijuinRXIqIUwBvbpEw==");
broadcastMessage.Sender = new UserBase
{
Name = MessageConstant.BOT_NAME, Avatar = MessageConstant.BOT_AVATAR
};
broadcastMessage.BroadcastList = viberUserIds;
broadcastMessage.MinApiVersion = 2;
broadcastMessage.Text = MessageConstant.UPDATE;
await _viberBotClient.SendBroadcastMessageAsync(broadcastMessage);
LeaguesCommand leaguesCommand = new LeaguesCommand(_leagueRepository, lastVersion);
foreach (var id in viberUserIds)
{
var callback = new Callback();
callback.Sender = new UserModel();
callback.Sender.Id = id;
await leaguesCommand.Execute(callback, _viberBotClient);
}
}
private void OnReceive(string message)
{
JObject jObject = JObject.Parse(message);
string broadcastEventName = jObject.GetValue(nameof(BroadcastMessage.EventName), StringComparison.OrdinalIgnoreCase)?.Value <string>();
if (broadcastEventName != null)
{
if (_broadcastEventSubscriptions.ContainsKey(broadcastEventName))
{
_broadcastEventSubscriptions[broadcastEventName].ForEach(a => a?.Invoke(jObject[nameof(BroadcastMessage.Data)].Value <JObject>()));
}
if (_allSubscriptions.Count > 0)
{
BroadcastMessage broadcastMessage = jObject.ToObject <BroadcastMessage>();
_allSubscriptions.ForEach(s => s?.Invoke(broadcastMessage));
}
}
else
{
JsonRpcResponse jsonRpcResponse = jObject.ToObject <JsonRpcResponse>();
MethodCall call = _methodCalls.ToList().FirstOrDefault(c => c.JsonRpcMessage.Id == jsonRpcResponse.Id);
if (jsonRpcResponse.Error.HasValue)
{
string methodCallString = call == null ? string.Empty : $" ({call})";
OnError?.Invoke(this, $"Error from server: {jsonRpcResponse.Error.Value.Message}{methodCallString}");
return;
}
if (call != null)
{
call.JsonRpcResponse = jsonRpcResponse;
}
}
}
public Broadcast(BroadcastMessage message)
{
From = message.From;
Content = message.Content;
Id = message.Id;
To = message.To;
}
protected virtual void SendMessage(BroadcastMessage message, short var1 = 0, int var2 = 0)
{
var msgVar1 = FromShorts((short)message, var1);
var lastTask = currentMessageTask;
currentMessageTask = new Task(() =>
{
lastTask.Wait();
lastTask.Dispose();
lastTask = null;
var timeSinceLastMsg = DateTime.Now - lastMessagePostedTime;
var throttleTime = (int)(MessageThrottleTime - timeSinceLastMsg.TotalMilliseconds);
if (throttleTime > 0)
{
Trace.WriteLine(string.Format("Throttle message {0} delivery to iRacing by {1} millisecond", message, throttleTime), "DEBUG");
Thread.Sleep(throttleTime);
}
lastMessagePostedTime = DateTime.Now;
if (!Win32.Messages.SendNotifyMessage(Win32.Messages.HWND_BROADCAST, messageId, msgVar1, var2))
{
throw new Exception(String.Format("Error in broadcasting message {0}", message));
}
});
currentMessageTask.Start();
}
protected void SendMessage(BroadcastMessage message, short var1 = 0, int var2 = 0)
{
var msgVar1 = FromShorts((short)message, var1);
var lastTask = currentMessageTask;
currentMessageTask = new Task(() =>
{
lastTask.Wait();
lastTask.Dispose();
lastTask = null;
var timeSinceLastMsg = DateTime.Now - lastMessagePostedTime;
var throttleTime = (int)(MessageThrottleTime - timeSinceLastMsg.TotalMilliseconds);
if (throttleTime > 0)
{
Trace.WriteLine(string.Format("Throttle message {0} delivery to iRacing by {1} millisecond", message, throttleTime), "DEBUG");
Thread.Sleep(throttleTime);
}
lastMessagePostedTime = DateTime.Now;
if (!Win32.Messages.SendNotifyMessage(Win32.Messages.HWND_BROADCAST, messageId, msgVar1, var2))
throw new Exception(String.Format("Error in broadcasting message {0}", message));
});
currentMessageTask.Start();
}
private void CheckAcceptedMessage()
{
if (acceptedMessage != null && acceptedMessage.IsCancelled())
{
acceptedMessage = null;
}
}
private void AddBroadcastListener()
{
connection_.AddBroadcastCallbackHandler("connecttovpn", (JObject response) =>
{
//RouterVpnManagerLogLibrary.Log("Connection has been made to " + response["data"].ToString());
ConnectToVpnResponse ctvr = response.ToObject <ConnectToVpnResponse>();
ctvr.SetData();
listener_?.ConnectedToVpn(ctvr);
});
connection_.AddBroadcastCallbackHandler("disconnectfrompvpn", (JObject response) =>
{
//RouterVpnManagerLogLibrary.Log("Disconnection has been made from " + response["data"].ToString());
DisconnectFromVpnResponse dfvr = response.ToObject <DisconnectFromVpnResponse>();
dfvr.SetData();
listener_?.DisconnectedFromVpn(dfvr);
});
connection_.AddBroadcastCallbackHandler("broadcastlog", (JObject response) =>
{
BroadcastMessage bm = response.ToObject <BroadcastMessage>();
bm.SetData();
RouterVpnManagerLogLibrary.LogBroadcastMessage(bm.Message);
});
}
public async Task ShouldResendMessageToEveryoneInTheSameGroupExceptTheSender(
ConnectedClient sender,
BroadcastMessage message,
List <ConnectedClient> clientsInGroup,
[Frozen] Mock <IConnectedClientStore> clients,
BroadcastMessageHandler sut)
{
var senderId = sender.ClientId;
Assert.NotEqual(senderId, message.SenderId);
clients.Setup(x => x.FindInGroups(It.Is <IEnumerable <string> >(
x => x.Count() == 1 && x.First() == sender.Group)))
.Returns(clientsInGroup.Append(sender));
await sut.HandleAsync(sender, message, Cts.Token);
// Sync senderId to broadcasted message since it's senderId might be not set by front end.
Assert.Equal(senderId, message.SenderId);
Mock.Get(sender.Connection).Verify(x => x.SendAsync(It.IsAny <object>(), Cts.Token), Times.Never);
foreach (var client in clientsInGroup)
{
Mock.Get(client.Connection).Verify(x => x.SendAsync(message, Cts.Token));
}
}
public void CheckPendingMessage()
{
if (pendingMessage != null && pendingMessage.AllHaveResponded() && !pendingMessage.IsAccepted() || pendingMessage != null && pendingMessage.IsCancelled())
{
pendingMessage = null;
}
}
private void ListenToBroadcast()
{
try
{
broadcastClient = new UdpClient();
if (Port == -1)
{
_port = GetNextAvailablePortNumber();
}
broadcastListenerGroupEP = new IPEndPoint(IPAddress.Any, Port);
broadcastClient.Client.Bind(broadcastListenerGroupEP);
while (true)
{
byte[] data = broadcastClient.Receive(ref broadcastListenerGroupEP);
BroadcastMessage message = new BroadcastMessage(broadcastListenerGroupEP, data);
new Thread(ReceivedMessage).Start(message);
}
}
catch (ThreadAbortException)
{
Port = 0;
broadcastClient.Close();
broadcastListenerGroupEP = null;
}
catch (Exception e)
{
Console.Error.WriteLine(e);
}
}
private void Broadcast()
{
message = MessageToBroadcast();
if (!communicationManager.Broadcast(message))
{
message = null; // Try again next frame
}
}
// This method is called by other agents if the EnableBroadcast property is true
public void ReceiveMessage(BroadcastMessage message)
{
if (BroadcastSettings == null || !EnableBroadcasting)
{
throw new DisabledException("You can't supply a message if the agents broadcasting is disabled");
}
messages.Add(message);
}
public override void Suppress()
{
if (message != null)
{
message.Cancel();
message = null;
}
}
public async Task <HttpResponseMessage> SendDeviceMessage([FromBody] BroadcastMessage message)
{
var success = await _iotHubService.InvokeDeviceMethod(message.DeviceId, message.MessageContents, Constants.MessageMethodName);
return(success
? Request.CreateResponse(HttpStatusCode.OK)
: Request.CreateResponse(HttpStatusCode.InternalServerError, "Could not find device"));
}
private void MessagePlayer(BroadcastMessage message)
{
for (int i = 0; i < m_playerManager.Length; i++)
{
GameObject player = m_playerManager.GetPlayer(i);
Broadcast.Send <IBroadcast>(player, (x, y) => x.Inform(message));
}
}
/// <summary>
/// Broadcast message can be any message received after the join message, in 1 second intervals.
/// </summary>
/// <param name="oldWorld">The current state of the world. </param>
/// <param name="message">The BroadcastMessage received. </param>
/// <returns>New world based on both the old world and the BroadcastMessage. </returns>
private static World FromBroadcastMessage(World oldWorld, BroadcastMessage message)
{
var brickWalls = message.DamagesDetails.Select(details =>
{
var oldBrickWall = oldWorld.GridItems[details.Location.X, details.Location.Y] as BrickWall;
// Assumption: BrickWall is the only thing which gets damaged.
Debug.Assert(oldBrickWall != null);
Trace.Assert(oldBrickWall != null);
var newBrickWall = new BrickWall(oldBrickWall.Health, oldBrickWall.Location);
return(newBrickWall);
}).ToArray();
var tanks = message.PlayersDetails
.Select(details =>
new Tank(
details.Location,
details.Health,
details.FacingDirection,
details.Points,
details.Coins,
details.PlayerNumber,
details.IsShot,
details.PlayerNumber == oldWorld.PlayerNumber
)
).ToArray();
return(new World(oldWorld.PlayerNumber)
{
BrickWalls = new HashSet <BrickWall>(brickWalls),
StoneWalls = oldWorld.StoneWalls,
Waters = oldWorld.Waters,
Tanks = new HashSet <Tank>(tanks),
// Acts as a clock for TimeVarient items.
// TODO Check accuracy of this calculation ( < 1 thing).
// TODO Confirm that we don't need an actual clock for this.
// TODO Identify what the server sends (does it actually sends time to disappear?).
Coinpacks =
new HashSet <Coinpack>(
oldWorld.Coinpacks
.Where(coinpack => coinpack.TimeToDisappear > 1) // ?
.Where(coinpack => !tanks.Select(tank => tank.Location).Contains(coinpack.Location))
.Select(coinpack =>
new Coinpack(coinpack.Location, coinpack.CoinValue, coinpack.TimeToDisappear - 1)
)
),
Lifepacks =
new HashSet <Lifepack>(
oldWorld.Lifepacks
.Where(lifepack => lifepack.TimeToDisappear > 1) // ?
.Where(lifepack => !tanks.Select(tank => tank.Location).Contains(lifepack.Location))
.Select(lifepack =>
new Lifepack(lifepack.Location, lifepack.HealthValue, lifepack.TimeToDisappear - 1)
)
)
});
}
public Task sendbroadcastMessage(BroadcastMessage broadcastMessage)
{
HostingEnvironment.QueueBackgroundWorkItem(cancellationToken =>
{
broadcastEvent.MessageBroadcasted += notification.OnMessageBroadcasted;
broadcastEvent.broadcast(broadcastMessage);
});
return(null);
}
public void SendBroadcastMessage(string sendMessage)
{
var command = new BroadcastMessage()
{
Message = sendMessage
};
Write(command);
}
void _OnBroadcastMessageReceived(string arg)
{
Debug.Log("OnBroadcastMessageReceived: " + arg);
if (jiverResponder != null)
{
BroadcastMessage message = new BroadcastMessage(arg);
jiverResponder.OnBroadcastMessageReceived(message);
}
}
protected override void SendMessage(BroadcastMessage message, short var1 = 0, int var2 = 0)
{
var msgVar1 = FromShorts((short)message, var1);
if (!Win32.Messages.SendNotifyMessage(Win32.Messages.HWND_BROADCAST, messageId, msgVar1, var2))
{
throw new Exception(String.Format("Error in broadcasting message {0}", message));
}
}
public NewBroadcastMessageViewModel(AppSettings settings, BroadcastMessage message)
{
_Settings = settings;
_Message = message;
ActionName = message.ActionName;
Title = message.Title;
Body = message.Body;
ActionToolTip = string.Format("Opens \"{0}\"", _Message.ActionUrl);
}
public void RespondBroadcast(BroadcastMessage Message)
{
//接收清除值的广播，并执行操作
if (Message.Message.ToString().ToLower().Equals("clear"))
{
tv_Start.Text = string.Empty;
tv_End.Text = string.Empty;
}
}
public KeyValuePair <int, String> BroadcastMessage_Insert(BroadcastMessage model)
{
var param = new SqlParameter[] {
new SqlParameter("@BroadcastMessageID", SqlDbType.UniqueIdentifier)
{
Value = CheckForDbNull(model.BroadcastMessageID)
},
new SqlParameter("@TeamID", SqlDbType.UniqueIdentifier)
{
Value = CheckForDbNull(model.TeamID)
},
new SqlParameter("@UserID", SqlDbType.UniqueIdentifier)
{
Value = CheckForDbNull(model.UserID)
},
new SqlParameter("@Content", SqlDbType.NVarChar, 4000)
{
Value = CheckForDbNull(model.Content)
},
new SqlParameter("@StartDate", SqlDbType.DateTime)
{
Value = CheckForDbNull(model.StartDate)
},
new SqlParameter("@ExpireDate", SqlDbType.DateTime)
{
Value = CheckForDbNull(model.ExpireDate)
},
new SqlParameter("@Severity", SqlDbType.Int)
{
Value = CheckForDbNull(model.Severity)
},
new SqlParameter("@ModifiedBy", SqlDbType.UniqueIdentifier)
{
Value = CheckForDbNull(model.ModifiedBy)
},
new SqlParameter("@BusinessUnit", SqlDbType.UniqueIdentifier)
{
Value = CheckForDbNull(model.BusinessUnit)
},
new SqlParameter("@RetVal", SqlDbType.Int)
{
Direction = ParameterDirection.Output
},
new SqlParameter("@Message", SqlDbType.NVarChar, 200)
{
Direction = ParameterDirection.Output
}
};
int rc = ((IObjectContextAdapter)this).ObjectContext.ExecuteStoreCommand("exec [CRM].[BroadcastMessage_Insert] @BroadcastMessageID, @TeamID, @UserID, @Content, @StartDate, @ExpireDate, @Severity, @ModifiedBy, @BusinessUnit, @RetVal out, @Message out", param);
int retVal = (int)param[9].Value;
string valueRes = param[10].Value.ToString();
return(new KeyValuePair <int, string>(retVal, valueRes));
}
private static void AddMessageToRecent(BroadcastMessage message, byte channelID)
{
var messages = _recentMessages.First(x => x.Key == channelID).Value;
if (messages.Count == 10)
{
messages.RemoveAt(0);
}
messages.Add(message);
}
protected virtual void OnMessageBroadcasted(BroadcastMessage broadcastMessage)
{
Debug.Print("----firing event-----again---" + MessageBroadcasted);
if (MessageBroadcasted != null)
{
MessageBroadcasted(this, new BroadcastMessageEventArgs()
{
BroadcastMessage = broadcastMessage
});
}
}
public Task UpdateBroadcast(Guid id, BroadcastMessage updatedBroadcast, CancellationToken cancellationToken = default)
{
if (updatedBroadcast is null)
{
throw new ArgumentNullException(nameof(updatedBroadcast));
}
updatedBroadcast.MessageId = id;
return(UpdateBroadcastInternalAsync(updatedBroadcast, cancellationToken));
}
public void RespondBroadcast(BroadcastMessage Message)
{
//接收清除值的广播，并执行操作
if (Message.Message.ToString().ToLower().Equals("clear"))
{
Date_End.Text = string.Empty;
Date_Start.Text = string.Empty;
Date_Start.DateTime = DateTime.MinValue;
Date_End.DateTime = DateTime.MinValue;
}
}
public async void EmailSender(BroadcastMessage broadcastMessage)
{
var apiKey = _configuration.GetSection("SkineroMotorsSendGridApiKey").Value;
var sendGridclient = new SendGridClient(apiKey);
var from = new EmailAddress(broadcastMessage.From.Email, broadcastMessage.From.Name);
var subject = broadcastMessage.Subject;
var to = new EmailAddress(broadcastMessage.To.Email, broadcastMessage.To.Name);
var htmlContent = $"<div style='background-color: #ffffff; margin: 0 auto; color: rgb(30, 31, 30);'><div style='background-color: #fcd2d2; padding: 12px; border-top-left-radius: 8px; border-top-right-radius: 8px;'><img src='./logo-1446293_640.png' style='max-height: 36px; max-width: 36px' /></div><div style='background-color: #ffffff; padding: 20px; font-size: 20px'><p>{broadcastMessage.Message}</p></div><div style='background-color: #fcd2d2; padding: 9px; border-bottom-left-radius: 8px;border-bottom-right-radius: 8px;'></div></div>";
var msg = MailHelper.CreateSingleEmail(from, to, subject, null, htmlContent);
var response = await sendGridclient.SendEmailAsync(msg);
}
private static void DelayedBroadcastExec(object state)
{
while (_BroadcastMessages.Count > 0)
{
BroadcastMessage message = _BroadcastMessages.Dequeue();
Broadcast(message);
}
lock (_BroadcastDelayTimerLock) {
_BroadcastDelayTimer = null;
}
}
private static void DelayedBroadcast(BroadcastMessage message)
{
_Logger.Debug("DelayedBroadcast '" + message.DebugInfo + "'");
_BroadcastMessages.Enqueue(message);
lock (_BroadcastDelayTimerLock) {
if (_BroadcastDelayTimer == null)
{
_BroadcastDelayTimer = new Timer(DelayedBroadcastExec, null, TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(-1));
}
}
}
public override void HandleMessageRecieved(BroadcastMessage message)
{
if (message.messgae == Message.ModelImported)
{
selected = Singleton<QbManager>.INSTANCE.models.Count - 1;
// we have a disabled tab not in use... so use it instead
// of creating new new tab from the imported model
// we still need to update though
if (selected < tabs.Count)
{
UpdateTabs();
return;
}
var tab = new QbModelTab(message.args[0] as QbModel);
tab.handler = tabHandler;
tabs.Add(tab);
// hacks
Client.OpenGLContextThread.Add(() =>
{
tab.AddWidgets(Singleton<GUI>.INSTANCE);
UpdateTabs();
});
}
else if (message.messgae == Message.ActiveModelChanged)
{
Singleton<Camera>.INSTANCE.LookAtModel();
}
else if (message.messgae == Message.ModelRemoved)
{
selected = selected < Singleton<QbManager>.INSTANCE.models.Count ? selected : Singleton<QbManager>.INSTANCE.models.Count-1;
UpdateTabs();
}
else if (message.messgae == Message.ModelRenamed)
{
UpdateTabs();
}
base.HandleMessageRecieved(message);
}
protected void SendMessage(BroadcastMessage message, short var1, short var2, short var3)
{
var var23 = FromShorts(var2, var3);
SendMessage(message, var1, var23);
}
public override void HandleMessageRecieved(BroadcastMessage message)
{
if (message.messgae == Message.ModelImported)
{
Refresh();
}
else if (message.messgae == Message.ActiveModelChanged)
{
offsetindex = 0;
lastActiveIndex = 0;
}
else if (message.messgae == Message.ActiveMatrixChanged)
{
Select((int)message.args[1]);
}
base.HandleMessageRecieved(message);
}
void _OnBroadcastMessageReceived(string arg)
{
Debug.Log ("OnBroadcastMessageReceived: " + arg);
if (jiverResponder != null) {
BroadcastMessage message = new BroadcastMessage(arg);
jiverResponder.OnBroadcastMessageReceived(message);
}
}
private static void Broadcast(BroadcastMessage message)
{
_Logger.Debug("Broadcast: '" + message.DebugInfo + "'");
List<Guid> inactive = new List<Guid>();
bool doCLientCountUpdate = false;
lock (_ClientsLock) {
IEnumerable<KeyValuePair<Guid, ClientInfo>> clients = _Clients.AsEnumerable();
if (message.Clients != null) {
clients = from pair in clients
join clientId in message.Clients on pair.Key equals clientId
select pair;
}
foreach (KeyValuePair<Guid, ClientInfo> pair in clients.ToArray()) {
try {
message.Action(pair.Value.Callback);
} catch (Exception exc) {
_Logger.Error("Broadcast error", exc);
inactive.Add(pair.Key);
}
}
if (inactive.Count > 0) {
foreach (Guid id in inactive) {
_Clients.Remove(id);
}
if (_Clients.Count > 0) {
doCLientCountUpdate = true;
}
}
}
if (doCLientCountUpdate) {
DelayedBroadcast(new BroadcastMessage {
Action = client => { client.ClientCountUpdate(_Clients.Count); },
DebugInfo = "ClientCountUpdate"
});
}
}
private static void DelayedBroadcast(BroadcastMessage message)
{
_Logger.Debug("DelayedBroadcast '" + message.DebugInfo + "'");
_BroadcastMessages.Enqueue(message);
lock (_BroadcastDelayTimerLock) {
if (_BroadcastDelayTimer == null) {
_BroadcastDelayTimer = new Timer(DelayedBroadcastExec, null, TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(-1));
}
}
}
public virtual void HandleMessageRecieved(BroadcastMessage message)
{
handler.messagerecived?.Invoke(this, message.messgae, message.widget, message.args);
}
