public TrainingsModel(UserTraining training)
: base()
{
this.Id = training.Training.Id;
this.Text = training.Training.Text;
this.Title = training.Training.Title;
}
public async Task <ActionResult <UserTraining> > PostUserTraining(UserTraining userTraining)
{
var currentId = User.Claims.FirstOrDefault(el => el.Type == ClaimTypes.NameIdentifier)?.Value;
if (currentId != userTraining.UserId && !User.IsInRole("admin"))
{
return(BadRequest());
}
var user = await _context.Users
.Include(el => el.UserDiseases)
.FirstAsync(el => el.Id == userTraining.UserId);
var training = await _context.Training.FindAsync(userTraining.TrainingId);
var trainingIndex = TrainingCalculator.CalculateExercise(user, training);
userTraining.ExerciseIndex = trainingIndex;
_context.UserTraining.Add(userTraining);
await _context.SaveChangesAsync();
userTraining.Training = null;
return(Ok(userTraining));
}
public async Task <IEnumerable <Exercise> > GetExercisesToDelete(UserTraining training)
{
return(await _trainingPlannerDbContext.Exercises
.Where(c => c.UserTrainingId == training.Id)
.Except(training.Exercises)
.ToListAsync());
}
public async Task <UserTraining> UpdateUserTraining(UserTraining training)
{
_trainingPlannerDbContext.Update(training);
await _trainingPlannerDbContext.SaveChangesAsync();
return(training);
}
public UserTrainingsModel(UserTraining train)
: base()
{
this.UserId = train.UserId;
this.TrainingId = train.TrainingId;
this.DateCompleted = train.DateCompleted;
}
public async Task <UserTraining> CreateUserTraining(UserTraining training)
{
await _trainingPlannerDbContext.UserTrainings.AddAsync(training);
await _trainingPlannerDbContext.SaveChangesAsync();
return(training);
}
public void Remove(UserTraining userTraining)
{
dbUserTraining.Remove(userTraining);
Training training = _trainingService.Find(userTraining.TrainingId);
training.Free = true;
_trainingService.Update(training);
}
public void Create(UserTraining userTraining)
{
dbUserTraining.Add(userTraining);
Training training = _trainingService.Find(userTraining.TrainingId);
training.Free = false;
_trainingService.Update(training);
}
public IActionResult EditUserTraining(int id, UserTraining UserTraining)
{
try
{
_ITraining.UpdateUserTraining(UserTraining);
return(RedirectToAction("UserTraining"));
}
catch
{
return(View());
}
}
public IActionResult DeleteUserTraining(int id, UserTraining UserTraining)
{
try
{
// TODO: Add update logic here
_ITraining.DeleteUserTraining(UserTraining.Id);
return(RedirectToAction("UserTraining"));
}
catch
{
return(View());
}
}
public async Task <ActionResult <UserTraining> > Calculate(UserTraining userTraining)
{
var user = await _context.Users
.Include(el => el.UserDiseases)
.FirstAsync(el => el.Id == userTraining.UserId);
var training = await _context.Training.FindAsync(userTraining.TrainingId);
var trainingIndex = TrainingCalculator.CalculateExercise(user, training);
userTraining.ExerciseIndex = trainingIndex;
userTraining.Training = null;
return(Ok(userTraining));
}
public async Task <Training> CreateTrainingAsync(Training training)
{
User user = await _context.Users.FirstOrDefaultAsync(x => x.Id == _authHelper.GetAuthenticatedUserId());
UserTraining newUserTraining = new UserTraining
{
UserId = user.Id,
Training = training
};
_context.Entry(user).Context
.Add(newUserTraining);
await _context.SaveChangesAsync();
return(newUserTraining.Training);
}
private async Task <Training> CreatePrivateTraining(int userId)
{
Training trainingModel = Factory.Training.GetModel(false);
await Context.Training.AddAsync(trainingModel);
await Context.SaveChangesAsync();
UserTraining userTraining = new UserTraining
{
TrainingId = trainingModel.Id,
UserId = userId
};
await Context.UserTraining.AddAsync(userTraining);
await Context.SaveChangesAsync();
return(trainingModel);
}
public IActionResult CreateUserTraining(UserTraining UserTraining)
{
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
_ITraining.InsertUserTraining(UserTraining);
return(RedirectToAction("UserTraining", new { UserId = UserTraining.UserId }));
}
return(View(UserTraining));
}
catch
{
return(View());
}
}
public async Task <IActionResult> PutUserTraining(int id, UserTraining userTraining)
{
var currentId = User.Claims.FirstOrDefault(el => el.Type == ClaimTypes.NameIdentifier)?.Value;
if (currentId != userTraining.UserId && !User.IsInRole("admin"))
{
return(BadRequest());
}
if (id != userTraining.Id)
{
return(BadRequest());
}
_context.Entry(userTraining).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserTrainingExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
// перерахунок рейтингу комлексу тренувань
var training = await _context.Training.Include(el => el.UserTrainings)
.FirstAsync(el => el.Id == userTraining.TrainingId);
training.Score = training.UserTrainings.Sum(el => el.Score) / training.UserTrainings.Count();
_context.Update(training);
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken)
{
var training = await context.Trainings.FindAsync(request.Id);
if (training == null)
{
throw new RestException(HttpStatusCode.NotFound, new { training = "Not found" });
}
var user = await context.Users.SingleOrDefaultAsync(x => x.UserName == _userAccessor.GetCurrentUserName());
var buy = await context.UserTrainings.SingleOrDefaultAsync(x => x.TrainingId == training.TrainingId && x.UserFasserlyId == user.Id);
if (buy != null)
{
if (buy.IsOwner)
{
throw new RestException(HttpStatusCode.NotFound, new { training = "You cannot buy your own courses! " });
}
else
{
throw new RestException(HttpStatusCode.NotFound, new { training = "Already bought this course! " });
}
}
buy = new UserTraining
{
UserFasserly = user,
Training = training,
DateJoined = DateTime.Now,
IsOwner = false,
};
context.Add(buy);
var success = await context.SaveChangesAsync() > 0;
if (success)
{
return(Unit.Value);
}
throw new Exception("Saving problem");
}
private async Task <Training> CreatePublicTraining(int userId = 0)
{
Training trainingModel = Factory.Training.GetModel(true);
await Context.Training.AddAsync(trainingModel);
await Context.SaveChangesAsync();
if (userId > 0)
{
UserTraining userTraining = new UserTraining
{
TrainingId = trainingModel.Id,
UserId = userId
};
await Context.UserTraining.AddAsync(userTraining);
await Context.SaveChangesAsync();
}
return(trainingModel);
}
public async Task <IActionResult> Create([Bind("UserId,TrainingId")] UserTraining userTraining)
{
if (ModelState.IsValid)
{
_userTrainingService.Create(userTraining);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
//ViewData["TrainingId"] = new SelectList(_context.Trainings.Select(t => new SelectListItem
//{ Text = t.Date.ToShortDateString() + " - " + t.Free.ToString(), Value = t.TrainingId.ToString()}).ToList());
//ViewData["UserId"] = new SelectList(_context.Users.Select(u => new SelectListItem
//{Text = u.Name + " - " + u.Address, Value = u.Id.ToString()}).ToList());
ViewData["ErrorMessage"] = "Doslo je do greske.";
return(View(userTraining));
}
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken)
{
var user = await context.Users.SingleOrDefaultAsync(x => x.UserName == _userAccessor.GetCurrentUserName());
var cat = await context.Categories.SingleOrDefaultAsync(x => x.Label == request.Category);
var training = new Training
{
TrainingId = request.TrainingId,
Title = request.Title,
IsActive = request.IsActive,
DateOfCreation = DateTime.Now,
Description = request.Description,
Price = Convert.ToDecimal(request.Price, new CultureInfo("en-US")),
Language = request.Language,
Category = cat,
};
context.Trainings.Add(training);
var buy = new UserTraining
{
UserFasserly = user,
Training = training,
DateJoined = DateTime.Now,
IsOwner = true,
};
context.Add(buy);
var success = await context.SaveChangesAsync() > 0;
if (success)
{
return(Unit.Value);
}
throw new Exception("Saving problem");
}
public int UpdateUserTraining(UserTraining UserTraining)
{
using (SqlConnection con = new SqlConnection(_ConnectionString.Value.ConnectionString))
{
con.Open();
SqlTransaction sqltrans = con.BeginTransaction();
var param = new DynamicParameters();
param.Add("@Id", UserTraining.Id);
param.Add("@UserId", UserTraining.UserId);
param.Add("@TrainingId", UserTraining.TrainingId);
var result = con.Execute("InsertUpdateSingleUserTraining", param, sqltrans, 0, System.Data.CommandType.StoredProcedure);
if (result > 0)
{
sqltrans.Commit();
}
else
{
sqltrans.Rollback();
}
return(result);
}
}
public async Task <UserTrainingGroupedDTO> GenerateAndGetUserTrainingAsync(int userId)
{
var lastNotPassedUserTraining = await _userTrainingRepository.Collection.Include(s => s.Exercises).Include(s => s.Exercises.Select(f => f.Exercise)).FirstOrDefaultAsync(f => f.UserId == userId && !f.IsPassed);
if (lastNotPassedUserTraining != null)
{
return(Mapper.Map <UserTraining, UserTrainingGroupedDTO>(lastNotPassedUserTraining));
}
var userProfessionId = await _settingsRepository.Collection.Where(s => s.Id == userId).Select(f => f.ProfessionId).FirstOrDefaultAsync();
if (!userProfessionId.HasValue)
{
throw new Exception("User has no setted up profession! Please, set up profession first!");
}
var criteriasIds = await _professionCriteriaRepository.Collection.OrderByDescending(s => s.Weight).Take(5).Select(s => s.CriteriaId).ToListAsync();
var exercises = await _exercisesRepository.Collection.IncludeFilter(s => s.ExerciseCriterias.Where(ec => criteriasIds.Any(cid => ec.CriteriaId == cid))).Where(s => s.ExerciseCriterias.Any(ec => criteriasIds.Any(cid => cid == ec.CriteriaId))).ToListAsync();
var exercisesFiltering = exercises.OrderByDescending(s => s.ExerciseCriterias.Sum(f => f.Weight)).Take(5).ToList();
var userTraining = new UserTraining
{
Created = DateTime.UtcNow,
UserId = userId,
Exercises = exercisesFiltering.Select(ex => new UserExercise
{
ExerciseId = ex.Id,
CountOfRepeats = 10
}).ToList()
};
_userTrainingRepository.Insert(userTraining);
await _unitOfWork.SaveChangesAsync();
lastNotPassedUserTraining = await _userTrainingRepository.Collection.Include(s => s.Exercises).Include(s => s.Exercises.Select(f => f.Exercise)).FirstOrDefaultAsync(f => f.UserId == userId && !f.IsPassed);
return(Mapper.Map <UserTraining, UserTrainingGroupedDTO>(lastNotPassedUserTraining));
}
public void Remove(UserTraining userTraining)
{
_context.UserTrainings.Remove(userTraining);
}
private async Task RemoveExercises(UserTraining mappedTraining)
{
var exercisesToDelete = await _userTrainingRepository.GetExercisesToDelete(mappedTraining);
await _userTrainingRepository.RemoveExercises(exercisesToDelete, false);
}
public void Update(UserTraining userTraining)
{
dbUserTraining.Update(userTraining);
}
public void Add(UserTraining userTraining)
{
dbUserTraining.Add(userTraining);
}
public async Task DeleteUserTraining(UserTraining training)
{
_trainingPlannerDbContext.UserTrainings.Remove(training);
await _trainingPlannerDbContext.SaveChangesAsync();
}
public void Update(UserTraining userTraining)
{
_context.UserTrainings.Update(userTraining);
}
public HttpResponseMessage MarkTrainingCompleted(JObject obj)
{
var msg = PerformOperation(() =>
{
string sessionId = obj["sessionId"].Value<string>();
int trainingId = obj["trainingId"].Value<int>();
ValidateSessionId(sessionId);
User currentUser = db.Users.SingleOrDefault(x => x.SessionId == sessionId);
Training tempTraining = db.Trainings.SingleOrDefault(x => x.Id == trainingId);
if (tempTraining == null)
{
throw BuildHttpResponseException("No such training ID", "ERR_ID");
}
UserTraining tempUserTraining = db.UserTrainings.SingleOrDefault(x => x.TrainingId == trainingId && x.UserId == currentUser.Id);
if (tempUserTraining != null)
{
throw BuildHttpResponseException("The selected training has already been marked as trained", "ERR_ID");
}
UserTraining ut = new UserTraining()
{
UserId = currentUser.Id,
TrainingId = trainingId,
DateCompleted = DateTime.Now
};
db.UserTrainings.Add(ut);
db.SaveChanges();
return "Success";
});
return msg;
}
public void Add(UserTraining userTraining)
{
_context.UserTrainings.Add(userTraining);
}
