public FixtureFulltimeHandler(IGuildRepository teamRepo, ILogger <NearDeadlineHandler> logger, IGlobalSettingsClient settingsClient, IFixtureClient fixtureClient)
{
_teamRepo = teamRepo;
_logger = logger;
_settingsClient = settingsClient;
_fixtureClient = fixtureClient;
}
public AcceptInviteValidator(IInviteRepository inviteRepository,
IMemberRepository memberRepository,
IGuildRepository guildRepository)
{
RuleFor(x => x.Id)
.NotEmpty()
.MustAsync(async(id, _) => await inviteRepository.ExistsWithIdAsync(id))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Invite), x.Invite.Id));
RuleFor(x => x.Invite)
.NotEmpty().NotEqual(new NullInvite())
.WithMessage("Invite was null or empty.");
RuleFor(x => x.Invite.Status).IsInEnum().Equal(InviteStatuses.Pending);
RuleFor(x => x.Invite.MemberId)
.NotEmpty()
.MustAsync(async(memberId, _) => await memberRepository.ExistsWithIdAsync(memberId))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Member), x.Invite.MemberId));
RuleFor(x => x.Invite.GuildId)
.NotEmpty()
.MustAsync(async(guildId, _) => await guildRepository.ExistsWithIdAsync(guildId))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Guild), x.Invite.GuildId));
}
public UpdateGuildValidator(IGuildRepository guildRepository, IMemberRepository memberRepository)
{
RuleFor(x => x.Id)
.NotEmpty()
.MustAsync(async(id, cancellationToken) => await guildRepository.ExistsWithIdAsync(id, cancellationToken))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Guild), x.Id));
RuleFor(x => x.Name)
.NotEmpty()
.MustAsync(async(name, cancellationToken) =>
!await memberRepository.ExistsWithNameAsync(name, cancellationToken))
.WithMessage(x => CommonValidationMessages.ForConflictWithKey(nameof(Guild), x.Name))
.UnlessAsync(async(x, cancellationToken) =>
{
var member = await memberRepository.GetByNameAsync(x.Name, true, cancellationToken);
return(x.Id.Equals(member.Id));
});
RuleFor(x => x.MasterId)
.NotEmpty()
.MustAsync(async(masterId, cancellationToken) =>
await memberRepository.ExistsWithIdAsync(masterId, cancellationToken))
.WithMessage("Member chosen for Guild Master not found.");
RuleFor(x => x)
.MustAsync(async(x, cancellationToken) =>
(await memberRepository.GetByIdAsync(x.MasterId, true, cancellationToken))
.GuildId.Equals(x.Id))
.WithMessage("Member chosen for Guild Master must be a Member of target Guild.");
}
public AutoResponse(DiscordSocketClient client, IGuildRepository guildRepo)
{
_client = client;
_guildRepo = guildRepo;
_client.MessageReceived += OnMessage;
}
public UnitOfWork()
{
_context = new MyVolunteerAppContext();
_context.Database.EnsureCreated();
UserRepository = new UserRepository(_context);
GuildRepository = new GuildRepository(_context);
}
/// <summary>
/// Keeps trying to checkout a guild (with backoff) until either maxTimeout has been hit,
/// or a value has been returned that's not Locked.
/// </summary>
/// <param name="repo">A repo. May not be null.</param>
/// <param name="guildId">An id associated with a guild.</param>
/// <param name="maxTimeout">The maximum amount of time to spend waiting for this to unlock.</param>
/// <param name="recycleResult">A preallocated result that should be returned if passed in.</param>
/// <returns>The result.</returns>
public static async Task <GuildCheckoutResult> WaitForNotLockedCheckout(
this IGuildRepository repo,
Snowflake guildId,
TimeSpan maxTimeout,
GuildCheckoutResult recycleResult = null)
{
Stopwatch timer = new Stopwatch();
var retVal = recycleResult ?? new GuildCheckoutResult();
TimeSpan nextDelay = TimeSpan.FromMilliseconds(1);
timer.Start();
retVal = await repo.Checkout(guildId, retVal);
while (retVal.Result == GuildCheckoutResult.ResultType.Locked &&
timer.Elapsed + nextDelay < maxTimeout)
{
await Task.Delay(nextDelay);
retVal = await repo.Checkout(guildId, retVal);
nextDelay *= 1.5;
}
return(retVal);
}
public GuildsController(
IGuildRepository guildRepository,
IQueryProcessor queryProcessor)
{
_guildRepository = guildRepository;
_queryProcessor = queryProcessor;
}
public GuildHandler(DiscordSocketClient client, IGuildRepository guildRepository)
{
client.JoinedGuild += OnJoinedGuildAsync;
client.LeftGuild += OnLeftGuildAsync;
_guildRepository = guildRepository;
}
public MemberValidator(IGuildRepository guildRepository)
{
RuleFor(x => x.Data.Name).NotEmpty();
RuleFor(x => x.Data)
.Must(x => x.Memberships.All(m => m.MemberId.Equals(x.Id)))
.WithMessage(x =>
$"Not all {nameof(Membership)}s with '{nameof(Membership.MemberId)}' matching '{x.Data.Id}'.");
RuleFor(x => x.Data.GuildId).NotEmpty().Unless(x => x.Data.Guild is null);
RuleFor(x => x.Data.GuildId)
.MustAsync(async(guildId, _) => await guildRepository.ExistsWithIdAsync(guildId.Value))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Guild), x.Data.GuildId.Value))
.When(x => x.Data.GuildId.HasValue);
RuleFor(x => x.Data.Guild.Id)
.Equal(x => x.Data.GuildId.Value)
.WithMessage(x =>
$"{nameof(Member.GuildId)} and {nameof(Guild)}.{nameof(Member.Guild.Id)} not matching.")
.Unless(x => x.Data.Guild is null);
RuleFor(x => x)
.Must(x => x.Data.Memberships.Any(ms
=> ms.MemberId == x.Data.Id &&
ms.GuildId == x.Data.GuildId &&
ms.Until == null &&
!ms.Disabled))
.WithMessage(x =>
$"{nameof(Member)} missing active {nameof(Membership)} for {nameof(Member.GuildId)} '{x.Data.GuildId}'.")
.When(x => x.Data.Memberships.Any() && x.Data.GuildId.HasValue &&
!x.Data.GuildId.Equals(Guid.Empty));
}
public Factory(IGuildRepository guildRepository, ICharacterRepository characterRepository, GuildManagementContext guildContext, IBlizzardConnectionRepository blizzardRepository)
{
_guildRepository = guildRepository;
_characterRepository = characterRepository;
_guildContext = guildContext;
_blizzardRepository = blizzardRepository;
}
public UpdateGuildValidator(IGuildRepository guildRepository, IMemberRepository memberRepository)
{
RuleFor(x => x.Id).NotEmpty();
RuleFor(x => x.Name).NotEmpty();
RuleFor(x => x.LeaderId).NotEmpty();
When(x => x.Name != string.Empty && x.Id != Guid.Empty && x.LeaderId != Guid.Empty, () =>
{
RuleFor(x => x)
.MustAsync((x, ct) => guildRepository.ExistsWithIdAsync(x.Id, ct))
.WithMessage(x => $"Record not found for guild with given id {x.Id}.")
.WithName("Id")
.WithErrorCode(nameof(HttpStatusCode.NotFound))
.MustAsync((x, ct) => memberRepository.ExistsWithIdAsync(x.LeaderId, ct))
.WithMessage(x => $"Record not found for member with given id {x.LeaderId}.")
.WithName("LeaderId")
.WithErrorCode(nameof(HttpStatusCode.NotFound))
.MustAsync((x, ct) => guildRepository.CanChangeNameAsync(x.Id, x.Name, ct))
.WithMessage(x => $"Record already exists for guild with given name {x.Name}.")
.WithName("Name")
.WithErrorCode(nameof(HttpStatusCode.Conflict))
.MustAsync((x, ct) => memberRepository.IsGuildMemberAsync(x.LeaderId, x.Id, ct))
.WithMessage("Member chosen for Guild Master must be member of target Guild.")
.WithName("LeaderId")
.WithErrorCode(nameof(HttpStatusCode.UnprocessableEntity));
});
}
public CommandHandler(DiscordSocketClient client, IGuildRepository guildRepo)
{
GuildRepo = guildRepo;
Client = client;
RegisterCommands();
Client.MessageReceived += OnMessage;
}
public FixtureEventsHandler(IGuildRepository repo, ILogger <FixtureEventsHandler> logger, IGlobalSettingsClient globalSettingsClient, ILeagueEntriesByGameweek leagueEntriesByGameweek, ITransfersByGameWeek transfersByGameWeek)
{
_repo = repo;
_logger = logger;
_globalSettingsClient = globalSettingsClient;
_leagueEntriesByGameweek = leagueEntriesByGameweek;
_transfersByGameWeek = transfersByGameWeek;
}
public GameweekStartedHandler(IGuildRepository repo, ILeagueClient leagueClient, ICaptainsByGameWeek captainsByGameweek, ITransfersByGameWeek transfersByGameweek, ILogger <GameweekStartedHandler> logger)
{
_repo = repo;
_leagueClient = leagueClient;
_logger = logger;
_captainsByGameweek = captainsByGameweek;
_transfersByGameweek = transfersByGameweek;
}
public RankingCommandHandler(
IUserPointsRepository userPointsRepository,
IDiscordRestClient discordRestClient,
IGuildRepository guildRepository)
{
_userPointsRepository = userPointsRepository;
_discordRestClient = discordRestClient;
_guildRepository = guildRepository;
}
public GameweekFinishedHandler(IGuildRepository repo,
ILogger <GameweekFinishedHandler> logger,
IGlobalSettingsClient settingsClient,
ILeagueClient leagueClient)
{
_repo = repo;
_logger = logger;
_settingsClient = settingsClient;
_leagueClient = leagueClient;
}
public RoleAssignment(DiscordSocketClient client, IGuildRepository guildRepo)
{
GuildRepo = guildRepo;
Client = client;
Client.MessageReceived += OnMessage;
Client.ReactionAdded += OnReactionAdded;
Client.ReactionRemoved += OnReactionRemoved;
Client.RoleDeleted += OnRoleDeleted;
}
public Startup(ServiceProvider provider)
{
_serviceProvider = provider;
_secrets = provider.GetService <Secrets>();
_redditService = provider.GetService <RedditService>();
_channelRepo = provider.GetService <IChannelRepository>();
_messageRepo = provider.GetService <IMessageRepository>();
_prefixRepository = provider.GetService <IPrefixRepository>();
_guildRepository = provider.GetService <IGuildRepository>();
_client = new DiscordSocketClient();
_commands = new CommandService();
}
public BlackjackCommandHandler(
IDiscordRestClient discordRestClient,
IGuildRepository guildRepository,
IUserPointsRepository usersPointsRepository,
IBlackjackRepository blackjackRepository,
ITrackedMessageRepository trackedMessageRepository)
{
_discordRestClient = discordRestClient;
_guildRepository = guildRepository;
_usersPointsRepository = usersPointsRepository;
_blackjackRepository = blackjackRepository;
_trackedMessageRepository = trackedMessageRepository;
}
public UnitOfWork(
ApiContext context,
IGuildRepository guilds,
IMemberRepository members,
IInviteRepository invites,
IMembershipRepository memberships)
{
_context = context;
Guilds = guilds;
Members = members;
Invites = invites;
Memberships = memberships;
}
public ManageController(IAuthenticationRepository authRepository,
IAuthUserCharacterRepository authUserCharRepository, IShardRepository shardRepository, IGuildRepository guildRepository,
IGuildRankRepository guildRankRepository,
IAuthUserCharacterGuildApplicationRepository authUserCharacterGuildApplicationRepository, ILogger logger)
{
//_repository = repository;
_authRepository = authRepository;
_authUserCharRepository = authUserCharRepository;
_shardRepository = shardRepository;
_guildRepository = guildRepository;
_guildRankRepository = guildRankRepository;
_authUserCharacterGuildApplicationRepository = authUserCharacterGuildApplicationRepository;
_logger = logger;
}
public CreateGuildValidator(IGuildRepository guildRepository, IMemberRepository memberRepository)
{
RuleFor(x => x.Name)
.NotEmpty()
.MustAsync(async(name, cancellationToken) =>
!await guildRepository.ExistsWithNameAsync(name, cancellationToken))
.WithMessage(x => CommonValidationMessages.ForConflictWithKey(nameof(Guild), x.Name));
RuleFor(x => x.MasterId)
.NotEmpty()
.WithMessage("No Member key reference was used to created this the Guild as guild master.")
.MustAsync(async(masterId, cancellationToken) =>
await memberRepository.ExistsWithIdAsync(masterId, cancellationToken))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Member), x.MasterId));
}
public GuildController(ILogger logger, IGuildRepository guildRepository, IAuthenticationRepository authRepository,
IGuildRankRepository guildRankRepository, IAuthUserCharacterGuildApplicationRepository authUserCharacterGuildApplicationRepository,
IAuthUserCharacterRepository authUserCharacterRepository, ISessionRepository sessionRepository,
IEncounterRepository encounterRepository, IGuildStatusRepository guildStatusRepository, IBossFightRepository bossFightRepository)
{
_logger = logger;
_guildRepository = guildRepository;
_authRepository = authRepository;
_guildRankRepository = guildRankRepository;
_authUserCharacterGuildApplicationRepository = authUserCharacterGuildApplicationRepository;
_authUserCharacterRepository = authUserCharacterRepository;
_sessionRepository = sessionRepository;
_encounterRepository = encounterRepository;
_guildStatusRepository = guildStatusRepository;
_bossFightRepository = bossFightRepository;
}
public RecordsController(IEncounterDifficultyRepository difficultyRepository, ILogger logger,
ISessionRepository sessionRepository, IBossFightRepository bossFightRepository,
IEncounterRepository encounterRepository, IRecordsRepository recordsRepository,
IGuildRepository guildRepository, IRecordCharts recordCharts,
IAuthenticationRepository authRepository, IAuthUserCharacterRepository authUserCharacterRepository)
{
_difficultyRepository = difficultyRepository;
_logger = logger;
_sessionRepository = sessionRepository;
_bossFightRepository = bossFightRepository;
_encounterRepository = encounterRepository;
_recordsRepository = recordsRepository;
_guildRepository = guildRepository;
_recordCharts = recordCharts;
_authRepository = authRepository;
_authUserCharacterRepository = authUserCharacterRepository;
}
public UpdateMemberValidator(IMemberRepository memberRepository, IGuildRepository guildRepository)
{
RuleFor(x => x.Id)
.NotEmpty()
.MustAsync(async(id, _) => await memberRepository.ExistsWithIdAsync(id))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Member), x.Id));
RuleFor(x => x.Name)
.NotEmpty()
.MustAsync(async(name, _) => !await memberRepository.ExistsWithNameAsync(name))
.WithMessage(x => CommonValidationMessages.ForConflictWithKey(nameof(Member), x.Name))
.Unless(x => x.Id.Equals(memberRepository.Query().SingleOrDefault(y => y.Name.Equals(x.Name)).Id));
RuleFor(x => x.GuildId)
.MustAsync(async(guildId, _) => await guildRepository.ExistsWithIdAsync(guildId))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Guild), x.GuildId))
.When(x => x.GuildId != Guid.Empty && x.GuildId != null);
}
public async Task <IActionResult> SetOrUpdateGuildTax(
[FromBody] UpdateUserRoleBinding binding,
[FromRoute] GamerRank rank,
[FromServices] IGuildRepository guildRepository,
CancellationToken cancellationToken)
{
var guild = await guildRepository.Get(HttpContext.GetGuildId(), cancellationToken);
if (guild == null)
{
throw new ApiException(HttpStatusCode.NotFound, ErrorCodes.GuildNotFound, "Guild not found");
}
guild.AddOrUpdateRole(rank, binding.Tariff.LoanTax, binding.Tariff.ExpiredLoanTax, binding.Tariff.Tax);
guildRepository.Save(guild);
return(Ok(new { }));
}
public CreateGuildValidator(IGuildRepository guildRepository, IMemberRepository memberRepository)
{
RuleFor(x => x.Name).NotEmpty();
RuleFor(x => x.LeaderId).NotEmpty();
When(x => x.Name != string.Empty && x.LeaderId != Guid.Empty, () =>
{
RuleFor(x => x)
.MustAsync(async(x, ct) => !await guildRepository.ExistsWithNameAsync(x.Name, ct))
.WithMessage(x => $"Record already exists for guild with given name {x.Name}.")
.WithName(nameof(Member.Name))
.WithErrorCode(nameof(HttpStatusCode.Conflict))
.MustAsync((x, ct) => memberRepository.ExistsWithIdAsync(x.LeaderId, ct))
.WithMessage(x => $"Record not found for leader with given id {x.LeaderId}.")
.WithName(x => nameof(x.LeaderId))
.WithErrorCode(nameof(HttpStatusCode.NotFound));
});
}
public LeaveGuildValidator(IMemberRepository memberRepository, IGuildRepository guildRepository)
{
RuleFor(x => x.Id)
.NotEmpty()
.MustAsync(async(id, _) => await memberRepository.ExistsWithIdAsync(id))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Member), x.Id));
RuleFor(x => x.Member)
.NotEmpty().NotEqual(new NullMember())
.WithMessage("Member was null or empty.");
RuleFor(x => x.Member.GuildId)
.NotEmpty().WithMessage("Missing a guild key reference.");
var guildNotEmptyMessage = "Members out of a guild do not have one to leave from.";
RuleFor(x => x.Member.Guild)
.NotEmpty().WithMessage(guildNotEmptyMessage)
.NotEqual(new NullGuild()).WithMessage(guildNotEmptyMessage);
}
public HomeController(IAuthenticationRepository authRepository,
ISessionRepository sessionRepository, INavigationRepository navigationRepository,
IStatRepository statRepository, IGuildRepository guildRepository,
ISearchRepository searchRepository, IAuthUserCharacterRepository authUserCharacterRepository,
IBossFightRepository bossFightRepository, INewsRecentChangesRepository recentChanges,
ISiteNotificationRepository siteNotification, IRecurringTaskRepo recurringTaskRepo, IDiscordService discord)
{
_authRepository = authRepository;
_sessionRepository = sessionRepository;
_navigationRepository = navigationRepository;
_statRepository = statRepository;
_guildRepository = guildRepository;
_searchRepository = searchRepository;
_authUserCharacterRepository = authUserCharacterRepository;
_bossFightRepository = bossFightRepository;
_recentChanges = recentChanges;
_siteNotification = siteNotification;
_recurringTaskRepo = recurringTaskRepo;
_discord = discord;
}
public InviteMemberValidator(IMemberRepository memberRepository, IGuildRepository guildRepository)
{
RuleFor(x => x.MemberId)
.NotEmpty()
.MustAsync(async(memberId, _) => await memberRepository.ExistsWithIdAsync(memberId))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Member), x.MemberId));
RuleFor(x => x.GuildId)
.NotEmpty()
.MustAsync(async(guildId, _) => await guildRepository.ExistsWithIdAsync(guildId))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Guild), x.GuildId));
RuleFor(x => x)
.MustAsync(async(x, _) => !await guildRepository.ExistsAsync(y =>
y.Id.Equals(x.GuildId) &&
y.Members.Any(m => m.Id.Equals(x.MemberId))
))
.WithMessage(x => string.Format(
"{0} already in target {1} with key {2}", nameof(Member), nameof(Guild), x.GuildId));
}
