public void SendMessage(MessageKey name, object param)
{
_isDealingMessage = true;
if (listeners.ContainsKey(name))
{
List <IListener> ls = listeners[name];
if (ls != null)
{
foreach (IListener listener in ls)
{
listener.OnMessage(name, param);
}
}
}
while (stack.Count > 0)
{
KeyValuePair <MessageKey, object> pair = stack.Dequeue();
SendMessage(pair.Key, pair.Value);
}
while (unregisterQueue.Count > 0)
{
KeyValuePair <MessageKey, IListener> pair = unregisterQueue.Dequeue();
List <IListener> ls = listeners[pair.Key];
ls.Remove(pair.Value);
}
_isDealingMessage = false;
}
public void OnMessage(MessageKey name, object param)
{
if (this.Enabled && this.Visible)
{
switch (name)
{
case MessageKey.Finish:
棋子 side = (棋子)(param);
Finish(side);
break;
case MessageKey.FinishTurn:
this.Invalidate();
break;
case MessageKey.Equal:
Finish(棋子.无);
break;
case MessageKey.Restart:
ChessPlayer[] players = param as ChessPlayer[];
this.Restart(players[0], players[1]);
break;
}
}
}
private void OnReceived(object sender, PayloadReceivedEventArgs args)
{
// TODO KZ: handle missing packets
var packet = (Packet)args.Payload;
if (packet.Total == 1)
{
Received?.Invoke(this, new MessageReceivedEventArgs(packet.Sender, packet.Total, packet.Message, args.Received, args.Received));
return;
}
var key = new MessageKey(packet.Sender, packet.Sequence, packet.Total);
var receivedContext = _receivedContexts.GetValueOrAdd(key, _ => new ReceivedContext(packet.Total));
receivedContext.Chunks.Add(packet.Message);
if (receivedContext.Chunks.Count == 1)
{
receivedContext.FirstSent = args.Received;
return;
}
if (receivedContext.Chunks.Count != packet.Total)
{
return;
}
Received?.Invoke(this, new MessageReceivedEventArgs(packet.Sender, packet.Total, receivedContext.Chunks.Concat(), receivedContext.FirstSent, args.Received));
_receivedContexts.Remove(key);
}
public void OnMessage(MessageKey name, object param)
{
switch (name)
{
case MessageKey.Restart:
ChessPlayer[] players = param as ChessPlayer[];
Initialize(players[0].Name, players[1].Name);
break;
case MessageKey.FinishTurn:
object[] os = param as object[];
int x = (int)os[1];
int y = (int)os[2];
棋子 side = (棋子)os[0];
Record(side, x, y);
break;
case MessageKey.Finish:
棋子 s = (棋子)param;
Finish(s);
break;
case MessageKey.Equal:
Finish(棋子.无);
break;
}
}
public void WhenMessageExists_MustReturnMessage()
{
var col = base.mongoDb.GetCollection <Message>(MongoDbConstants.GetCollectionNameForMessage(topicId));
var msg = new Message
{
UtcReceivedOn = DateTime.UtcNow,
TopicId = topicId,
Payload = new byte[] { 1, 2, 3, 4, 5 }
};
col.Save(msg);
Assert.IsNotNull(msg.Id);
var key = new MessageKey {
MessageId = msg.Id.Value, TopicId = topicId
};
var query = new MessageByMessageKey(base.connectionString);
var result = query.Get(key);
Assert.IsNotNull(result);
Assert.AreEqual(msg.Id, result.Id);
Assert.AreEqual(msg.UtcReceivedOn.Date, result.UtcReceivedOn.Date);
Assert.AreEqual(msg.TopicId, result.TopicId);
CollectionAssert.AreEqual(msg.Payload, result.Payload);
}
static public void SetMessageSuppressed(MessageKey messageKey, bool value)
{
bool change = false;
if (value)
{
if (!GetMessageSuppressed(messageKey))
{
s_suppressMessages.Add(messageKey.ToString());
change = true;
}
}
else
{
if (GetMessageSuppressed(messageKey))
{
s_suppressMessages.Remove(messageKey.ToString());
change = true;
}
}
if (change)
{
Util.AppSettings.SaveList(c_suppressMessagesSettingName, s_suppressMessages, false, MessageForm.Warn);
}
}
internal TimeDeltaEntry(DateTime at, TimeSpan delta, MessageKey messageKey, M.Event evt)
{
At = at;
Delta = delta;
RelatedMessageKey = messageKey;
RelatedMessagingEvent = evt;
}
public void GetMessageKeyAsyncCallResultShouldBe(
string messageKey)
{
_scenarioContext
.GetCallResult <MessageKey>()
.ShouldBe(MessageKey.Parse(messageKey));
}
public bool Exist(MessageKey key, string filter)
{
Guard.Instance.ArgumentNotNull(() => key, key);
var query = string.IsNullOrWhiteSpace(filter) ?
new QueryDocument() :
filter.ToQueryDocument();
if (query.Contains(Constants.FieldNames.Id))
{
if (query[Constants.FieldNames.Id] != key.MessageId.ToBson())
{
// Filter already has a different message's id. So the query will always return false.
return(false);
}
}
else
{
// The filter does not include the message's id. Then add it to que query.
query.Add(Constants.FieldNames.Id, key.MessageId.ToBson());
}
string collectionName = MongoDbConstants.GetCollectionNameForMessage(key.TopicId);
return(DB.GetCollection <Message>(collectionName).Exists(query));
}
public void Should_get_a_messagge()
{
var contentType = "text/text";
var payload = "Hello!";
var message = new Message()
{
Id = Identity.Random(),
TopicId = Identity.Random(),
Payload = Encoding.ASCII.GetBytes(payload),
UtcReceivedOn = DateTime.UtcNow
};
message.Headers.Add("Content-Type", new[] { contentType });
var key = new MessageKey {
MessageId = message.Id.Value, TopicId = message.TopicId
};
messageByMessageKey
.Setup(r => r.Get(It.Is <MessageKey>(k => k.TopicId == key.TopicId && k.MessageId == key.MessageId)))
.Returns(message);
var client = new HttpClient(baseUri);
var url = baseUri + message.Id.Value.ToString() + "/topic/" + message.TopicId;
var result = client.Get(url);
messageByMessageKey.Verify(r => r.Get(It.Is <MessageKey>(k => k.TopicId == key.TopicId && k.MessageId == key.MessageId)));
Assert.IsNotNull(result);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(payload, result.Content.ReadAsString());
Assert.AreEqual(contentType, result.Content.Headers.ContentType.MediaType);
}
/// <summary>
/// Gets the message with the specified MessageKey enum key from the assembly resource file
/// </summary>
public string this [MessageKey key, params object[] parameters]
{
get
{
return(this.FormatMessage(key, parameters));
}
}
public void MakeTransient(MessageKey key)
{
MongoCollection <Message> collection =
DB.GetCollection <Message>(MongoDbConstants.GetCollectionNameForMessage(key.TopicId));
collection.Remove(key.MessageId);
}
protected void SetRedirectMessage(MessageKey key)
{
Response.Cookies.Add(new HttpCookie(MessageResolver.MessageCookieName, key.ToString())
{
Expires = DateTime.UtcNow.AddMinutes(1)
});
}
public string Find(MessageKey key)
{
if (_messages.ContainsKey(key))
{
return(_messages[key]);
}
throw new KeyNotFoundException(Constants.KeyDoesNotExists);
}
/// <summary>
/// Gets the message with the specified MessageKey enum key from the assembly resource file
/// </summary>
public string this [MessageKey key]
{
get
{
string keyValue = key.ToString();
return(_rm.GetString(keyValue, CultureInfo.CurrentUICulture));
}
}
public void SendMessageLater(MessageKey name, object param)
{
if (!_isDealingMessage)
{
SendMessage(name, param);
}
else
{
stack.Enqueue(new KeyValuePair <MessageKey, object>(name, param));
}
}
public static string GetMsgValue(MessageKey key)
{
if (dict.ContainsKey(key))
{
return(dict[key]);
}
else
{
return(String.Empty);
}
}
protected ReusableSingletonMemoryStream HandleGetLoadedMods(MessageKey key)
{
if (LogEnabled)
{
Logger.WriteLineAsync($"[{nameof(ServerBase)}] Retrieving Loaded Mods, Key: {key.Key}");
}
var response = new GetLoadedModsResponse(Loader.GetLoadedMods(), key);
return(response.Serialize(ref response));
}
public Task VASPSetItsContractMessageKeyTo(
string messageKey)
{
return(_scenarioContext
.GetContractByType <VASPContract>()
.SetMessageKey
(
owner: _accounts.Owner,
messageKey: MessageKey.Parse(messageKey)
));
}
public async Task VASPSetItsContractMessageKeyTo(
string messageKey)
{
await _scenarioContext
.GetContractByType <VASPContract>()
.SetMessageKeyAsync
(
owner: await _accounts.GetOwnerAsync(),
messageKey: MessageKey.Parse(messageKey)
);
}
private SyndicationFeed GetFeedForMessage(Message message)
{
var messageId = message.Id.Value;
var topicId = message.TopicId;
var feedEntry = new FeedEntry()
{
MessageId = messageId, TimeStamp = DateTime.UtcNow
};
var feed = new Feed()
{
Entries = new List <FeedEntry>(new[] { feedEntry }),
Id = Identity.Random(),
TopicId = topicId,
Updated = DateTime.UtcNow
};
var topic = new Topic()
{
Id = topicId,
Name = "Topic Name",
Description = "Topic Description",
GroupId = Identity.Random()
};
var key = new MessageKey {
MessageId = messageId, TopicId = topicId
};
messageByMessageKey
.Setup(r => r.Get(It.Is <MessageKey>(k => k.TopicId == key.TopicId && k.MessageId == key.MessageId)))
.Returns(message);
getWorkingFeedForTopic
.Setup(r => r.Execute(topicId))
.Returns(feed);
entityById
.Setup(r => r.Get <Topic>(topicId))
.Returns(topic);
var client = new HttpClient(baseUri);
var response = client.Get(topicId.ToString());
var formatter = new Atom10FeedFormatter();
using (var rdr = XmlReader.Create(response.Content.ContentReadStream))
{
formatter.ReadFrom(rdr);
return(formatter.Feed);
}
}
/// <summary>
/// Gets the message with the specified MessageKey enum key from the assembly resource file
/// </summary>
public string this [MessageKey key]
{
get
{
#if NET10
string keyValue = key.ToString(CultureInfo.InvariantCulture);
#endif
#if NET20
string keyValue = key.ToString();
#endif
return(_rm.GetString(keyValue, CultureInfo.CurrentUICulture));
}
}
protected BaseApplicationException(
string carrierCode,
MessageKey messageKey,
Exception innerException,
bool knownMessage = true,
string[] messageVariables = null,
object request = null,
object response = null)
: this(
carrierCode, MessageManager.GetMessage(messageKey, messageVariables), innerException, knownMessage,
messageVariables, request, response)
{
}
public void OnMessage(MessageKey name, object param)
{
if (!this.Visible || !this.Enabled)
{
return;
}
switch (name)
{
case MessageKey.FinishArena:
Finish();
break;
}
}
public void Register(MessageKey name, IListener listener)
{
List <IListener> ls = null;
if (listeners.ContainsKey(name))
{
ls = listeners[name];
}
else
{
ls = new List <IListener>();
listeners[name] = ls;
}
ls.Add(listener);
}
public static Uri GetResizeRequest(out MessageKey key)
{
CloudQueue queue = GetQueue();
if (queue.RetrieveApproximateMessageCount() == 0)
{
key = null;
return(null);
}
CloudQueueMessage message = queue.GetMessage();
Uri result = new Uri(message.AsString);
key = new MessageKey(message.Id, message.PopReceipt);
return(result);
}
public void OnMessage(MessageKey name, object param)
{
switch (name)
{
case MessageKey.RefreshDebug:
object[] test = param as object[];
float[][] black = test[0] as float[][];
float[][] white = test[1] as float[][];
Refresh(black, white);
break;
default:
break;
}
}
public void UnRegister(MessageKey name, IListener listener)
{
if (!_isDealingMessage)
{
if (listeners.ContainsKey(name))
{
List <IListener> ls = null;
ls = listeners[name];
ls.Remove(listener);
}
}
else
{
unregisterQueue.Enqueue(new KeyValuePair <MessageKey, IListener>(name, listener));
}
}
/// <summary>
/// This method gets the message key of a message or null if the method doesn`t have it.
/// </summary>
/// <param name="message">Message string.</param>
/// <returns>Message key or null.</returns>
public static MessageKey GetMessageKey(string message)
{
MessageType messageType = MessageUtils.GetMessageType(message);
switch (messageType)
{
case MessageType.Current:
case MessageType.CurrentAggregation:
case MessageType.Trade:
MessageKey messageKey = new MessageKey();
messageKey.Unpack(message);
return(messageKey);
}
return(null);
}
public ASOASystemException(
string carrierCode,
MessageKey messageKey,
Exception innerException,
string[] messageVariables = null,
object request = null,
object response = null)
: base(
carrierCode,
messageKey,
innerException,
true,
messageVariables,
request,
response)
{
}
/// <summary>
/// Formats a message stored in the assembly resource file
/// </summary>
/// <param name="key"><see cref="MessageKey"/> enumeration key</param>
/// <param name="format">format arguments</param>
/// <returns>a formated string</returns>
public string FormatMessage( MessageKey key, params object[] format )
{
return String.Format( CultureInfo.CurrentUICulture, this[key], format );
}
/// <summary>
/// Gets the message with the specified MessageKey enum key from the assembly resource file
/// </summary>
public string this [ MessageKey key, params object[] parameters ]
{
get
{
return this.FormatMessage( key, parameters );
}
}
/// <summary>
/// Gets the message with the specified MessageKey enum key from the assembly resource file
/// </summary>
public string this [ MessageKey key ]
{
get
{
#if NET10
string keyValue = key.ToString(CultureInfo.InvariantCulture);
#endif
#if NET20
string keyValue = key.ToString();
#endif
return _rm.GetString( keyValue, CultureInfo.CurrentUICulture );
}
}
