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)));
}
