public void updateAthlete(AthleteDTO athlete)
{
var result = context.athelete
.Include("user")
.FirstOrDefault(x => x.id == athlete.id);
var result2 = context.user
.FirstOrDefault(x => x.id == athlete.userId);
if (result != null && result2 != null)
{
result.disciplineId = athlete.disciplineId;
result.user.username = athlete.username;
result.user.password = athlete.password;
result.user.userType = athlete.userType;
result.user.firstName = athlete.firstName;
result.user.lastName = athlete.lastName;
result.user.cellPhone = athlete.cellPhone;
result.user.address = athlete.address;
result.user.emailAddress = athlete.emailAddress;
context.SaveChanges();
}
}
public NewAthleteResponseDTO insertAthlete(AthleteDTO athleteDTO)
{
if (context.user.FirstOrDefault(u => u.username == athleteDTO.username) != null)
{
return(new NewAthleteResponseDTO()
{
response = "El nombre de usuario ya existe", id = 0
});
}
else
{
var userAdded = context.user.Add(athleteDTO.toUser());
context.SaveChanges();
athleteDTO.userId = userAdded.id;
var athleteAdded = context.athelete.Add(athleteDTO.toAthlete());
context.athleteDetails.Add(new athleteDetails()
{
athleteId = athleteAdded.id,
available = true
//dateOfDetailInserted = DateTime.UtcNow.Date
});
context.SaveChanges();
return(new NewAthleteResponseDTO()
{
response = "Usuario agregado", id = athleteAdded.id
});
}
}
public List <AthleteDTO> findByName(string name)
{
List <AthleteDTO> athletesDTO = new List <AthleteDTO>();
var athletes = context.athelete
.Include("user")
.Where(x => x.user.firstName == name && x.available)
.ToList();
athletes.ForEach(x => athletesDTO.Add(AthleteDTO.from(x)));
return(athletesDTO);
}
public List <AthleteDTO> findAll()
{
List <AthleteDTO> athletesDTO = new List <AthleteDTO>();
var athletes = context.athelete
.Include("user")
.Where(a => a.available)
.ToList();
athletes.ForEach(x => athletesDTO.Add(AthleteDTO.from(x)));
return(athletesDTO);
}
// PUT: api/Athletes/5
public IHttpActionResult Put(int id, [FromBody] AthleteDTO value)
{
try
{
athleteService.updateAthlete(value);
}
catch (Exception e)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.ToString())));
}
return(Ok());
}
public List <AthleteDTO> atheletesByCoachId(int id)
{
List <AthleteDTO> athletesDTO = new List <AthleteDTO>();
var athletesByCoach = context.coachByAthelete
.Include("coach")
.Include("athelete")
.Where(a => a.coachId == id && a.available)
.ToList();
athletesByCoach.ForEach(x => athletesDTO.Add(AthleteDTO.from(x.athelete)));
return(athletesDTO);
}
public AthleteDTO findById(int id)
{
var x = context.athelete
.Include("user")
.FirstOrDefault(c => c.id == id && c.available);
if (x == null)
{
return(null);
}
return(AthleteDTO.from(x));
}
// POST: api/Athletes
public IHttpActionResult Post([FromBody] AthleteDTO value)
{
try
{
NewAthleteResponseDTO athleteAdded = athleteService.insertAthlete(value);
return(ResponseMessage(Request.CreateResponse(new
{
response = athleteAdded.response,
idAthleteAdded = athleteAdded.id
})));
}
catch (Exception e)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.ToString())));
}
}
public ActionResult AddAthlete([FromBody] AthleteDTO athlete, int raceId, string city, string team, string bib)
{
try
{
var athleteId = athlete.AthleteId;
if (athlete.AthleteId == 0)
{
athleteId = _model.AddAthlete(athlete);
}
//add athlete to race, i.e. add result
_model.AddAthleteToRace(athleteId, raceId, city, team, bib);
return(CreatedAtAction("New athlete added", athlete));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
public void Post(AthleteDTO athlete)
{
Athlete athleteToSave = dBContext.Athletes.Where(x => x.Id == athlete.Id).SingleOrDefault();
bool isNew = false;
if (athleteToSave == null)
{
isNew = true;
athleteToSave = new Athlete();
}
athleteToSave.Country = athlete.Country;
athleteToSave.Birth = athlete.Birth;
athleteToSave.BirthPlace = athlete.BirthPlace;
athleteToSave.FullName = athlete.FullName;
if (!isNew)//remove existing links
{
dBContext.AthleteSports.RemoveRange(dBContext.AthleteSports.Where(x => x.AthleteId == athleteToSave.Id));
}
if (isNew)
{
dBContext.Athletes.Add(athleteToSave);
}
dBContext.SaveChanges();
if (athlete.Sports != null)
{
foreach (var sportDTO in athlete.Sports)
{
dBContext.AthleteSports.Add(new AthleteSport()
{
AthleteId = athleteToSave.Id,
SportId = sportDTO.Id
});
}
}
dBContext.SaveChanges();
}
public async Task <IHttpActionResult> PostAthlete(Athlete athlete)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Athletes.Add(athlete);
try
{
await db.SaveChangesAsync();
// New code:
// Load team name
db.Entry(athlete).Reference(x => x.team).Load();
var dto = new AthleteDTO()
{
student_number = athlete.student_number,
student_firstname = athlete.student_firstname,
student_lastname = athlete.student_lastname
};
}
catch (DbUpdateException)
{
if (AthleteExists(athlete.student_number))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = athlete.student_number }, athlete));
}
public List <AthleteDTO> atheletesByCoachIdSubAge(int id, int edadInicio, int edadFin)
{
List <AthleteDTO> athletesDTO = new List <AthleteDTO>();
var athletesByCoach = context.coachByAthelete
.Include("coach")
.Include("athelete")
.Where(a => a.coachId == id && a.available)
.ToList();
athletesByCoach.ForEach(a => athletesDTO.Add(AthleteDTO.from(a.athelete)));
List <AthleteDTO> athletesDTOSubAge = new List <AthleteDTO>();
athletesDTO.ForEach(a => {
int age = DateTime.Now.Year - a.birthDate.Year;
if (age >= edadInicio && age <= edadFin)
{
athletesDTOSubAge.Add(a);
}
});
return(athletesDTOSubAge);
}
public void updateAthlete(AthleteDTO athleteDTO)
{
athleteRepository.updateAthlete(athleteDTO);
}
public NewAthleteResponseDTO insertAthlete(AthleteDTO athleteDTO)
{
return(athleteRepository.insertAthlete(athleteDTO));
}
