public async Task <string> SocialSignIn(SocialSignInViewModel model)
{
await _authValidationService.ValidateSocialSignInViewModel(model);
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
user = new OmdleUser
{
UserName = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email
};
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new SocialSignInFailedException(
$"An error occured while signing in Facebook user: {result.Errors.Select(e => e.Description).Join(", ")}");
}
await _userManager.AddToRoleAsync(user, "Student");
}
await _signInManager.SignInAsync(user, false);
var token = await GetToken(user);
return(token);
}
private async Task <string> GetToken(OmdleUser user)
{
var utcNow = DateTime.UtcNow;
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName),
new Claim(JwtRegisteredClaimNames.GivenName, $"{user.FirstName} {user.LastName }"),
new Claim(JwtRegisteredClaimNames.Jti, user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Iat, utcNow.ToString(CultureInfo.InvariantCulture))
};
var userRoles = await _userManager.GetRolesAsync(user);
foreach (var role in userRoles)
{
claims.Add(new Claim("role", role));
}
var signingKey =
new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.GetValue <string>("Tokens:Key")));
var signingCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
var jwt = new JwtSecurityToken(
signingCredentials: signingCredentials,
claims: claims,
notBefore: utcNow,
expires: utcNow.AddSeconds(_configuration.GetValue <int>("Tokens:Lifetime"))
);
return(new JwtSecurityTokenHandler().WriteToken(jwt));
}
public async Task <string> Register(RegisterViewModel model)
{
await _authValidationService.ValidateRegisterViewModel(model);
var newUser = new OmdleUser
{
UserName = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email
};
var result = await _userManager.CreateAsync(newUser, model.Password);
if (!result.Succeeded)
{
throw new RegistrationFailedException(
$"An error occured while registering user: {result.Errors.Select(e => e.Description).Join(", ")}");
}
await _userManager.AddToRoleAsync(newUser, "Student");
await _signInManager.SignInAsync(newUser, false);
var token = await GetToken(newUser);
return(token);
}
public UserViewModel(OmdleUser x)
{
Id = x.Id.ToString();
Firstname = x.FirstName;
Lastname = x.LastName;
Email = x.Email;
}
/// <summary>check out of course as an asynchronous operation.</summary>
/// <param name="student">The student.</param>
/// <param name="course">The course.</param>
/// <returns>Task.</returns>
public async Task CheckOutOfCourseAsync(OmdleUser student, Data.Models.Course course)
{
StudentCourse studentCourse = _dataService.GetSet <Data.Models.StudentCourse>().FirstOrDefault(x => x.Course == course && x.Student == student);
_dataService.GetSet <Data.Models.StudentCourse>().Remove(studentCourse);
await _dataService.SaveDbAsync();
}
/// <summary>Creates the teacher.</summary>
/// <param name="student">The student.</param>
/// <returns>Task.</returns>
public async Task CreateTeacher(OmdleUser student)
{
await _userManager.RemoveFromRoleAsync(student, "Student");
await _userManager.AddToRoleAsync(student, "Teacher");
await _dataService.SaveDbAsync();
}
/// <summary>Determines whether [is student in course] [the specified student].</summary>
/// <param name="student">The student.</param>
/// <param name="course">The course.</param>
/// <returns>
/// <c>true</c> if [is student in course] [the specified student]; otherwise, <c>false</c>.</returns>
public bool IsStudentInCourse(OmdleUser student, Data.Models.Course course)
{
var model = _dataService.GetSet <StudentCourse>().Where(x => x.Student == student && x.Course == course);
if (model != null)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>create course as an asynchronous operation.</summary>
/// <param name="title">The title.</param>
/// <param name="owner">The owner.</param>
/// <returns>Task<Data.Models.Course>.</returns>
public async Task <Data.Models.Course> CreateCourseAsync(string title, OmdleUser owner)
{
var model = new Data.Models.Course
{
Title = title,
OwnerUser = owner,
OwnerId = owner.Id
};
await _dataService.GetSet <Data.Models.Course>().AddAsync(model);
await _dataService.SaveDbAsync();
return(model);
}
/// <summary>Signs the in course.</summary>
/// <param name="student">The student.</param>
/// <param name="course">The course.</param>
/// <returns>Task.</returns>
public async Task SignInCourse(OmdleUser student, Data.Models.Course course)
{
var model = new StudentCourse
{
Student = student,
StudentId = student.Id,
Course = course,
CourseId = course.Id
};
await _dataService.GetSet <StudentCourse>().AddAsync(model);
await _dataService.SaveDbAsync();
}
/// <summary>Saves the message asynchronous.</summary>
/// <param name="message">The message.</param>
/// <param name="messageOwner">The message owner.</param>
/// <returns></returns>
public async Task <ChatMessage> SaveMessageAsync(string message, OmdleUser messageOwner)
{
var chatMessage = new ChatMessage
{
Message = message,
MessageOwner = messageOwner,
UserId = messageOwner.Id,
SendTime = DateTime.Now
};
await _dataService.GetSet <ChatMessage>().AddAsync(chatMessage);
await _dataService.SaveDbAsync();
return(chatMessage);
}
/// <summary>Gets the courses from teacher.</summary>
/// <param name="teacher">The teacher.</param>
/// <param name="skip">The skip.</param>
/// <param name="take">The take.</param>
/// <returns>Task<CourseListing>.</returns>
public async Task <CourseListing> GetCoursesFromTeacher(OmdleUser teacher, int skip = 0, int take = 10)
{
var result = new CourseListing();
var query = _dataService.GetSet <Data.Models.Course>();
result.TotalCount = query.Count();
result.Courses = await query
.Where(x => x.OwnerUser == teacher)
.Include(x => x.Lessons)
.Include(x => x.OwnerUser)
.Skip(skip * take)
.Take(take)
.ToListAsync();
return(result);
}
/// <summary>Gets the courses from student.</summary>
/// <param name="student">The student.</param>
/// <returns>CourseListing.</returns>
public CourseListing GetCoursesFromStudent(OmdleUser student)
{
var result = new CourseListing();
result.Courses = _dataService.GetSet <Data.Models.StudentCourse>()
.Where(x => x.Student == student)
.Select(x => x.Course)
.Include(x => x.OwnerUser)
.Include(x => x.Lessons)
.ToList();
result.TotalCount = result.Courses.Count();
return(result);
}
/// <summary>create reminder as an asynchronous operation.</summary>
/// <param name="title">The title.</param>
/// <param name="description">The description.</param>
/// <param name="date">The date.</param>
/// <param name="owner">The owner.</param>
/// <returns>Task<Data.Models.Reminder>.</returns>
public async Task <Reminder> CreateReminderAsync(
string title,
string description,
DateTime date,
OmdleUser owner)
{
var reminder = new Reminder
{
Title = title,
Description = description,
Date = date,
OwnerId = owner.Id,
};
await _dataService.GetSet <Reminder>().AddAsync(reminder);
await _dataService.SaveDbAsync();
return(reminder);
}
public UserProfileViewModel(OmdleUser user)
{
Email = user.Email;
FirstName = user.FirstName;
LastName = user.LastName;
}
