public PlayerManager(IUserStore <Player> store, IdentityFactoryOptions <PlayerManager> options,
IMapper mapper, IAchievementRepository achievementRepository,
IPlayerAchievementRepository playerAchievementRepository)
: base(store)
{
_achievementRepository = achievementRepository;
_playerAchievementRepository = playerAchievementRepository;
_mapper = mapper;
// Configure validation logic for usernames
this.UserValidator = new UserValidator <Player>(this)
{
AllowOnlyAlphanumericUserNames = true,
RequireUniqueEmail = true,
};
// Configure validation logic for passwords
this.PasswordValidator = new PasswordValidator
{
RequiredLength = 6,
RequireNonLetterOrDigit = true,
RequireDigit = true,
RequireLowercase = false,
RequireUppercase = false,
};
// Configure user lockout defaults
this.UserLockoutEnabledByDefault = true;
this.DefaultAccountLockoutTimeSpan = TimeSpan.FromMinutes(5);
this.MaxFailedAccessAttemptsBeforeLockout = 5;
}
public ProfileController(IUserInfoRepository userInfo, IUnitOfWork unitOfWork, IAchievementRepository achievements, IFeedbackRepository feedbacks)
{
_userInfo = userInfo;
_unitOfWork = unitOfWork;
_achievements = achievements;
_feedbacks = feedbacks;
}
public CreateAchievementModelValidator
(
IAchievementRepository achievementRepository,
IStringLocalizer <ValidatorMessages> stringLocalizer,
IActionContextAccessor actionContextAccessor
) : base(stringLocalizer, actionContextAccessor)
{
_achievementRepository = achievementRepository;
RuleFor(achievement => achievement.Name)
.NotEmpty().WithMessage(_stringLocalizer["EmptyField"])
.MaximumLength(70).WithMessage(_stringLocalizer["TooLong"])
.MustAsync(CheckNameAsync).WithMessage(_stringLocalizer["UniqueName"]);
RuleFor(achievement => achievement.Description)
.NotEmpty().WithMessage(_stringLocalizer["EmptyField"])
.MaximumLength(250);
RuleFor(achievement => achievement.XP)
.NotEmpty().WithMessage(_stringLocalizer["EmptyField"])
.GreaterThanOrEqualTo(0).WithMessage(_stringLocalizer["SmallValue"]);
RuleFor(achievement => achievement.Icon)
.NotEmpty().WithMessage(_stringLocalizer["EmptyField"]);
}
public SteamAchievementStorage(IAchievementRepository achievementRepository,
IFileReader reader, StorageId storageId)
{
this.achievementRepository = achievementRepository;
this.reader = reader;
this.storageId = storageId;
}
public FeedbackController(UserManager <User> userManager, IFeedbackRepository repository, IAchievementRepository achievementRepository, IUnitOfWork unitOfWork, IUserInfoRepository userInfo)
{
_userManager = userManager;
_achievements = achievementRepository;
_unitOfWork = unitOfWork;
_repository = repository;
_userInfo = userInfo;
}
public FlyingController(
IAchievementRepository achievementRepository,
ICharacterAchievementRepository characterAchievementRepository)
{
_achievementRepository = achievementRepository;
_characterAchievementRepository = characterAchievementRepository;
_achievementsService = new AchievementsService(_achievementRepository);
}
public AchievementService(IAcademicYearRepository academicYearRepository,
IAchievementRepository achievementRepository, IAchievementTypeRepository achievementTypeRepository,
IAchievementOutcomeRepository achievementOutcomeRepository)
{
_academicYearRepository = academicYearRepository;
_achievementRepository = achievementRepository;
_achievementTypeRepository = achievementTypeRepository;
_achievementOutcomeRepository = achievementOutcomeRepository;
}
public AllAchievementsViewModel()
{
this.AchievementsOrdered = new ObservableCollection <AchievementsPerCategory>();
this.ResetCommand = new RelayCommand(ResetExecute);
AchievementContext.AchievementsUnlocked += AchievementContext_AchievementsUnlocked;
achievementRepository = ObjectFactory.GetInstance <IAchievementRepository>();
ReloadViewModel();
}
public UnitOfWork(Context context,
IUserRepository userRepository,
INotificationRepository notificationRepository,
IUserViceRepo userVice,
IViceRepository vice,
IAchievementRepository achievementRepository)
{
Context = context;
Vices = vice;
UserVices = userVice;
Users = userRepository;
Notifications = notificationRepository;
Achievements = achievementRepository;
}
public UserAchievementService
(
IUserRepository userRepository,
IAchievementRepository achievementRepository,
IUserAchievementRepository userAchievementsRepository,
IEventRepository eventRepository,
IUnitOfWork unitOfWork,
IMapper mapper
)
{
_userRepository = userRepository;
_achievementRepository = achievementRepository;
_userAchievementRepository = userAchievementsRepository;
_eventRepository = eventRepository;
_unitOfWork = unitOfWork;
_mapper = mapper;
}
public AchievementService
(
IUserRepository userRepository,
IUserAchievementRepository userAchievementRepository,
IAchievementRepository achievementRepository,
IFileService fileService,
IMapper mapper,
IUnitOfWork unitOfWork
)
{
_userRepository = userRepository;
_userAchievementRepository = userAchievementRepository;
_achievementRepository = achievementRepository;
_fileService = fileService;
_mapper = mapper;
_unitOfWork = unitOfWork;
}
//Skarner Alston Reztip pentakill 5/29/2019
//Perfect Game ABCDE vs TDK semi finals 10/17/2019
public PlayerProfileService(ISummonerInfoRepository summonerInfoRepository, IAchievementRepository achievementRepository,
ITeamPlayerRepository teamPlayerRepository, ITeamRosterRepository teamRosterRepository, IAlternateAccountRepository alternateAccountRepository,
IPlayerStatsRepository playerStatsRepository, ISeasonInfoRepository seasonInfoRepository, IPlayerStatsMapper playerStatsMapper,
IAlternateAccountMapper alternateAccountMapper, ITierDivisionMapper tierDivisionMapper, IMatchDetailRepository matchDetailRepository, ILogger <PlayerProfileService> logger)
{
_summonerInfoRepository = summonerInfoRepository ?? throw new ArgumentNullException(nameof(summonerInfoRepository));
_achievementRepository = achievementRepository ?? throw new ArgumentNullException(nameof(achievementRepository));
_teamPlayerRepository = teamPlayerRepository ?? throw new ArgumentNullException(nameof(teamPlayerRepository));
_teamRosterRepository = teamRosterRepository ?? throw new ArgumentNullException(nameof(teamRosterRepository));
_alternateAccountRepository = alternateAccountRepository ?? throw new ArgumentNullException(nameof(alternateAccountRepository));
_playerStatsRepository = playerStatsRepository ?? throw new ArgumentNullException(nameof(playerStatsRepository));
_seasonInfoRepository = seasonInfoRepository ?? throw new ArgumentNullException(nameof(seasonInfoRepository));
_playerStatsMapper = playerStatsMapper ?? throw new ArgumentNullException(nameof(playerStatsMapper));
_alternateAccountMapper = alternateAccountMapper ?? throw new ArgumentNullException(nameof(alternateAccountMapper));
_tierDivisionMapper = tierDivisionMapper ?? throw new ArgumentNullException(nameof(tierDivisionMapper));
_matchDetailRepository = matchDetailRepository ?? throw new ArgumentNullException(nameof(matchDetailRepository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public static async Task SetupAchievements(AchievementsConfig config, IAchievementRepository achievementRepository)
{
var dbAchievements = await GetAchievementsFromDb(achievementRepository);
var achievementsFromConfig = GetAchievementsFromConfig(config);
if (!dbAchievements.Any())
{
await AddAchievementsAsync(achievementsFromConfig, achievementRepository);
}
else
{
if (dbAchievements.Count() != achievementsFromConfig.Count)
{
throw new DataAccessException("Achievements setup failed - different number of achievements");
}
}
}
public UnitOfWork(
IAchievementRepository achievement,
ICommentRepository comment,
INotificationRepository notification,
IProjectRepository project,
ISprintRepository sprint,
IUserRepository user,
IWorkItemRepository workItem,
FantasyScrumBoardDbContext dbContext)
{
Achievement = achievement;
Comment = comment;
Notification = notification;
Project = project;
Sprint = sprint;
User = user;
WorkItem = workItem;
_dbContext = dbContext;
}
public MatchDetailService(ILogger <MatchDetailService> logger, IEmailService emailService, IPlayerStatsRepository playerStatsRepository, ISummonerInfoRepository summonerInfoRepository,
ISeasonInfoRepository seasonInfoRepository, IMatchDetailRepository matchDetailRepository, IMatchMvpRepository matchMvpRepository,
IChampionStatsRepository championStatsRepository, IScheduleService scheduleService, ITeamPlayerRepository teamPlayerRepository, ITeamRosterRepository teamRosterRepository,
IAchievementRepository achievementRepository, ILookupRepository lookupRepository)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_emailService = emailService ?? throw new ArgumentNullException(nameof(emailService));
_playerStatsRepository = playerStatsRepository ?? throw new ArgumentNullException(nameof(playerStatsRepository));
_summonerInfoRepository = summonerInfoRepository ?? throw new ArgumentNullException(nameof(summonerInfoRepository));
_seasonInfoRepository = seasonInfoRepository ?? throw new ArgumentNullException(nameof(seasonInfoRepository));
_matchDetailRepository = matchDetailRepository ?? throw new ArgumentNullException(nameof(matchDetailRepository));
_matchMvpRepository = matchMvpRepository ?? throw new ArgumentNullException(nameof(matchMvpRepository));
_championStatsRepository = championStatsRepository ?? throw new ArgumentNullException(nameof(championStatsRepository));
_scheduleService = scheduleService ?? throw new ArgumentNullException(nameof(scheduleService));
_teamPlayerRepository = teamPlayerRepository ?? throw new ArgumentNullException(nameof(teamPlayerRepository));
_teamRosterRepository = teamRosterRepository ?? throw new ArgumentNullException(nameof(teamRosterRepository));
_achievementRepository = achievementRepository ?? throw new ArgumentNullException(nameof(achievementRepository));
_lookupRepository = lookupRepository ?? throw new ArgumentNullException(nameof(lookupRepository));
}
public RequestAchievementService
(
IRequestAchievementRepository requestAchievementRepository,
IEmailService emailService,
IMapper mapper,
IUserAchievementService userAchievementService,
IUserRepository userRepository,
IAchievementRepository achievementRepository,
IStringLocalizer <HtmlPages> stringLocalizer,
IUnitOfWork unitOfWork
)
{
_requestAchievementRepository = requestAchievementRepository;
_emailService = emailService;
_mapper = mapper;
_userRepository = userRepository;
_achievementRepository = achievementRepository;
_stringLocalizer = stringLocalizer;
_unitOfWork = unitOfWork;
_userAchievementService = userAchievementService;
}
public AchievementService(
IOptions <AchievementsConfig> options,
IUserAchievementRepository userAchievementRepository,
IAchievementRepository achievementRepository,
IMealRepository mealRepository,
IFavouriteRepository favouriteRepository,
IMealIngredientRepository mealIngredientRepository,
IFriendRepository friendRepository,
IMealScheduleRepository mealScheduleRepository,
IActivityService activityService,
IMapper mapper)
{
achievementsConfig = options.Value;
_userAchievementRepository = userAchievementRepository;
_achievementRepository = achievementRepository;
_mealRepository = mealRepository;
_friendRepository = friendRepository;
_mealScheduleRepository = mealScheduleRepository;
_activityService = activityService;
_mapper = mapper;
}
public PlayerAchievement GetPlayerAchievement(String playerId, String achievementName)
{
PlayerAchievement playerAchievement = null;
playerAchievement = _allPlayerAchievements.Find(item => (item.AchievementName.Equals(achievementName)) &&
(item.PlayerID.Equals(playerId)));
_achievementRepository = new AchievementRepository();
if (playerAchievement != null)
{
Achievement achievement = _achievementRepository.GetAchievementByName(achievementName);
playerAchievement.Achievement = achievement;
_playerRepository = new PlayerRepository();
playerAchievement.Player = _playerRepository.GetPlayerByID(playerId);
return(playerAchievement);
}
else
{
return(null);
}
}
public AchievementParser(IAchievementRepository achievementRepository)
{
_service = achievementRepository;
}
public AchievementController(IAchievementRepository repository,
UserManager <CFlixUser> userManager)
{
_userManager = userManager;
_repo = repository;
}
public SerialStrokesAchievementService(IAchievementRepository achievementRepository)
: base(achievementRepository)
{
}
private static async Task AddAchievementsAsync(IEnumerable <Achievement> achievements, IAchievementRepository achievementsRepository)
{
if (!await achievementsRepository.AddAchievementsAsync(achievements))
{
throw new DataAccessException("Achievements setup failed - adding achievements to the DB failed");
}
}
private static async Task <IEnumerable <Achievement> > GetAchievementsFromDb(IAchievementRepository repository) => await repository.GetAllAsync();
public AchievementManager(IAchievementRepository achievementRepository)
{
_achievementRepository = achievementRepository;
}
public AchievementService(IAchievementRepository achievementRepository)
{
_achievementRepository = achievementRepository;
}
public AchievementController(IAchievementRepository repository)
{
_repository = repository;
}
protected StrokesAchievementServiceBase(IAchievementRepository achievementRepository)
{
AchievementRepository = achievementRepository;
}
public AchievementListParser(IAchievementRepository achievementRepository)
{
_achievementRepository = achievementRepository;
}
public CharacterParser(IAchievementRepository achievementRepository)
{
_achievementParser = new AchievementParser(achievementRepository);
}
public AchievementService(IContext context, IAchievementRepository repository)
: base(context, repository)
{
_repository = repository;
_context = context;
}
public AchievmentController(IStudentRepository studentRepository, IAchievementRepository achievmentRepository)
{
this.studentRepository = studentRepository;
this.achievmentRepository = achievmentRepository;
}
public ParallelStrokesAchievementService(IAchievementRepository achievementRepository)
: base(achievementRepository)
{
}
public AchievementService(IUnitOfWork unitOfWork, IAchievementRepository achievementRepository)
: base(unitOfWork, achievementRepository)
{
this.achievementRepository = achievementRepository;
}
public AchievementController(IAchievementRepository achievementRepository)
{
_achievementRepository = achievementRepository;
}
public AchievementLogic(IAchievementRepository repository)
{
_repository = repository;
}
public ProfileController(UserManager <CFlixUser> userManager,
IAchievementRepository achievementRepository)
{
_userManager = userManager;
_achievementRepository = achievementRepository;
}
public BadgesController(IAchievementRepository achievementRepository)
{
Check.Argument.IsNotNull(achievementRepository, "achievementRepository");
_achievementRepository = achievementRepository;
}
protected StrokesAchievementServiceBase(IAchievementRepository achievementRepository)
{
AchievementRepository = achievementRepository;
}
public WowHeadAchievementParser(IAchievementRepository achievementRepository)
{
_achievementRepository = achievementRepository;
}
