/// <summary>
/// Tries to reject all pending requests.
/// </summary>
/// <param name="messageRouter">The message router.</param>
/// <param name="messageRouterResultHandler">The message router result handler.</param>
/// <returns>True, if successful. False otherwise.</returns>
public async Task <bool> RejectAllPendingRequestsAsync(
MessageRouter messageRouter, MessageRouterResultHandler messageRouterResultHandler)
{
bool wasSuccessful = false;
IList <ConnectionRequest> connectionRequests = messageRouter.RoutingDataManager.GetConnectionRequests();
if (connectionRequests.Count > 0)
{
IList <ConnectionRequestResult> connectionRequestResults =
new List <ConnectionRequestResult>();
foreach (ConnectionRequest connectionRequest in connectionRequests)
{
connectionRequestResults.Add(
messageRouter.RejectConnectionRequest(connectionRequest.Requestor));
}
foreach (ConnectionRequestResult connectionRequestResult in connectionRequestResults)
{
await messageRouterResultHandler.HandleResultAsync(connectionRequestResult);
}
wasSuccessful = true;
}
return(wasSuccessful);
}
void Check(string checkName, GetMethod getMethod, SetMethod setMethod)
{
string s = "Check name ; " + checkName + "\n";
try
{
setMethod();
s += "Set succeeded\n";
}
catch (Exception e)
{
s += "Set through exception :\n\t" + e.Message + "\n";
}
try
{
s += "Value set is : " + getMethod().ToString() + "\n";
s += "Get succeeded\n";
}
catch (Exception e)
{
s += "Get through exception : \n\t" + e.Message;
}
MessageRouter.MessageBox(new List <string> {
s
});
}
protected override async Task HandleTurnAsync(ITurnContext turnContext, ChatUserContext userContext,
MessageRouter messageRouter, NextDelegate next, CancellationToken cancellationToken = default(CancellationToken))
{
Activity activity = turnContext.Activity;
if (turnContext.TurnState.TryGetValue(typeof(CommandSendMessageProperties).FullName, out object result))
{
CommandSendMessageProperties properties = (CommandSendMessageProperties)result;
//Log broadcast
if (properties.From.Role == ChatUserRole.Admin && properties.UserId == "*")
{
var allConsumerConservations = await _routingDataManager.GetConsumerConversations();
foreach (var consumerConversation in allConsumerConservations)
{
await _reportDataManager.CreateOrUpdateChatReport(new ChatReportLogCreationModel()
{
User = properties.From.Role == ChatUserRole.Admin ? new ChatUserModel()
{
Id = consumerConversation.User.Id
} : properties.From,
Message = new ChatReportLogModel()
{
From = properties.From,
Date = activity.Timestamp.Value.DateTime,
Message = activity.Text,
ReportType = properties.ReportType,
Id = activity.Id,
IsBroadcast = true
}
});
}
}
else
{
//Log one message
ChatReportModel chatReportModel = await _reportDataManager.CreateOrUpdateChatReport(new ChatReportLogCreationModel()
{
User = properties.From.Role == ChatUserRole.Admin ? new ChatUserModel()
{
Id = properties.UserId
} : properties.From,
ChannelId = activity.ChannelId,
Message = new ChatReportLogModel()
{
From = properties.From,
Date = activity.Timestamp.Value.DateTime,
Message = activity.Text,
ReportType = properties.ReportType,
Id = activity.Id
}
});
turnContext.TurnState.Add(typeof(ChatReportModel).FullName, chatReportModel);
}
await next(cancellationToken).ConfigureAwait(false);
}
}
public void WhenIScheduleAMeeting()
{
var scheduleMeetingCommand = new ScheduleMeetingCommand(MEETING_ID, meetingDate, locationId, speakerId, capacity);
new DomainDatabaseBootStrapper().ReCreateDatabaseSchema();
var sqliteConnectionString = string.Format("Data Source={0}", DATA_BASE_FILE);
var domainEventStorage = new DomainEventStorage<IDomainEvent>(sqliteConnectionString, new BinaryFormatter());
var eventStoreIdentityMap = new EventStoreIdentityMap<IDomainEvent>();
var bus = new DirectBus(new MessageRouter());
var eventStoreUnitOfWork = new EventStoreUnitOfWork<IDomainEvent>(domainEventStorage, eventStoreIdentityMap, bus);
var repository = new DomainRepository<IDomainEvent>(eventStoreUnitOfWork, eventStoreIdentityMap);
new ReportingDatabaseBootStrapper().ReCreateDatabaseSchema();
reportingRepository = new SQLiteReportingRepository(sqliteConnectionString, new SqlSelectBuilder(), new SqlInsertBuilder(), new SqlUpdateBuilder(), new SqlDeleteBuilder());
handler = new ScheduleMeetingCommandHandler(repository);
var messageRouter = new MessageRouter();
messageRouter.Register<ScheduleMeetingCommand>(command => handler.Handle(command));
bus.Publish(scheduleMeetingCommand);
//how do we publish to report, directly or via command handler. Looks like by using transaction handler we go through unit of work whose commit method fires events to BUS
//so if we have event and then save they get re-ublished and report canpick up
}
protected override async Task HandleTurnAsync(ITurnContext turnContext, ChatUserContext userContext,
MessageRouter messageRouter, NextDelegate next, CancellationToken cancellationToken = default(CancellationToken))
{
Activity activity = turnContext.Activity;
if (turnContext.TurnState.TryGetValue(typeof(CommandSendMessageProperties).FullName, out object result))
{
CommandSendMessageProperties properties = (CommandSendMessageProperties)result;
ConversationReference selfConversation = activity.GetConversationReference();
//Broadcast to many users
IEnumerable <ConversationReference> conversations = await GetHandoffConversation(turnContext, activity, properties, selfConversation);
//Send messages
if (conversations != null)
{
foreach (var conversation in conversations)
{
await messageRouter.SendMessageAsync(conversation, properties, activity.Text);
}
}
await next(cancellationToken).ConfigureAwait(false);
}
}
private static IDisposable CreateLocalSubscription(IReactivePlatform platform, Uri uri, IObserver <T> observer)
{
var messagingConnection = platform.Environment.MessagingService.GetInstance <IReactiveMessagingConnection>();
var messageRouter = new MessageRouter(messagingConnection);
return(messageRouter.Subscribe(uri, new Deserializer(observer)));
}
private bool TrySendMessage(object message)
{
EntityActorMessage castedMessage = (EntityActorMessage)message;
EntityActorMessageContext context = new EntityActorMessageContext(Sender, Self, Context.System.Scheduler);
return(MessageRouter.RouteMessage(context, ActorState, castedMessage));
}
public async Task OnTurnAsync(ITurnContext context, NextDelegate next, CancellationToken cancellationToken = default(CancellationToken))
{
Activity activity = context.Activity;
if (activity.Type is ActivityTypes.Message)
{
bool.TryParse(
Configuration[KeyRejectConnectionRequestIfNoAggregationChannel],
out bool rejectConnectionRequestIfNoAggregationChannel);
// Store the conversation references (identities of the sender and the recipient [bot])
// in the activity
MessageRouter.StoreConversationReferences(activity);
AbstractMessageRouterResult messageRouterResult = null;
// Check the activity for commands
if (await CommandHandler.HandleCommandAsync(context) == false)
{
// No command detected/handled
// Let the message router route the activity, if the sender is connected with
// another user/bot
messageRouterResult = await MessageRouter.RouteMessageIfSenderIsConnectedAsync(activity, false);
if (messageRouterResult is MessageRoutingResult &&
(messageRouterResult as MessageRoutingResult).Type == MessageRoutingResultType.NoActionTaken)
{
// No action was taken by the message router. This means that the user
// is not connected (in a 1:1 conversation) with a human
// (e.g. customer service agent) yet.
// Check for cry for help (agent assistance)
if (!string.IsNullOrWhiteSpace(activity.Text) &&
activity.Text.ToLower().Contains("human"))
{
// Create a connection request on behalf of the sender
// Note that the returned result must be handled
messageRouterResult = MessageRouter.CreateConnectionRequest(
MessageRouter.CreateSenderConversationReference(activity),
rejectConnectionRequestIfNoAggregationChannel);
}
else
{
// No action taken - this middleware did not consume the activity so let it propagate
await next(cancellationToken).ConfigureAwait(false);
}
}
}
// Uncomment to see the result in a reply (may be useful for debugging)
//if (messageRouterResult != null)
//{
// await MessageRouter.ReplyToActivityAsync(activity, messageRouterResult.ToString());
//}
// Handle the result, if necessary
await MessageRouterResultHandler.HandleResultAsync(messageRouterResult);
}
}
public TimeoutMiddleware(IConfiguration configuration, ILoggerFactory loggerFactory)
{
_logger = loggerFactory.CreateLogger <TimeoutMiddleware>();
string connectionString = configuration[KeyAzureTableStorageConnectionString];
if (string.IsNullOrEmpty(connectionString))
{
_logger.LogError($"WARNING!!! No connection string found - using {nameof(InMemoryRoutingDataStore)}");
_routingDataStore = new InMemoryRoutingDataStore();
}
else
{
_logger.LogDebug($"Found a connection string - using {nameof(AzureTableRoutingDataStore)}");
_routingDataStore = new AzureTableRoutingDataStore(connectionString, new Underscore.Bot.MessageRouting.Logging.ConsoleLogger(loggerFactory.CreateLogger <AzureTableRoutingDataStore>()));
}
_timeout = TimeSpan.FromSeconds(Double.Parse(configuration[KeyConversationTimeout] ?? "3600"));
_logger.LogInformation($"Bot Conversation Timeout set to {_timeout.ToString()}");
_messageRouter = new MessageRouter(
_routingDataStore,
new MicrosoftAppCredentials(configuration["MicrosoftAppId"], configuration["MicrosoftAppPassword"]),
logger: new Underscore.Bot.MessageRouting.Logging.ConsoleLogger(loggerFactory.CreateLogger <MessageRouter>()));
_endOfConversationActivity = Activity.CreateMessageActivity();
_endOfConversationActivity.Type = ActivityTypes.EndOfConversation;
}
/// <summary>
/// Closes a connection that was open with ForwardOpen or ConnectOverControlNet
/// </summary>
/// <param name="si">Session Info</param>
/// <param name="Path">Path to the target</param>
/// <returns>True if the request was successful, false otherwise</returns>
public static bool ForwardClose(SessionInfo si, byte[] Path)
{
ForwardCloseRequest request = new ForwardCloseRequest();
request.ConnectionSerialNumber = si.ConnectionParameters.ConnectionSerialNumber;
request.VendorId = si.ConnectionParameters.VendorID;
request.OriginatorSerialNumber = si.ConnectionParameters.OriginatorSerialNumber;
byte[] tPath = new byte[Path.Length + CommonPaths.Router.Length];
Buffer.BlockCopy(Path, 0, tPath, 0, Path.Length);
Buffer.BlockCopy(CommonPaths.Router, 0, tPath, Path.Length, CommonPaths.Router.Length);
request.Path = tPath;
EncapsReply response = MessageRouter.SendMR_Request(si, (byte)ConnectionManagerService.ForwardClose, CommonPaths.ConnectionManager,
request.Pack());
if (response == null)
{
return(false);
}
if (response.Status == 0)
{
return(true);
}
return(false);
}
protected override void SetupDependencies()
{
_handler = new FirstTestCommandHandler();
var messageRouter = new MessageRouter();
messageRouter.Register <TestCommand>(x => _handler.Execute(x));
DoNotMock.Add(typeof(IRouteMessages), messageRouter);
}
public OutboundPipelineConfigurator(IServiceBus bus)
{
_bus = bus;
var router = new MessageRouter <ISendContext>();
_pipeline = new OutboundMessagePipeline(router, this);
}
private void Start()
{
_playerDataService = ServiceFactory.Instance.GetService <PlayerDataService>();
_enemyService = ServiceFactory.Instance.GetService <MinionService>();
_messageRouter = ServiceFactory.Instance.GetService <MessageRouter>();
swingHitBox = GetComponent <CapsuleCollider2D>();
_entityIDsHit = new List <int>();
}
public MessageRouterTests()
{
_route1 = new Mock <NmeaSinkAndSource>(MockBehavior.Strict, "1");
_route2 = new Mock <NmeaSinkAndSource>(MockBehavior.Strict, "2");
_router = new MessageRouter();
_router.AddEndPoint(_route1.Object);
_router.AddEndPoint(_route2.Object);
}
public OutboundPipelineConfigurator(IServiceBus bus)
{
_bus = bus;
var router = new MessageRouter<ISendContext>();
_pipeline = new OutboundMessagePipeline(router);
}
public static void OnCustomEvent(this GameObject gameObject, EventData eventData)
{
MessageRouter messageRouter = gameObject.GetComponent <MessageRouter>();
if (messageRouter)
{
messageRouter.OnCustomEvent(eventData);
}
}
private void OnOutReceived(MessageRouter router, Message message, object tag)
{
// server is about to disconnect us
this.notifyRouter.Close();
this.notifyRouter = null;
control.ForcedDisconnect();
timer.Stop();
timeoutTimer.Stop();
}
private void OnAuthResponseResponse(MessageRouter router, Message message, object tag)
{
if (message.Header.Status == YahooStatus.Error)
{
// authentication failed
((OperationCompleteEvent)tag).Execute(
new ConnectionCompleteArgs(ConnectionFailedReport.AuthFailed));
}
}
public static void OnCustomEvent(this Component component, EventData eventData)
{
MessageRouter messageRouter = component.GetComponent <MessageRouter>();
if (messageRouter)
{
messageRouter.OnCustomEvent(eventData);
}
}
public static void Dispatch(this GameObject gameObject, string message)
{
MessageRouter messageRouter = gameObject.GetComponent <MessageRouter>();
if (messageRouter)
{
messageRouter.Dispatch(message);
}
}
public static void OnCustomEvent(this Component component, string message)
{
MessageRouter messageRouter = component.GetComponent <MessageRouter>();
if (messageRouter)
{
messageRouter.OnCustomEvent(new EventData(message));
}
}
public static void OnCustomEvent <T>(this GameObject gameObject, string message, T arg)
{
MessageRouter messageRouter = gameObject.GetComponent <MessageRouter>();
if (messageRouter)
{
messageRouter.OnCustomEvent(new EventData <T>(message, arg));
}
}
/// <summary>
/// Called when context created.
/// </summary>
/// <param name="browser">The browser.</param>
/// <param name="frame">The frame.</param>
/// <param name="context">The context.</param>
protected override void OnContextCreated(CefBrowser browser, CefFrame frame, CefV8Context context)
{
if (frame == null)
{
throw new ArgumentNullException("frame");
}
MessageRouter.OnContextCreated(browser, frame, context);
}
public static void Dispatch <T>(this Component component, string message, T arg)
{
MessageRouter messageRouter = component.GetComponent <MessageRouter>();
if (messageRouter)
{
messageRouter.Dispatch(message, arg);
}
}
public SignalRBrooker(
Uri baseAddress,
MessageRouter messageQueue,
IAccessTokenProvider accessTokenProvider)
{
this.baseAddress = baseAddress ?? throw new ArgumentNullException(nameof(baseAddress));
this.messageQueue = messageQueue ?? throw new ArgumentNullException(nameof(messageQueue));
this.accessTokenProvider = accessTokenProvider ?? throw new ArgumentNullException(nameof(accessTokenProvider));
}
private void Awake()
{
var messageRouter = new MessageRouter();
ServiceFactory.Instance.RegisterSingleton(messageRouter);
RegisterServices();
StartCoroutine(SpawnEnemy());
StartCoroutine(SpawnGoldDelayed());
}
InboundPipelineConfigurator(IServiceBus bus)
{
_subscriptionEventHandlers = new RegistrationList <ISubscriptionEvent>();
_bus = bus;
var router = new MessageRouter <IConsumeContext>();
_pipeline = new InboundMessagePipeline(router, this);
}
public void when_configure_ingress_and_call_without_ingress_it_should_fail()
{
Action sut1 = () =>
MessageRouter.Configure(
router => router
.AddMessageBroker(
broker => broker
.WithId("broker id")
.Ingress(
ingress => ingress
.WithTestDriver(new TestDriverState())
.WithEnterPipeFitter <EmptyPipeFitter>()
.WithExitPipeFitter <EmptyPipeFitter>()
.WithQueueNameMatcher <RegexQueueNameMatcher>()
.AddApi(
api => api
.WithId("ingress-api")
.WithHandlerRegistry <EmptyHandlerRegistry>()
.WithMessageKey <string>()
.WithMessagePayload <string>()
.WithMessageTypesRegistry <EmptyIngressApiMessageTypesRegistry>()
.WithPipeFitter <EmptyPipeFitter>()
.WithQueueNamePatternsProvider <ProvidingNothingQueueNamePatternsProvider>()
))
.WithoutIngress()
.WithoutEgress()));
sut1.Should().ThrowExactly <PoezdConfigurationException>().Which.Message.Should().Contain("WithoutIngress");
Action sut2 = () =>
MessageRouter.Configure(
router => router
.AddMessageBroker(
broker => broker
.WithId("broker id")
.WithoutIngress()
.Ingress(
ingress => ingress
.WithTestDriver(new TestDriverState())
.WithEnterPipeFitter <EmptyPipeFitter>()
.WithExitPipeFitter <EmptyPipeFitter>()
.WithQueueNameMatcher <RegexQueueNameMatcher>()
.AddApi(
api => api
.WithId("ingress-api")
.WithHandlerRegistry <EmptyHandlerRegistry>()
.WithMessageKey <string>()
.WithMessagePayload <string>()
.WithMessageTypesRegistry <EmptyIngressApiMessageTypesRegistry>()
.WithPipeFitter <EmptyPipeFitter>()
.WithQueueNamePatternsProvider <ProvidingNothingQueueNamePatternsProvider>()
))
.WithoutEgress()));
sut2.Should().ThrowExactly <PoezdConfigurationException>().Which.Message.Should().Contain("WithoutIngress");
}
//--------------------------------------------------------------------------------------------------
#endregion
#region Initialization and Property handling
public MessageHandler()
{
_MessageItems = new ObservableCollection <MessageItem>();
_EntityMessages = new ConditionalWeakTable <Entity, List <MessageItem> >();
//Messages(MessageSeverity.Warning, "This is an extended Warning.", "And this is extended Information.\nMultiline if you want to.");
_MessageRouter = new MessageRouter();
_MessageRouter.MessageArrived += _MessageRouter_MessageArrived;
_MessageRouter.TraceLevel = Message_Gravity.Message_Warning;
}
private void OnSwitchBoardUsrResponse(MessageRouter router, Message message, object tag)
{
object[] objs = (object[])tag;
Friend friend = (Friend)objs[0];
OperationCompleteEvent e = (OperationCompleteEvent)objs[1];
this.InviteFriend(friend, e);
router.RemoveMessageEvent(message);
}
private void OnVersionResponse(MessageRouter router, Message message, object tag)
{
router.RemoveMessageEvent(message);
// send CVR command - describes our local machine and client version
router.SendMessage(
Message.ConstructMessage("CVR", "0x0409 winnt 5.1 i386 MSMSGS 4.7.2009 WindowsMessenger " + settings.Username),
new ResponseReceivedHandler(OnCvrResponse),
tag);
}
/// <summary>
/// Called when process message received.
/// </summary>
/// <param name="browser">The browser.</param>
/// <param name="sourceProcess">The source process.</param>
/// <param name="message">The process message.</param>
/// <returns></returns>
protected override bool OnProcessMessageReceived(CefBrowser browser, CefProcessId sourceProcess, CefProcessMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
return(V8NativeHandler.ProcessMessage(browser, sourceProcess, message) ||
MessageRouter.OnProcessMessageReceived(browser, sourceProcess, message));
}
void InitRoutes()
{
m_router = new MessageRouter(m_diagnostics);
if (!m_settings.HasRoutes)
{
return;
}
using (new MethodTracer(Logger))
{
m_router.Init(m_settings.IncomingRoutes);
}
}
private void OnForcedDisconnect(MessageRouter router, Message message, object tag)
{
// control.ForcedDisconnection();
}
private void OnSwitchBoardUsrResponse(MessageRouter router, Message message, object tag)
{
object[] objs = (object[])tag;
Friend friend = (Friend)objs[0];
OperationCompleteEvent e = (OperationCompleteEvent)objs[1];
this.InviteFriend(friend, e);
router.RemoveMessageEvent(message);
}
public void StartByInvitation(Friend friend, OperationCompleteEvent opCompleteEvent, object tag)
{
object[] objs = (object[])tag;
string sbIP = (string)objs[0];
int sbPort = (int)objs[1];
string hash = (string)objs[2];
string sessionID = (string)objs[3];
try
{
Proxy.IConnection conn = this.control.CreateConnection();
conn.Connect("", 0, sbIP, sbPort, Proxy.ConnectionType.Tcp);
sbRouter = new MessageRouter(this.protocol, conn, null, null);
RegisterCodeEvents();
sbRouter.SendMessage(Message.ConstructMessage("ANS",
this.settings.Username + " " + hash + " " + sessionID),
new ResponseReceivedHandler(OnAnswerResponse), opCompleteEvent);
}
catch
{
opCompleteEvent.Execute(new OperationCompleteArgs("Could not connect", true));
}
}
private void OnSayAck(MessageRouter router, Message message, object tag)
{
switch (message.Code)
{
case "ACK":
((OperationCompleteEvent)tag).Execute(new OperationCompleteArgs());
break;
case "NAK":
((OperationCompleteEvent)tag).Execute(new OperationCompleteArgs("Message could not be sent", false));
break;
default:
((OperationCompleteEvent)tag).Execute(new OperationCompleteArgs("Unknown error occurred", false));
break;
}
}
private void OnSwitchBoardRequestResponse(MessageRouter router, Message message, object tag)
{
object[] o = (object[])tag;
Friend friend = (Friend)o[0];
OperationCompleteEvent op = (OperationCompleteEvent)o[1];
Regex.Regex regex = new Regex.Regex(@"SB (?<sbServerIP>\d+\.\d+\.\d+\.\d+):(?<sbServerPort>\d+) CKI (?<hash>.*$)");
Regex.Match match = regex.Match(message.Arguments);
if (match.Success)
{
string sbIP = match.Groups["sbServerIP"].Value;
int sbPort = int.Parse(match.Groups["sbServerPort"].Value);
string conversationID = match.Groups["hash"].Value;
// connect
try
{
Proxy.IConnection conn = this.control.CreateConnection();
conn.Connect("", 0, sbIP, sbPort, Proxy.ConnectionType.Tcp);
sbRouter = new MessageRouter(this.protocol, conn, null, new ResponseReceivedHandler(OnForcedDisconnect));
}
catch
{
op.Execute(new OperationCompleteArgs("Could not connect", true));
return;
}
RegisterCodeEvents();
sbRouter.SendMessage(Message.ConstructMessage("USR", this.settings.Username + " " + conversationID),
new ResponseReceivedHandler(OnSwitchBoardUsrResponse), tag);
}
else
op.Execute(new OperationCompleteArgs("Could not connect", true));
router.RemoveMessageEvent(message);
}
private void OnJoinReceived(MessageRouter router, Message message, object tag)
{
Regex.Regex regex = new Regex.Regex(@"(?<username>\S+)\s+(?<screenName>\S+)");
Regex.Match match = regex.Match(message.Arguments);
if (match.Success)
{
string email = match.Groups["username"].Value;
string screenName = match.Groups["screenName"].Value;
control.FriendJoin(email);
}
}
private void OnMsgReceived(MessageRouter router, Message message, object tag)
{
// seperate message from all the crap
string actualMessage = message.Body.Substring( message.Body.IndexOf("\r\n\r\n") + 4 );
actualMessage.TrimEnd('\r', '\n');
// locate content type in mime headers
Regex.Regex contentTypeRegex = new Regex.Regex(@"\r\nContent-Type:\s+(?<contentType>[^\;\s]+)");
Regex.Match contentTypeMatch = contentTypeRegex.Match(message.Body);
if (contentTypeMatch.Success)
{
string contentType = contentTypeMatch.Groups["contentType"].Value;
switch (contentType)
{
case "text/x-msmsgscontrol": // user typing notification
{
// get username of typing user
Regex.Regex notifyRegex = new Regex.Regex(@"TypingUser: (?<username>[^\r]+)");
Regex.Match notifyMatch = notifyRegex.Match(message.Body);
if (notifyMatch.Success)
{
this.control.TypingNotification(notifyMatch.Groups["username"].Value);
}
}
return;
case "text/x-msmsgsinvite": // file transfer, netmeeting invitation
return;
}
}
// find user's name
Regex.Regex regex = new Regex.Regex(@"(?<username>\S+)\s+(?<displayName>\S+)\s+\d+");
Regex.Match match = regex.Match(message.Header);
if (match.Success)
{
string username = match.Groups["username"].Value;
string displayName = match.Groups["displayName"].Value;
control.FriendSay(username, actualMessage);
}
}
private void OnJoinAfterInvite(MessageRouter router, Message message, object tag)
{
router.AddCodeEvent("JOI", new ResponseReceivedHandler(OnJoinReceived), null);
OnJoinReceived(router, message, null);
((OperationCompleteEvent)tag).Execute(new OperationCompleteArgs());
}
private void OnInviteFriendComplete(MessageRouter router, Message message, object tag)
{
router.RemoveMessageEvent(message);
}
private void onDisconnect(MessageRouter router, Message message, object tag)
{
if (ExpectingDisconnection)
this.connection.Disconnect();
else
{
if (this.onDisconnectHandler != null)
this.onDisconnectHandler(router, message, tag);
}
}
private void OnByeReceived(MessageRouter router, Message message, object tag)
{
Regex.Regex regex = new Regex.Regex(@"(?<username>\S*)\s*\d*");
Regex.Match match = regex.Match(message.Arguments);
if (match.Success)
{
string username = match.Groups["username"].Value;
control.FriendLeave(username);
}
}
private void OnAnswerResponse(MessageRouter router, Message message, object tag)
{
if (message.Arguments == "OK")
{
((OperationCompleteEvent)tag).Execute(new OperationCompleteArgs());
router.RemoveMessageEvent(message);
}
else
{
if (message.Code == "IRO")
{
Regex.Regex regex = new Regex.Regex(
@"(?<userNumber>\d+)\s+(?<totalUsers>\d+)\s+(?<username>\S+)\s+(?<screenName>.*$)"
);
Regex.Match match = regex.Match(message.Arguments);
if (match.Success)
{
string username = match.Groups["username"].Value;
control.FriendJoin(username);
}
}
}
}
