public void Test_Client_Can_Create_MessageHandlerService_From_DependencyModules()
{
//TODO: This won't work if we have multiple configurable modules.
//arrange
ContainerBuilder builder = TestIoC.CreateDefaultContainer();
IContainer resolver = builder.Build();
MessageHandlerService <GameServerPacketPayload, GameClientPacketPayload> handler = null;
//act
try
{
handler = resolver.Resolve <MessageHandlerService <GameServerPacketPayload, GameClientPacketPayload> >();
}
catch (DependencyResolutionException e)
{
//This makes it so the error is more readable. So we can see the exact dependency that is missing.
DependencyResolutionException dependencyResolveException = e;
while (dependencyResolveException.InnerException is DependencyResolutionException)
{
dependencyResolveException = (DependencyResolutionException)dependencyResolveException.InnerException;
}
Assert.Fail($"Failed: {dependencyResolveException.Message}\n\n{dependencyResolveException.StackTrace}");
}
//assert
Assert.NotNull(handler);
}
/// <inheritdoc />
public DefaultManagedClientSessionFactory(
[NotNull] ILog logger,
[NotNull] MessageHandlerService <BaseGameClientPayload, BaseGameServerPayload, IPeerSessionMessageContext <BaseGameServerPayload> > handlerService)
{
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
HandlerService = handlerService ?? throw new ArgumentNullException(nameof(handlerService));
}
//Turn Related Material
public Timer turnSpanner(MessageHandlerService instance, Timer initTimer, GameRoom room)
{
if (turn == 0)
{
initTimer.Dispose();
timer2 = enableActions();
timer3 = executeActionsTimer(room);
}
TimeSpan startTimeSpan = TimeSpan.Zero;
TimeSpan periodTimeSpan = TimeSpan.FromSeconds(60);
Timer timer = new Timer(async(e) =>
{
if (turn != 0)
{
editable = false;
GameRequest GameRequest = new GameRequest();
GameRequest.EventType = "UpdateInformation";
try
{
await instance.updateTurnAsync(GameRequest, room, "server");
} catch (HttpRequestException exc)
{
Console.WriteLine("Server could not parse user data;\n" + exc.ToString());
}
canMakeEditable = true;
}
Console.WriteLine("Editable? =>" + editable);
turn++;
}, null, startTimeSpan, periodTimeSpan);
return(timer);
}
internal async Task ConnectAsync(DiscordBotConfig config)
{
Log.Information("Initializing connection.");
_commandHandler = new CommandHandlerService(_client, _logger, config, _service, _serviceProvider);
_messageHandler = new MessageHandlerService(_client, _logger, config, _levelingService, _userAccountRepository);
_userEventsHandler = new UserEventsHandlerService(_client, _logger, config, _userAccountRepository);
_client.Log += _logger.Log;
_client.Ready += ReadyAsync;
if (config.Token == null || config.Token == "")
{
throw new ArgumentNullException("Token", "Discord Bot Token is empty!");
}
if (config.CmdPrefix == null || config.CmdPrefix == "")
{
throw new ArgumentNullException("cmdPrefix", "Discord Bot cmdPrefix is empty!");
}
await _client.LoginAsync(TokenType.Bot, config.Token);
await _client.StartAsync();
await _commandHandler.InitializeAsync();
_messageHandler.Initialize();
_userEventsHandler.Initialize();
await Task.Delay(-1);
}
public Startup(IServiceProvider services)
{
_services = services;
_client = _services.GetRequiredService <DiscordSocketClient>();
_commands = _services.GetRequiredService <CommandService>();
_log = _services.GetRequiredService <LogService>();
_messageHandler = _services.GetRequiredService <MessageHandlerService>();
_tokens = _services.GetRequiredService <Tokens>();
}
/// <inheritdoc />
public ZoneClientSession(IManagedNetworkServerClient <GameServerPacketPayload, GameClientPacketPayload> internalManagedNetworkClient,
SessionDetails details,
MessageHandlerService <GameClientPacketPayload, GameServerPacketPayload, IPeerSessionMessageContext <GameServerPacketPayload> > messageHandlers,
[NotNull] ILog logger)
: base(internalManagedNetworkClient, details)
{
MessageHandlers = messageHandlers ?? throw new ArgumentNullException(nameof(messageHandlers));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <inheritdoc />
protected BaseUnityNetworkClient(
MessageHandlerService <TIncomingPayloadType, TOutgoingPayloadType> handlers,
ILog logger,
IPeerMessageContextFactory messageContextFactory)
{
Handlers = handlers;
Logger = logger;
MessageContextFactory = messageContextFactory;
}
/// <inheritdoc />
public DefaultManagedClientSessionFactory(
[NotNull] ILog logger,
[NotNull] MessageHandlerService <GameClientPacketPayload, GameServerPacketPayload, IPeerSessionMessageContext <GameServerPacketPayload> > handlerService,
[NotNull] IRegisterable <int, ZoneClientSession> sessionRegisterable)
{
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
HandlerService = handlerService ?? throw new ArgumentNullException(nameof(handlerService));
SessionRegisterable = sessionRegisterable ?? throw new ArgumentNullException(nameof(sessionRegisterable));
}
/// <inheritdoc />
public AuthServerClientSession(IManagedNetworkServerClient <AuthenticationServerPayload, AuthenticationClientPayload> internalManagedNetworkClient, SessionDetails details,
[NotNull] MessageHandlerService <AuthenticationClientPayload, AuthenticationServerPayload, IPeerSessionMessageContext <AuthenticationServerPayload> > authMessageHandlerService)
: base(internalManagedNetworkClient, details)
{
if (authMessageHandlerService == null)
{
throw new ArgumentNullException(nameof(authMessageHandlerService));
}
AuthMessageHandlerService = authMessageHandlerService;
}
public HackyInstanceSharedClientData([NotNull] INetworkSerializationService serializerService,
[JetBrains.Annotations.NotNull] MessageHandlerService <GameServerPacketPayload, GameClientPacketPayload> messageHandler,
[JetBrains.Annotations.NotNull] IPeerMessageContextFactory messageContextFactory,
[JetBrains.Annotations.NotNull] IConnectionService connectionService,
[JetBrains.Annotations.NotNull] IPeerPayloadSendService <GameClientPacketPayload> sendService)
{
SerializerService = serializerService ?? throw new ArgumentNullException(nameof(serializerService));
MessageHandler = messageHandler ?? throw new ArgumentNullException(nameof(messageHandler));
MessageContextFactory = messageContextFactory ?? throw new ArgumentNullException(nameof(messageContextFactory));
ConnectionService = connectionService ?? throw new ArgumentNullException(nameof(connectionService));
SendService = sendService ?? throw new ArgumentNullException(nameof(sendService));
}
public View(DiscordService discord,
MessageHandlerService messageHandler,
ReactionHandlerService reactionHandler,
InteractiveManager interactive,
FeedChannelUpdateService feedChannelUpdater)
{
_discord = discord;
_messageHandler = messageHandler;
_reactionHandler = reactionHandler;
_interactive = interactive;
_feedChannelUpdater = feedChannelUpdater;
}
/// <summary>
/// Implements must override this and implement domain-specific message handling logic.
/// </summary>
/// <param name="message">The message to handle.</param>
/// <param name="context">The actor message context.</param>
/// <returns>True if the message was successfully handled.</returns>
protected Task <bool> HandleMessageAsync(EntityActorMessage message, EntityActorMessageContext context)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(MessageHandlerService.HandleMessageAsync(context, message, CancellationToken.None));
}
/// <inheritdoc />
public ProxiedManagedClientSession(IManagedNetworkServerClient <TPayloadWriteType, TPayloadReadType> internalManagedNetworkClient, SessionDetails details,
[NotNull] MessageHandlerService <TPayloadReadType, TPayloadWriteType, TMessageContextType> authMessageHandlerService,
IGenericMessageContextFactory <TPayloadWriteType, TMessageContextType> messageContextFactory)
: base(internalManagedNetworkClient, details)
{
if (authMessageHandlerService == null)
{
throw new ArgumentNullException(nameof(authMessageHandlerService));
}
AuthMessageHandlerService = authMessageHandlerService;
MessageContextFactory = messageContextFactory;
}
/// <inheritdoc />
public GameNetworkClient(MessageHandlerService <GameServerPacketPayload, GameClientPacketPayload> handlers, ILog logger, IPeerMessageContextFactory messageContextFactory)
: base(handlers, logger, messageContextFactory)
{
}
/// <inheritdoc />
public GenericProxiedManagedClientSession(IManagedNetworkServerClient <TPayloadWriteType, TPayloadReadType> internalManagedNetworkClient, SessionDetails details, [NotNull] MessageHandlerService <TPayloadReadType, TPayloadWriteType, IProxiedMessageContext <TPayloadWriteType, TPayloadReadType> > authMessageHandlerService, IGenericMessageContextFactory <TPayloadWriteType, IProxiedMessageContext <TPayloadWriteType, TPayloadReadType> > messageContextFactory)
: base(internalManagedNetworkClient, details, authMessageHandlerService, messageContextFactory)
{
}