public ChatBusiness(IHubContext <ChatHub, IChatClient> context, IMessageBusiness messageBusiness, IPlayerService playerService, IGuildService guildService)
{
_context = context;
_messageBusiness = messageBusiness;
_playerService = playerService;
_guildService = guildService;
}
public GuildCommands(
IGuildService guildService,
IEmbedContentBuilder embedContentBuilder)
{
_guildService = guildService;
_embedContentBuilder = embedContentBuilder;
}
/// <summary>
/// Create a new CommandManager instance with DI. Use <see cref="StartAsync"/> afterwards to actually start the CommandManager/>
/// </summary>
public CommandManager(IServiceProvider serviceProvider)
{
this.serviceProvider = serviceProvider;
discordClient = serviceProvider.GetRequiredService <DiscordSocketClient>();
commandService = serviceProvider.GetRequiredService <CommandService>();
guildService = serviceProvider.GetRequiredService <IGuildService>();
}
public BattlefieldNewsService(DiscordSocketClient discordClient, IGuildService guildService, ISchedulingService schedulingService, ILogger <BattlefieldNewsService> logger)
{
this.discordClient = discordClient;
this.guildService = guildService;
this.schedulingService = schedulingService;
this.logger = logger;
}
public BattlefieldNewsService(DiscordClient discordClient, IGuildService guildService, ISchedulingService schedulingService, ILogger <BattlefieldNewsService> logger)
{
_discordClient = discordClient;
_guildService = guildService;
_schedulingService = schedulingService;
_logger = logger;
}
private SwgohService(
IPlayerService playerService,
IGuildService guildService)
{
this._playerService = playerService;
this._guildService = guildService;
}
public GuildController(
IRaidService raidService,
IGuildService guildService)
{
this.raidService = raidService;
this.guildService = guildService;
}
public RealmStoreById(IGuildService guildService, IMemoryCache memoryCache, GuildToolsContext context, IKeyedResourceManager resourceManager)
{
this.MemoryDuration = TimeSpan.FromDays(1);
this.guildService = guildService;
this.context = context;
this.cache = new MemoryCachedDatabaseValue <StoredRealm>(memoryCache, this.MemoryDuration, resourceManager);
}
public static void CreateGuild(string name)
{
API.Guild.Models.CreateGuild guild = new API.Guild.Models.CreateGuild();
guild.Name = name;
IGuildService guildservice = AuthenticatedRestFactory.GetGuildService();
guildservice.CreateGuild(guild);
}
public static void ModifyGuildMemberNickname(string guildId, string userId, string nickname)
{
IGuildService guildservice = AuthenticatedRestFactory.GetGuildService();
guildservice.ModifyGuildMemberNickname(guildId, userId, new ModifyGuildMember()
{
Nick = nickname
});
}
public GuildsController(
IGuildService guildService,
IMapper mapper,
IOptions <AppSettings> appSettings)
{
_guildService = guildService;
_mapper = mapper;
_appSettings = appSettings.Value;
}
public PluginService(IPluginRepository pluginRepository, IGuildService guildService,
IUserService userService, ILogService logService, IBotService botService)
{
_pluginRepository = pluginRepository;
_guildService = guildService;
_userService = userService;
_logService = logService;
_botService = botService;
}
public GuildInfoModule(
IGuildService guildService,
IMessageRepository messageRepository,
IHttpClientFactory httpClientFactory)
{
GuildService = guildService;
MessageRepository = messageRepository;
HttpClientFactory = httpClientFactory;
}
public AuthController(UserManager <User> userManager,
IDiscordDataService discordDataService, IUserService userService,
IConfiguration configuration, IGuildService guildService)
{
_userManager = userManager;
_discordDataService = discordDataService;
_userService = userService;
_configuration = configuration;
_guildService = guildService;
}
public PlayerStoreByValue(
IGuildService guildService,
IMemoryCache memoryCache,
GuildToolsContext context,
IKeyedResourceManager resourceManager)
{
this.guildService = guildService;
this.context = context;
this.cache = new MemoryCachedDatabaseValueWithSource <StoredPlayer>(memoryCache, this.MemoryDuration, resourceManager);
}
public GuildServiceTests()
{
_monkeyDbContext = new Mock <MonkeyDBContext>();
var guildConfigs = PrepareGuildConfigs(100, 4);
_mockGuildConfig = _monkeyDbContext.SetDbSetData(guildConfigs, c => c.GuildConfigs);
guildService = new GuildService(_monkeyDbContext.Object);
}
public GuildInfoModule(
IGuildService guildService,
IMessageRepository messageRepository,
IEmojiRepository emojiRepository,
IImageService imageService)
{
_guildService = guildService;
_messageRepository = messageRepository;
_emojiRepository = emojiRepository;
_imageService = imageService;
}
public UsersController(
IUserService userService,
IGuildService guildService,
IDiscordDataService discordDataService, UserManager <User> userManager
)
{
_userService = userService;
_guildService = guildService;
_discordDataService = discordDataService;
_userManager = userManager;
}
public SwitchRequestCommands(
ISwitchRequestService switchRequestService,
IGuildService guildService,
IGuildMemberService guildMemberService,
IEmbedContentBuilder embedContentBuilder)
{
_switchRequestService = switchRequestService;
_guildService = guildService;
_guildMemberService = guildMemberService;
_embedContentBuilder = embedContentBuilder;
}
public MonkeyClient(IGuildService guildService, ILogger <MonkeyClient> logger) : base(discordConfig)
{
this.logger = logger;
this.guildService = guildService;
Connected += Client_ConnectedAsync;
UserJoined += Client_UserJoinedAsync;
UserLeft += Client_UserLeftAsync;
JoinedGuild += Client_JoinedGuildAsync;
LeftGuild += Client_LeftGuildAsync;
GuildMemberUpdated += Client_GuildMemberUpdateAsync;
Log += MonkeyClient_LogAsync;
}
public MonkeyHelpFormatter(CommandContext ctx, IGuildService guildService) : base(ctx)
{
_embedBuilder = new DiscordEmbedBuilder()
.WithTitle("Help")
.WithColor(DiscordColor.CornflowerBlue)
.WithThumbnail("https://cdn.discordapp.com/emojis/899999039620259850.png?size=40");
if (ctx.Guild != null && guildService != null)
{
prefix = guildService.GetPrefixForGuild(ctx.Guild.Id).GetAwaiter().GetResult();
}
}
public GuildsController(
IBotService botService,
UserManager <User> userManager,
IGuildService guildService,
IMapper mapper
)
{
_botService = botService;
_userManager = userManager;
_guildService = guildService;
_mapper = mapper;
}
public static async void AckGuild(string guildId)
{
try
{
IGuildService guildservice = AuthenticatedRestFactory.GetGuildService();
await guildservice.AckGuild(guildId);
}
catch (Exception exception)
{
//App.NavigateToBugReport(exception);
}
}
public static void ModifyGuildRole(string guildId, string roleId, ModifyGuildRole newRole)
{
try
{
IGuildService guildservice = AuthenticatedRestFactory.GetGuildService();
guildservice.ModifyGuildRole(guildId, roleId, newRole).Wait();
}
catch (Exception exception)
{
App.NavigateToBugReport(exception);
}
}
/// <summary>
/// Creates and returns the Timer regardless of business errors.
/// </summary>
public static async Task <Timer> GetOrCreateTimerAsync(
this IGuildService service, GuildUserReference guildUser)
{
try
{
return(await service.GetTimerAsync(guildUser));
}
catch (EntityNullException <Timer> )
{
return(await service.CreateTimerAsync(guildUser));
}
}
public static void DeleteGuild(string guildid)
{
try
{
IGuildService guildservice = AuthenticatedRestFactory.GetGuildService();
guildservice.DeleteGuild(guildid).Wait();
}
catch (Exception exception)
{
App.NavigateToBugReport(exception);
}
}
/// <summary>
/// Creates and returns the LocalExperience regardless of business errors.
/// </summary>
public static async Task <LocalExperience> GetOrCreateLocalExperienceAsync(
this IGuildService service, GuildUserReference guildUser)
{
try
{
return(await service.GetLocalExperienceAsync(guildUser));
}
catch (EntityNullException <LocalExperience> )
{
return(await service.CreateLocalExperienceAsync(guildUser));
}
}
public OldGuildMemberCache(
IGuildService guildMemberService,
IDataRepository dataRepository,
IBackgroundTaskQueue backgroundTaskQueue)
{
this.cache = new Dictionary <string, ExpiringData <IEnumerable <GuildMemberStats> > >();
this.guildMemberService = guildMemberService;
this.updatingSet = new HashSet <string>();
this.dataRepository = dataRepository;
this.backgroundTaskQueue = backgroundTaskQueue;
}
public LoginStage(
LoginStageConfig config,
ILogger <IStage <LoginStage, LoginStageUser> > logger,
IServerRegistry serverRegistry,
ISessionRegistry sessionRegistry,
IMigrationRegistry migrationRegistry,
IGuildService guildService,
IPartyService partyService,
IAccountRepository accountRepository,
IAccountWorldRepository accountWorldRepository,
ICharacterRepository characterRepository,
ITickerManager timerManager,
IPacketProcessor <LoginStage, LoginStageUser> processor,
ITemplateRepository <WorldTemplate> worldTemplates,
ITemplateRepository <ItemTemplate> itemTemplates
) : base(
ServerStageType.Login,
config,
logger,
serverRegistry,
sessionRegistry,
migrationRegistry,
accountRepository,
accountWorldRepository,
characterRepository,
timerManager,
processor
)
{
Logger = logger;
GuildService = guildService;
PartyService = partyService;
WorldTemplates = worldTemplates;
ItemTemplates = itemTemplates;
processor.Register(new CheckPasswordHandler(this));
processor.Register(new WorldInfoRequestHandler());
processor.Register(new SelectWorldHandler());
processor.Register(new CheckUserLimitHandler());
processor.Register(new SetGenderHandler());
processor.Register(new CheckPinCodeHandler());
processor.Register(new WorldRequestHandler());
processor.Register(new LogoutWorldHandler());
processor.Register(new CheckDuplicatedIDHandler());
processor.Register(new CreateNewCharacterHandler());
processor.Register(new DeleteCharacterHandler());
processor.Register(new ExceptionLogHandler(this));
processor.Register(new EnableSPWRequestHandler(false));
processor.Register(new CheckSPWRequestHandler(false));
}
public static async Task <IEnumerable <SharedModels.GuildMember> > GetGuildMembers(string id)
{
try
{
IGuildService guildservice = AuthenticatedRestFactory.GetGuildService();
return(await guildservice.ListGuildMemebers(id));
}
catch (Exception exception)
{
App.NavigateToBugReport(exception);
}
return(null);
}
public override bool OnStart()
{
// Autofac setup.
var builder = new ContainerBuilder();
IoC.RegisterServices(builder);
var container = builder.Build();
// Assign injections.
this._guildsQueueClient = container.Resolve<IQueueClientWrapper<ProcessRealmGuildsRequest>>();
this._guildService = container.Resolve<IGuildService>();
Trace.TraceInformation("WoW.Crawler.Guild.Worker has been started");
return base.OnStart();
}
public WvWController(IWvWService wvwService, IPlayerService playerService, IHasWvWMap hasMap, IGuildService guildService, WvWUserData userData)
{
logger.Debug("Initializing WvW Controller");
this.wvwService = wvwService;
this.playerService = playerService;
this.guildService = guildService;
this.currentMap = hasMap;
this.userData = userData;
this.timerCount = 0;
this.isStopped = false;
// Initialize the refresh timer
this.objectivesRefreshTimer = new Timer(this.Refresh);
this.ObjectivesRefreshInterval = 500;
// Initialize the start call count to 0
this.startCallCount = 0;
// Initialize the collections, but do it on a seperate thread since it can take a little time
logger.Info("WvW Controller initialized");
}
