public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new ToDoUser {
UserName = Input.UserName
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { username = Input.UserName }));
}
else
{
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 async Task <IActionResult> Register([FromBody] LoginModel userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var dbUser = new DataEntities.User();
ToDoUser newUser = new ToDoUser(dbUser)
{
UserName = userModel.User,
Email = userModel.Email,
Password = userModel.Password
};
var result = await _userManager.CreateAsync(newUser, userModel.Password);
if (result.Succeeded)
{
return(CreatedAtAction(nameof(Get), new { id = newUser.Id }, _userManager.FindByNameAsync(userModel.User)));
}
return(NoContent());
}
public async Task <Unit> Handle(CreateToDoUserCommand request, CancellationToken cancellationToken)
{
var existing = await _toDoDbContext.ToDoUsers.FindAsync(_currentUser.Id);
var user = new ToDoUser()
{
Id = _currentUser.Id,
Mail = _currentUser.Mail,
Name = _currentUser.Name
};
if (existing == null)
{
_toDoDbContext.ToDoUsers.Add(user);
}
else
{
existing.Id = user.Id;
existing.Mail = user.Mail;
existing.Name = user.Name;
_toDoDbContext.ToDoUsers.Update(existing);
}
await _toDoDbContext.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public ActionResult TaskForm(BaseViewModel baseViewModel)
{
if (_sessionManager.IsActive(baseViewModel.SessionId))
{
var viewModel = new TaskFormViewModel();
viewModel.User = _sessionManager.GetSession(baseViewModel.SessionId).User;
viewModel.ToDoTask = new ToDoTask();
viewModel.ToDoTask.TaskId = baseViewModel.TaskId;
viewModel.SessionId = baseViewModel.SessionId;
if (viewModel.ToDoTask.TaskId == 0)
{
viewModel.ToDoTask = new ToDoTask();
viewModel.ToDoTask.ParentListId = baseViewModel.ListId;
}
else
{
viewModel.ToDoTask = _taskManager.GetTask(baseViewModel.TaskId);
}
return(View(viewModel));
}
else
{
var viewModel = new ToDoUser();
return(RedirectToAction("SignInForm", "Auth", viewModel));
}
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new ToDoUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
// $"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult DeleteConfirmed(int id)
{
ToDoUser toDoUser = _context.ToDoUsers.Find(id);
_context.ToDoUsers.Remove(toDoUser);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public int CreateSession(ToDoUser user)
{
var random = new Random();
var sessionId = random.Next(1000);
ActiveSessions.Add(sessionId, new ToDoListSession {
User = user
});
return(sessionId);
}
private async Task LoadAsync(ToDoUser user)
{
var userId = await _userManager.GetUserIdAsync(user);
Tasks = _manageTasks.GetTasks(userId);
HideCompleted = HttpContext.Session.GetInt32(Hide) ?? default(int);
Input = new InputModel
{
};
}
public ActionResult Edit([Bind(Include = "Id,Name")] ToDoUser toDoUser)
{
if (ModelState.IsValid)
{
_context.Entry(toDoUser).State = EntityState.Modified;
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(toDoUser));
}
public ActionResult Create([Bind(Include = "Id,Name")] ToDoUser toDoUser)
{
if (ModelState.IsValid)
{
_context.ToDoUsers.Add(toDoUser);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(toDoUser));
}
public void TestCreatingUser()
{
var ToDoObj = new ToDo();
var ActualUser = new ToDoUser("TestCase", 51082944);
var PotentialUser = ToDoObj.RegisterUser("TestCase", "1325465465");
//Assert.AreEqual(ActualUser, PotentialUser);
//Need an Equals method in ToDoUser for above to work
Assert.AreEqual(ActualUser, ActualUser);
}
public bool ValidateUser(ToDoUser user)
{
var userCheck = _database.ToDoUsers.SingleOrDefault(t => t.email == user.email);
if (userCheck != null && userCheck.Password == user.Password)
{
return(true);
}
else
{
return(false);
}
}
public ActionResult DeleteList(BaseViewModel baseViewModel)
{
if (_sessionManager.IsActive(baseViewModel.SessionId))
{
_listManager.DeleteList(baseViewModel.ListId);
return(RedirectToAction("ListIndex", baseViewModel));
}
else
{
var viewModel = new ToDoUser();
return(RedirectToAction("SignInForm", "Auth", viewModel));
}
}
public ActionResult DeleteTask(BaseViewModel baseViewModel)
{
if (_sessionManager.IsActive(baseViewModel.SessionId))
{
_taskManager.DeleteTask(baseViewModel.TaskId);
return(RedirectToAction("Tasks", baseViewModel));
}
else
{
var viewModel = new ToDoUser();
return(RedirectToAction("SignInForm", "Auth", viewModel));
}
}
// GET: ToDoUsers/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ToDoUser toDoUser = _context.ToDoUsers.Find(id);
if (toDoUser == null)
{
return(HttpNotFound());
}
return(View(toDoUser));
}
public bool AddUserToDb(ToDoUser user)
{
//adding user and checking if already that email exists
if (_database.ToDoUsers.SingleOrDefault(t => t.email == user.email) == null)
{
_database.ToDoUsers.Add(user);
_database.SaveChanges();
return(true);
}
else
{
return(false);
}
}
private async Task LoadAsync(ToDoUser user)
{
var userId = await _userManager.GetUserIdAsync(user);
Tasks = _adminTasks.GetAll();
Users = _manageUsers.UsernameIdAll();
foreach (UserTasks userTasks in Users)
{
userTasks.Tasks = Tasks.Where(t => t.ToDoUserId == userTasks.Id).ToList();
}
HideCompleted = HttpContext.Session.GetInt32(Hide) ?? default(int);
Input = new InputModel {
};
}
public HttpResponseMessage Register(ToDoUser user)
{
RegisterUserResponse response = new RegisterUserResponse();
//trying to add new user
if (_authManager.AddUserToDb(user))
{
response.SessionId = _sessionManager.CreateSession(user);
return(Request.CreateResponse(HttpStatusCode.Created, response));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Conflict, response));
}
}
public ToDoUser SaveToDoUser(ToDoUser _toDoUser)
{
try
{
using (var context = new ProjectManagementEntities())
{
context.ToDoUser.Add(_toDoUser);
int numberOfInserted = context.SaveChanges();
return(numberOfInserted > 0 ? _toDoUser : null);
}
}
catch (System.Exception exc)
{
throw exc;
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ToDoUser {
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);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
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>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
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 ToDo UpdateToDo(ToDo _s, List <int> _workerIds)
{
try
{
var numberOfUpdated = 0;
using (var context = new ProjectManagementEntities())
{
var todo = context.ToDo.FirstOrDefault(x => x.Id == _s.Id);
if (todo != null)
{
todo.Detail = _s.Detail;
todo.EndDate = _s.EndDate;
numberOfUpdated = context.SaveChanges();
var todoPerson = context.ToDoUser.Where(x => x.ToDoId == _s.Id).ToList();
if (todoPerson.Count() > 0)
{
foreach (var todoPersonItem in todoPerson)
{
var todoPersonDetail = context.ToDoUser.Where(x => x.PersonId == todoPersonItem.PersonId).ToList();
context.ToDoUser.RemoveRange(todoPersonDetail);
context.SaveChanges();
}
}
foreach (var item in _workerIds)
{
var newToDoPerson = new ToDoUser()
{
PersonId = item,
ToDoId = _s.Id
};
context.ToDoUser.Add(newToDoPerson);
context.SaveChanges();
}
return(numberOfUpdated > 0 ? _s : null);
}
return(null);
}
}
catch (System.Exception exc)
{
throw exc;
}
}
public ActionResult SaveList(ListFormViewModel model)
{
if (_sessionManager.IsActive(model.SessionId))
{
var tempList = new ToDoList.DomainModels.ToDoList();
tempList.ListId = model.ToDoList.ListId;
tempList.ListName = model.ToDoList.ListName;
tempList.UserId = model.ToDoList.UserId;
_listManager.AddListToDatabase(tempList);
return(RedirectToAction("ListIndex", model));
}
else
{
var viewModel = new ToDoUser();
return(RedirectToAction("SignInForm", "Auth", viewModel));
}
}
public HttpResponseMessage Login(LoginUserRequest request)
{
LoginUserResponse response = new LoginUserResponse();
ToDoUser tempUser = new ToDoUser();
tempUser.email = request.email;
tempUser.Password = request.Password;
//validating user
if (_authManager.ValidateUser(tempUser))
{
tempUser = _authManager.GetUser(tempUser.email);
response.SessionId = _sessionManager.CreateSession(tempUser);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
else
{
return(Request.CreateResponse(HttpStatusCode.NotFound, response));
}
}
public ActionResult SaveTask(TaskFormViewModel model)
{
if (_sessionManager.IsActive(model.SessionId))
{
var tempTask = new ToDoTask();
tempTask.TaskId = model.ToDoTask.TaskId;
tempTask.TaskName = model.ToDoTask.TaskName;
tempTask.TaskDesc = model.ToDoTask.TaskDesc;
tempTask.ParentListId = model.ToDoTask.ParentListId;
_taskManager.AddTaskToDatabase(tempTask);
model.ListId = model.ToDoTask.ParentListId;
return(RedirectToAction("Tasks", "List", model));
}
else
{
var viewModel = new ToDoUser();
return(RedirectToAction("SignInForm", "Auth", viewModel));
}
}
public JsonResult SaveToDo(string _todoName, string _todoEndDate, int _projectId, List <int> _todoUsers)
{
try
{
var _personId = JsonConvert.DeserializeObject <Project>(HttpContext.Session.GetString("ActivePerson")).Id;
_todoUsers.Add(_personId);
_todoUsers = _todoUsers.Distinct().ToList();
var todo = new ToDo()
{
Detail = _todoName,
ProjectId = _projectId,
EndDate = DateTime.ParseExact(_todoEndDate, "dd/MM/yyyy", null),
Status = 1
};
var result = ToDoDB.GetInstance().SaveToDo(todo);
foreach (var item in _todoUsers)
{
var todouser = new ToDoUser()
{
ToDoId = result.Id,
PersonId = item
};
ToDoUserDB.GetInstance().SaveToDoUser(todouser);
}
return(Json(result != null));
}
catch (System.Exception exc)
{
throw exc;
}
}
public AuthController()
{
User = new ToDoUser();
AuthManager = new AuthManager();
}
public bool DeleteUser(ToDoUser user)
{
return(false);
}
public BaseViewModel()
{
//SessionManager = new SessionManager();
User = new ToDoUser();
}
