public StartGameAdminCommand(int size, IPhysics physics, IStateTracker stateTracker, IPlayerRepository playerRepository)
{
_size = size;
_physics = physics;
_stateTracker = stateTracker;
_playerRepository = playerRepository;
}
static void Main(string[] args)
{
var dbFactory = new DBFactory();
Players = new SqlPlayerRepository(dbFactory);
var url = string.Format("http://football.myfantasyleague.com/2011/export?TYPE=players");
var result = Send(url, verb: "GET");
//Console.WriteLine(result);
dynamic d = ToDynamic(result);
foreach (dynamic player in d.player)
{
if (WhiteListPositions.Contains((string)player.position, StringComparer.OrdinalIgnoreCase))
{
var names = ((string)player.name).Split(',');
var p = new Player { FirstName = names[1], LastName = names[0], Team = player.team, MyFantasyLeagueId = player.id, Position = GetPositionByName(player.position) };
Console.WriteLine("Saving {0}, {1}: {2} {3}", p.LastName, p.FirstName, p.Position, p.Team);
Players.SavePlayer(p);
}
else
{
Console.WriteLine("Skipped {0}: {1}", player.position, player.name);
}
}
Console.WriteLine("Done....");
Console.ReadLine();
}
public PlayersController()
{
SportsDataContext context = new SportsDataContext();
_playerDb = new PlayerRepository(context);
_teamDb = new TeamRepository(context);
}
public EventViewModel(int eventId, IPlayerRepository playerRepository)
{
this._eventId = eventId;
this._playerRepository = playerRepository;
InitalizeData();
InitalizeCommands();
}
public ColorService(IPlayerRepository playerRepository, IGameRoundRepository gameRoundRepository, IUnitOfWorkFactory unitOfWorkFactory, IGameRoundScorerSpecification gameRoundScorerSpecification)
{
_playerRepository = playerRepository;
_gameRoundRepository = gameRoundRepository;
_unitOfWorkFactory = unitOfWorkFactory;
_gameRoundScorerSpecification = gameRoundScorerSpecification;
}
public static void Initialize()
{
if (_initialized)
return;
Player = ObjectFactory.GetInstance<IPlayerRepository>();
Map = ObjectFactory.GetInstance<IMapRepository>();
_initialized = true;
}
public MatchReportServices(IMatchRepository matchRepository, IPlayerMatchObjectiveRepository playerMatchObjectiveRepository, IPlayerMatchStatisticRepository playerMatchStatisticRepository, IPlayerRepository playerRepository, IMatchMomRepository matchMomRepository)
{
_matchRepository = matchRepository;
_playerMatchObjectiveRepository = playerMatchObjectiveRepository;
_playerMatchStatisticRepository = playerMatchStatisticRepository;
_playerRepository = playerRepository;
_matchMomRepository = matchMomRepository;
}
public ShotService(IShotRepository shotRepository, IShotTypeRepository shotTypeRepository, IGameRepository gameRepository, IPlayerRepository playerRepository, IHoleRepository holeRepository)
{
_shotRepository = shotRepository;
_shotTypeRepository = shotTypeRepository;
_gameRepository = gameRepository;
_playerRepository = playerRepository;
_holeRepository = holeRepository;
}
private GameManager()
{
// TODO Logs. (UNITY)
repoPlayer = PlayerDao.GetInstance();
repoPlayerInBattle = PlayerInBattleDao.GetInstance();
typeMapping = new TypeGameMappingByReflection();
ran = new Random();
}
public void TestSetUp()
{
dataContext = new NemeStatsDataContext();
playerRepository = new EntityFrameworkPlayerRepository(dataContext);
playedGameRetriever = new PlayedGameRetriever(dataContext);
playerRetriever = new PlayerRetriever(dataContext, playerRepository, playedGameRetriever);
}
public RankingService(IGameRepository gameRepository, IShotRepository shotRepository, IPlayerRepository playerRepository, IRankingRepository rankingRepository, IPlayerGameStatisticsRepository playerGameStatisticsRepository)
{
_gameRepository = gameRepository;
_shotRepository = shotRepository;
_playerRepository = playerRepository;
_rankingRepository = rankingRepository;
_playerGameStatisticsRepository = playerGameStatisticsRepository;
}
public PlayerService(IPlayerRepository playerRepository, IHoleRepository holeRepository, IPlayerStatisticsRepository playerStatisticsRepository, IPlayerHoleStatisticsRepository playerHoleStatisticsRepository, IGameStatisticsRepository gameStatisticsRepository, IUnitOfWork unitOfWork)
{
_playerRepository = playerRepository;
_holeRepository = holeRepository;
_playerStatisticsRepository = playerStatisticsRepository;
_playerHoleStatisticsRepository = playerHoleStatisticsRepository;
_gameStatisticsRepository = gameStatisticsRepository;
_unitOfWork = unitOfWork;
}
public ShotService(IShotRepository shotRepository, IShotTypeRepository shotTypeRepository, IGameRepository gameRepository, IPlayerRepository playerRepository, IHoleRepository holeRepository, IUnitOfWork unitOfWork)
{
_shotRepository = shotRepository;
_shotTypeRepository = shotTypeRepository;
_gameRepository = gameRepository;
_playerRepository = playerRepository;
_holeRepository = holeRepository;
_unitOfWork = unitOfWork;
}
public GameService(IGameRepository gameRepository, IShotRepository shotRepository, IPlayerRepository playerRepository, IGameStatisticsRepository gameStatisticsRepository, IPlayerGameStatisticsRepository playerGameStatisticsRepository, IPlayerRivalryStatisticsRepository playerRivalryStatisticsRepository)
{
_gameRepository = gameRepository;
_shotRepository = shotRepository;
_playerRepository = playerRepository;
_gameStatisticsRepository = gameStatisticsRepository;
_playerGameStatisticsRepository = playerGameStatisticsRepository;
_playerRivalryStatisticsRepository = playerRivalryStatisticsRepository;
}
public TeamServices(ITeamRepository teamRepository, IPlayerRepository playerRepository, ICoachRepository coachRepository, ICurriculumRepository curriculumRepository, ITeamCurriculumRepository teamCurriculumRepository, IClubRepository clubRepository)
{
_teamRepository = teamRepository;
_playerRepository = playerRepository;
_coachRepository = coachRepository;
_curriculumRepository = curriculumRepository;
_teamCurriculumRepository = teamCurriculumRepository;
_clubRepository = clubRepository;
}
public PlayerController(IPlayerRepository playerRepository)
{
if (playerRepository == null)
{
throw new ArgumentNullException("playerRepository");
}
_playerRepository = playerRepository;
}
public PlayerServices(IPlayerRepository playerRepository, IActivityStatusChangeRepository activityStatusChangeRepository, ITeamRepository teamRepository, IUserRepository userRepository, IClubRepository clubRepository, IAddressRepository addressRepository, IUserDetailRepository userDetailRepository)
{
_playerRepository = playerRepository;
_activityStatusChangeRepository = activityStatusChangeRepository;
_teamRepository = teamRepository;
_userRepository = userRepository;
_clubRepository = clubRepository;
_addressRepository = addressRepository;
_userDetailRepository = userDetailRepository;
}
public PlayerConnection(LoginDto loginDto, IPlayerCommandFactory playerCommandFactory, IPlayerRepository playerRepository, IGame game)
{
_playerCommandFactory = playerCommandFactory;
_playerRepository = playerRepository;
_game = game;
_loginDto = loginDto;
_dataToSend = new BufferBlock<string>();
}
public PlayerService(IPlayerRepository playerRepository, IHoleRepository holeRepository, IShotRepository shotRepository, IGameRepository gameRepository, IPlayerStatisticsRepository playerStatisticsRepository, IPlayerHoleStatisticsRepository playerHoleStatisticsRepository, IGameStatisticsRepository gameStatisticsRepository, IPlayerGameStatisticsRepository playerGameStatisticsRepository, IPlayerCareerStatisticsRepository playerCareerStatisticsRepository)
{
_playerRepository = playerRepository;
_holeRepository = holeRepository;
_shotRepository = shotRepository;
_gameRepository = gameRepository;
_playerStatisticsRepository = playerStatisticsRepository;
_playerHoleStatisticsRepository = playerHoleStatisticsRepository;
_gameStatisticsRepository = gameStatisticsRepository;
_playerGameStatisticsRepository = playerGameStatisticsRepository;
_playerCareerStatisticsRepository = playerCareerStatisticsRepository;
}
public MainWindowViewModel()
{
PlayerRepository = new PlayerRepository();
ScoreRepository = new ScoreRepository();
PictureRepository = new PictureRepository();
PlayerGroupItemRepository = new PlayerGroupItemRepository();
NewPlayer = new Player();
PicturesToDrag = new ObservableCollection<Picture>();
ListOfDraggedPictures = new ObservableCollection<Picture>();
_timer.Interval = new TimeSpan(0, 0, 1);
_timer.Tick += new EventHandler(timer_Tick);
}
public AdminController(
IPlayerRepository repoPlayers,
IClubRepository repoClubs,
IPositionRepository repoPositions,
IStatRepository repoStats,
IAppDataRepository repoAppData)
{
repositoryPlayers = repoPlayers;
repositoryClubs = repoClubs;
repositoryPositions = repoPositions;
repositoryStats = repoStats;
repositoryAppData = repoAppData;
}
public Game(IRandom random, IPhysics physics, IStateTracker stateTracker, IPlayerRepository playerRepository, IClock clock)
{
_physics = physics;
_stateTracker = stateTracker;
_playerRepository = playerRepository;
_clock = clock;
Random = random;
_blobs = new List<Blob>();
Settings = new WorldSettings();
GameMode = new ClassicGameMode(this, physics, stateTracker, playerRepository);
Stop();
}
public ConnectionListener(
IConnectionSettings connectionSettings,
IConnectionFactory connectionFactory,
IPlayerRepository playerRepository,
IAdminCredentials adminCredentials)
{
_connectionSettings = connectionSettings;
_connectionFactory = connectionFactory;
_playerRepository = playerRepository;
_adminCredentials = adminCredentials;
_connections = new List<IConnection>();
var taskScheduler = new ThreadPerTaskScheduler();
_taskFactory = new TaskFactory(taskScheduler);
}
public void SetUp()
{
_playerRepositoryMock = MockRepository.GenerateMock<IPlayerRepository>();
_dataContextMock = MockRepository.GenerateMock<IDataContext>();
_nemesisRecalculator = new NemesisRecalculator(_dataContextMock, _playerRepositoryMock);
_currentUser = new ApplicationUser();
_minionPlayer = new Player()
{
NemesisId = _existingNemesisId
};
_dataContextMock.Expect(mock => mock.FindById<Player>(_playerId))
.Return(_minionPlayer);
_savedNemesis = new Nemesis() { Id = _newNemesisId };
_dataContextMock.Expect(mock => mock.Save<Nemesis>(Arg<Nemesis>.Is.Anything, Arg<ApplicationUser>.Is.Anything))
.Return(_savedNemesis);
}
public void SetUp()
{
dataContextMock = MockRepository.GenerateMock<IDataContext>();
playerRepositoryMock = MockRepository.GenerateMock<IPlayerRepository>();
nemesisRecalculatorPartialMock = MockRepository.GeneratePartialMock<NemesisRecalculator>(dataContextMock, playerRepositoryMock);
List<Player> allPlayers = new List<Player>()
{
new Player(){ Active = true, Id = 1 },
new Player(){ Active = true, Id = 2 },
new Player(){ Active = false, Id = 3 }
};
allPlayersQueryable = allPlayers.AsQueryable();
dataContextMock.Expect(mock => mock.GetQueryable<Player>())
.Return(allPlayersQueryable);
}
public UserServices(IUserRepository userRepository, IClubAdminRepository clubAdminRepository,
ICoachRepository coachRepository, IClubRepository clubRepository,
IWelfareOfficerRepository welfareOfficerRepository, IScoutRepository scoutRepository,
IPhysiotherapistRepository physiotherapistRepository, IHeadOfEducationRepository headOfEducationRepository,
IHeadOfAcademyRepository headOfAcademyRepository, ISportScientistRepository sportScientistRepository,
IAddressRepository addressRepository, IUserDetailRepository userDetailRepository, IPlayerRepository playerRepository)
{
_userRepository = userRepository;
_clubAdminRepository = clubAdminRepository;
_coachRepository = coachRepository;
_clubRepository = clubRepository;
_welfareOfficerRepository = welfareOfficerRepository;
_scoutRepository = scoutRepository;
_physiotherapistRepository = physiotherapistRepository;
_headOfEducationRepository = headOfEducationRepository;
_headOfAcademyRepository = headOfAcademyRepository;
_sportScientistRepository = sportScientistRepository;
_addressRepository = addressRepository;
_userDetailRepository = userDetailRepository;
_playerRepository = playerRepository;
}
public PlayerService(IPlayerRepository playerRepository)
{
_playerRepository = playerRepository;
}
public PlayerService(IMapper mapper, IPlayerRepository repository, IConfiguration config)
{
this.mapper = mapper;
this.playerRepo = repository;
this.config = config;
}
public PlayersController(IPlayerRepository playerRepository, IHeroRepository heroRepository, IPlayerHeroRepository playerHeroRepository)
{
_playerRepository = playerRepository;
_heroRepository = heroRepository;
_playerHeroRepository = playerHeroRepository;
}
public PlayerController(IPlayerRepository repo)
{
repository = repo;
}
public PlayerService(IPlayerRepository repo)
{
_repo = repo;
}
public TeamManagementService(ITeamRepository teamRepository, IPlayerRepository playerRepository, ILeagueRepository leagueRepository)
{
_teamRepository = teamRepository;
_playerRepository = playerRepository;
_leagueRepository = leagueRepository;
}
public PlayerController(IConnectionManager connectionManager, IPlayerRepository playerRepository)
{
_playerHub = connectionManager.GetHubContext <PlayerHub>();
_playerRepository = playerRepository;
}
public PlayerController(ILogger <PlayerController> logger, IPlayerRepository playerRepository, IMapper mapper)
{
this.logger = logger;
this.playerRepository = playerRepository;
this.mapper = mapper;
}
public PlayerStatusRequestHandler(ILogger logger,
IThreadContextSessionProvider threadContextSessionProvider, IBotUserRepository botUserRepository, IPlayerRepository playerRepository)
{
_logger = logger;
_threadContextSessionProvider = threadContextSessionProvider;
_botUserRepository = botUserRepository;
_playerRepository = playerRepository;
}
public PlayerList(IPlayerRepository repository)
{
_repository = repository;
}
public PassingService(IPassingRepository passingRepository, IUnitOfWork unitOfWork, IPlayerRepository playerRepository)
{
_passingRepository = passingRepository;
_unitOfWork = unitOfWork;
_playerRepository = playerRepository;
}
public UpdatePlayerCommandHandler(ILogger <UpdatePlayerCommandHandler> logger, UpdatePlayerCommandValidator validator, IUnitOfWork unitOfWork, IPlayerRepository playerRepository, IApplicationUser applicationUser)
{
this._logger = logger;
this._validator = validator;
this._unitOfWork = unitOfWork;
this._playerRepository = playerRepository;
this._applicationUser = applicationUser;
}
public ManagerController()
{
playerRepository = new PlayerRepository();
cardRepository = new CardRepository();
}
public DataController(IPlayerRepository playerRepository, ISkaterStatisticRepository skaterStatistic)
{
_playerRepo = playerRepository;
_skaterRepo = skaterStatistic;
}
public AdminController(IPlayerRepository playerRepository, ITeamRepository teamRepository, IMatchRepository matchRepository)
{
_playerRepository = playerRepository;
_teamRepository = teamRepository;
_matchRepository = matchRepository;
}
public HistoryService(IPlayerRepository playerRepository, IMoveRepository moveRepository, IPlayerGameStatusRepository playerGameStatusRepository)
{
_playerRepository = playerRepository;
_moveRepository = moveRepository;
_playerGameStatusRepository = playerGameStatusRepository;
}
public RosterController(ITeamRepository teamRepository, IPlayerRepository playerRepository, IStateRepository stateRepository)
{
this.teamRepository = teamRepository;
this.playerRepository = playerRepository;
this.stateRepository = stateRepository;
}
public PlayerController(IPlayerRepository <Player> playerRepository)
{
this._playerRepository = playerRepository;
}
public MapController(IContractRepository contractRepository, IPlayerRepository playerRepository, ITeamRepository teamRepository) : base(contractRepository, playerRepository, teamRepository)
{
}
public HomeController(IClubRepository clubRepo, IPlayerRepository playerRepo, IFixtureRepository fixtureRepo)
{
clubRepository = clubRepo;
playerRepository = playerRepo;
fixtureRepository = fixtureRepo;
}
public TopSquadService(ITopSquadApiClient topSquadApiClient, IPlayerRepository playerRepository, IBlobStorageService blobStorageService)
{
_topSquadApiClient = topSquadApiClient;
_playerRepository = playerRepository;
_blobStorageService = blobStorageService;
}
public StartBattleCommandHandler(IEnumerable <ConnectedClient> activeClients, IPlayerRepository playerRepository, BattleRepository battleRepository)
{
_activeClients = activeClients;
_playerRepository = playerRepository;
_battleRepository = battleRepository;
}
public PlayerService(IPlayerRepository playerRepository, IMapper mapper)
{
this.playerRepository = playerRepository;
this.mapper = mapper;
}
public PlayerRepositoryTests()
{
_playerRepository = GetRequiredService <IPlayerRepository>();
}
public TournamentPriceChangedIntegrationEventHandler(ISmsProvider smsProvider, IPlayerRepository playerRepository)
{
_smsProvider = smsProvider;
_playerRepository = playerRepository;
}
public RegisterValidator(IPlayerRepository repository, BrandQueries brandQueries)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(p => p.FirstName)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.FirstNameRequired.ToString());
RuleFor(p => p.LastName)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.LastNameRequired.ToString());
RuleFor(p => p.Email)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.EmailIsRequired.ToString());
RuleFor(p => p.PhoneNumber)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.PhoneNumberIsRequired.ToString());
RuleFor(p => p.MailingAddressLine1)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.MailingAddressLine1IsRequired.ToString());
RuleFor(p => p.MailingAddressCity)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.MailingAddressCityIsRequired.ToString());
RuleFor(p => p.MailingAddressPostalCode)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.MailingAddressPostalCodeIsRequired.ToString());
RuleFor(p => p.PhysicalAddressLine1)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.PhysicalAddressLine1Required.ToString());
RuleFor(p => p.PhysicalAddressCity)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.PhysicalAddressCityRequired.ToString());
RuleFor(p => p.PhysicalAddressPostalCode)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.PhysicalAddressPostalCodeRequired.ToString());
RuleFor(p => p.CountryCode)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.CountryCodeIsRequired.ToString());
RuleFor(p => p.CurrencyCode)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.CurrencyCodeRequired.ToString());
RuleFor(p => p.CultureCode)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.CultureCodeRequired.ToString());
RuleFor(p => p.Username)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.UsernameRequired.ToString());
RuleFor(p => p.Password)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.PasswordRequired.ToString());
RuleFor(p => p.PasswordConfirm)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.PasswordConfirmRequired.ToString());
RuleFor(p => p.DateOfBirth)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.DateOfBirthIsMissingOrIncorrect.ToString());
RuleFor(p => p.BrandId)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.BrandIdRequired.ToString());
RuleFor(p => p.Gender)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.GenderIsRequired.ToString());
RuleFor(p => p.Title)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(PlayerInfoValidatorResponseCodes.TitleIsRequired.ToString());
RuleFor(p => p.ContactPreference)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.ContactPreferenceRequired.ToString());
RuleFor(p => p.IdStatus)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.IdStatusRequired.ToString());
RuleFor(p => p.SecurityQuestionId)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.SecurityQuestionIdRequired.ToString())
.Must(v => repository.SecurityQuestions.Any(x => x.Id == new Guid(v)))
.WithMessage(RegisterValidatorResponseCodes.InvalidSecurityQuestionId.ToString());
RuleFor(p => p.SecurityAnswer)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.SecurityAnswerIsMissing.ToString());
RuleFor(p => p.MailingAddressStateProvince)
.Must(v => !string.IsNullOrWhiteSpace(v))
.WithMessage(RegisterValidatorResponseCodes.AddressStateProvinceIsMissing.ToString());
When(p => !string.IsNullOrWhiteSpace(p.FirstName), () =>
{
var firstNameMinLength = CommonPlayerSettings.FirstNameMinLength;
var firstNameMaxLength = CommonPlayerSettings.FirstNameMaxLength;
RuleFor(p => p.FirstName)
.Length(firstNameMinLength, firstNameMaxLength)
.WithMessage(PlayerInfoValidatorResponseCodes.FirstNameLengthIsNotInTheAllowedRange.ToString());
RuleFor(p => p.FirstName)
.Matches(CommonPlayerSettings.FirstNamePattern)
.WithMessage(PlayerInfoValidatorResponseCodes.FirstNameFormatIsWrong.ToString());
});
When(p => !string.IsNullOrWhiteSpace(p.LastName), () =>
{
var lastNameMinLength = CommonPlayerSettings.LastNameMinLength;
var lastNameMaxLength = CommonPlayerSettings.LastNameMaxLength;
RuleFor(p => p.LastName)
.Length(lastNameMinLength, lastNameMaxLength)
.WithMessage(PlayerInfoValidatorResponseCodes.LastNameLengthIsNotInTheAllowedRange.ToString());
RuleFor(p => p.LastName)
.Matches(CommonPlayerSettings.LastNamePattern)
.WithMessage(PlayerInfoValidatorResponseCodes.LastNameFormatIsWrong.ToString());
});
When(p => !string.IsNullOrWhiteSpace(p.Email), () =>
{
const int emailMaxLength = 50;
RuleFor(p => p.Email)
.Length(0, emailMaxLength)
.WithMessage(PlayerInfoValidatorResponseCodes.EmailLengthIsNotInAllowedRange.ToString());
RuleFor(p => p.Email)
.Matches(CommonPlayerSettings.EmailPattern)
.WithMessage(PlayerInfoValidatorResponseCodes.EmailFormatIsWrong.ToString());
RuleFor(p => p.Email)
.Must(
(r, e) =>
!repository.Players.AsNoTracking()
.Any(p => p.Email == e && p.BrandId == new Guid(r.BrandId)))
.WithMessage(PlayerInfoValidatorResponseCodes.EmailAlreadyExists.ToString());
});
When(p => !string.IsNullOrWhiteSpace(p.PhoneNumber), () =>
{
const int phoneMinLength = 8, phoneMaxLength = 15;
RuleFor(p => p.PhoneNumber)
.Length(phoneMinLength, phoneMaxLength)
.WithMessage(PlayerInfoValidatorResponseCodes.PhoneNumberLengthIsWrong.ToString());
RuleFor(p => p.PhoneNumber)
.Matches(CommonPlayerSettings.PhonePattern)
.WithMessage(PlayerInfoValidatorResponseCodes.PhoneNumberFormatIsWrong.ToString());
});
When(p => !string.IsNullOrWhiteSpace(p.MailingAddressLine1), () =>
{
const int addressMinLength = 1, addressMaxLength = 50;
RuleFor(p => p.MailingAddressLine1)
.Length(addressMinLength, addressMaxLength)
.WithMessage(PlayerInfoValidatorResponseCodes.MailingAddressLine1LengthIsIncorrect.ToString());
});
When(p => !string.IsNullOrWhiteSpace(p.MailingAddressPostalCode), () =>
{
const int zipCodesMinLength = 1, zipCodeMaxLength = 10;
RuleFor(p => p.MailingAddressPostalCode)
.Length(zipCodesMinLength, zipCodeMaxLength)
.WithMessage(PlayerInfoValidatorResponseCodes.MailingAddressPostalCodeLengthIsIncorrect.ToString());
});
When(p => brandQueries.DoesBrandExist(new Guid(p.BrandId)) && !string.IsNullOrWhiteSpace(p.CountryCode),
() => RuleFor(p => p.CountryCode)
.Must((r, c) => brandQueries.BrandHasCountry(new Guid(r.BrandId), c))
.WithMessage(PlayerInfoValidatorResponseCodes.InvalidCountryCode.ToString()));
When(p => brandQueries.DoesBrandExist(new Guid(p.BrandId)) && !string.IsNullOrWhiteSpace(p.CurrencyCode),
() => RuleFor(p => p.CurrencyCode)
.Must((r, c) => brandQueries.BrandHasCurrency(new Guid(r.BrandId), c))
.WithMessage(PlayerInfoValidatorResponseCodes.InvalidCurrencyCode.ToString()));
When(p => brandQueries.DoesBrandExist(new Guid(p.BrandId)) && !string.IsNullOrWhiteSpace(p.CultureCode),
() => RuleFor(p => p.CultureCode)
.Must((r, c) => brandQueries.BrandHasCulture(new Guid(r.BrandId), c))
.WithMessage(RegisterValidatorResponseCodes.InvalidCultureCode.ToString()));
When(p => !string.IsNullOrWhiteSpace(p.Username), () =>
{
const int usernameMinLength = 6;
const int usernameMaxLength = 12;
RuleFor(p => p.Username)
.Length(usernameMinLength, usernameMaxLength)
.WithMessage(RegisterValidatorResponseCodes.UsernameLengthIsNotInAllowedRange.ToString());
RuleFor(p => p.Username)
.Matches(CommonPlayerSettings.UsernamePatter)
.WithMessage(RegisterValidatorResponseCodes.UsernameFormatIsWrong.ToString());
RuleFor(p => p.Username)
.Must(
(r, u) =>
!repository.Players.AsNoTracking()
.Any(p => p.Username == u && p.BrandId == new Guid(r.BrandId)))
.WithMessage(RegisterValidatorResponseCodes.UsernameAlreadyExists.ToString());
});
When(p => !string.IsNullOrWhiteSpace(p.Password), () =>
{
int passwordMinLength = CommonPlayerSettings.PasswordMinLength;
int passwordMaxLength = CommonPlayerSettings.PasswordMaxLength;
RuleFor(p => p.Password)
.Length(passwordMinLength, passwordMaxLength)
.WithMessage(RegisterValidatorResponseCodes.PasswordLengthIsNotInItsAllowedRange.ToString());
});
When(p => !string.IsNullOrWhiteSpace(p.Password) && !string.IsNullOrWhiteSpace(p.PasswordConfirm), () =>
RuleFor(p => p.PasswordConfirm)
.Must((r, p) => r.Password == p)
.WithMessage(RegisterValidatorResponseCodes.ConfirmationPasswordDoesntMatch.ToString())
);
When(p => !string.IsNullOrWhiteSpace(p.DateOfBirth), () =>
{
RuleFor(p => p.DateOfBirth)
.Must(p => ValidatorUtils.ToDateTime(p, "yyyy/MM/dd") != null)
.WithMessage(PlayerInfoValidatorResponseCodes.DateOfBirthIsMissingOrIncorrect.ToString());
RuleFor(p => p.DateOfBirth)
.Must(p =>
{
DateTime?dateTime = ValidatorUtils.ToDateTime(p, "yyyy/MM/dd");
if (dateTime == null)
{
return(true);
}
return(dateTime >= DateTime.UtcNow.AddYears(-100));
})
.WithMessage(PlayerInfoValidatorResponseCodes.DateOfBirthIsMissingOrIncorrect.ToString());
RuleFor(p => p.DateOfBirth)
.Must(p =>
{
DateTime?dateTime = ValidatorUtils.ToDateTime(p, "yyyy/MM/dd");
if (dateTime == null)
{
return(true);
}
return(dateTime <= DateTime.UtcNow.AddYears(-18));
})
.WithMessage(PlayerInfoValidatorResponseCodes.AgeIsUnderAllowed.ToString());
});
When(p => !string.IsNullOrWhiteSpace(p.BrandId), () => RuleFor(p => p.BrandId)
.Must(brand => brandQueries.DoesBrandExist(new Guid(brand)))
.WithMessage(RegisterValidatorResponseCodes.BrandIsUnknown.ToString()));
When(p => !string.IsNullOrEmpty(p.Gender), () => RuleFor(p => p.Gender)
.Must(g => Enum.IsDefined(typeof(Gender), g))
.WithMessage(PlayerInfoValidatorResponseCodes.GenderIsRequired.ToString()));
When(p => !string.IsNullOrEmpty(p.Title), () => RuleFor(p => p.Title)
.Must(g => Enum.IsDefined(typeof(Title), g))
.WithMessage(PlayerInfoValidatorResponseCodes.TitleIsRequired.ToString()));
When(p => !string.IsNullOrEmpty(p.ContactPreference), () => RuleFor(p => p.ContactPreference)
.Must(cp => Enum.IsDefined(typeof(ContactMethod), cp))
.WithMessage(RegisterValidatorResponseCodes.InvalidContractPreference.ToString()));
}
public UseIntent(IPlayerRepository playerRepository,
IMapRepository mapRepository) : base(playerRepository, mapRepository)
{
}
public AddPlayerHandler(IPlayerRepository playerRepository, ITownRepository townRepository)
{
_playerRepository = playerRepository;
_townRepository = townRepository;
}
public PlayerApiController(IPlayerRepository playerRepository)
{
_playerRepository = playerRepository;
}
public PlayerConnection(LoginDto loginDto, IPlayerCommandFactory playerCommandFactory, IPlayerRepository playerRepository, IGame game)
{
_playerCommandFactory = playerCommandFactory;
_playerRepository = playerRepository;
_game = game;
_loginDto = loginDto;
_dataToSend = new BufferBlock <string>();
}
public PlayersProvider(IPlayerRepository repository)
{
_repo = repository;
}
public FightService(IWarriorRepository warriorRepository, IGameRepository gameRepository, IPlayerRepository playerRepository)
{
_gameRepository = gameRepository;
_playerRepository = playerRepository;
_warriorRepository = warriorRepository;
}
public PlayersController(IPlayerRepository userRepository)
{
_userRepository = userRepository;
}
public HomeController(IPlayerRepository playerRepository, IDiscColorManager discColorManager)
{
_playerRepository = playerRepository;
_discColorManager = discColorManager;
}
