private Encounter AddNew(Encounter aMatch)
{
EncounterEntity toAdd = matchConverter.ToEntity(aMatch);
context.Entry(toAdd).State = EntityState.Added;
AddComments(toAdd, aMatch.GetAllCommentaries());
//We also need to ask if it is an Sql database, so that we can execute the sql scripts.
if (aMatch.Id > 0 && context.Database.IsSqlServer())
{
SaveWithIdentityInsert();
}
else
{
context.SaveChanges();
}
Encounter added = factory.CreateEncounter(toAdd.Id, aMatch.GetParticipants(), aMatch.Date, aMatch.Sport);
ICollection <EncounterTeam> playingTeams = matchConverter.ConvertParticipants(added);
foreach (EncounterTeam team in playingTeams)
{
context.Entry(team).State = EntityState.Added;
}
context.SaveChanges();
context.Entry(toAdd).State = EntityState.Detached;
return(added);
}
private void DeleteExistent(int anId)
{
EncounterEntity retrieved = context.Encounters.Include(m => m.Commentaries).First(m => m.Id == anId);
context.Encounters.Remove(retrieved);
context.Comments.RemoveRange(retrieved.Commentaries);
context.SaveChanges();
}
public void MatchToEntityWithResultTest()
{
Result matchResult = GetFakeResult();
match.Result = matchResult;
EncounterEntity converted = testMapper.ToEntity(match);
Assert.IsTrue(converted.HasResult);
}
private Commentary CommentOnExistingMatch(int idMatch, Commentary aComment)
{
CommentEntity comment = commentConverter.ToEntity(aComment);
EncounterEntity commented = context.Encounters.Include(m => m.Commentaries).First(m => m.Id == idMatch);
commented.Commentaries.Add(comment);
context.Attach(comment).State = EntityState.Added;
context.SaveChanges();
return(commentConverter.ToComment(comment));
}
private void AddComments(EncounterEntity entity, ICollection <Commentary> commentaries)
{
IEnumerable <CommentEntity> commentEntities = commentaries.Select(c => commentConverter.ToEntity(c));
foreach (CommentEntity ce in commentEntities)
{
entity.Commentaries.Add(ce);
context.Entry(ce.Maker).State = EntityState.Unchanged;
}
}
public Encounter Map(EncounterEntity entity)
{
IEnumerable <Team> teams = entity.Teams.Select(t => t.Team.ToModel());
ICollection <Comment> comments = entity.Comments.ToList().Select(t => t.ToModel()).ToList();
Sport sport = sportMapper.Map(entity.Sport);
Dictionary <Team, int> results = new Dictionary <Team, int>();
entity.Results.ToList().ForEach(p => results.Add(p.Team.ToModel(), p.Position));
return(new Encounter(entity.Id, sport, teams, entity.DateTime, comments, results));
}
public bool InsertEncounter(EncounterModel em)
{
//Mappers
EncounterEntity ee = new EncounterEntity();
ee.Id = em.Id;
ee.Name = em.Name;
ee.IdInstance = em.IdInstance;
ee.Media = em.Media;
return(_encounterRepo.Insert(ee));
}
public EncounterEntity ToEntity(Encounter anEncounter)
{
SportEntity sportEntity = sportConverter.ToEntity(anEncounter.Sport);
EncounterEntity conversion = new EncounterEntity()
{
Id = anEncounter.Id,
Date = anEncounter.Date,
Commentaries = TransformCommentaries(anEncounter.GetAllCommentaries()),
SportEntity = sportEntity,
HasResult = anEncounter.HasResult()
};
return(conversion);
}
public bool InsertEncounterAndItem(EncounterModel em)
{
//Mappers
EncounterEntity ee = new EncounterEntity();
ee.Id = em.Id;
ee.Name = em.Name;
ee.IdInstance = em.IdInstance;
ee.Media = em.Media;
ee.ItemEntities = new List <ItemEntity>();
foreach (var item in em.Items)
{
//ee.ItemEntities.Add(new ItemEntity()
//{
// Id = item.Id,
// Name = item.Name,
// Type = item.Type,
// SubType = item.SubType,
// CreatureName = item.CreatureName,
// Icon = item.Icon,
// Media = item.Media,
//});
ItemEntity ie = new ItemEntity()
{
Id = item.Id,
Name = item.Name,
Type = item.Type,
SubType = item.SubType,
CreatureName = item.CreatureName,
Icon = item.Icon,
Media = item.Media,
};
this._itemRepo.Insert(ie);
EncounterItemEntity encounterItemEntity = new EncounterItemEntity()
{
IdEncounter = em.Id,
IdItem = item.Id,
};
this._encounterItemRepo.Insert(encounterItemEntity);
}
return(_encounterRepo.Insert(ee));
}
public Encounter ToEncounter(EncounterEntity anEncounter, ICollection <EncounterTeam> playingTeams)
{
ICollection <Commentary> comments = anEncounter.Commentaries.Select(ce => commentConverter.ToComment(ce)).ToList();
ICollection <Team> teams = playingTeams.Select(tm => teamConverter.ToTeam(tm.Team)).ToList();
DateTime date = anEncounter.Date;
Sport sport = sportConverter.ToSport(anEncounter.SportEntity);
Encounter created = factory.CreateEncounter(anEncounter.Id, teams, date, sport, comments);
if (anEncounter.HasResult)
{
Result matchResult = ToResults(playingTeams);
created.Result = matchResult;
}
return(created);
}
public void ModifyExistent(Encounter aMatch)
{
EncounterEntity converted = matchConverter.ToEntity(aMatch);
if (context.Encounters.Any(m => m.Id == aMatch.Id))
{
EncounterEntity old = context.Encounters.First(m => m.Id == aMatch.Id);
context.Entry(old).State = EntityState.Detached;
}
context.Entry(converted).State = EntityState.Modified;
ICollection <EncounterTeam> playingTeams = matchConverter.ConvertParticipants(aMatch);
RemoveMissingParticipants(aMatch);
AddNewParticipants(playingTeams);
context.SaveChanges();
context.Entry(converted).State = EntityState.Detached;
}
public void MatchToEntityCommentsCountTest()
{
UserId identity = new UserId
{
Name = "aName",
Surname = "aSurname",
UserName = "******",
Password = "******",
Email = "*****@*****.**"
};
Mock <User> user = new Mock <User>(identity, false);
match.AddCommentary(new Commentary("test comment", user.Object));
EncounterEntity converted = testMapper.ToEntity(match);
Assert.AreEqual(converted.Commentaries.Count, 1);
}
public void SetUp()
{
factory = new EncounterFactory();
testMapper = new EncounterMapper();
SportEntity testSport = new SportEntity()
{
Name = "Soccer", IsTwoTeams = true
};
TeamEntity homeTest = new TeamEntity {
TeamNumber = 3, SportEntityName = "Soccer", Sport = testSport, Name = "Nacional", Photo = "aPath"
};
TeamEntity awayTest = new TeamEntity {
TeamNumber = 4, SportEntityName = "Soccer", Sport = testSport, Name = "Torque", Photo = "aPath"
};
entity = new EncounterEntity()
{
Id = 3,
Date = DateTime.Now,
SportEntity = testSport,
HasResult = false,
Commentaries = new List <CommentEntity>()
};
EncounterTeam homeRel = new EncounterTeam()
{
Team = homeTest, TeamNumber = 3, Encounter = entity, EncounterId = 3
};
EncounterTeam awayRel = new EncounterTeam()
{
Team = awayTest, TeamNumber = 4, Encounter = entity, EncounterId = 3
};
playingTeams = new List <EncounterTeam>()
{
homeRel, awayRel
};
homeMock = new Team(3, "Nacional", "aPath", new Sport("Soccer", true));
awayMock = new Team(4, "Torque", "aPath", new Sport("Soccer", true));
Sport sport = new Sport("Soccer", true);
match = factory.CreateEncounter(new List <Team>()
{
homeMock, awayMock
}, DateTime.Now, sport);
}
public void Update(Encounter source, EncounterEntity destination)
{
List <TeamEntity> teams = source.Teams.Select(sourceTeam => new TeamEntity(sourceTeam)).ToList();
destination.DateTime = source.DateTime;
destination.Sport = new SportEntity(source.Sport);
destination.Id = source.Id;
destination.Comments = source.Comments.Select(c => new CommentEntity(c)).ToList();
destination.Teams = source.Teams.Select(t => new EncounterTeam(destination, new TeamEntity(t))).ToList();
List <TeamResult> results = source.Results.Select(p => new TeamResult()
{
EncounterId = source.Id,
Team = new TeamEntity(p.Key),
TeamId = p.Key.Name + "_" + p.Key.Sport.Name,
Position = p.Value
}).ToList();
destination.Results = results;
}
private Encounter GetExistentMatch(int anId)
{
EncounterEntity entity = context.Encounters
.Include(m => m.SportEntity)
.Include(m => m.Commentaries).ThenInclude(c => c.Maker)
.First(me => me.Id == anId);
ICollection <EncounterTeam> match_teams = context.EncounterTeams.Include(mt => mt.Team)
.ThenInclude(t => t.Sport)
.Where(mt => mt.EncounterId == anId)
.ToList();
Encounter conversion = matchConverter.ToEncounter(entity, match_teams);
context.Entry(entity).State = EntityState.Detached;
foreach (EncounterTeam mt in match_teams)
{
context.Entry(mt).State = EntityState.Detached;
}
return(conversion);
}
public ICollection <EncounterTeam> ConvertParticipants(Encounter anEncounter)
{
EncounterEntity matchEntity = ToEntity(anEncounter);
ICollection <EncounterTeam> conversions = new List <EncounterTeam>();
foreach (Team participant in anEncounter.GetParticipants())
{
TeamEntity team = teamConverter.ToEntity(participant);
EncounterTeam participantConversion = new EncounterTeam()
{
Encounter = matchEntity,
EncounterId = matchEntity.Id,
Team = team,
TeamNumber = team.TeamNumber
};
conversions.Add(participantConversion);
}
if (anEncounter.HasResult())
{
ResultsToEntity(conversions, anEncounter.Result);
}
return(conversions);
}
public EncounterEntity Map(Encounter encounter)
{
IEnumerable <TeamEntity> teams = encounter.Teams.Select(t => teamMapper.Map(t));
EncounterEntity encounterEntity = new EncounterEntity()
{
DateTime = encounter.DateTime,
Sport = sportMapper.Map(encounter.Sport),
Id = encounter.Id,
Comments = encounter.Comments.Select(c => new CommentEntity(c)).ToList()
};
ICollection <TeamResult> results = new List <TeamResult>();
encounter.Results.ToList().ForEach(p => results.Add(new TeamResult()
{
Team = new TeamEntity(p.Key),
Position = p.Value,
EncounterId = encounterEntity.Id
}));
encounterEntity.Results = results;
encounterEntity.Teams = encounter.Teams.Select(t => new EncounterTeam(encounterEntity, new TeamEntity(t))).ToList();
return(encounterEntity);
}
public void MatchToEntityNoResultTest()
{
EncounterEntity converted = testMapper.ToEntity(match);
Assert.IsFalse(converted.HasResult);
}
public void MatchToEntityDateTest()
{
EncounterEntity converted = testMapper.ToEntity(match);
Assert.AreEqual(converted.Date.ToString(), entity.Date.ToString());
}
