protected override void UpdateWinsLossesAndTiesForTeamSeasons(
TeamSeasonDecorator?guestSeasonDecorator, TeamSeasonDecorator?hostSeasonDecorator,
IGameDecorator gameDecorator)
{
if (gameDecorator.IsTie())
{
if (!(guestSeasonDecorator is null))
{
guestSeasonDecorator.Ties--;
}
if (!(hostSeasonDecorator is null))
{
hostSeasonDecorator.Ties--;
}
}
else
{
var seasonYear = gameDecorator.SeasonYear;
var winnerSeason =
_teamSeasonRepository.GetTeamSeasonByTeamAndSeason(gameDecorator.WinnerName !, seasonYear);
if (!(winnerSeason is null))
{
winnerSeason.Wins--;
}
var loserSeason =
_teamSeasonRepository.GetTeamSeasonByTeamAndSeason(gameDecorator.LoserName !, seasonYear);
if (!(loserSeason is null))
{
loserSeason.Losses--;
}
}
}
public OrderDetailsDecorator(
IAsyncRepository <OrderDetails> orderDetailsRepository,
IGameDecorator gameDecorator)
{
_orderDetailsRepository = orderDetailsRepository;
_gameDecorator = gameDecorator;
}
protected void EditWinLossData(TeamSeasonDecorator?guestSeasonDecorator,
TeamSeasonDecorator?hostSeasonDecorator, IGameDecorator gameDecorator)
{
UpdateGamesForTeamSeasons(guestSeasonDecorator, hostSeasonDecorator);
UpdateWinsLossesAndTiesForTeamSeasons(guestSeasonDecorator, hostSeasonDecorator, gameDecorator);
UpdateWinningPercentageForTeamSeasons(guestSeasonDecorator, hostSeasonDecorator);
}
/// <summary>
/// Processes a <see cref="Game"/> entity into the Teams data store asynchronously.
/// </summary>
/// <param name="game"></param>
/// <returns></returns>
public virtual async Task ProcessGameAsync(IGameDecorator gameDecorator)
{
Guard.ThrowIfNull(gameDecorator, $"{GetType()}.{nameof(ProcessGameAsync)}: {nameof(gameDecorator)}");
var seasonYear = gameDecorator.SeasonYear;
var guestSeason =
await _teamSeasonRepository.GetTeamSeasonByTeamAndSeasonAsync(gameDecorator.GuestName, seasonYear);
TeamSeasonDecorator?guestSeasonDecorator = null;
if (!(guestSeason is null))
{
guestSeasonDecorator = new TeamSeasonDecorator(guestSeason);
}
var hostSeason =
await _teamSeasonRepository.GetTeamSeasonByTeamAndSeasonAsync(gameDecorator.HostName, seasonYear);
TeamSeasonDecorator?hostSeasonDecorator = null;
if (!(hostSeason is null))
{
hostSeasonDecorator = new TeamSeasonDecorator(hostSeason);
}
await EditWinLossDataAsync(guestSeasonDecorator, hostSeasonDecorator, gameDecorator);
EditScoringData(guestSeasonDecorator, hostSeasonDecorator, gameDecorator.GuestScore,
gameDecorator.HostScore);
}
public OrderDecorator(
IAsyncRepository <Order> orderRepository,
IAsyncReadonlyRepository <Order> mongoOrderRepository,
IAsyncReadonlyRepository <Shipper> shippersRepository,
IGameDecorator gameDecorator)
{
_sqlOrderRepository = orderRepository;
_mongoOrderRepository = mongoOrderRepository;
_shippersRepository = shippersRepository;
_gameDecorator = gameDecorator;
}
public void SetUp()
{
_sqlOrderRepository = A.Fake <IAsyncRepository <Order> >();
_mongoOrderRepository = A.Fake <IAsyncReadonlyRepository <Order> >();
_gameDecorator = A.Fake <IGameDecorator>();
_shippersRepository = A.Fake <IAsyncReadonlyRepository <Shipper> >();
_orderDecorator = new OrderDecorator(
_sqlOrderRepository,
_mongoOrderRepository,
_shippersRepository,
_gameDecorator);
}
public GameService(
IUnitOfWork unitOfWork,
IGameDecorator gameDecorator,
ISortOptionFactory <GameRoot> sortOptionFactory,
IMapper mapper,
IPublisherService publisherService)
{
_unitOfWork = unitOfWork;
_mapper = mapper;
_publisherService = publisherService;
_gameDecorator = gameDecorator;
_sortOptionFactory = sortOptionFactory;
}
/// <summary>
/// Edits the wrapped <see cref="Game"/> entity with data from another <see cref="Game"/> entity.
/// </summary>
/// <param name="srcGame">The <see cref="Game"/> entity from which data will be copied.</param>
public void Edit(IGameDecorator srcGame)
{
_game.Week = srcGame.Week;
_game.GuestName = srcGame.GuestName;
_game.GuestScore = srcGame.GuestScore;
_game.HostName = srcGame.HostName;
_game.HostScore = srcGame.HostScore;
_game.WinnerName = srcGame.WinnerName;
_game.WinnerScore = srcGame.WinnerScore;
_game.LoserName = srcGame.LoserName;
_game.LoserScore = srcGame.LoserScore;
_game.IsPlayoff = srcGame.IsPlayoff;
_game.Notes = srcGame.Notes;
}
private void EditTeams(Direction direction, IGameDecorator gameDecorator)
{
var processGameStrategy = _processGameStrategyFactory.CreateStrategy(direction);
// TODO - 2020-09-25: Implement ObjectNotFoundException class so it can be caught and used here.
//try
//{
processGameStrategy.ProcessGame(gameDecorator);
//}
//catch (ObjectNotFoundException ex)
//{
// Log.Error("ObjectNotFoundException in GamesService.EditTeams: " + ex.Message);
// _sharedService.ShowExceptionMessage(ex, "ObjectNotFoundException");
//}
}
public OrderService(
IUnitOfWork unitOfWork,
IGameService gameService,
INotificationService <Order> notificationService,
ILogger <OrderService> logger,
IGameDecorator gameDecorator,
IMapper mapper)
{
_unitOfWork = unitOfWork;
_gameService = gameService;
_notificationService = notificationService;
_logger = logger;
_gameDecorator = gameDecorator;
_mapper = mapper;
_orderDecorator = _unitOfWork.GetRepository <IAsyncRepository <Order> >();
}
public void Setup()
{
_unitOfWork = A.Fake <IUnitOfWork>();
_gameDecorator = A.Fake <IGameDecorator>();
_mapper = A.Fake <IMapper>();
_visitRepository = A.Fake <IAsyncRepository <Visit> >();
_sortOptionFactory = A.Fake <ISortOptionFactory <GameRoot> >();
_sortOption = A.Fake <ISortOption <GameRoot> >();
_publisherService = A.Fake <IPublisherService>();
A.CallTo(() => _sortOption.SortDirection).Returns(SortDirection.Descending);
A.CallTo(() => _sortOption.SortPropertyAccessor).Returns(root => root.Details.Price);
A.CallTo(() => _sortOptionFactory.Create(A <string> ._)).Returns(_sortOption);
A.CallTo(() => _unitOfWork.GetRepository <IAsyncRepository <Visit> >()).Returns(_visitRepository);
_gameServices =
new GameService(_unitOfWork, _gameDecorator, _sortOptionFactory, _mapper, _publisherService);
}
public void Setup()
{
_unitOfWork = A.Fake <IUnitOfWork>();
_gameService = A.Fake <IGameService>();
_notificationService = A.Fake <INotificationService <Order> >();
_orderRepository = A.Fake <IAsyncRepository <Order> >();
_mapper = A.Fake <IMapper>();
_gameDecorator = A.Fake <IGameDecorator>();
_logger = A.Fake <ILogger <OrderService> >();
_orderDetailsDecorator = A.Fake <IAsyncRepository <OrderDetails> >();
A.CallTo(() => _unitOfWork.GetRepository <IAsyncRepository <Order> >()).Returns(_orderRepository);
A.CallTo(() => _unitOfWork.GetRepository <IAsyncRepository <OrderDetails> >()).Returns(_orderDetailsDecorator);
_orderService = new OrderService(
_unitOfWork,
_gameService,
_notificationService,
_logger,
_gameDecorator,
_mapper);
}
// Do nothing methods, for this is an implementation of the Null Object Pattern.
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
public override async Task ProcessGameAsync(IGameDecorator gameDecorator)
{
}
protected virtual void UpdateWinsLossesAndTiesForTeamSeasons(TeamSeasonDecorator?guestSeasonDecorator,
TeamSeasonDecorator?hostSeasonDecorator, IGameDecorator gameDecorator)
{
throw new NotImplementedException(
nameof(UpdateWinsLossesAndTiesForTeamSeasons) + " must be implemented in a subclass.");
}
protected async Task EditWinLossDataAsync(TeamSeasonDecorator?guestSeasonDecorator,
TeamSeasonDecorator?hostSeasonDecorator, IGameDecorator gameDecorator)
{
UpdateGamesForTeamSeasons(guestSeasonDecorator, hostSeasonDecorator);
await UpdateWinsLossesAndTiesForTeamSeasonsAsync(guestSeasonDecorator, hostSeasonDecorator, gameDecorator);
UpdateWinningPercentageForTeamSeasons(guestSeasonDecorator, hostSeasonDecorator);
}
