public async Task OneTimeSetUp()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "Test")
.Options;
var dbContext = new ApplicationDbContext(options,
new OptionsWrapper <OperationalStoreOptions>(new OperationalStoreOptions()));
tagRepository = new TagRepository(dbContext);
cardRepository = new CardRepository(dbContext);
deckRepository = new DeckRepository(dbContext, cardRepository);
user = dbContext.Users.Add(new ApplicationUser()
{
UserName = "******"
}).Entity;
await InitTagRepository();
var mapperConfiguration = new MapperConfiguration(cfg =>
{
cfg.AddProfile(typeof(CreationCardProfile));
cfg.AddProfile(typeof(CreationDeckProfile));
});
mapper = new Mapper(mapperConfiguration);
}
private readonly IShuffled<Card> _choosenMixer; //выбранный тип растасовки
public DeckManager()
{
_packTypes = DIKernel.Get<IPackTypes>();
_packFactory = DIKernel.Get<IFactory>();
_packStorage = DIKernel.Get<IDeckRepository>();
_choosenMixer = DIKernel.Get<IShuffled<Card>>();
}
public void Init()
{
deckRepo = new MongoDeckRepository("mongodb://localhost");
UserId = Guid.NewGuid();
Deck deck = new Deck();
List <DeckCard> cards = new List <DeckCard>();
cards.Add(new DeckCard()
{
MultiverseId = 1,
Amount = 2
});
List <DeckCard> sideBoard = new List <DeckCard>();
sideBoard.Add(new DeckCard()
{
MultiverseId = 34,
Amount = 3
});
deck.Cards = cards;
deck.SideBoard = sideBoard;
deck.Description = "This is a test deck.";
deck.IsPublic = true;
deck.Name = "Test Deck";
deck.CreatedAt = DateTime.Now;
deck.UserId = UserId;
deck = deckRepo.AddDeck(deck);
DeckId = deck.Id;
}
public GameService(
IGameValidator gameValidator,
IDeckRepository deckRepository,
IGameDeckRepository gameDeckRepository,
IGameRepository gameRepository,
IGameUserRepository gameUserRepository,
ITurnRepository turnRepository,
IDataMapper <GameData, GameModel> gameMapper,
IDataMapper <GameCreateData, GameCreateModel> gameCreateMapper,
IDataMapper <GameDeckCardCollectionData, GameDeckCardCollectionModel> gameDeckCardCollectionMapper,
IDataMapper <GameDeckData, GameDeckModel> gameDeckMapper,
IDataMapper <GameUserData, GameUserModel> gameUserMapper,
ICardService cardService
)
{
_gameValidator = gameValidator;
_deckRepository = deckRepository;
_gameDeckRepository = gameDeckRepository;
_gameRepository = gameRepository;
_gameUserRepository = gameUserRepository;
_turnRepository = turnRepository;
_gameMapper = gameMapper;
_gameCreateMapper = gameCreateMapper;
_gameDeckCardCollectionMapper = gameDeckCardCollectionMapper;
_gameDeckMapper = gameDeckMapper;
_gameUserMapper = gameUserMapper;
_cardService = cardService;
}
public DeckBuilderController(ICardRepository repo, IDeckRepository deckRepo, CurDeck deckService, UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager)
{
repository = repo;
deckRepository = deckRepo;
curDeck = deckService;
_userManager = userManager;
_signInManager = signInManager;
}
public PlayerRepository(GodsArenaApiContext context, IWalletRepository walletRepository, IPlayerStatsRepository playerStatsRepository, IDeckRepository deckRepository, IPackRepository packRepository)
: base(context)
{
_walletRepository = walletRepository;
_playerStatsRepository = playerStatsRepository;
_deckRepository = deckRepository;
_packRepository = packRepository;
}
public UpdateDeckUseCase(IDeckRepository deckRepository,
ICardRepository cardRepository, IFileRepository fileRepository, AuthUtils authUtils)
{
this.deckRepository = deckRepository;
this.cardRepository = cardRepository;
_fileRepository = fileRepository;
_authUtils = authUtils;
}
public DecksController(IDeckRepository deckRepo, IMapper mapper, UserManager <ApplicationUser> userManager,
IUserRepository userRepo)
{
this.deckRepo = deckRepo;
this.mapper = mapper;
this.userManager = userManager;
this.userRepo = userRepo;
}
public DecksController(IDeckRepository deckRepository, ICardRepository cardRepository, UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager, IHostingEnvironment hostingEnvironment)
{
_deckRepository = deckRepository;
_cardRepository = cardRepository;
_userManager = userManager;
_signInManager = signInManager;
_hostingEnvironment = hostingEnvironment;
}
public DeckManager(IDeckRepository deckRepository, ICardRepository cardRepository,
DeckMapper deckMapper, CardMapper cardMapper, Random rng)
{
this.deckRepository = deckRepository;
this.cardRepository = cardRepository;
this.deckMapper = deckMapper;
this.cardMapper = cardMapper;
this.rng = rng;
}
public DeckService(IDeckRepository deckRepository, IManaCostConverter manaCostConverter, ILogger <DeckService> logger, IMtgHttpClient mtgHttpClient, IRepoContext context, IMapper mapper)
{
_deckRepository = deckRepository;
_manaCostConverter = manaCostConverter;
_logger = logger;
_mtgHttpClient = mtgHttpClient;
_context = context;
_mapper = mapper;
}
public DeckOperationsController(
IDeckRepository deckRepository,
IMapper mapper,
IDeckCardsInterractor deckCardsInterractor)
{
_deckRepository = deckRepository;
_mapper = mapper;
_deckCardsInterractor = deckCardsInterractor;
}
public PileOperationsController(IPileCardsInterractor pileCardsInterractor,
IMapper mapper,
IDeckRepository deckRepository,
IHashids hashids)
{
_pileCardsInterractor = pileCardsInterractor;
_mapper = mapper;
_deckRepository = deckRepository;
_hashids = hashids;
}
public DeckController(IDeckRepository deckRepository, ICardInDeckRepository cardInDeckRepository,
IDeckBuilder deckBuilder,
ICardRepository cardRepository, IMapper mapper)
{
_deckRepository = deckRepository;
_deckBuilder = deckBuilder;
_cardInDeckRepository = cardInDeckRepository;
_cardRepository = cardRepository;
_mapper = mapper;
}
public DeckController(IDeckRepository deckRepository, IUserDeckRepository userDeckRepository,
ILogger <DeckController> logger, SnakeCaseConverter snakeCaseConverter, DeleteDeckUseCase deleteDeckUseCase, UpdateDeckUseCase updateDeckUseCase, GetDecksForTrainUseCase getDecksForTrainUseCase)
{
this.deckRepository = deckRepository;
this.userDeckRepository = userDeckRepository;
this.logger = logger;
this.snakeCaseConverter = snakeCaseConverter;
this.deleteDeckUseCase = deleteDeckUseCase;
this.updateDeckUseCase = updateDeckUseCase;
this.getDecksForTrainUseCase = getDecksForTrainUseCase;
}
public AddUserToGameHandler(
IDeckRepository deckRepository,
IGameDeckRepository gameDeckRepository,
IGameRepository gameRepository,
ITurnRepository turnRepository
)
{
_deckRepository = deckRepository;
_gameDeckRepository = gameDeckRepository;
_gameRepository = gameRepository;
_turnRepository = turnRepository;
}
public UserController(IDeckRepository deckRepository, ICardRepository cardRepository,
IStatisticRepository statisticRepository, IConfiguration config,
UserManager <User> userManager,
SignInManager <User> signInManager, IMapper mapper)
{
_config = config;
_userManager = userManager;
_signInManager = signInManager;
_mapper = mapper;
_cardRepository = cardRepository;
_deckRepository = deckRepository;
_statisticRepository = statisticRepository;
}
public DeckService(
ICardCollectionRepository cardCollectionRepository,
ICardRepository cardRepository,
IDeckRepository deckRepository,
IDataMapper <DeckData, DeckModel> deckDataMapper
)
{
_cardCollectionRepository = cardCollectionRepository;
_cardRepository = cardRepository;
_deckRepository = deckRepository;
_deckDataMapper = deckDataMapper;
}
public DeckService
(
IDeckRepository deckRepository,
ICardRepository cardRepository,
IDeckTypeRepository deckTypeRepository,
IDeckCardRepository deckCardRepository,
IDeckFileSystem deckFileSystem)
{
_deckRepository = deckRepository;
_cardRepository = cardRepository;
_deckTypeRepository = deckTypeRepository;
_deckCardRepository = deckCardRepository;
_deckFileSystem = deckFileSystem;
}
public DeckViewModel(
IBackgroundWorkInterface backgroundWorkInterface,
ICardInfoProvider cardInfoProvider,
IDeckImportInterface deckImportInterface,
ISerializer <Models.Client.Decklist> decklistSerializer,
IDeckRepository deckRepository,
IEventDispatcher gameEventDispatcher,
IGameResultRepository gameResultRepository,
IPlayerDeckTrackerInterface playerDeckTrackerInterface,
IReplaceDeckInterface replaceDeckInterface,
IUserConfirmationInterface userConfirmationInterface,
IEventDispatcher viewEventDispatcher,
Guid deckID,
Models.Client.Decklist decklist,
Func <DeckViewModel, ushort> getPosition,
string title,
IEnumerable <Models.Client.GameResult> gameResults = null)
{
_backgroundWorkInterface = backgroundWorkInterface.Require(nameof(backgroundWorkInterface));
_cardInfoProvider = cardInfoProvider.Require(nameof(cardInfoProvider));
_deckImportInterface = deckImportInterface.Require(nameof(deckImportInterface));
_decklistSerializer = decklistSerializer.Require(nameof(decklistSerializer));
_deckRepository = deckRepository.Require(nameof(deckRepository));
_gameEventDispatcher = gameEventDispatcher.Require(nameof(gameEventDispatcher));
_gameResultRepository = gameResultRepository.Require(nameof(gameResultRepository));
_playerDeckTrackerInterface = playerDeckTrackerInterface.Require(nameof(playerDeckTrackerInterface));
_replaceDeckInterface = replaceDeckInterface.Require(nameof(replaceDeckInterface));
_userConfirmationInterface = userConfirmationInterface.Require(nameof(userConfirmationInterface));
_viewEventDispatcher = viewEventDispatcher.Require(nameof(viewEventDispatcher));
DeckID = deckID;
Decklist = decklist;
_gameResults = (gameResults ?? Enumerable.Empty <Models.Client.GameResult>()).ToList();
_getPosition = getPosition.Require(nameof(getPosition));
Title = title ?? string.Empty;
_viewEventHandlers.Add(
new DelegateEventHandler <ViewEvents.DeckTracking>(
__event =>
{
IsTracking = __event.DeckViewModel == this;
_deleteCanExecuteChanged?.Invoke();
_replaceCanExecuteChanged?.Invoke();
}));
_viewEventHandlers.ForEach(__handler => _viewEventDispatcher.RegisterHandler(__handler));
}
public void SetUp()
{
_deckRepository = Substitute.For <IDeckRepository>();
_cardRepository = Substitute.For <ICardRepository>();
_deckTypeRepository = Substitute.For <IDeckTypeRepository>();
var deckCardRepository = Substitute.For <IDeckCardRepository>();
var deckFileSystem = Substitute.For <IDeckFileSystem>();
_sut = new DeckService
(
_deckRepository,
_cardRepository,
_deckTypeRepository,
deckCardRepository,
deckFileSystem
);
}
public HistoryService(
IUserRepository userRepository,
IBotRepository botRepository,
IGameRepository gameRepository,
IDeckRepository deckRepository,
IUsersStepRepository usersStepRepository,
IBotsStepRepository botsStepRepository,
IUsersPointsRepository usersPointsRepository,
IBotsPointsRepository botsPointsRepository)
{
_userRepository = userRepository;
_botRepository = botRepository;
_gameRepository = gameRepository;
_usersStepRepository = usersStepRepository;
_deckRepository = deckRepository;
_botsStepRepository = botsStepRepository;
_usersPointsRepository = usersPointsRepository;
_botsPointsRepository = botsPointsRepository;
}
public UnitOfWork(MemoContext context)
{
this.databaseContext = context;
this.algorithms = new AlgorithmRepository(databaseContext);
this.answers = new AnswerRepository(databaseContext);
this.cards = new CardRepository(databaseContext);
this.cardTypes = new CardTypeRepository(databaseContext);
this.categories = new CategoryRepository(databaseContext);
this.comments = new CommentRepository(databaseContext);
this.courses = new CourseRepository(databaseContext);
this.decks = new DeckRepository(databaseContext);
this.reports = new ReportRepository(databaseContext);
this.roles = new RoleRepository(new RoleStore <Role>(databaseContext));
this.statistics = new StatisticsRepository(databaseContext);
this.courseSubscriptions = new CourseSubscriptionsRepository(databaseContext);
this.users = new UserRepository(new UserStore <User>(databaseContext));
this.deckSubscriptions = new DeckSubscriptionsRepository(databaseContext);
this.userProfiles = new UserProfileRepository(databaseContext);
}
public GameService(
IUserRepository userRepository,
IBotRepository botRepository,
IGameRepository gameRepository,
IDeckRepository deckRepository,
IUsersStepRepository usersStepRepository,
IBotsStepRepository botsStepRepository,
IUsersPointsRepository usersPointsRepository,
IBotsPointsRepository botsPointsRepository,
IDeckHelper deckHelper)
{
_userRepository = userRepository;
_botRepository = botRepository;
_gameRepository = gameRepository;
_usersStepRepository = usersStepRepository;
_deckRepository = deckRepository;
_botsStepRepository = botsStepRepository;
_usersPointsRepository = usersPointsRepository;
_botsPointsRepository = botsPointsRepository;
_deckHelper = deckHelper;
}
public GameService(
IGameValidator gameValidator,
IDeckRepository deckRepository,
IGameDeckRepository gameDeckRepository,
IGameRepository gameRepository,
ITurnRepository turnRepository,
IDataMapper <GameData, GameModel> gameMapper,
IDataMapper <GameCreateData, GameCreateModel> gameCreateMapper,
IGameDataService gameDataService
)
{
_gameValidator = gameValidator;
_deckRepository = deckRepository;
_gameDeckRepository = gameDeckRepository;
_gameRepository = gameRepository;
_turnRepository = turnRepository;
_gameMapper = gameMapper;
_gameCreateMapper = gameCreateMapper;
_gameDataService = gameDataService;
}
public DeckService(IDeckRepository _repo)
{
Repository = _repo;
}
public DeckController(IPlayerRepository playerRepository, IDeckRepository deckRepository, ILevelSlotRepository levelSlotRepository)
{
_playerRepository = playerRepository;
_deckRepository = deckRepository;
_levelSlotRepository = levelSlotRepository;
}
public PackContentRepository(GodsArenaApiContext context /*, IPackRepository packRepository, IDeckRepository deckRepository*/, ILevelSlotRepository levelSlotRepository)
: base(context)
{
_packRepository = new PackRepository(context, this);
_deckRepository = new DeckRepository(context, levelSlotRepository, _packRepository, this);
}
protected virtual Domain.Deck GetDeck(IDeckRepository repo, string deckId)
{
return repo.Get(Convert.ToInt32(deckId));
}
public CardsController(IDeckManager manager, IDeckRepository deckRepository, ICardRepository cardRepository)
{
this.manager = manager;
this.deckRepository = deckRepository;
this.cardRepository = cardRepository;
}
public DecksController(IDeckRepository repository)
{
_repository = repository;
}
