コード例 #1
0
        public async Task <DropResult> MakeDropRequest(Publisher publisher, PublisherGame publisherGame)
        {
            if (publisherGame.CounterPick)
            {
                return(new DropResult(Result.Failure("You can't drop a counterpick."), false));
            }

            if (publisherGame.MasterGame.HasNoValue)
            {
                return(new DropResult(Result.Failure("You can't drop a game that is not linked to a master game. Please see the FAQ section on dropping games."), false));
            }

            MasterGame masterGame = publisherGame.MasterGame.Value.MasterGame;
            IReadOnlyList <DropRequest> dropRequests = await _fantasyCriticRepo.GetActiveDropRequests(publisher);

            bool alreadyDropping = dropRequests.Select(x => x.MasterGame.MasterGameID).Contains(masterGame.MasterGameID);

            if (alreadyDropping)
            {
                return(new DropResult(Result.Failure("You cannot have two active drop requests for the same game."), false));
            }

            DropRequest dropRequest    = new DropRequest(Guid.NewGuid(), publisher, publisher.LeagueYear, masterGame, _clock.GetCurrentInstant(), null);
            var         supportedYears = await _fantasyCriticRepo.GetSupportedYears();

            var publishersInLeague = await _fantasyCriticRepo.GetPublishersInLeagueForYear(publisher.LeagueYear);

            var otherPublishers = publishersInLeague.Except(new List <Publisher>()
            {
                publisher
            });

            var dropResult = CanDropGame(dropRequest, supportedYears, publisher.LeagueYear, publisher, otherPublishers);

            if (dropResult.Result.IsFailure)
            {
                return(dropResult);
            }

            await _fantasyCriticRepo.CreateDropRequest(dropRequest);

            return(dropResult);
        }
コード例 #2
0
    public async Task <DropResult> MakeDropRequest(LeagueYear leagueYear, Publisher publisher, PublisherGame publisherGame, bool justCheck)
    {
        if (publisherGame.CounterPick)
        {
            return(new DropResult(Result.Failure("You can't drop a counter pick.")));
        }

        if (publisherGame.MasterGame is null)
        {
            return(new DropResult(Result.Failure("You can't drop a game that is not linked to a master game. Please see the FAQ section on dropping games.")));
        }

        MasterGame masterGame = publisherGame.MasterGame.MasterGame;
        IReadOnlyList <DropRequest> dropRequests = await _fantasyCriticRepo.GetActiveDropRequests(leagueYear, publisher);

        bool alreadyDropping = dropRequests.Select(x => x.MasterGame.MasterGameID).Contains(masterGame.MasterGameID);

        if (alreadyDropping)
        {
            return(new DropResult(Result.Failure("You cannot have two active drop requests for the same game.")));
        }

        DropRequest dropRequest = new DropRequest(Guid.NewGuid(), publisher, leagueYear, masterGame, _clock.GetCurrentInstant(), null, null);
        var         dropResult  = CanDropGame(dropRequest, leagueYear, publisher);

        if (dropResult.Result.IsFailure)
        {
            return(dropResult);
        }

        if (!justCheck)
        {
            await _fantasyCriticRepo.CreateDropRequest(dropRequest);
        }

        return(dropResult);
    }