public void Build(HostPluginBuildContext ctx)
{
ctx.HostStarting += h =>
{
h.DependencyResolver.Register<ILeaderboardsService, LeaderboardsService>();
_apis.Get["/"] = _ =>
{
var service = h.DependencyResolver.Resolve<ILeaderboardsService>();
return service.ListLeaderboards().Result.Select(l => new LeaderboardDto { id = l.Name, name = l.Name, description = l.Description });
};
_apis.Get["/{id:string}/{skip:int}/{take:int}"] = parameters =>
{
var service = h.DependencyResolver.Resolve<ILeaderboardsService>();
var id = (string)parameters.id;
var skip = (int)parameters.skip;
var take = (int)parameters.take;
var leaderboard = service.GetLeaderboard(id).Result;
var scores = leaderboard.GetScores(skip, take).Result;
var scores2 = scores.Select(s => new LeaderboardScoreDto { userid = s.UserId, username = s.Username, score = s.Value, leaderboard = s.Leaderboard });
return new LeaderboardDto { id = leaderboard.Name, name = leaderboard.Name, description = leaderboard.Description, scores = scores2.ToArray() };
};
};
}
public void Build(HostPluginBuildContext ctx)
{
//ctx.HostStarting += HostStarting;
ctx.SceneDependenciesRegistration += SceneDependenciesRegistration;
ctx.SceneCreated += SceneCreated;
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostStarting += h =>
{
h.DependencyResolver.Register<IESClientFactory, ESClientFactory>();
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += (IDependencyBuilder b) =>
{
b.Register <ESClientFactory>().As <IESClientFactory>().SingleInstance();
b.Register <ESClientFactoryEventHandler>().As <IESClientFactoryEventHandler>();
SmartFormat.Smart.Default.AddExtensions(new TimeIntervalFormatter());
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
new ChatServer(scene);
}
};
}
public void Build(HostPluginBuildContext ctx)
{
//ctx.HostStarting += HostStarting;
ctx.SceneDependenciesRegistration += SceneDependenciesRegistration;
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <GameFinderController>();
builder.Register <GameFinderService>().As <IGameFinderService>().InstancePerScene();
builder.Register <GameFinderData>().AsSelf().InstancePerScene();
};
ctx.SceneCreated += SceneCreated;
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <UsersTestController>().InstancePerRequest();
};
ctx.SceneDependenciesRegistration += (IDependencyBuilder builder, ISceneHost scene) => {
if (scene.Template == UsersManagementPlugin.SCENE_TEMPLATE)
{
builder.Register <TestAuthenticationProvider>().As <IAuthenticationProvider>();
}
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <LogsController>().InstancePerRequest();
};
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
scene.AddController <LogsController>();
}
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.SceneDependenciesRegistration += (IDependencyBuilder builder, ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
builder.Register <ChatService>().As <IChatService>().InstancePerScene();
builder.Register <UserInfoChatEventHandler>().As <IChatUserInfoEventHandler>();
builder.Register <ChatAntiFlood>().As <IChatEventHandler>().InstancePerScene();
//builder.Register<ChatService.Accessor>();
builder.Register <ChatController>().InstancePerRequest();
}
};
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
scene.AddController <ChatController>();
scene.DependencyResolver.Resolve <IChatService>();
//scene.DependencyResolver.Resolve<ChatService.Accessor>();
}
};
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <ESChatLogRepository>().As <IChatRepository>().SingleInstance();
builder.Register <ChatWebApiConfig>().As <IAdminWebApiConfig>();
builder.Register <ChatAdminController>();
};
ctx.HostStarted += (IHost host) =>
{
_host = host;
_config = host.DependencyResolver.Resolve <IConfiguration>();
_config.SettingsChanged += OnSettingsChange;
OnSettingsChange(_config, _config.Settings);
_chatLogRepository = host.DependencyResolver.Resolve <IChatRepository>();
_flushTask = Task.Run(() => FlushSchedule(), _cts.Token);
};
ctx.HostShuttingDown += (IHost host) =>
{
_cts.Cancel();
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <Plugins.Nat.NatUserSessionEventHandler>().As <IUserSessionEventHandler>();
builder.Register <NatController>().InstancePerRequest();
builder.Register <NatIndex>().SingleInstance();
};
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
scene.AddController <NatController>();
}
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <SerialsService>().As <ISerialsService>();
builder.Register <AdminWebApiConfig>().As <IAdminWebApiConfig>();
builder.Register <SerialsController>().InstancePerRequest();
builder.Register <SerialsAdminController>();
};
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
scene.AddController <SerialsController>();
}
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.SceneDependenciesRegistration += (IDependencyBuilder builder, ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
builder.Register <PlayerDataService>().As <IPlayerDataService>().SingleInstance();
builder.Register <PlayerDataController>().InstancePerRequest();
}
};
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
scene.AddController <PlayerDataController>();
}
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostStarting += (Stormancer.Server.IHost host) =>
{
host.RegisterAdminApiFactory((builder, scene) =>
{
var type = typeof(Microsoft.Owin.Builder.AppBuilder);
var config = new HttpConfiguration();
config.DependencyResolver = new DependencyResolver(scene.DependencyResolver);
var configurators = host.DependencyResolver.ResolveAll <IAdminWebApiConfig>();
foreach (var c in configurators)
{
c.Configure(config);
}
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
builder.UseWebApi(config);
});
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.SceneDependenciesRegistration += (IDependencyBuilder builder, ISceneHost scene) =>
{
if (scene.Template == UsersManagementPlugin.SCENE_TEMPLATE)
{
builder.Register <LocatorController>().InstancePerRequest();
}
};
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <ServiceLocator>().As <IServiceLocator>().InstancePerRequest();
};
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Template == UsersManagementPlugin.SCENE_TEMPLATE)
{
scene.AddController <LocatorController>();
}
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <TransactionController>().InstancePerRequest();
};
ctx.SceneDependenciesRegistration += (IDependencyBuilder builder, ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
builder.Register <TurnBasedGame>().InstancePerScene();
}
};
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
scene.AddController <TransactionController>();
scene.DependencyResolver.Resolve <TurnBasedGame>();
}
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
var prefix = scene.Metadata[METADATA_KEY];
var config = scene.DependencyResolver.Resolve <IConfiguration>();
var environment = scene.DependencyResolver.Resolve <IEnvironment>();
environment.ActiveDeploymentChanged += (sender, v) =>
{
if (!environment.IsActive)
{
scene.Broadcast("serverVersion.update", v.ActiveDeploymentId);
}
};
string currentGameVersion = GetVersion(config.Settings, prefix);
config.SettingsChanged += (sender, v) =>
{
var newGameVersion = GetVersion(v, prefix);
if (newGameVersion != currentGameVersion)
{
currentGameVersion = newGameVersion;
scene.Broadcast("gameVersion.update", currentGameVersion);
}
};
scene.Connected.Add(p =>
{
p.Send("gameVersion.update", currentGameVersion);
return(Task.FromResult(true));
});
}
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += (builder) =>
{
builder.Register <ProfileService>().As <IProfileService>();
builder.Register <ProfilesUserEventHandler>().As <IUserEventHandler>();
};
ctx.SceneDependenciesRegistration += (IDependencyBuilder builder, ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(TurnByTurnPlugin.METADATA_KEY))
{
builder.Register <GameSessionEventHandler>().As <IGameSessionEventHandler>().InstancePerScene();
}
};
ctx.HostStarted += (IHost host) =>
{
// Create PlayerProfile mapping
var clientFactory = host.DependencyResolver.Resolve <IESClientFactory>();
var environment = host.DependencyResolver.Resolve <IEnvironment>();
var _ = Task.Run(async() =>
{
var client = await clientFactory.CreateClient((string)environment.Configuration.index);
await client.MapAsync <PlayerProfile>(m =>
m.Properties(p =>
p.String(s =>
s.Name(profile => profile.PlayerId)
.Index(FieldIndexOption.NotAnalyzed)
)
)
);
});
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <AnalyticsController>().InstancePerRequest();
builder.Register <AnalyticsService>().As <IAnalyticsService>().SingleInstance();
//builder.Register<AnalyticsEventHandler>().As<IUserSessionEventHandler>().As<IApiHandler>().SingleInstance();
};
ctx.HostStarted += (IHost host) =>
{
Task.Run(async() =>
{
while (true)
{
try
{
await Task.Delay(1000 * 5);
var analyticsService = host.DependencyResolver.Resolve <IAnalyticsService>();
await analyticsService.Flush();
}
catch (Exception ex)
{
host.DependencyResolver.Resolve <ILogger>().Log(LogLevel.Error, "analytics", "failed to push analytics", ex);
}
}
});
};
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
scene.AddController <AnalyticsController>();
}
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += (IDependencyBuilder builder) =>
{
builder.Register <AssetsStorageService>().As <IAssetsStorageService>();
builder.Register <AssetsStorageController>().InstancePerRequest();
builder.Register <AssetsStorageWebApiConfig>().As <IAdminWebApiConfig>();
builder.Register <AssetsStorageAdminController>();
builder.Register <ESAssetsStorageRepository>().As <IAssetsStorageRepository>().SingleInstance();
builder.Register <AssetsStorageService.Accessor>();
};
ctx.SceneCreated += (ISceneHost scene) =>
{
if (scene.Metadata.ContainsKey(METADATA_KEY))
{
scene.AddController <AssetsStorageController>();
}
};
ctx.HostStarted += (IHost host) =>
{
_host = host;
_config = host.DependencyResolver.Resolve <IConfiguration>();
_config.SettingsChanged += OnSettingsChange;
OnSettingsChange(_config, _config.Settings);
_assetStorageRepo = host.DependencyResolver.Resolve <IAssetsStorageRepository>();
_flushTask = Task.Run(() => FlushSchedule(), _cts.Token);
};
ctx.HostShuttingDown += (IHost host) =>
{
_cts.Cancel();
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += RegisterHost;
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostDependenciesRegistration += builder => builder.Register <DefaultConfiguration>().As <IConfiguration>();
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostStarting += OnHostStarting;
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostStarting += h => {
h.DependencyResolver.Register<ManagementClientAccessor, ManagementClientAccessor>();
};
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostStarting += HostStarting;
ctx.HostStarted += HostStarted;
ctx.HostDependenciesRegistration += RegisterDependencies;
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostStarting += HostStarting;
ctx.HostStarted += HostStarted;
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostStarted += HostStarted;
ctx.HostShuttingDown += HostShuttingDown;
}
public void Build(HostPluginBuildContext ctx)
{
ctx.HostStarting += RegisterHost;
}
