public async Task <Question> PostQuestion(int lectureId, [FromBody] QuestionCreate model)
{
Lecture lecture = await _context.Lectures
.Where(x => x.Id == lectureId)
.Where(x => x.Course.Members.Any(y => y.MemberId == GetUserId()))
.Include(x => x.Questions)
.ThenInclude(x => x.Answers)
.SingleOrDefaultAsync();
ILAUser user = await _context.Users.FindAsync(GetUserId());
Question question = new Question
{
PointedQuestion = model.PointedQuestion,
Lecture = lecture,
User = user
};
await _context.Questions.AddAsync(question);
await _context.SaveChangesAsync();
question.User = null;
question.Lecture = null;
return(question);
}
public async Task <JsonWebToken> Create(ILAUser user, UserManager <ILAUser> userManager)
{
var nowUtc = DateTime.UtcNow;
var expires = nowUtc.AddMinutes(_options.ExpiryMinutes);
var exp = ((DateTimeOffset)expires).ToUnixTimeSeconds();
var iat = ((DateTimeOffset)nowUtc).ToUnixTimeSeconds();
var guid = Guid.NewGuid().ToString();
var payload = new JwtPayload
{
{ JwtRegisteredClaimNames.Sub, user.Id },
{ JwtRegisteredClaimNames.Iss, _options.Issuer },
{ JwtRegisteredClaimNames.Iat, iat },
{ JwtRegisteredClaimNames.Exp, exp },
{ JwtRegisteredClaimNames.Jti, guid }
};
await _tokenManager.ActivateAsync(guid);
return(new JsonWebToken
{
AccessToken = _jwtSecurityTokenHandler.WriteToken(new JwtSecurityToken(_jwtHeader, payload)),
Expires = exp
});
}
public async Task <PushTokens> SaveToken(string userId, string token, string deviceId)
{
ILAUser user = await _context.Users.FindAsync(userId);
PushTokens pushToken = await _context.PushTokens.Where(x => x.DeviceId == deviceId).SingleOrDefaultAsync(x => x.User.Id == userId);
if (pushToken == null)
{
pushToken = new PushTokens {
DeviceId = deviceId, User = user, Token = token
};
await _context.PushTokens.AddAsync(pushToken);
}
else
{
pushToken.Token = token;
pushToken.User = user;
_context.PushTokens.Update(pushToken);
}
await _context.SaveChangesAsync();
pushToken.User = null;
return(pushToken);
}
public async Task DeleteUser(ILAUser user)
{
var identityResult = await _userManager.DeleteAsync(user);
if (!identityResult.Succeeded)
{
throw new UserException(identityResult.Errors.Select(x => x.Description).ToList());
}
}
public async Task ChangePassword(ILAUser user, string oldPassword, string newPassword)
{
var identityResult = await _userManager.ChangePasswordAsync(user, oldPassword, newPassword);
if (!identityResult.Succeeded)
{
throw new UserException(identityResult.Errors.Select(x => x.Description).ToList());
}
}
public async Task SignUp(string email, string password, string firstName, string lastName)
{
ILAUser user = new ILAUser
{
UserName = email,
Email = email,
LastName = lastName,
FirstName = firstName,
};
var identityResult = await _userManager.CreateAsync(user, password);
if (!identityResult.Succeeded)
{
throw new UserException(identityResult.Errors.Select(x => x.Description).ToList());
}
}
public async Task <TestPush> TestPush()
{
ILAUser user = await _dbContext.Users
.Where(x => x.Id == GetUserId())
.Include(x => x.PushTokens)
.SingleOrDefaultAsync();
if (user == null)
{
throw new UserException(404);
}
_fireBaseService.SendPushNotificationMessageToSingleUser(user, "Test", "Ping", null);
return(new TestPush {
Message = "Send Test Notifications"
});
}
public async Task <Pause> PostPause(int lectureId)
{
Lecture lecture = await _context.Lectures
.Include(x => x.Pauses)
.ThenInclude(x => x.User)
.FirstOrDefaultAsync(x => x.Id == lectureId);
ILAUser user = await _context.Users.FindAsync(GetUserId());
if (lecture == null)
{
throw new UserException("Lecture not found", 404);
}
if (user == null)
{
throw new UserException("Internal server Error", 500);
}
Pause pause = new Pause
{
Lecture = lecture,
TimeStamp = DateTime.Now.ToUniversalTime(),
User = user
};
if (lecture.Pauses.Any(x => x.User.Id == GetUserId() && (pause.TimeStamp - x.TimeStamp).TotalSeconds < 120))
{
throw new UserException("You can pause ery 120 seconds only.", 481);
}
await _context.Pauses.AddAsync(pause);
await _context.SaveChangesAsync();
pause.User = null;
pause.Lecture = null;
await _hubContext.Clients.Group(lectureId.ToString()).SendAsync("Pause", pause);
return(pause);
}
public async Task <IActionResult> Create([Bind("Id,Title,Description,Archived")] Course course)
{
if (ModelState.IsValid)
{
ILAUser user = await _context.Users.FindAsync(GetUserId());
if (user == null)
{
return(NotFound());
}
course.Owner = user;
_context.Add(course);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(course));
}
public async Task <Answer> PostAnswer(int questionId, [FromBody] AnswerCreate model)
{
Question question = await _context.Questions
.Where(x => x.Lecture.Course.Members.Any(y => y.MemberId == GetUserId()))
.Where(x => x.Id == questionId)
.Include(x => x.User)
.ThenInclude(x => x.PushTokens)
.SingleOrDefaultAsync();
ILAUser user = await _context.Users.FindAsync(GetUserId());
if (question == null || user == null)
{
throw new UserException(404);
}
Answer answer = new Answer
{
Question = question,
User = user,
Comment = model.Comment,
};
await _context.Answers.AddAsync(answer);
await _context.SaveChangesAsync();
_fireBaseService.SendPushNotificationMessageToSingleUser(question.User, "New Answer",
"Someone answerd your question",
new Dictionary <string, string>
{
{ "questionId", question.Id.ToString() },
{ "answerId", answer.Id.ToString() }
});
question.User = null;
question.Lecture = null;
return(answer);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new ILAUser {
UserName = Input.Email, Email = Input.Email, FirstName = Input.FirstName, LastName = Input.LastName
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public void SendPushNotificationMessageToSingleUser(ILAUser user, string title, string body, Dictionary <string, string> data = null) =>
SendPushNotificationMessage(new List <ILAUser> {
user
}, title, body, data);
