public async Task <ExerciseHistoryDto> AddExerciseHistoryAsync(int exerciseId, int userId)
{
Exercise exercise = await exerciseRepository.GetByIdAsync(exerciseId);
if (exercise?.TrainingTemplate.CreatorId != userId)
{
return(null);
}
ActiveTraining activeTraining = exercise.TrainingTemplate.Creator.ActiveTraining;
if (activeTraining is null || !exercise.TrainingTemplate.Equals(activeTraining.TrainingTemplate))
{
return(null);
}
ExerciseHistory exerciseHistory = mapper.Map <Exercise, ExerciseHistory>(exercise);
exerciseHistory.EndDate = DateTime.Now.ToUniversalTime();
exerciseHistory.TrainingHistoryId = activeTraining.TrainingHistory.Id;
exerciseHistory.Properties =
exercise.Properties.Select(p => mapper.Map <ExerciseProperty, ExercisePropertyHistory>(p)).ToList();
exerciseHistory = await exerciseHistoryRepository.AddAsync(exerciseHistory);
await exerciseHistoryRepository.SaveChangesAsync();
return(mapper.Map <ExerciseHistory, ExerciseHistoryDto>(exerciseHistory));
}
public async Task <ActiveTrainingDto> StartTrainingAsync(int trainingTemplateId, int userId)
{
TrainingTemplate trainingTemplate = await trainingTemplateRepository.GetByIdAsync(trainingTemplateId);
if (
trainingTemplate?.CreatorId != userId ||
trainingTemplate.Exercises.Count == 0 ||
trainingTemplate.Creator.ActiveTraining is not null)
{
return(null);
}
TrainingHistoryDto trainingHistoryDto =
await trainingHistoryService.AddTrainingHistoryAsync(trainingTemplateId, userId);
TrainingHistory trainingHistory = await trainingHistoryRepository.GetByIdAsync(trainingHistoryDto.Id);
ActiveTraining activeTraining = new ActiveTraining()
{
UserId = trainingHistory.UserId,
TrainingHistoryId = trainingHistory.Id,
TrainingTemplateId = trainingTemplate.Id
};
activeTraining = await activeTrainingRepository.AddAsync(activeTraining);
await activeTrainingRepository.SaveChangesAsync();
return(mapper.Map <ActiveTraining, ActiveTrainingDto>(activeTraining));
}
public async Task <ExerciseDto> PeformExerciseAsync(int userId)
{
ExerciseDto exerciseDto = await GetExerciseAsync(userId);
if (exerciseDto is null)
{
return(null);
}
ActiveTraining activeTraining = (await userRepository.GetByIdAsync(userId)).ActiveTraining;
activeTraining.ExerciseDonePosition++;
await activeTrainingRepository.UpdateAsync(activeTraining);
ExerciseHistoryDto exerciseHistoryDto =
await exerciseHistoryService.AddExerciseHistoryAsync(exerciseDto.Id, userId);
if (exerciseHistoryDto is null)
{
return(null);
}
return(exerciseDto);
}
public void SetResult(ActiveTraining activeTraining, int gainedXP, TrainingGameResultFeedbackData data)
{
//skillNameField.text = activeTraining.Training.Name;
//skillSpriteImage.sprite = activeTraining.Training.Visual;
//xpAmountField.text = gainedXP.ToString();
feedbackData = data;
GameObject feedbackDisplay = Instantiate(activeTraining.Training.FeedbackController.gameObject, feedbackContainer);
feedbackController = feedbackDisplay.GetComponent <TrainingGameResultFeedback>();
feedbackController.Setup(data);
}
public async Task <ActiveTrainingDto> GetActiveTrainingAsync(int userId)
{
ActiveTraining activeTraining = (await userRepository.GetByIdAsync(userId)).ActiveTraining;
if (activeTraining is null)
{
return(null);
}
return(mapper.Map <ActiveTraining, ActiveTrainingDto>(activeTraining));
}
public override void Setup(ActiveTraining training)
{
activeTraining = training;
trainingRunTime = 0;
itemsCorrect = 0;
itemsLate = 0;
itemsEarly = 0;
doughBowlButton.onClick.AddListener(TryAddItem);
foreach (TapReactionItem item in reactionItems)
{
item.Disable();
}
}
public async Task <bool> EndTrainingAsync(int userId)
{
ActiveTraining activeTrainging = (await userRepository.GetByIdAsync(userId))?.ActiveTraining;
if (activeTrainging is null)
{
return(false);
}
bool result = await activeTrainingRepository.DeleteAsync(activeTrainging);
await activeTrainingRepository.SaveChangesAsync();
return(result);
}
public async Task <ExerciseDto> GetExerciseAsync(int userId)
{
ActiveTraining activeTraining = (await userRepository.GetByIdAsync(userId))?.ActiveTraining;
if (activeTraining is null)
{
return(null);
}
Exercise exercise =
activeTraining.TrainingTemplate.Exercises
.FirstOrDefault(e => e.Position == activeTraining.ExerciseDonePosition + 1);
if (exercise is null)
{
return(null);
}
return(mapper.Map <Exercise, ExerciseDto>(exercise));
}
public abstract void Setup(ActiveTraining training);
public UnlockReturn HandleUnlock(BaseData newUnlock)
{
if (newUnlock is Skill)
{
Skill newSkill = newUnlock as Skill;
ActiveSkillCategory activeSkillCategory = GetActiveSkillCategory(newSkill.SkillCategory);
if (activeSkillCategory == null)
{
activeSkillCategory = new ActiveSkillCategory(newSkill.SkillCategory);
ActiveSkillCategories.Add(activeSkillCategory);
}
ActiveSkill activeSkill = activeSkillCategory.GetActiveSkill(newSkill);
if (activeSkill == null)
{
activeSkill = new ActiveSkill(newSkill);
activeSkillCategory.ActiveSkills.Add(activeSkill);
return(UnlockReturn.NewUnlock);
}
return(UnlockReturn.WasUnlocked);
}
if (newUnlock is SkillLevel)
{
SkillLevel newSkillLevel = newUnlock as SkillLevel;
ActiveSkillCategory activeSkillCategory = GetActiveSkillCategory(newSkillLevel.Skill.SkillCategory);
if (activeSkillCategory == null)
{
activeSkillCategory = new ActiveSkillCategory(newSkillLevel.Skill.SkillCategory);
ActiveSkillCategories.Add(activeSkillCategory);
}
ActiveSkill activeSkill = activeSkillCategory.GetActiveSkill(newSkillLevel.Skill);
if (activeSkill == null)
{
activeSkill = new ActiveSkill(newSkillLevel.Skill);
activeSkillCategory.ActiveSkills.Add(activeSkill);
}
ActiveSkillLevel activeSkillLevel = activeSkill.GetActiveSkillLevel(newSkillLevel);
if (activeSkillLevel == null)
{
activeSkillLevel = new ActiveSkillLevel(newSkillLevel);
activeSkill.ActiveSkillLevels.Add(activeSkillLevel);
return(UnlockReturn.NewUnlock);
}
return(UnlockReturn.WasUnlocked);
}
if (newUnlock is TrainingData)
{
TrainingData newTraining = newUnlock as TrainingData;
ActiveSkillCategory activeSkillCategory = GetActiveSkillCategory(newTraining.TargetSkill.SkillCategory);
if (activeSkillCategory == null)
{
activeSkillCategory = new ActiveSkillCategory(newTraining.TargetSkill.SkillCategory);
ActiveSkillCategories.Add(activeSkillCategory);
}
ActiveSkill activeSkill = activeSkillCategory.GetActiveSkill(newTraining.TargetSkill);
if (activeSkill == null)
{
activeSkill = new ActiveSkill(newTraining.TargetSkill);
activeSkillCategory.ActiveSkills.Add(activeSkill);
}
ActiveTraining activeTraining = activeSkill.ActiveTraining;
if (activeTraining == null)
{
activeTraining = new ActiveTraining(newTraining);
activeSkill.ActiveTraining = activeTraining;
return(UnlockReturn.NewUnlock);
}
if (activeTraining.Data == null)
{
activeTraining.Data = newTraining;
return(UnlockReturn.NewUnlock);
}
else
{
if (activeTraining.Training.XPGainTraining < newTraining.XPGainTraining)
{
activeTraining.Data = newTraining;
return(UnlockReturn.NewUnlock);
}
}
return(UnlockReturn.WasUnlocked);
}
throw new System.ArgumentException("Unlock not supported for " + newUnlock);
}
