public IHttpActionResult GetTrainersProfile(string UserID)
{
try
{
var Trainer = context.Trainers.FirstOrDefault(ts => ts.UserID == UserID);
if (Trainer != null)
{
TrainerDto trainerDto = new TrainerDto
{
ID = Trainer.ID,
Courses = Trainer.Courses,
JobTitle = Trainer.JobTitle,
Overview = Trainer.Overview,
PricePerHour = Trainer.PricePerHour,
TrainePlace = Trainer.TrainePlace
};
return(Ok(trainerDto));
}
else
{
return(NotFound());
}
}
catch
{ return(BadRequest()); }
}
public ResultHandler <TrainerDto> Update(TrainerDto trainerDto)
{
ResultHandler <TrainerDto> resultHandler = new ResultHandler <TrainerDto>();
if (trainerDto.Id == Guid.Empty)
{
resultHandler.Errors.Add("Trainer id can't be empty");
return(resultHandler);
}
try
{
Trainer trainer = _trainerRepository.FindOne(trainerDto.Id);
if (trainer == null)
{
resultHandler.Errors.Add("No such trainer exists");
return(resultHandler);
}
trainer = _trainer.Update(trainer, trainerDto.FirstName, trainerDto.LastName, trainerDto.Description, trainerDto.PayRate, trainerDto.IsActive);
_trainerRepository.Update(trainer);
resultHandler.Data = AutoMapper.Mapper.Map <Trainer, TrainerDto>(trainer);
}
catch (Exception ex)
{
resultHandler.Errors.Add(ex.Message);
}
return(resultHandler);
}
public IActionResult Edit(Guid id, [Bind("Id,FirstName,LastName,Description,PayRate,IsActive", Prefix = "Data")] TrainerDto trainer)
{
ResultHandler <TrainerDto> resultHandler = new ResultHandler <TrainerDto>();
if (id != trainer.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
resultHandler = _trainerService.Update(trainer);
}
catch (DbUpdateConcurrencyException)
{
if (!TrainerExists(trainer.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ResultViewModel <TrainerDto> resultViewModel =
AutoMapper.Mapper.Map <ResultHandler <TrainerDto>, ResultViewModel <TrainerDto> >(resultHandler);
return(View(resultViewModel));
}
/// <summary>
/// Ensures that the user property is set.
/// This property can be unset when not in cache.
/// </summary>
/// <param name="trainerDto">The trainer.</param>
/// <returns>Returns the fixed trainer.</returns>
private async Task <TrainerDto> EnsureTrainer(TrainerDto trainerDto)
{
if (!(trainerDto.User is null))
{
return(trainerDto);
}
UserDto userDto = await _userService.FindUserAsync(trainerDto.UserId);
trainerDto.User = userDto;
return(trainerDto);
}
private static void ValidateTrainer(TrainerDto item)
{
if (item is null)
{
throw new BusinessLogicException(StringRes.NullEntityMsg, new ArgumentNullException(nameof(item)));
}
if (string.IsNullOrEmpty(item.Description))
{
throw new ValidationException(Resources.StringRes.EmptyDescriptionMsg, nameof(item.Description));
}
}
public Trainer CreateTrainer(TrainerDto dto)
{
Trainer t = new Trainer()
{
FirstName = dto.FirstName,
LastName = dto.LastName,
Email = dto.Email
};
_context.Trainers.Add(t);
_context.SaveChanges();
return(t);
}
public bool UpdateTrainerNum(int id, TrainerDto trainerDto)
{
Trainer trainerFromDatabase = datacontext.Trainers.FirstOrDefault(x => x.Id == id);
if (trainerFromDatabase != null)
{
trainerFromDatabase.TraineeNum = trainerDto.TraineeNum;
}
else
{
return(false);
}
return(datacontext.SaveChanges() != -1);
}
public IHttpActionResult CreateTrainer(TrainerDto trainerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var trainer = Mapper.Map <TrainerDto, Trainer>(trainerDto);
_context.Trainers.Add(trainer);
_context.SaveChanges();
trainerDto.Id = trainer.Id;
return(Created(new Uri(Request.RequestUri + "/" + trainer.Id), trainerDto));
}
public IActionResult CreateTrainer(TrainerDto dto)
{
Log.Information("Attempting to create trainer.");
Trainer t = _AdminService.CreateTrainer(dto);
if (t == null)
{
Log.Error("Failed to create trainer.");
return(BadRequest());
}
else
{
Log.Information("Trainer created successfully. " + t);
return(Created("Trainer created successfully.", t));
}
}
public IActionResult UpdateTrainer(int trainerId, TrainerDto dto)
{
Log.Information("Attempting to update trainer. TrainerID: " + trainerId);
Trainer t = _AdminService.UpdateTrainer(trainerId, dto);
if (t == null)
{
Log.Error("Failed to update trainer.");
return(BadRequest());
}
else
{
Log.Information("Trainer updated successfully. " + t);
return(Ok(t));
}
}
public Trainer UpdateTrainer(int trainerId, TrainerDto dto)
{
Trainer t = _context.Trainers.Where(x => x.TrainerId == trainerId).FirstOrDefault();
if (t == null)
{
return(null);
}
t.FirstName = dto.FirstName;
t.LastName = dto.LastName;
t.Email = dto.Email;
_context.Update(t);
_context.SaveChanges();
return(t);
}
public ResultHandler <TrainerDto> Create(TrainerDto trainerDto)
{
ResultHandler <TrainerDto> resultHandler = new ResultHandler <TrainerDto>();
try
{
Trainer trainer = _trainer.Create(trainerDto.FirstName, trainerDto.LastName, trainerDto.Description, trainerDto.PayRate, trainerDto.IsActive);
_trainerRepository.Create(trainer);
resultHandler.Data = AutoMapper.Mapper.Map <Trainer, TrainerDto>(trainer);
}
catch (Exception ex)
{
resultHandler.Errors.Add(ex.Message);
}
return(resultHandler);
}
public bool UpdateTrainer(int id, TrainerDto trainerDto)
{
Trainer trainerFromDatabase = datacontext.Trainers.FirstOrDefault(x => x.Id == id);
if (trainerFromDatabase != null)
{
trainerFromDatabase.Picture = trainerDto.Picture;
trainerFromDatabase.Name = trainerDto.Name;
trainerFromDatabase.Field = trainerDto.Field;
trainerFromDatabase.Bio = trainerDto.Bio;
trainerFromDatabase.PostNum = trainerDto.PostNum;
}
else
{
return(false);
}
return(datacontext.SaveChanges() != -1);
}
private void getTrainer(Trainer item)
{
TrainerDto SingleTrainers = new TrainerDto();
SingleTrainers.Courses = item.Courses;
SingleTrainers.ID = item.ID;
SingleTrainers.JobTitle = item.JobTitle;
SingleTrainers.Overview = item.Overview;
SingleTrainers.PricePerHour = item.PricePerHour;
SingleTrainers.TrainePlace = item.TrainePlace;
SingleTrainers.user.Email = item.user.Email;
SingleTrainers.user.Id = item.user.Id;
SingleTrainers.user.PhoneNumber = item.user.PhoneNumber;
SingleTrainers.user.Photo = item.user.Photo;
SingleTrainers.user.FirstName = item.user.FirstName;
SingleTrainers.user.UserName = item.user.UserName;
Traines.Add(SingleTrainers);
}
public IActionResult Create([Bind("Id,FirstName,LastName,Description,PayRate,IsActive", Prefix = "Data")] TrainerDto trainer)
{
ResultHandler <TrainerDto> resultHandler = new ResultHandler <TrainerDto>();
if (ModelState.IsValid)
{
resultHandler = _trainerService.Create(trainer);
if (!resultHandler.HasErrors)
{
return(RedirectToAction(nameof(Index)));
}
}
ResultViewModel <TrainerDto> resultViewModel =
AutoMapper.Mapper.Map <ResultHandler <TrainerDto>, ResultViewModel <TrainerDto> >(resultHandler);
return(View(resultViewModel));
}
public void CreateTrainerAccount(TrainerDto trainer)
{
var newTrainer = new Trainer
{
Id = Guid.NewGuid(),
Name = trainer.Name,
Cnp = trainer.Cnp,
Age = trainer.Age,
Department = trainer.Department,
TechnicalLevel = trainer.TechnicalLevel,
Username = trainer.Username,
Password = trainer.Password,
IdProject = "0",
IdTeam = "0"
};
_repository.Insert(newTrainer);
_repository.Save();
}
public IHttpActionResult UpdateTrainer(int id, TrainerDto trainerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var trainerInDb = _context.Trainers.SingleOrDefault(c => c.Id == id);
if (trainerInDb == null)
{
return(NotFound());
}
Mapper.Map(trainerDto, trainerInDb);
_context.SaveChanges();
return(Ok());
}
public bool AddTrainer(TrainerDto trainerDto)
{
Trainer trainer = new Trainer()
{
Name = trainerDto.Name,
City = trainerDto.City,
Age = trainerDto.Age,
Countery = trainerDto.Countery,
Email = trainerDto.Email,
Password = trainerDto.Password,
Field = trainerDto.Field,
Rate = trainerDto.Rate,
Bio = trainerDto.Bio,
Picture = trainerDto.Picture,
TraineeNum = trainerDto.TraineeNum,
PostNum = trainerDto.PostNum
};
datacontext.Trainers.Add(trainer);
return(datacontext.SaveChanges() != -1);
}
public async Task UpdateTrainerAsync(TrainerDto item)
{
ValidateTrainer(item);
await _trainerEntityService.UpdateAsync(_mapper.Map <Trainer>(item));
}
public IActionResult CreateTrainerAccount([FromBody] TrainerDto trainerDto)
{
_userLogic.CreateTrainerAccount(trainerDto);
return(NoContent());
}
public IActionResult UpdateTrainer([FromBody] TrainerDto trainerDto)
{
throw new NotImplementedException();
}
// TRAINER
public async Task <int> CreateTrainerAsync(TrainerDto item)
{
ValidateTrainer(item);
return(await _trainerEntityService.CreateAsync(_mapper.Map <Trainer>(item)));
}
public TrainerDto UpdateTrainer(TrainerDto trainerDto)
{
throw new NotImplementedException();
}
