public ActionResult Users_Destroy([DataSourceRequest]DataSourceRequest request, UserAdminViewModel model) { var user = this.users.GetById(model.Id); this.users.Delete(user); return Json(new[] { model }.ToDataSourceResult(request, ModelState)); }
public ActionResult Users_Create([DataSourceRequest]DataSourceRequest request, UserAdminViewModel model) { if (ModelState.IsValid && model != null) { //var movie = Mapper.Map<Movie>(model); var user = new User() { FirstName = model.FirstName, LastName = model.LastName, Avatar = model.Avatar, BirthDate = model.BirthDate, Gender = model.Gender, About = model.About, CreatedOn = model.CreatedOn, PreserveCreatedOn = model.PreserveCreatedOn, IsHidden = model.IsHidden, ModifiedOn = model.ModifiedOn, IsDeleted = model.IsDeleted, DeletedOn = model.DeletedOn }; var result = this.users.Add(user); Mapper.Map(result, model); } return Json(new[] { model }.ToDataSourceResult(request, ModelState)); }
public ActionResult Update([DataSourceRequest]DataSourceRequest request, UserAdminViewModel user) { if (this.ModelState.IsValid && user != null) { this.users.Update(user.Id, user.UserName, user.Email, user.PhoneNumber); } return this.Json(new[] { user }.ToDataSourceResult(request, this.ModelState)); }
public ActionResult UsersDestroy([DataSourceRequest]DataSourceRequest request, UserAdminViewModel model) { if (ModelState.IsValid && model != null) { this.usersService.DeleteUser(model.Id); } return Json(new[] { model }.ToDataSourceResult(request, ModelState)); }
public async Task <ActionResult> Details(string id) { AppUser user = await _userManager.FindByIdAsync(id); if (user != null) { UserAdminViewModel viewModel = Mapper.Map <UserAdminViewModel>(user); return(View(viewModel)); } return(Redirect("Index")); }
private UserAdminViewModel GetUserModel(ApplicationUser user) { var model = new UserAdminViewModel { User = user, SubscriptionCount = Db.Subscriptions.Count(s => s.UserId.Equals(user.Id)), IsStudent = (StudentService.GetCurrentStudent(user.Id) != null), Members = MemberService.GetMemberships(user.Id), }; return(model); }
public ActionResult Users_Destroy([DataSourceRequest]DataSourceRequest request, UserAdminViewModel user) { var userManager = this.HttpContext.GetOwinContext().GetUserManager<SteepUserManager>(); var model = userManager.FindById(user.Id); if (this.ModelState.IsValid) { userManager.Delete(model); } return this.Json(new[] { user }.ToDataSourceResult(request, this.ModelState)); }
public override void Setup() { base.Setup(); _model = new UserAdminViewModel(); _controller = new AccountAdminController( _userManager.Object, _unitOfWork.Object, _mapper.Object ); MockHttpContext(); }
public ActionResult Edit(string id, [Bind("Id,Name,Password,Password2,Email")] UserAdminViewModel vm) { if (User.IsInRole("Student") && vm.Id != _userManager.GetUserId(User)) // a student is trying to inspect/edit another student { return(NotFound()); } if (id != vm.Id) { return(NotFound()); } if (vm.Password2 != vm.Password) { ModelState.AddModelError("Password2", "The two passwords do not match!"); return(View(vm)); } if (!ModelState.IsValid) { return(View(vm)); } var theUser = _userManager.FindByIdAsync(vm.Id); theUser.Wait(); if (theUser.Result is null) { return(NotFound()); } var token = _userManager.GeneratePasswordResetTokenAsync(theUser.Result); token.Wait(); theUser.Result.FullName = vm.Name; theUser.Result.Email = vm.Email; theUser.Result.UserName = vm.Email; _userManager.UpdateAsync(theUser.Result).Wait(); var result = _userManager.ResetPasswordAsync(theUser.Result, token.Result, vm.Password); result.Wait(); if (result.Result.Succeeded) { TempData["AlertMsg"] = "Saved changes"; return(View("Details", vm)); } else { ModelState.AddModelError("Password", "Invalid password"); return(View(vm)); } }
public ActionResult Users_Update([DataSourceRequest]DataSourceRequest request, UserAdminViewModel user) { var updated = false; if (this.ModelState.IsValid) { updated = this.usersService.Update(user.Email, user.FirstName, user.LastName, user.IsDeleted, user.Id); } var userById = this.usersService.ById(user.Id, true); var data = this.Mapper.Map<UserAdminViewModel>(userById); return this.Json(new[] { data }.ToDataSourceResult(request, this.ModelState)); }
// GET: UserAdmin/Details/GUID public ActionResult Details(string id) { Task <User> theUser = _userManager.FindByIdAsync(id); theUser.Wait(); var vm = new UserAdminViewModel() { Email = theUser.Result.Email, Name = theUser.Result.FullName, Id = theUser.Result.Id, }; return(View(vm)); }
// GET: UserAdmin/Edit/GUID public ActionResult Edit(string id) { var theUser = _userManager.FindByIdAsync(id); theUser.Wait(); var vm = new UserAdminViewModel() { Id = theUser.Result.Id, Name = theUser.Result.FullName, Email = theUser.Result.Email }; return(View(vm)); }
private UserAdminViewModel GetUserModel(ApplicationUser user) { var memberService = new MemberService(Db, UserManager); var model = new UserAdminViewModel { User = user, SubscriptionCount = Db.Subscriptions.Count(s => s.UserId.Equals(user.Id)), IsStudent = memberService.IsStudent(user.UserName), Members = memberService.GetMemberships(user.UserName), }; return(model); }
public ActionResult UsersUpdate([DataSourceRequest]DataSourceRequest request, UserAdminViewModel model) { if (ModelState.IsValid && model != null) { var currentData = this.usersService.GetUser(model.UserName); currentData.Avatar = model.Avatar; currentData.Email = model.Email; var result = this.usersService.UpdateUser(currentData, model.Role); Mapper.Map(result, model); } return Json(new[] { model }.ToDataSourceResult(request, ModelState)); }
public async Task <ActionResult> Edit(string id) { AppUser user = await _userManager.FindByIdAsync(id); UserAdminViewModel model = _mapper.Map <UserAdminViewModel>(user); if (user != null) { return(View(model)); } else { return(RedirectToAction("Index")); } }
public IActionResult UpdateUser(UserAdminViewModel viewModel) { if (User.HasClaim("UserAdmin", "IsUserAdmin") || User.HasClaim("SystemAdmin", "IsSystemAdmin")) { if (ModelState.IsValid) { try { var user = _dataAccess.LaundryUsers.GetSingleLaundryUser(viewModel.CurrentLaundryUser.UserName); user.Name = viewModel.CurrentLaundryUser.Name; user.PhoneNumber = viewModel.CurrentLaundryUser.PhoneNumber; user.Email = viewModel.CurrentLaundryUser.Email; if (user.Address == null && viewModel.CurrentLaundryUser.Address != null) { user.Address = new Address(); user.Address.StreetAddress = viewModel.CurrentLaundryUser.Address.StreetAddress; user.Address.Zipcode = viewModel.CurrentLaundryUser.Address.Zipcode; } user.PaymentMethod = viewModel.CurrentLaundryUser.PaymentMethod; user.PaymentDueDate = viewModel.CurrentLaundryUser.PaymentDueDate; user.UserName = viewModel.CurrentLaundryUser.UserName; _dataAccess.LaundryUsers.Update(user); _dataAccess.Complete(); } catch (DbUpdateConcurrencyException) { if (!_dataAccess.LaundryUsers.LaundryUserExists(viewModel.CurrentLaundryUser.Email)) { return(NotFound()); } else { return(RedirectToAction(nameof(MyUsers))); } } return(RedirectToAction(nameof(MyUsers))); } return(RedirectToAction(nameof(MyUsers))); } return(Unauthorized()); }
public async Task Edit_WhenValidModelPassed_UserUpdated() { _model = new UserAdminViewModel { Email = "email", Name = "name", PhoneNumber = "123", Surname = "surname" }; MockSetupFindByIdAsyncMethod(_user); SetupMockedWhenValidModelPassed(); ActionResult result = await _controller.Edit(_model); AssertUserIsUpdated(); }
public ActionResult UpdateUser(UserAdminViewModel model) { if (ModelState.IsValid) { _userDal.UpdateUser(model.Id, model.Username, model.Email, model.ActivStatus, model.IsAdmin); var testIdFromUserTest = _userTestDal.GetTestIdByUserId(model.Id); var userTestId = _userTestDal.GetAllUserTests().Where(p => p.TestId == testIdFromUserTest).First().Id; var testId = _testsDal.GetAllTests().Where(p => p.Name == model.TestName).FirstOrDefault().Id; _userTestDal.SetTestIdById(userTestId, testId); return(Json(new { success = true })); } return(PartialView("EditUser", model)); }
public async Task Put_Toggle_Admin_Returns_Bad_Request_Invalis_ModelState() { //Arrange UserAdminViewModel userAdminViewModel = new UserAdminViewModel() { Id = _user.Id }; _usersController.ModelState.AddModelError("IsAdmin", "IsAdmin is required."); //Act int usersCount = _userRepository.Count(); var iactionResult = await _usersController.Put(userAdminViewModel); //Assert Assert.IsType <BadRequestResult>(iactionResult); }
public IActionResult Index() { string section = "Settings"; IDictionary settings = _config.GetSection(section) .AsEnumerable() .Where(x => x.Key != section) .ToDictionary(x => x.Key.RemoveStart($"{section}:"), x => x.Value); string webApi = (string)settings["WebApi"]; UserAdminViewModel userAdminViewModel = new UserAdminViewModel(); userAdminViewModel.WebApi = webApi; return(View(userAdminViewModel)); }
public ActionResult Users_Update([DataSourceRequest]DataSourceRequest request, UserAdminViewModel user) { var userManager = this.HttpContext.GetOwinContext().GetUserManager<SteepUserManager>(); var model = userManager.FindById(user.Id); if (this.ModelState.IsValid) { model.Firstname = user.Firstname; model.Lastname = user.Lastname; model.Quote = user.Quote; model.UserName = user.UserName; model.Email = user.Email; userManager.Update(model); } return this.Json(new[] { model }.ToDataSourceResult(request, this.ModelState)); }
public IActionResult ToggleBlockUser(UserAdminViewModel viewModel) { if (User.HasClaim("UserAdmin", "IsUserAdmin") || User.HasClaim("SystemAdmin", "IsSystemAdmin")) { if (ModelState.IsValid) { LaundryUser user; try { user = _dataAccess.LaundryUsers.GetSingleLaundryUser(viewModel.CurrentLaundryUser.UserName); if (user.LockoutEnd == null) { user.LockoutEnd = new DateTimeOffset(DateTime.MaxValue); user.ActiveUser = false; } else { user.LockoutEnd = null; user.ActiveUser = true; } _dataAccess.Complete(); } catch (DbUpdateConcurrencyException) { if (!_dataAccess.LaundryUsers.LaundryUserExists(viewModel.CurrentLaundryUser.Email)) { return(NotFound()); } TempData["alertMessage"] = "Blocking/Unblocking unsuccessful"; return(RedirectToAction("EditUser", "UserAdmin", new { email = viewModel.CurrentLaundryUser.Email })); } TempData["alertMessage"] = "Blocking/Unblocking successful"; return(RedirectToAction("EditUser", "UserAdmin", new { email = user.Email })); } return(BadRequest()); } return(Unauthorized()); }
public static UserAdminViewModel UserAdminViewModel(this IdentityUser source) { var destination = new UserAdminViewModel(); destination.Id = source.Id; destination.UserName = source.UserName; destination.Email = source.Email; destination.EmailConfirmed = source.EmailConfirmed; if (source.Roles != null) { //foreach (var userRole in source.Roles) //{ // destination.RoleNames.Add(userRole.Name); //} } return(destination); }
// GET: UserAdmin/Details/GUID public ActionResult Details(string id) { Task <User> theUser = _userManager.FindByIdAsync(id); theUser.Wait(); if (User.IsInRole("Student") && theUser.Result.Id != _userManager.GetUserId(User)) // a student is trying to inspect/edit another student { return(NotFound()); } var vm = new UserAdminViewModel() { Email = theUser.Result.Email, Name = theUser.Result.FullName, Id = theUser.Result.Id, }; return(View(vm)); }
public ActionResult EditUser(int id) { SetView(); UserAdminViewModel viewModel = new UserAdminViewModel(); var user = _userDal.GetUserById(id); viewModel.Id = id; viewModel.Username = user.Username; viewModel.Password = user.Password; viewModel.Email = user.Email; viewModel.ActivStatus = user.ActivStatus; viewModel.IsAdmin = user.IsAdmin; var testId = _userTestDal.GetTestIdByUserId(id); var testName = _testsDal.GetTestById(testId).Name; viewModel.TestName = testName; return(PartialView(viewModel)); }
public async Task Delete_user_Returns_Ok() { UserAdminViewModel userAdminViewModel = new UserAdminViewModel() { Id = _user.Id, IsAdmin = false }; //Act var iactionResult = await _usersController.Delete(1) as ObjectResult; var objectResponse = iactionResult as ObjectResult; string result = objectResponse.Value as string; int usersCount = _userRepository.Count(); //Assert Assert.Equal($"{_user.FirstName} was deleted successfully.", result); Assert.IsType <OkObjectResult>(iactionResult); Assert.Equal(200, objectResponse.StatusCode); Assert.Equal(0, usersCount); }
public ActionResult UpdateUser(UserAdminViewModel item) { var account = ctx.Users.FirstOrDefault(c => c.UserID == item.UserID); account.UserFirstname = item.Firstname; account.UserLastname = item.Lastname; account.UserPosition = item.Position; account.UserPhoneNumber = item.Phonenumber; account.UserIsAdmin = item.isAdmin; account.UserTeamID = item.TeamID; ctx.SaveChanges(); var autoCtx = new ApplicationDbContext(); var loginInfo = autoCtx.Users.FirstOrDefault(l => l.Id == item.UserID); loginInfo.Email = item.Email; loginInfo.UserName = item.Email; autoCtx.SaveChanges(); return(RedirectToAction("AllUsers")); }
/// <summary> /// /// </summary> public ActionResult Index() { var userDb = new ApplicationDbContext(); var users = userDb.Users.Where(x => x.UserName.StartsWith("stud")).ToList(); var model = new List <UserAdminViewModel>(); foreach (var user in users) { var stud = new UserAdminViewModel(); stud.User = user; stud.Student = Db.Students.Where(x => x.UserId.Equals(user.Id)).OrderByDescending(x => x.Created) .FirstOrDefault(); model.Add(stud); } return(View(model)); }
public async Task Put_Toggle_Admin_Returns_Ok_Admin() { //Arrange UserAdminViewModel userAdminViewModel = new UserAdminViewModel() { Id = _user.Id, IsAdmin = false }; //Act int usersCount = _userRepository.Count(); var iactionResult = await _usersController.Put(userAdminViewModel); var objectResponse = iactionResult as ObjectResult; string result = objectResponse.Value as string; //Assert Assert.Equal($"{_user.FirstName} set to Admin successfully.", result); Assert.IsType <OkObjectResult>(iactionResult); Assert.Equal(200, objectResponse.StatusCode); }
public async Task <ActionResult> Edit(UserAdminViewModel model) { AppUser user = await _userManager.FindByIdAsync(model.Id); if (user != null) { user.Email = model.Email; IdentityResult validEmail = await _userManager.UserValidator.ValidateAsync(user); if (!validEmail.Succeeded) { AddErrorsFromResult(validEmail); } if (validEmail.Succeeded) { user.Name = model.Name; user.Surname = model.Surname; user.PhoneNumber = model.PhoneNumber; user.UserName = model.Email; IdentityResult result = await _userManager.UpdateAsync(user); if (result.Succeeded) { return(RedirectToAction("Index")); } else { AddErrorsFromResult(result); } } } else { ModelState.AddModelError("", "User Not Found"); } return(View(model)); }
/// <summary> /// Updates the specified user. /// </summary> /// <param name="key">The key of the user to update.</param> /// <param name="update">The updates to make to the user.</param> /// <returns> /// HTTP 400 - Bad Request if the model is invalid /// HTTP 404 - Not Found if the user doesn't exist /// HTTP 200 - OK if the user is updated /// </returns> /// @mapping PUT /odata/User(key) /// @notanon public async Task<IHttpActionResult> Put([FromODataUri] string key, UserAdminViewModel update) { Validate(update); if (!ModelState.IsValid) { return BadRequest(ModelState); } var user = await UserManager.FindByIdAsync(key); if (user == null) { return NotFound(); } var changes = new List<string>(); if (user.Email != update.EmailAddress) { await UserManager.SetEmailAsync(key, update.EmailAddress); await UserManager.GenerateEmailConfirmationEmailAsync(new System.Web.Mvc.UrlHelper(HttpContext.Current.Request.RequestContext), key); changes.Add("Email"); } if (!await UserManager.IsInRoleAsync(key, update.Role)) { var roles = await UserManager.GetRolesAsync(key); await UserManager.RemoveFromRolesAsync(key, roles.ToArray()); await UserManager.AddToRoleAsync(key, update.Role); changes.Add("Role"); } if (changes.Count > 0) await LogService.LogUserUpdated(User.Identity.GetUserName(), user.UserName, changes); return Ok(); }
public ActionResult AddUser(UserAdminViewModel model) { if (ModelState.IsValid) { _userDal.AddUser(model.Username, SHA512Encrypter.Encrypt(model.Password), model.Email); var userId = _userDal.GetUserByUsername(model.Username).Id; var tests = _testsDal.GetAllTests(); int testId = 0; foreach (var test in tests) { if (test.Name == model.TestName) { testId = test.Id; } } _userTestDal.AddUserTest(userId, testId, false); return(RedirectToAction("UserAdmin", "AdminUser")); } SetView(); return(View("UserAdmin", model)); }
private async Task PutUser(string id, string email, ApplicationRole role, IEnumerable <string> oldRoles = null, bool changeRole = true, bool changeEmail = true, string username = null, ResultType expectedResult = ResultType.Success) { var userManager = CreateMockUserManager(); var roleManager = CreateMockRoleManager(); var configuration = new Mock <HttpConfiguration>(); var logService = CreateMockLogService(); var controller = new UserController(userManager.Object, roleManager.Object, logService.Object) { Configuration = configuration.Object }; var principal = MockHelpers.CreateMockPrincipal(TestUsername); controller.User = principal.Object; var request = new HttpRequest("", "http://localhost", ""); var context = new HttpContext(request, new HttpResponse(new StringWriter())); HttpContext.Current = context; var model = new UserAdminViewModel { Id = id, EmailAddress = email, Role = role.Name, RoleId = role.Id, RoleDisplayName = role.DisplayName, UserName = email }; var res = await controller.Put(id, model); switch (expectedResult) { case ResultType.Success: Assert.IsType <OkResult>(res); if (changeEmail) { userManager.Verify(u => u.SetEmailAsync(id, email)); userManager.Verify(u => u.GenerateEmailConfirmationEmailAsync(It.IsNotNull <UrlHelper>(), id)); } else { userManager.Verify(u => u.SetEmailAsync(id, email), Times.Never); userManager.Verify(u => u.GenerateEmailConfirmationEmailAsync(It.IsNotNull <UrlHelper>(), id), Times.Never); } if (changeRole) { userManager.Verify(u => u.RemoveFromRolesAsync(id, It.Is <string[]>(s => s.SequenceEqual(oldRoles)))); userManager.Verify(u => u.AddToRoleAsync(id, role.Name)); } else { userManager.Verify(u => u.RemoveFromRolesAsync(id, It.Is <string[]>(s => s.SequenceEqual(oldRoles))), Times.Never); userManager.Verify(u => u.AddToRoleAsync(id, role.Name), Times.Never); } if (changeEmail || changeRole) { logService.Verify(l => l.LogUserUpdated(TestUsername, username, It.Is <IEnumerable <string> >(s => CheckUpdateProperties(s, changeRole, changeEmail)))); } else { logService.Verify(l => l.LogUserUpdated(TestUsername, It.IsAny <string>(), It.IsAny <IEnumerable <string> >()), Times.Never); } break; case ResultType.ModelError: Assert.IsType <InvalidModelStateResult>(res); userManager.Verify(u => u.GenerateEmailConfirmationEmailAsync(It.IsNotNull <UrlHelper>(), id), Times.Never); break; case ResultType.NotFoundError: Assert.IsType <NotFoundResult>(res); userManager.Verify(u => u.GenerateEmailConfirmationEmailAsync(It.IsNotNull <UrlHelper>(), id), Times.Never); break; } }
public ActionResult Users_Update([DataSourceRequest] DataSourceRequest request, UserAdminViewModel model) { if (ModelState.IsValid && model != null) { var user = new User() { Id = model.Id, FirstName = model.FirstName, LastName = model.LastName, Avatar = model.Avatar, BirthDate = model.BirthDate, Gender = model.Gender, About = model.About, CreatedOn = model.CreatedOn, PreserveCreatedOn = model.PreserveCreatedOn, IsHidden = model.IsHidden, ModifiedOn = model.ModifiedOn, IsDeleted = model.IsDeleted, DeletedOn = model.DeletedOn }; var result = this.users.Update(user).To <UserAdminViewModel>().FirstOrDefault(); Mapper.Map(result, model); } return(Json(new[] { model }.ToDataSourceResult(request, ModelState))); }
public ActionResult Users_Destroy([DataSourceRequest] DataSourceRequest request, UserAdminViewModel model) { var user = this.users.GetById(model.Id); this.users.Delete(user); return(Json(new[] { model }.ToDataSourceResult(request, ModelState))); }
public UserAdmin(UserAdminViewModel vm) { InitializeComponent(); DataContext = vm; }
public ActionResult Destroy([DataSourceRequest]DataSourceRequest request, UserAdminViewModel user) { this.users.Delete(user.Id); return this.Json(new[] { user }.ToDataSourceResult(request)); }
public ActionResult UsersDestroy([DataSourceRequest] DataSourceRequest request, UserAdminViewModel model) { if (ModelState.IsValid && model != null) { this.usersService.DeleteUser(model.Id); } return(Json(new[] { model }.ToDataSourceResult(request, ModelState))); }
public ActionResult ViewStudent(string username) { var user = this.Data.Users.All() .Select(u => new {u.UserName, u.Email, u.FNumber, u.Id}) .FirstOrDefault(u => u.UserName == username); if (user == null) { return Redirect("/Admin"); } var userCourseWork = this.Data.Problems.All() .FirstOrDefault(p => p.UserId == user.Id && p.ProblemType == ProblemType.Coursework); var userModel = new UserAdminViewModel() { Id = user.Id, Email = user.Email, FNnumber = user.FNumber, Username = user.UserName, HasCoursework = userCourseWork != null }; userModel.Problems = this.Data.Problems.All() .Where(p => p.UserId == user.Id || p.Solutions.Any(s => s.User.UserName == user.UserName)) .Select(p => new ProblemViewModel() { Id = p.Id, Function = new Function() { Function1 = p.Function, Function2 = p.Function2 }, ProblemStatus = p.ProblemStatus, ProblemType = p.ProblemType }) .ToList(); for (int i = 0; i < userModel.Problems.Count; i++) { int problemId = userModel.Problems.ElementAt(i).Id; var mistakes = this.Data.Mistakes.All().Where(m => m.ProblemId == problemId).ToList(); userModel.Problems.ElementAt(i).Mistakes = mistakes; var solution = this.Data.Solutions.All() .Select(s => new SolutionViewModel() { Id = s.ProblemId, TruthTable = s.TruthTable, BooleanFunction = s.BooleanFunction, TestVectors = s.TestVectors, GMatrix = s.GMatrix, MinimizeHistory = s.MinimizationHistory, MistakesCount = s.Mistakes, MinimizedGMatrix = s.MinimizedGMatrix, MinimizedGMatrixRows = s.MinimizedGMatrixRows, Grade = s.Grade == null ? 0 : s.Grade.Mark, NoneMinimizedCols = s.NoneMinimizedCols, NoneMinimizedRows = s.NoneMinimizedRows }) .FirstOrDefault(s => s.Id == problemId); if (solution != null) { var table = FunctionParser.GenerateTable(); var charTable = new char[8, 8]; for (int j = 0; j < 8; j++) { for (int k = 0; k < 8; k++) { charTable[j, k] = table[j, k].ToString()[0]; } } int truthTableIndex = 0; if (solution.TruthTable.Length > 50) { var table2 = FunctionParser.GenerateTable(); var charTable2 = new char[8, 8]; for (int j = 0; j < 8; j++) { for (int k = 0; k < 8; k++) { charTable[j, k] = table2[j, k].ToString()[0]; } } for (int j = 0; j < 8; j++) { for (int k = 3; k < 8; k++) { charTable[j, k] = solution.TruthTable[truthTableIndex]; charTable2[j, k] = solution.TruthTable[truthTableIndex + 1]; truthTableIndex += 2; } } solution.TruthTableTable = charTable; solution.TruthTableTable2 = charTable2; } else { for (int j = 0; j < 8; j++) { for (int k = 3; k < 8; k++) { charTable[j, k] = solution.TruthTable[truthTableIndex]; truthTableIndex++; } } solution.TruthTableTable = charTable; } var gMatrixTable = new char[8, 10]; int gMatrixCounter = 0; for (int j = 0; j < 8; j++) { for (int k = 0; k < 10; k++) { gMatrixTable[j, k] = solution.GMatrix[gMatrixCounter]; gMatrixCounter++; } } solution.GMatrixTable = gMatrixTable; var rows = solution.MinimizedGMatrixRows; var cols = solution.MinimizedGMatrix.Length/rows; var minimizedTable = new char[rows, cols]; var minimizedIndex = 0; for (int j = 0; j < rows; j++) { for (int k = 0; k < cols; k++) { minimizedTable[j, k] = solution.MinimizedGMatrix[minimizedIndex]; minimizedIndex++; } } solution.MinimizedGMatrixCols = cols; solution.MinimizedGMatrixTable = minimizedTable; } userModel.Problems.ElementAt(i).Solution = solution; } if (userModel.HasCoursework) { var coursework = this.Data.Problems.All() .FirstOrDefault(p => p.ProblemType == ProblemType.Coursework && p.User.UserName == username); if (coursework != null) { var courseworkSolution = this.GetProblemSolution(coursework); userModel.CourseworkSolution = courseworkSolution; } var grade = this.Data.Grades.All().FirstOrDefault(g => g.User.UserName == username); if (grade != null) { userModel.CourseworkGrade = grade.Mark; } else { userModel.CourseworkGrade = null; } } return View(userModel); }
public ActionResult UsersUpdate([DataSourceRequest] DataSourceRequest request, UserAdminViewModel model) { if (ModelState.IsValid && model != null) { var currentData = this.usersService.GetUser(model.UserName); currentData.Avatar = model.Avatar; currentData.Email = model.Email; var result = this.usersService.UpdateUser(currentData, model.Role); Mapper.Map(result, model); } return(Json(new[] { model }.ToDataSourceResult(request, ModelState))); }