public void AddCheckoutToTeam(int serverTeamId, CheckoutEntity checkout)
{
TeamEntity team = teamRepository.GetTeamById(serverTeamId);
if (checkout.ShiftDate.Date != team.ShiftDate.Date)
{
throw new InvalidOperationException("You cannot add a checkout to a team with different shift dates.");
}
TeamCheckoutEntity addedCheckout = new TeamCheckoutEntity
{
Team = team,
Checkout = checkout,
ShiftDate = checkout.ShiftDate
};
if (teamRepository.CheckoutHasAlreadyBeenAdded(checkout.Id, checkout.ShiftDate))
{
throw new InvalidOperationException("That checkout is currently on another team");
}
teamRepository.AddCheckoutToTeam(addedCheckout);
if (!teamRepository.Save())
{
throw new Exception("An unexpected error occured while trying to add the checkout to the team.");
}
}
public void DeleteCheckout(int checkoutId)
{
CheckoutEntity checkout = _repository.GetCheckOutById(checkoutId);
_repository.DeleteCheckOut(checkout);
UtilityMethods.VerifyDatabaseSaveSuccess(_repository);
}
public void CreateCheckout_Creates_Checkout()
{
var entity = new CheckoutEntity();
var dto = new CheckoutDto();
mockMapper.Setup(m => m.Map <CheckoutEntity>(dto)).Returns(entity);
checkoutService.CreateCheckout(dto);
mockRepo.Verify(r => r.Insert(entity), Times.Once);
}
public void CreateCheckout_Returns_CheckoutDto()
{
var entity = new CheckoutEntity();
var dto = new CheckoutDto();
mockRepo.Setup(r => r.Insert(It.IsAny <CheckoutEntity>())).Returns(entity);
mockMapper.Setup(m => m.Map <CheckoutDto>(entity)).Returns(dto);
var actual = checkoutService.CreateCheckout(dto);
Assert.AreEqual(dto, actual);
}
public void UpdateCheckout_Calls_Update_In_Repo()
{
var entity = new CheckoutEntity();
var dto = new CheckoutDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.Get(It.IsAny <Guid>())).Returns(entity);
checkoutService.UpdateCheckout(dto);
mockRepo.Verify(r => r.Update(It.IsAny <CheckoutEntity>()), Times.Once);
}
public void GetByReservationId_Returns_Collection_CheckoutDtos()
{
var reservationId = Guid.NewGuid();
var entity = new CheckoutEntity();
var dto = new CheckoutDto();
mockRepo.Setup(r => r.GetByReservationId(It.IsAny <Guid>())).Returns(entity);
mockMapper.Setup(m => m.Map <CheckoutDto>(entity)).Returns(dto);
var actual = checkoutService.GetByReservationId(reservationId);
Assert.AreEqual(dto, actual);
}
public CheckoutDto GetCheckoutByDate(GetCheckoutByDateDto data, StaffMemberDto staffMemberDto)
{
DateTime shiftDate = Convert.ToDateTime(data.StringDate).Date;
CheckoutEntity checkoutEntity = _repository.GetCheckOutForStaffMemberForSpecificDate(shiftDate, staffMemberDto.Id, data.LunchOrDinner);
if (checkoutEntity == null)
{
throw new KeyNotFoundException("No checkout for the provided staffmember was found for the given parameters.");
}
CheckoutDto checkoutDto = Mapper.Map <CheckoutDto>(checkoutEntity);
return(checkoutDto);
}
public void UpdateCheckout_Updates_Checkout()
{
var entity = new CheckoutEntity();
var dto = new CheckoutDto {
Id = Guid.NewGuid(), CheckoutDateTime = DateTime.UtcNow
};
mockRepo.Setup(r => r.Get(It.IsAny <Guid>())).Returns(entity);
checkoutService.UpdateCheckout(dto);
mockRepo.Verify(r => r.Update(
It.Is <CheckoutEntity>(r =>
r.CheckoutDateTime == dto.CheckoutDateTime)),
Times.Once);
}
public List <StaffMemberEntity> GetTeamMembers(int teamId)
{
List <StaffMemberEntity> staffMembers = new List <StaffMemberEntity>();
foreach (TeamCheckoutEntity x in _context.TeamCheckouts
.Where(r => r.TeamId == teamId))
{
CheckoutEntity checkoutEntity = _context.CheckOuts.Where(c => c.Id == x.CheckoutId)
.Include(c => c.StaffMember).FirstOrDefault();
StaffMemberEntity s = checkoutEntity.StaffMember;
staffMembers.Add(s);
}
return(staffMembers);
}
public CheckoutDto CreateCheckout(CreateCheckoutDto data, StaffMemberDto staffMemberDto, JobDto jobDto)
{
Checkout checkout = new Checkout(Mapper.Map <StaffMember>(staffMemberDto), data.ShiftDate, Mapper.Map <Job>(jobDto));
if (_repository.CheckoutExists(data.ShiftDate, staffMemberDto.Id, data.LunchOrDinner))
{
throw new InvalidOperationException("A checkout for this employee already exists for this day and shift.");
}
Mapper.Map(data, checkout);
CheckoutEntity checkOutEntity = Mapper.Map <CheckoutEntity>(checkout);
_repository.AddCheckOut(checkOutEntity);
_repository.VerifyDatabaseSaveSuccess();
return(Mapper.Map <CheckoutDto>(checkOutEntity));
}
public bool UpdateCheckout(UpdateCheckoutDto data)
{
CheckoutEntity checkoutToUpdate = _repository.GetCheckOutById(data.Id);
List <CheckoutEntity> checkouts = _repository.GetCheckOutsForAShift(checkoutToUpdate.ShiftDate.Date, checkoutToUpdate.LunchOrDinner).ToList();
if (checkouts.Any(c => c.StaffMemberId == data.StaffMemberId && c.Id != data.Id))
{
throw new InvalidOperationException("The staff member is already assigned to a checkout for that shift");
}
Mapper.Map(data, checkoutToUpdate);
UtilityMethods.VerifyDatabaseSaveSuccess(_repository);
return(true);
}
public List <ServerTeamGroupedCheckoutsDto> FormatServerTeamGroupCheckouts(ServerTeamDto s, IEnumerable <CheckoutEntity> entities, List <CheckoutOverviewDto> checkouts, List <ServerTeamDto> serverTeams, List <EarningDto> shiftEarnings)
{
List <ServerTeamGroupedCheckoutsDto> pageData = new List <ServerTeamGroupedCheckoutsDto>();
//Grab the first entity to get a related earning for the team
CheckoutEntity checkout = entities.ElementAt(0);
if (entities.Count() == 1)
{
//Mark the teams that have only one server so they can be presented as a solo team
ServerTeamGroupedCheckoutsDto soloTeam = new ServerTeamGroupedCheckoutsDto
{
CheckoutHasBeenRun = s.CheckoutHasBeenRun,
IsSoloTeam = true,
TeamId = s.Id,
TeamEarning = shiftEarnings.FirstOrDefault(e => e.StaffMemberId == checkout.StaffMemberId),
};
soloTeam.TeamCheckouts.Add(Mapper.Map <CheckoutOverviewDto>(checkout));
pageData.Add(soloTeam);
}
else
{
ServerTeamGroupedCheckoutsDto team = new ServerTeamGroupedCheckoutsDto
{
CheckoutHasBeenRun = s.CheckoutHasBeenRun,
IsSoloTeam = false,
TeamId = s.Id,
TeamEarning = shiftEarnings.FirstOrDefault(e => e.StaffMemberId == checkout.StaffMemberId)
};
foreach (CheckoutEntity c in entities)
{
team.TeamCheckouts.Add(Mapper.Map <CheckoutOverviewDto>(c));
}
pageData.Add(team);
}
return(pageData);
}
public void DeleteCheckOut(CheckoutEntity c)
{
_context.CheckOuts.Remove(c);
}
public void AddCheckOut(CheckoutEntity c)
{
_context.CheckOuts.Add(c);
}
public void Update(CheckoutEntity checkout)
{
_context.Checkouts.Update(checkout);
_context.SaveChanges();
}
public CheckoutEntity Insert(CheckoutEntity checkout)
{
_context.Checkouts.Add(checkout);
_context.SaveChanges();
return(checkout);
}