private void UpdateDateTimeIfNecessary(EncounterDTO servicesDTO)
{
if (DateTime != new DateTime())
{
servicesDTO.DateTime = DateTime;
}
}
public ActionResult UpdateEncounter([FromBody] EncounterDTO data)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var encounter = mapper.Map <Encounter>(data);
encounterBusinessLogic.Update(encounter);
return(Ok(mapper.Map <EncounterDTO>(encounter)));
}
catch (EncounterDoesNotExistException e)
{
return(NotFound(e.Message));
}
catch (EncounterException e)
{
return(BadRequest(e.Message));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
private EncounterDTO GetUpdatedEncounter(EncounterUpdateModelIn encounterModel)
{
EncounterDTO toUpdate = encounterSimpleServices.GetEncounter(encounterModel.Id.ToString());
encounterModel.UpdateServicesDTO(toUpdate, teamServices);
return(toUpdate);
}
public async Task <EncounterValue> GetValue(EncounterDTO encounterDTO)
{
List <int> playerLevels = encounterDTO.Level.ToList();
playerLevels.Sort();
List <int> distinctLevels = playerLevels.Distinct().ToList();
var returnedData = await _characterXp.Aggregate()
.Match(characterXp => distinctLevels.Contains(characterXp.Level))
.Group(
x => BsonNull.Value,
g => new EncounterValue
{
Level = g.Select(x => x.Level),
EncounterXpEasy = g.Select(x => x.Difficulty.Easy),
EncounterXpMedium = g.Select(x => x.Difficulty.Medium),
EncounterXpHard = g.Select(x => x.Difficulty.Hard),
EncounterXpDeadly = g.Select(x => x.Difficulty.Deadly),
XpDay = g.Select(x => x.AdjustedXpDay)
})
.SingleAsync();
int[] Level = new int[playerLevels.Count];
int[] EncounterXpEasy = new int[playerLevels.Count];
int[] EncounterXpMedium = new int[playerLevels.Count];
int[] EncounterXpHard = new int[playerLevels.Count];
int[] EncounterXpDeadly = new int[playerLevels.Count];
int[] XpDay = new int[playerLevels.Count];
int i = 0;
foreach (var playerLevel in playerLevels)
{
int index = Array.IndexOf(returnedData.Level.ToArray(), playerLevel);
Level[i] = returnedData.Level.ToArray()[index];
EncounterXpEasy[i] = returnedData.EncounterXpEasy.ToArray()[index];
EncounterXpMedium[i] = returnedData.EncounterXpMedium.ToArray()[index];
EncounterXpHard[i] = returnedData.EncounterXpHard.ToArray()[index];
EncounterXpDeadly[i] = returnedData.EncounterXpDeadly.ToArray()[index];
XpDay[i] = returnedData.EncounterXpDeadly.ToArray()[index];
i++;
}
EncounterValue returnValue = new EncounterValue
{
Level = Level.AsEnumerable(),
EncounterXpEasy = EncounterXpEasy.AsEnumerable(),
EncounterXpMedium = EncounterXpMedium.AsEnumerable(),
EncounterXpHard = EncounterXpHard.AsEnumerable(),
EncounterXpDeadly = EncounterXpDeadly.AsEnumerable(),
XpDay = XpDay.AsEnumerable()
};
return(returnValue);
}
public void UpdateServicesDTO(EncounterDTO servicesDTO, ITeamServices teamServices)
{
try
{
UpdateDateTimeIfNecessary(servicesDTO);
UpdateResultsIfNecessary(servicesDTO, teamServices);
}
catch (ArgumentException ex)
{
throw new ServicesException("There are teams repeated in the results");
}
}
public void GetCommentariesOfLoggedUserUsersController()
{
var userServicesMock = new Mock <IUserServices>();
var encounterServicesMock = new Mock <IEncounterSimpleServices>();
var encounterQueryServicesMock = new Mock <IEncounterQueryServices>();
ILoginServices loginServices = new LoginServicesMock(pablo);
EncounterDTO encounter = new EncounterDTO()
{
SportName = "Futbol", DateTime = new DateTime(3018 / 08 / 08), TeamIds = new List <string>()
{
"team1", "team2"
}
};
List <EncounterDTO> encounters = new List <EncounterDTO>()
{
encounter
};
CommentDTO comment = new CommentDTO()
{
Message = "This is a test comment!", UserName = pablo.UserName, TimeStamp = new DateTime(2019 / 03 / 03)
};
List <CommentDTO> comments = new List <CommentDTO>()
{
comment
};
encounterQueryServicesMock.Setup(e => e.GetAllEncountersWithFollowedTeams()).Returns(encounters);
encounterQueryServicesMock.Setup(e => e.GetAllCommentsToOneEncounter(It.IsAny <string>())).Returns(comments);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new UsersController(loginServices, userServicesMock.Object, encounterServicesMock.Object, encounterQueryServicesMock.Object)
{
ControllerContext = controllerContext,
};
encounterQueryServicesMock.Verify(u => u.GetAllEncountersWithFollowedTeams(), Times.AtMostOnce);
encounterQueryServicesMock.Verify(u => u.GetAllCommentsToOneEncounter(It.IsAny <string>()), Times.AtMostOnce);
var obtainedResult = controller.GetFollowedTeamCommentariesOfLoggedUser();
var commentaries = obtainedResult.Value as List <CommentDTO>;
Assert.IsNotNull(commentaries);
Assert.AreEqual(comment.Message, commentaries[0].Message);
Assert.AreEqual(comment.UserName, commentaries[0].UserName);
Assert.AreEqual(comment.TimeStamp, commentaries[0].TimeStamp);
}
private IActionResult TryToPut(string id, EncounterUpdateModelIn encounterModel)
{
try
{
EncounterDTO toUpdate = GetUpdatedEncounter(encounterModel);
encounterSimpleServices.UpdateEncounter(toUpdate);
return(Ok());
}
catch (ServicesException e)
{
return(BadRequest(e.Message));
}
}
public async Task <List <EncounterMonsterDTO> > GetMonsters(EncounterDTO encounterDTO)
{
var result = _monsters.Aggregate()
.Match(monster => monster.Xp <= encounterDTO.EncounterBudget &&
monster.ChallengeRating <= encounterDTO.Level.Max())
.Project <EncounterMonsterDTO>(Builders <Monster> .Projection
.Include(monster => monster.Id)
.Include(monster => monster.MonsterName)
.Include(monster => monster.Type)
.Include(monster => monster.ChallengeRating)
.Include(monster => monster.Xp))
.ToListAsync();
return(await result);
}
public void CreateEncounterWithInvalidDateTest()
{
login.CreateSession("sSanchez", "user");
EncounterSimpleServices encounterSimpleServices = new EncounterSimpleServices(login, encounterRepo, sportRepo, teamRepo, userRepo, commentRepo);
EncounterDTO encounter = new EncounterDTO()
{
SportName = "Football",
TeamIds = new List <string>()
{
"River Plate_Futbol", ""
}
};
encounterSimpleServices.CreateEncounter(encounter);
}
private void UpdateResultsIfNecessary(EncounterDTO servicesDTO, ITeamServices teamServices)
{
if (!Results.Any())
{
return;
}
Dictionary <TeamDTO, int> results = new Dictionary <TeamDTO, int>();
foreach (TeamResult result in Results)
{
TeamDTO team = teamServices.GetTeam(result.TeamId);
results.Add(team, result.Result);
}
servicesDTO.Results = results;
}
public void AddCommentToEncounterDoesNotExistsEncountersController()
{
var encounterServices = new Mock <IEncounterSimpleServices>();
var encounterQueryServices = new Mock <IEncounterQueryServices>();
var fixtureGeneratorServices = new Mock <IFixtureServices>();
ILoginServices loginServices = new LoginServicesMock(santiago);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
EncounterDTO encounter = new EncounterDTO()
{
Id = IntToGuid(4), SportName = "Futbol", TeamIds = new List <string>()
{
"Peñarol", "Nacional"
}
};
IEnumerable <EncounterDTO> encounters = new List <EncounterDTO>()
{
encounter
};
encounterServices.Setup(e => e.AddComment(4 + "", "This is a test comment in a mock!")).Throws(new ServicesException());
var controller = new EncountersController(loginServices, encounterServices.Object, new LoggerStub(), encounterQueryServices.Object, fixtureGeneratorServices.Object, teamServices.Object)
{
ControllerContext = controllerContext,
};
var comment = new CommentModelIn()
{
Message = "This is a test comment in a mock!"
};
var obtainedResult = controller.AddEncounterComment(4 + "", comment) as BadRequestObjectResult;
encounterServices.Verify(m => m.AddComment(4 + "", "This is a test comment in a mock!"), Times.AtMostOnce());
Assert.IsNotNull(obtainedResult);
Assert.AreEqual(400, obtainedResult.StatusCode);
}
public EncounterModelOut(EncounterDTO encounter)
{
Id = encounter.Id;
DateTime = encounter.DateTime;
TeamIds = encounter.TeamIds;
SportName = encounter.SportName;
encounter.Results.ToList().ForEach(p => Results.Add(new TeamResult()
{
Result = p.Value,
TeamId = p.Key.Name + "_" + p.Key.SportName
}));
CommentariesUrl = "/api/encounters/" + Id + "/commentaries";
AddCommentariesUrl = "/api/encounters/" + Id + "/commentaries";
GetAvailableFixturesGeneratorsUrl = "/api/encounters/fixture";
SetAvailableFixturesGeneratorsUrl = "/api/encounters/fixture";
}
public void GetEncountersByTeamOkTeamsController()
{
var teamServicesMock = new Mock <ITeamServices>();
var encounterServicesMock = new Mock <IEncounterSimpleServices>();
var encounterQueryServicesMock = new Mock <IEncounterQueryServices>();
EncounterDTO encounter = new EncounterDTO()
{
TeamIds = new List <string>()
{
"team1", "team2"
}, SportName = "Sport"
};
string teamName = "Team_Sport";
List <EncounterDTO> encounters = new List <EncounterDTO>()
{
encounter
};
encounterQueryServicesMock.Setup(e => e.GetEncountersByTeam(teamName)).Returns(encounters);
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new TeamsController(login, teamServicesMock.Object, encounterServicesMock.Object, encounterQueryServicesMock.Object)
{
ControllerContext = controllerContext,
};
var result = controller.GetTeamEncounters(teamName);
encounterQueryServicesMock.Verify(e => e.GetEncountersByTeam(teamName), Times.AtMostOnce);
var resultRequest = result as ActionResult <List <EncounterModelOut> >;
List <EncounterModelOut> obtaniedEncounters = resultRequest.Value;
Assert.IsNotNull(result);
Assert.IsNotNull(resultRequest);
Assert.AreEqual(encounter.SportName, obtaniedEncounters[0].SportName);
Assert.AreEqual(encounter.TeamIds.First(), obtaniedEncounters[0].TeamIds.First());
Assert.AreEqual(encounter.TeamIds.Last(), obtaniedEncounters[0].TeamIds.Last());
}
public void GetAllEncountersOkEncountersController()
{
ILoginServices loginServices = new LoginServicesMock(santiago);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
DateTime encounterDate = new DateTime(2018, 12, 10);
EncounterDTO enc = new EncounterDTO();
enc.SportName = football.Name;
enc.TeamIds = new List <string>()
{
river.Name, boca.Name
};
enc.DateTime = encounterDate;
List <EncounterDTO> encs = new List <EncounterDTO>()
{
enc
};
encounterServicesMock.Setup(m => m.GetAllEncounters()).Returns(encs);
var controller = new EncountersController(loginServices, encounterServicesMock.Object, new LoggerStub(), encounterQueryServices.Object, fixtureGeneratorServices.Object, teamServices.Object)
{
ControllerContext = controllerContext,
};
var obtainedResult = controller.GetAllEncounters(new DateTime(), new DateTime()) as ActionResult <List <EncounterModelOut> >;
encounterServicesMock.Verify(e => e.GetAllEncounters(), Times.AtMostOnce());
Assert.IsNotNull(obtainedResult);
Assert.AreEqual(enc.Id, obtainedResult.Value[0].Id);
Assert.AreEqual(enc.SportName, obtainedResult.Value[0].SportName);
Assert.AreEqual(enc.TeamIds.First(), obtainedResult.Value[0].TeamIds.First());
}
public void CreateEncounterOkEncountersController()
{
ILoginServices loginServices = new LoginServicesMock(santiago);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
DateTime encounterDate = new DateTime(2018, 12, 10);
EncounterDTO enc = new EncounterDTO
{
SportName = football.Name,
TeamIds = new List <string>()
{
river.Name, boca.Name
},
DateTime = encounterDate
};
encounterServicesMock.Setup(m => m.CreateEncounter(enc)).Returns(enc);
var controller = new EncountersController(loginServices, encounterServicesMock.Object, new LoggerStub(), encounterQueryServices.Object, fixtureGeneratorServices.Object, teamServices.Object)
{
ControllerContext = controllerContext,
};
var obtainedResult = controller.CreateEncounter(new EncounterModelIn()
{
TeamIds = enc.TeamIds,
DateTime = enc.DateTime,
SportName = enc.SportName
}) as CreatedAtRouteResult;
encounterServicesMock.Verify(e => e.CreateEncounter(enc), Times.AtMostOnce());
Assert.IsNotNull(obtainedResult);
Assert.IsNotNull(obtainedResult.Value);
Assert.AreEqual(201, obtainedResult.StatusCode);
}
public void TryToAddFollowerWihoutExistsToLoggedUser()
{
var teamServicesMock = new Mock <ITeamServices>();
var encounterServicesMock = new Mock <IEncounterSimpleServices>();
var encounterQueryServicesMock = new Mock <IEncounterQueryServices>();
EncounterDTO encounter = new EncounterDTO()
{
TeamIds = new List <string>()
{
"team1", "team2"
}, SportName = "Sport"
};
string teamName = "Team_Sport";
List <EncounterDTO> encounters = new List <EncounterDTO>()
{
encounter
};
teamServicesMock.Setup(e => e.AddFollowedTeam(teamName)).Throws(new ServicesException());
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new TeamsController(login, teamServicesMock.Object, encounterServicesMock.Object, encounterQueryServicesMock.Object)
{
ControllerContext = controllerContext,
};
var result = controller.AddFollowedTeamToLogedUser(teamName);
teamServicesMock.Verify(e => e.AddFollowedTeam(teamName), Times.AtMostOnce);
var resultRequest = result as BadRequestObjectResult;
Assert.IsNotNull(result);
Assert.IsNotNull(resultRequest);
Assert.AreEqual(400, resultRequest.StatusCode);
}
public EncounterDTO CreateEncounter(EncounterDTO encounterDTO)
{
try
{
adminValidator.ValidatePermissions();
Encounter encounter = mapper.Map(encounterDTO);
ValidateNonOverlappingOfDates(encounter);
encounterRepository.Add(encounter);
return(mapper.Map(encounter));
}
catch (DataAccessException e)
{
throw new ServicesException(e.Message, e);
}
catch (DomainException e)
{
throw new ServicesException(e.Message, e);
}
}
public void UpdateEncounter(EncounterDTO encounterModel)
{
adminValidator.ValidatePermissions();
try
{
Encounter encounter = mapper.Map(encounterModel);
ValidateNonOverlappingOfDates(encounter);
encounterRepository.Update(encounter);
}
catch (DataAccessException e)
{
throw new ServicesException($"Failure to update encounter id = {encounterModel.Id}", e);
}
catch (DomainException e)
{
throw new ServicesException(e.Message, e);
}
}
public void GetEncountersBySportOkSportsController()
{
var encounterQueryServicesMock = new Mock <IEncounterQueryServices>();
EncounterDTO encounter = CreateAEncounter(football.Name);
List <EncounterDTO> encounters = new List <EncounterDTO>()
{
encounter
};
encounterQueryServicesMock.Setup(e => e.GetEncountersBySport(football.Name)).Returns(encounters);
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(login, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServicesMock.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
var obtainedResult = controller.GetEncountersBySport(football.Name) as ActionResult <List <EncounterModelOut> >;
encounterQueryServicesMock.Verify(e => e.GetEncountersBySport(football.Name), Times.AtMostOnce);
Assert.IsNotNull(obtainedResult);
Assert.IsNotNull(obtainedResult.Value);
List <EncounterModelOut> encounterResult = obtainedResult.Value;
Assert.AreEqual(encounter.Id, encounterResult[0].Id);
Assert.AreEqual(encounter.SportName, encounterResult[0].SportName);
Assert.AreEqual(encounter.TeamIds.First(), encounterResult[0].TeamIds.First());
Assert.AreEqual(encounter.TeamIds.Last(), encounterResult[0].TeamIds.Last());
Assert.AreEqual(encounter.DateTime, encounterResult[0].DateTime);
}
public void GetEncounterByIdOk()
{
login.CreateSession("sSanchez", "user");
EncounterSimpleServices encounterSimpleServices = new EncounterSimpleServices(login, encounterRepo, sportRepo, teamRepo, userRepo, commentRepo);
IEnumerable <Team> teams = new List <Team> {
atenas, wanderers
};
DateTime date = new DateTime(3018, 10, 07);
Encounter expected = new Encounter(futbol, teams, date);
EncounterDTO expectedDTO = mapper.Map(expected);
expectedDTO.Id = IntToGuid(2);
Encounter expectedWithId = mapper.Map(expectedDTO);
encounterRepo.Add(expectedWithId);
EncounterDTO recovered = encounterSimpleServices.GetEncounter(IntToGuid(2) + "");
Assert.AreEqual(expectedWithId.Id, recovered.Id);
}
public void GetAllEncountersOfASpecificSport1()
{
string sportName = "Futbol";
EncounterDTO encounter = CreateAEncounter(sportName);
var expectedEncounters = new List <EncounterDTO>()
{
encounter
};
var encounterQueryServicesMock = new Mock <IEncounterQueryServices>();
encounterQueryServicesMock.Setup(s => s.GetEncountersBySport(sportName)).Returns(expectedEncounters);
ILoginServices login = new LoginServicesMock(mariano);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers["Authorization"] = "";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new SportsController(login, sportServicesMock.Object, encounterServicesMock.Object, encounterQueryServicesMock.Object, positionServicesMock.Object, teamServicesMock.Object)
{
ControllerContext = controllerContext,
};
var obtainedResult = controller.GetEncountersBySport(sportName) as ActionResult <List <EncounterModelOut> >;
var val = obtainedResult.Value;
encounterQueryServicesMock.Verify(e => e.GetEncountersBySport(sportName), Times.AtMostOnce);
Assert.IsNotNull(obtainedResult);
Assert.IsNotNull(obtainedResult.Value);
Assert.AreEqual(encounter.Id, obtainedResult.Value[0].Id);
Assert.AreEqual(encounter.SportName, obtainedResult.Value[0].SportName);
Assert.AreEqual(encounter.TeamIds.First(), obtainedResult.Value[0].TeamIds.First());
Assert.AreEqual(encounter.TeamIds.Last(), obtainedResult.Value[0].TeamIds.Last());
Assert.AreEqual(encounter.DateTime, obtainedResult.Value[0].DateTime);
}
private IActionResult TryToAddEncounter(EncounterModelIn encounter)
{
EncounterDTO createdEncounter = encounterSimpleServices.CreateEncounter(encounter.ToServicesDTO());
return(CreatedAtRoute("GetEncounter", new { id = createdEncounter.Id }, createdEncounter));
}
public async Task <ActionResult <List <EncounterMonsterDTO> > > GetMonsters([FromQuery] EncounterDTO encounterDTO)
{
return(await _encounterService.GetMonsters(encounterDTO));
}
public async Task <ActionResult <EncounterValue> > GetValue([FromQuery] EncounterDTO encounterDTO)
{
return(await _encounterService.GetValue(encounterDTO));
}