public async Task CreateUsersWithAllAchievementsAsync()
{
var user = new User()
{
FirstName = "Vadim", LastName = "Prokopchuk"
};
var newUser = new User()
{
FirstName = "New", LastName = "User"
};
usersRepository.Add(user);
usersRepository.Add(newUser);
await dataContext.SaveChangesAsync();
var achievements = await achievementRepository.GetQuery().ToListAsync();
foreach (var achievement in achievements)
{
var userAchievement = new UserAchievement()
{
CreatedAt = DateTime.Now,
UserId = user.Id,
AchievementId = achievement.Id
};
userAchievementRepository.Add(userAchievement);
}
await dataContext.SaveChangesAsync();
}
public async Task CreateAchievementsAsync()
{
var data = new List <Achievement>()
{
new Achievement()
{
Name = "C# - Bronze"
},
new Achievement()
{
Name = "C# - Silver"
},
new Achievement()
{
Name = "C# - Gold"
},
};
foreach (var achievement in data)
{
achievementRepository.Add(achievement);
}
await dataContext.SaveChangesAsync();
}
public async Task <TestTemplateModel> Create(TestTemplateModel model)
{
var testTemplate = new TestTemplate
{
ExecuteTime = new TimeSpan(0, 10, 0),
Name = model.Name,
CountOfQuestions = model.CountOfQuestions,
Description = model.Description,
CreatedAt = model.CreatedAt,
IsActive = true,
Questions = model.Questions
.Select(x => new QuestionTemplate
{
Name = x.Name,
ControlType = x.ControlType,
Answers = x.Answers.Select(f => new AnswerTemplate
{
Answer = f.Answer,
IsCorrect = f.IsCorrect
}).ToList()
}).ToList()
};
testTemplateRepository.Add(testTemplate);
await dataContext.SaveChangesAsync();
return(TestTemplateMap.Map(testTemplate));
}
public async Task Update(string content)
{
var literature = await literatureRepository.GetQuery().FirstOrDefaultAsync();
if (literature == null)
{
literature = new Literature();
literatureRepository.Add(literature);
}
literature.Content = content;
await dataContext.SaveChangesAsync();
}
public async Task <UserViewModel> CreateAsync(CreateUserViewModel createUserViewModel)
{
var user = new User()
{
FirstName = createUserViewModel.FirstName,
LastName = createUserViewModel.LastName
};
usersRepository.Add(user);
await dataContext.SaveChangesAsync();
return(MapUser(user));
}
public async Task <GroupModel> Create(string name)
{
var group = new StudyGroup {
Name = name
};
groupsRepository.Add(group);
await dataContext.SaveChangesAsync();
return(new GroupModel
{
Id = group.Id,
Name = group.Name,
CreatedAt = group.CreatedAt,
ModifiedAt = group.ModifiedAt,
Users = Enumerable.Empty <UserModel>().ToList()
});
}
public async Task <LectureModel> CreateAsync(LectureModel model)
{
var lecture = new Lecture
{
Name = model.Name,
Url = model.Url,
Content = model.Content,
Preview = model.Preview,
Section = model.Section,
};
lectureRepository.Add(lecture);
await dataContext.SaveChangesAsync();
lecture = await lectureTagBinder.BindTags(lecture, model.Tags);
return(LectureMap.Map(lecture));
}
public async Task <KnowledgeTestModel> Execute(ExecuteTestModel model)
{
var template = await testTemplateRepository.GetQuery().FirstOrDefaultAsync(x => x.Id == model.Id);
if (!template.IsActive)
{
throw new ApplicationException();
}
var user = await currentUser.GetCurrentUserAsync();
var knowledgeTest = new KnowledgeTest
{
UserId = user.Id,
TestTemplateId = template.Id,
ExpiredAt = DateTime.UtcNow.AddMinutes(10),
Questions = template.Questions.Select(x => new KnowledgeTestQuestion
{
QuestionTemplateId = x.Id,
}).ToList(),
};
knowledgeTestRepository.Add(knowledgeTest);
await dataContext.SaveChangesAsync();
return(new KnowledgeTestModel
{
Id = knowledgeTest.Id,
Name = knowledgeTest.TestTemplate.Name,
Questions = knowledgeTest.Questions.Select(x => new KnowledgeQuestionModel
{
Id = x.Id,
Name = x.QuestionTemplate.Name,
ControlType = x.QuestionTemplate.ControlType,
Answers = x.QuestionTemplate.Answers.Select(f => new KnowledgeAnswerModel
{
Id = f.Id,
Answer = x.QuestionTemplate.ControlType == ControlType.Text ? null : f.Answer
}).ToList()
}).ToList()
});
}
private async Task <Lecture> BindTags(Lecture lecture, List <Tag> tags)
{
lecture = ResetTags(lecture);
foreach (var tag in tags)
{
var lectureTag = new LectureTag
{
LectureId = lecture.Id,
TagId = tag.Id
};
lecture.LectureTags.Add(lectureTag);
lectureTagRepository.Add(lectureTag);
}
await dataContext.SaveChangesAsync();
return(lecture);
}
private async Task <List <Tag> > CreateTagsAsync(List <TagModel> tagList)
{
tagList ??= new List <TagModel>();
var tags = tagList
.Where(x => x.Value.HasValue)
.Select(TagMap.Map)
.ToList();
foreach (var tag in tagList.Where(x => !x.Value.HasValue))
{
var entityTag = new Tag()
{
Name = tag.Display
};
tagRepository.Add(entityTag);
tags.Add(entityTag);
}
await dataContext.SaveChangesAsync();
return(tags);
}
public async Task <UserModel> RegisterAsync(RegisterUserModel registerUser)
{
var user = await usersService.GetByEmailAsync(registerUser.Email);
if (user != null)
{
throw new ApplicationException("Пользователь с таким email уже существует.");
}
var verificationCode = GetVerificationCode(registerUser.Email);
if (registerUser.VerificationCode?.Trim() != verificationCode.Trim())
{
throw new ApplicationException("Неверный код подтверждения.");
}
var encryptedPassword = passwordEncrypter.Encrypt(registerUser.Password);
user = new User
{
FirstName = registerUser.FirstName,
LastName = registerUser.LastName,
Email = registerUser.Email,
Password = encryptedPassword,
UserRoles = new List <UserRole> {
new UserRole {
Role = Role.Student
}
}
};
usersRepository.Add(user);
await dataContext.SaveChangesAsync();
return(UserMap.Map(user));
}