public CandidatesController(ICandidateDesignationRepository candidateDesignationRepository,
ICandidateRepository candidateRepository,
ICandidateActivityRepository candidateActivityRepository,
IInterviewRoundRepository interviewRoundRepository,
IInterviewRoundActivityRepository interviewRoundActivityRepository,
ICandidateTechnologyMapRepository candidateTechnologyMapRepository,
IUserRepository userRepository,
IJobOpeningRepository jobOpeningRepository,
IRoundRepository roundRepository,
ICandidateDocumentRepository candidateDocumentRepository,
ITechnologyRepository technologyRepository,
ICandidateService candidateService,
ISettingsService settingsService,
EmailComposerService emailComposerService,
IUnitOfWork unitOfWork)
{
_candidateDesignationRepository = candidateDesignationRepository;
_candidateRepository = candidateRepository;
_candidateActivityRepository = candidateActivityRepository;
_interviewRoundRepository = interviewRoundRepository;
_interviewRoundActivityRepository = interviewRoundActivityRepository;
_userRepository = userRepository;
_jobOpeningRepository = jobOpeningRepository;
_roundRepository = roundRepository;
_candidateDocumentRepository = candidateDocumentRepository;
_candidateService = candidateService;
_candidateTechnologyMapRepository = candidateTechnologyMapRepository;
_technologyRepository = technologyRepository;
_emailComposerService = emailComposerService;
_unitOfWork = unitOfWork;
_settingsService = settingsService;
}
public PlayCardHandler(IGameRepository gameRepository, IPlayerRepository playerRepository, IPlayCardRepository playCardRepository, IRoundRepository roundRepository)
{
_gameRepository = gameRepository;
_playerRepository = playerRepository;
_playCardRepository = playCardRepository;
_roundRepository = roundRepository;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="roundRepository"></param>
/// <param name="gameRepository"></param>
/// <param name="mapper"></param>
/// <param name="logger"></param>
public RoundController(IRoundRepository roundRepository, IGameRepository gameRepository, IMapper mapper, ILogger <GameController> logger)
{
_logger = logger;
_roundRepository = roundRepository;
_gameRepository = gameRepository;
_mapper = mapper;
}
public RoundService(IRoundRepository roundRepo,
IMatchRepository matchRepo)
{
_roundRepo = roundRepo;
_matchRepo = matchRepo;
_roundVali = new RoundValidator();
}
private RoundController(IDalContext context)
{
_tournaments = context.Tournaments;
_members = context.Members;
_rounds = context.Rounds;
_tables = context.Tables;
}
public PointCalculator(IPlayerRepository playerRepository, IFixtureRepository fixtureRepository, IRoundRepository roundRepository, IBetRepository betRepository, ITeamRepository teamRepository)
{
PlayerRepository = playerRepository;
FixtureRepository = fixtureRepository;
RoundRepository = roundRepository;
BetReposiory = betRepository;
TeamRepository = teamRepository;
}
public HistoryService(IGameRepository <Game> gameRepository,
IRoundRepository <Round> roundRepository,
IPlayersGameRepository <PlayerGames> playerGameRepository)
{
_gameRepository = gameRepository;
_roundRepository = roundRepository;
_playersGameRepository = playerGameRepository;
}
public GameController(IMembershipService membershipService, IGameRepository gameRepository,
IRoundRepository roundRepository, ILoggingRepository _errorRepository)
{
_membershipService = membershipService;
_gameRepository = gameRepository;
_roundRepository = roundRepository;
_loggingRepository = _errorRepository;
}
public RoundService(IRoundRepository roundRepository,
IRoundPlayerRepository roundPlayerRepository,
ICardService cardService)
{
_roundRepository = roundRepository;
_roundPlayerRepository = roundPlayerRepository;
_cardService = cardService;
}
public ScoreRound(IRoundRepository roundRepository)
{
if (roundRepository == null)
{
throw new ArgumentNullException(nameof(roundRepository));
}
this.roundRepository = roundRepository;
}
public RoundService(IRoundRepository roundRepository,
IRankingRepository rankingRepository,
IUnitOfWork unitOfWork,
INotificationHandler notifications)
: base(unitOfWork, notifications)
{
_roundRepository = roundRepository;
_rankingRepository = rankingRepository;
}
public TournamentController(ITournamentRepository tournamentRepository,
IPlayerRepository playerRepository,
IRoundRepository roundRepository,
IMatchupManager matchupManger)
{
this.tournamentRepository = tournamentRepository;
this.playerRepository = playerRepository;
this.roundRepository = roundRepository;
this.matchupManger = matchupManger;
}
public RoundService(
IRoundRepository roundRepository,
ITicketRepository ticketRepository,
ICalculateCombination calculateCombination
)
{
_roundRepository = roundRepository;
_ticketRepository = ticketRepository;
_calculateCombination = calculateCombination;
}
public RoundPointService(IRoundPointRepository roundPointRepository,
IPlayerRepository playerRepository,
IRoundRepository roundRepository,
IUnitOfWork unitOfWork,
INotificationHandler notifications)
: base(unitOfWork, notifications)
{
_roundPointRepository = roundPointRepository;
_playerRepository = playerRepository;
_roundRepository = roundRepository;
}
public TournamentService(
ITournamentRepository tournamentRepository,
IFederationRepository federationRepository,
IRoundRepository roundRepository,
IPlayerRepository playerRepository)
{
_tournamentRepository = tournamentRepository;
_federationRepository = federationRepository;
_roundRepository = roundRepository;
_playerRepository = playerRepository;
}
public TicketService(
ITicketRepository ticketRepository,
IRoundRepository roundRepository,
IUserRepository userRepository,
ICalculateCombination calculateCombination
)
{
_ticketRepository = ticketRepository;
_roundRepository = roundRepository;
_userRepository = userRepository;
_calculateCombination = calculateCombination;
}
public AppService(
IGameRepository gameRepository,
IPlayerRepository playerRepository,
IMoveRepository moveRepository,
IRoundRepository roundRepository
)
{
GameRepository = gameRepository;
PlayerRepository = playerRepository;
MoveRepository = moveRepository;
RoundRepository = roundRepository;
}
public GameService(IGameRepository <Game> gameRepository,
IPlayerRepository <Player> playerRepository,
IRoundRepository <Round> roundRepository,
ICardRepository <Card> cardRepository,
IPlayersGameRepository <PlayerGames> playersGameRepository)
{
_gameRepository = gameRepository;
_playerRepository = playerRepository;
_roundRepository = roundRepository;
_cardRepository = cardRepository;
_playersGameRepository = playersGameRepository;
}
public GameService(IGameRepository gameRepository, ICardRepository cardRepository, IRoundRepository roundRepository, IMoveRepository moveRepository, IUserGamesRepository userGamesRepository, IUserRepository userRepository, IUserRoundRepository userRoundRepository, IMemoryCache cache, IMapper mapper)
{
this._gameRepository = gameRepository;
this._cardRepository = cardRepository;
this._roundRepository = roundRepository;
this._moveRepository = moveRepository;
this._userGamesRepository = userGamesRepository;
this._userRepository = userRepository;
this._userRoundRepository = userRoundRepository;
this._mapper = mapper;
_deckProvider = new DeckProvider(cache);
_handCardsProvider = new HandCardsProvider(cache);
}
public HistoryService(IPlayerRepository playerRepository,
IGameRepository gameRepository,
IRoundRepository roundRepository,
ICardRepository cardRepository,
IPlayerRoundHandRepository playerRoundHandRepository,
HistoryServiceMapProvider maping)
{
_playerRepository = playerRepository;
_gameRepository = gameRepository;
_roundRepository = roundRepository;
_cardRepository = cardRepository;
_playerRoundHandRepository = playerRoundHandRepository;
_maping = maping;
}
public CreateRound(IRoundRepository roundRepository, IBandRepository bandRepository)
{
if (roundRepository == null)
{
throw new ArgumentNullException(nameof(roundRepository));
}
if (bandRepository == null)
{
throw new ArgumentNullException(nameof(bandRepository));
}
this.roundRepository = roundRepository;
this.bandRepository = bandRepository;
}
public RouletteTable(ValidationManager validationmanager, IMessageBroker messageBroker, IRoundRepository roundRepo)
{
_messageBroker = messageBroker;
_roundRepo = roundRepo;
_stateTimer = new RouletteTimer(Constants.AfterRoundTime)
{
Elapsed = BettingTimeStart
};
_stateTimer.Start();
_connectedUsers = new ConcurrentDictionary <long, UserOnTable>();
RoundHistory = new Queue <RouletteRound>(100);
CurrentRound = _roundRepo.CreateNewRound(TableId);
RoundHistory.Enqueue(CurrentRound);
ValidationManager = validationmanager;
}
public async Task ReturnNullWhenRoundDoNotExistsInDbByGivenId()
{
// Arrange
_roundRepository = SoccerStatisticsContextMocker.GetInMemoryRoundRepository("GetRoundByIdReturnNull");
Round testRound = null;
// Act
var err = await Record.ExceptionAsync(async
() => testRound = await _roundRepository.GetByIdAsync(0));
// Assert
err.Should().BeNull();
testRound.Should().BeNull();
}
public GameService(
IGameRepository gameRepository,
IImageRepository imageRepository,
IRoundRepository roundRepository,
IRepository <ImageInRoundEntity> imageInRoundRepository,
IRepository <UserEntity> userRepository,
IMetaDataRepository metaDataRepository)
{
_gameRepository = gameRepository;
_imageRepository = imageRepository;
_roundRepository = roundRepository;
_imageInRoundRepository = imageInRoundRepository;
_userRepository = userRepository;
_metaDataRepository = metaDataRepository;
IMAGES_PER_ROUND = _metaDataRepository.GetByName <int>(MetaDataEnum.ImagesPerRound);
ROUNDS_PER_GAME = _metaDataRepository.GetByName <int>(MetaDataEnum.RoundsPerGame);
}
public GameLogicService(IGameRepository gameRepository, IPlayerRepository playerRepository,
ICardRepository cardRepository, IPlayerGameRepository playerGameRepository,
IRoundRepository roundRepository, IHandRepository handRepository, IHandCardRepository handCardRepository,
IMapper mapper, IGameUtility gameUtility, IDeckProvider deckProvider)
{
_gameRepository = gameRepository;
_playerRepository = playerRepository;
_playerGameRepository = playerGameRepository;
_roundRepository = roundRepository;
_handRepository = handRepository;
_cardRepository = cardRepository;
_handCardRepository = handCardRepository;
_mapper = mapper;
_gameUtility = gameUtility;
_deckProvider = deckProvider;
}
public PortalController(ICandidateRepository candidateRepository,
IJobOpeningRepository jobOpeningRepository,
IInterviewRoundRepository interviewRoundRepository,
IRoundRepository roundRepository,
ICandidateTechnologyMapRepository candidateTechnologyMapRepository,
ITechnologyRepository technologyRepository,
ICandidateDesignationRepository candidateDesignationRepository,
IUnitOfWork unitOfWork)
{
_candidateRepository = candidateRepository;
_jobOpeningRepository = jobOpeningRepository;
_roundRepository = roundRepository;
_interviewRoundRepository = interviewRoundRepository;
_candidateTechnologyMapRepository = candidateTechnologyMapRepository;
_technologyRepository = technologyRepository;
_candidateDesignationRepository = candidateDesignationRepository;
_unitOfWork = unitOfWork;
}
public NotifyScoreRound(Notifications notifications, IBandRepository bandRepository, IRoundRepository roundRepository)
{
if (notifications == null)
{
throw new ArgumentNullException(nameof(notifications));
}
if (bandRepository == null)
{
throw new ArgumentNullException(nameof(bandRepository));
}
if (roundRepository == null)
{
throw new ArgumentNullException(nameof(roundRepository));
}
this.notifications = notifications;
this.bandRepository = bandRepository;
this.roundRepository = roundRepository;
}
public InterviewRoundsController(IInterviewRoundRepository interviewRoundRepository,
IInterviewRoundActivityRepository interviewRoundActivityRepository,
IInterviewRoundDocumentRepository interviewRoundDocumentRepository,
ICandidateRepository candidateRepository,
IRoundRepository roundRepository,
IUserRepository userRepository,
IJobOpeningRepository jobOpeningRepository,
EmailComposerService emailComposerService,
IUnitOfWork unitOfWork)
{
_interviewRoundRepository = interviewRoundRepository;
_interviewRoundActivityRepository = interviewRoundActivityRepository;
_interviewRoundDocumentRepository = interviewRoundDocumentRepository;
_candidateRepository = candidateRepository;
_userRepository = userRepository;
_jobOpeningRepository = jobOpeningRepository;
_roundRepository = roundRepository;
_unitOfWork = unitOfWork;
_emailComposerService = emailComposerService;
}
public async Task ReturnRoundWhichExistsInDbByGivenId()
{
// Arrange
_roundRepository = SoccerStatisticsContextMocker.GetInMemoryRoundRepository("GetRoundByIdReturnRound");
var expectedRound = new Round()
{
Id = 1,
Name = "Round 1",
};
Round testRound = null;
// Act
var err = await Record.ExceptionAsync(async
() => testRound = await _roundRepository.GetByIdAsync(1));
// Assert
err.Should().BeNull();
testRound.Should().NotBeNull();
testRound.Should().BeEquivalentTo(expectedRound);
}
public RoundService(IRoundRepository roundRepository, IPairingRepository pairingRepository, IPlayerInPairRepository playerInPairRepository)
{
_roundRepository = roundRepository;
_pairingRepository = pairingRepository;
_playerInPairRepository = playerInPairRepository;
}
public TournamentsConroller(ITournamentRepository tournamentRepository, IRoundRepository roundRepository, ITaskRepository taskRepository)
{
_tournamentRepository = tournamentRepository;
_roundRepository = roundRepository;
_taskRepository = taskRepository;
}
public RoundService(IRoundRepository repository)
{
_repository = repository;
}
