public async Task <IResponse> AddPoints([FromBody] AddPointsModel addPointsModel)
{
AddPointsResponse addPointsResponse = new AddPointsResponse();
PointsModel points = await _context.Points.SingleOrDefaultAsync(x => x.Account.Id == addPointsModel.UserId);
Account account = await _userManager.FindByIdAsync(addPointsModel.UserId);
if (account == null)
{
List <string> errors = new List <string>();
errors.Add("User does not exist.");
addPointsResponse.Errors = errors;
}
else
{
if (points == null)
{
_context.Points.Add(new PointsModel {
Account = account, Value = 0
});
await _context.SaveChangesAsync();
points = await _context.Points.SingleOrDefaultAsync(x => x.Account.Id == addPointsModel.UserId);
}
var result = await _pointManager.AddToUserAsync(account, addPointsModel.Value);
double test = result.pointTransaction.Amount;
addPointsResponse.Succeeded = result.succeeded;
}
return(addPointsResponse);
}
public async Task <ActionResult> GivePoints(ManagePointsModel managePointsModel)
{
string userId = (string)TempData["UserId"];
AddPointsModel addPointsModel = new AddPointsModel();
addPointsModel.UserId = userId;
addPointsModel.Value = managePointsModel.Points;
string jsonString = JsonConvert.SerializeObject(addPointsModel);
HttpResponseMessage responseMessage = await ApiClient.PostAsync("/Point/addPoints", jsonString);
string responseResult = responseMessage.Content.ReadAsStringAsync().Result;
AddPointsResponse addPointsResponse = JsonConvert.DeserializeObject <AddPointsResponse>(responseResult);
if (addPointsResponse.Succeeded)
{
string[] message = { "Points added to account" };
TempData["ManagePointMessage"] = message;
}
else
{
TempData["ManagePointMessage"] = addPointsResponse.Errors;
}
return(RedirectToAction("Index", new { id = userId }));
}
public async Task <IResponse> RemovePoints([FromBody] AddPointsModel addPointsModel)
{
AddPointsResponse addPointsResponse = new AddPointsResponse();
PointsModel points = await _context.Points.SingleOrDefaultAsync(x => x.Account.Id == addPointsModel.UserId);
Account account = await _userManager.FindByIdAsync(addPointsModel.UserId);
List <string> errors = new List <string>();
if (account == null)
{
errors.Add("User does not exist.");
addPointsResponse.Errors = errors;
}
else
{
if (points == null)
{
_context.Points.Add(new PointsModel {
Account = account, Value = 0
});
await _context.SaveChangesAsync();
points = await _context.Points.SingleOrDefaultAsync(x => x.Account.Id == addPointsModel.UserId);
}
if (points.Value >= addPointsModel.Value && !points.Value.Equals(0.0))
{
var result = await _pointManager.RemoveFromUserAsync(account, addPointsModel.Value);
double test = result.pointTransaction.Amount;
if (result.succeeded)
{
addPointsResponse.Succeeded = true;
}
else
{
errors.Add("Action failed.");
}
}
else
{
errors.Add("User doesn't have enough points");
}
}
if (errors.Count > 0)
{
addPointsResponse.Errors = errors;
}
return(addPointsResponse);
}
public async Task <IActionResult> AddPoints(int?id) //enrollment id
{
if (id == null)
{
return(NotFound());
}
var enrollment = _context.Enrollment.Where(e => e.Id == id).Include(e => e.Student).Include(e => e.Course).First();
AddPointsModel viewmodel = new AddPointsModel
{
Enrollment = enrollment
};
return(View(viewmodel));
}
public async Task <IActionResult> AddPoints(int id, AddPointsModel viewmodel)
{
if (id == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _context.SaveChangesAsync();
IQueryable <Enrollment> toBeRemoved = _context.Enrollment.Where(e => e.Id == id);
_context.Enrollment.RemoveRange(toBeRemoved);
_context.Enrollment.Add(new Enrollment
{
StudentId = viewmodel.Enrollment.StudentId,
CourseId = viewmodel.Enrollment.CourseId,
AdditionalPoints = viewmodel.inputAdditionalPoints,
ExamPoints = viewmodel.inputExamPoints,
ProjectPoints = viewmodel.inputProjectPoints,
SeminarPoints = viewmodel.inputSeminarPoints,
Grade = viewmodel.inputGrade,
FinishDate = viewmodel.inputFinishDate
});
_context.Update(viewmodel.Enrollment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnrollmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(viewmodel));
}
public async Task <IActionResult> PutTeacher(int id, AddPointsModel viewmodel)
{
if (id != viewmodel.Enrollment.Id)
{
return(BadRequest());
}
_context.Entry(viewmodel.Enrollment).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
IQueryable <Enrollment> toBeRemoved = _context.Enrollment.Where(e => e.Id == id);
_context.Enrollment.RemoveRange(toBeRemoved);
_context.Enrollment.Add(new Enrollment
{
StudentId = viewmodel.Enrollment.StudentId,
CourseId = viewmodel.Enrollment.CourseId,
AdditionalPoints = viewmodel.inputAdditionalPoints,
ExamPoints = viewmodel.inputExamPoints,
ProjectPoints = viewmodel.inputProjectPoints,
SeminarPoints = viewmodel.inputSeminarPoints,
Grade = viewmodel.inputGrade,
FinishDate = viewmodel.inputFinishDate
});
_context.Update(viewmodel.Enrollment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TeacherExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
throw new ApplicationException("Error loading external login information during confirmation.");
}
var user = new ApplicationUser {
UserName = model.Username, Email = info.Principal.FindFirstValue(ClaimTypes.Email)
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
AddPointsModel addpoints = new AddPointsModel {
UserName = user.UserName, Value = 0
};
HttpResponseMessage responseMessage = await client.PostAsJsonAsync("api/Point/AddPoints", addpoints);
responseMessage.EnsureSuccessStatusCode();
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(nameof(ExternalLogin), model));
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Username, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
AddPointsModel addpoints = new AddPointsModel {
UserName = user.UserName, Value = 0
};
HttpResponseMessage responseMessage = await client.PostAsJsonAsync("api/Point/AddPoints", addpoints);
responseMessage.EnsureSuccessStatusCode();
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
