public async Task Post(CinemaCreateDto value)
{
if (!ModelState.IsValid)
{
var keys = ModelState.Keys;
var modelError = new Dictionary <string, string>();
foreach (var key in keys)
{
ModelStateEntry modeState = null;
if (ModelState.TryGetValue(key, out modeState) && modeState != null && modeState.ValidationState != ModelValidationState.Valid)
{
var error = new KeyValuePair <string, string>(key, string.Join(";", modeState.Errors.Select(e => e.ErrorMessage)));
modelError.Add(error.Key, error.Value);
}
}
var rootMsg = "输入错误！";
if (ModelState.Root.Errors.Any())
{
rootMsg = string.Join(";", ModelState.Root.Errors.Select(e => e.ErrorMessage));
}
var err = new InputError(modelError, rootMsg);
throw err;
}
await CommandBus.SendAsync(new CinemaCreateCommand { Input = value });
}
private Dictionary <string, object> ToProperties(ModelStateEntry entry)
{
if (entry.Errors.Count != 1)
{
throw new InvalidOperationException("Can operate only on convertion errors. Count of errors is not right.");
}
if (!(entry.Errors.Single().Exception is JsonReaderException exc))
{
throw new InvalidOperationException("Can only operate on JsonReaderException");
}
var type = Regex
.Match(exc.Message, @"^Could not convert (?:\w+) to (?<type>\w+)")
.Groups["type"];
if (!type.Success)
{
throw new InvalidOperationException("Can operate only on convertion errors. Format of error is not right.");
}
return(new Dictionary <string, object> {
{ "type", type.Value }
});
}
public async Task AdminController_ManualChanges_POST_Fix_Database_Errors_Fails_When_Parameters_Are_Provided_Async()
{
// Arrange
User databaseAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(databaseAdminUser.UserId, null, databaseAdminUser);
var manualChangesViewModel = Mock.Of <ManualChangesViewModel>();
manualChangesViewModel.Command = FixDatabaseErrorsCommand;
manualChangesViewModel.Parameters = "not empty";
// Act
var fixDatabaseErrorsActualResult = await adminController.ManualChanges(manualChangesViewModel) as ViewResult;
Assert.NotNull(fixDatabaseErrorsActualResult);
var actualManualChangesViewModel = (ManualChangesViewModel)fixDatabaseErrorsActualResult.Model;
ModelStateEntry modelState = adminController.ModelState[""];
ModelError reportedError = modelState.Errors.First();
// Assert
Assert.Multiple(
() => {
Assert.AreEqual("ERROR: parameters must be empty", reportedError.ErrorMessage);
Assert.IsNull(actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("", actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.False(actualManualChangesViewModel.Tested, "Must be false as this case has failed");
});
}
private static bool HasError(this HtmlHelper htmlHelper, ModelExplorer modelExplorer)
{
string modelName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(modelExplorer.Metadata.PropertyName);
FormContext formContext = htmlHelper.ViewContext.FormContext;
if (formContext == null)
{
return(false);
}
if (!htmlHelper.ViewData.ModelState.ContainsKey(modelName))
{
return(false);
}
ModelStateEntry modelState = htmlHelper.ViewData.ModelState[modelName];
if (modelState == null)
{
return(false);
}
ModelErrorCollection modelErrors = modelState.Errors;
if (modelErrors == null)
{
return(false);
}
return(modelErrors.Count > 0);
}
private static void Visit(
ModelStateEntry modelStateEntry,
ModelMetadata metadata,
List <ModelStateEntry> orderedModelStateEntries)
{
if (metadata.ElementMetadata != null && modelStateEntry.Children != null)
{
foreach (var indexEntry in modelStateEntry.Children)
{
Visit(indexEntry, metadata.ElementMetadata, orderedModelStateEntries);
}
}
else
{
for (var i = 0; i < metadata.Properties.Count; i++)
{
var propertyMetadata = metadata.Properties[i];
var propertyModelStateEntry = modelStateEntry.GetModelStateForProperty(propertyMetadata.PropertyName);
if (propertyModelStateEntry != null)
{
Visit(propertyModelStateEntry, propertyMetadata, orderedModelStateEntries);
}
}
}
if (!modelStateEntry.IsContainerNode)
{
orderedModelStateEntries.Add(modelStateEntry);
}
}
public Entry(ModelStateEntry entry)
{
RawValue = entry.RawValue;
AttemptedValue = entry.AttemptedValue;
State = entry.ValidationState;
Errors = entry.Errors?.Select(x => x.ErrorMessage) ?? Enumerable.Empty<string>();
}
public IActionResult Country(CountryVM countryVM)
{
CountryVM_DataManager countryVM_DataManager = new CountryVM_DataManager();
ModelStateDictionary msd = CountryVM_DataManager.ValidateCountry(ref countryVM);
//Model validation occurs prior to each controller action being invoked, and it's the action method's responsibility to inspect ModelState.IsValid and react appropriately.
//Manual validation
//After model binding and validation are complete, you may want to repeat parts of it. For example, a user may have entered text in a field expecting an integer, or you may need to compute a value for a model's property.
//You may need to run validation manually.To do so, call the TryValidateModel
//when TryUpdateModel() is called it doesnot raise exceptions you should use ValidateModel Or TryValidateModel
bool b = TryValidateModel(countryVM);
foreach (string K in msd.Keys)
{
ModelStateEntry mse = null;
msd.TryGetValue(K, out mse);
ModelState.AddModelError(K, mse.Errors[0].ErrorMessage);
}
bool c = ModelState.IsValid;
if (!c)
{
return(View(countryVM));
}
countryVM_DataManager.SaveCountry(countryVM);
return(RedirectToAction("Country"));
}
public ValidationErrorViewModel(
string property,
ModelStateEntry entry)
{
Property = property;
Errors = entry.Errors.Select(error => error.ErrorMessage).ToArray();
}
public Entry(ModelStateEntry entry)
{
RawValue = entry.RawValue;
AttemptedValue = entry.AttemptedValue;
State = entry.ValidationState;
Errors = entry.Errors?.Select(x => x.ErrorMessage) ?? Enumerable.Empty <string>();
}
/// <summary>
/// 验证Model，如果验证失败，抛出异常
/// </summary>
protected void ValidateModelOrThrow()
{
if (ModelState.IsValid)
{
return;
}
var keys = ModelState.Keys;
var modelError = new Dictionary <string, string>();
foreach (var key in keys)
{
ModelStateEntry modeState = null;
if (ModelState.TryGetValue(key, out modeState) && modeState != null && modeState.ValidationState != ModelValidationState.Valid)
{
var error = new KeyValuePair <string, string>(key, string.Join(";", modeState.Errors.Select(e => e.ErrorMessage)));
modelError.Add(error.Key, error.Value);
}
}
var rootMsg = "输入错误！";
if (ModelState.Root.Errors.Any())
{
rootMsg = string.Join(";", ModelState.Root.Errors.Select(e => e.ErrorMessage));
}
var err = new InputError(modelError, rootMsg);
throw err;
}
private void ExecuteValidationInArgument <TCommand>(ActionExecutingContext context, TCommand command)
where TCommand : class
{
var result = new Result();
if (command == null)
{
result.Set(ResultCode.BadRequest, "Command cannot be null.");
context.Result = new BadRequestObjectResult(result);
return;
}
if (context.ModelState.IsValid)
{
return;
}
foreach (KeyValuePair <string, ModelStateEntry> kvp in context.ModelState)
{
string key = kvp.Key.Split('.').LastOrDefault();
ModelStateEntry value = kvp.Value;
if (value.Errors == null || !value.Errors.Any())
{
continue;
}
result.Validations.Add(new ResultValidation {
Attribute = key, Message = value.Errors.First().ErrorMessage
});
}
result.Set(ResultCode.BadRequest, "See validations.");
context.Result = new BadRequestObjectResult(result);
}
/// <summary>
/// ネストされた複数のモデルからエラー情報を収集する。
/// </summary>
/// <param name="entry"></param>
/// <param name="metadata"></param>
/// <param name="entries"></param>
/// <param name="namePrefix">デバッグ用なので不要</param>
private void Visit(
ModelStateEntry entry,
ModelMetadata metadata,
IList <ModelStateEntry> entries, string name)
{
// 配列やリスト型のプロパティの場合、含まれる全てを再帰処理
if (metadata.ElementMetadata != null && entry.Children != null)
{
for (int i = 0; i < entry.Children.Count; i++)
{
Visit(entry.Children[i], metadata.ElementMetadata,
entries, name + metadata.ElementMetadata.Name + $"[{i}]");
}
}
// プロパティを含む場合はそれぞれに対して再帰処理
for (var i = 0; i < metadata.Properties.Count; i++)
{
var propMetadata = metadata.Properties[i];
var propModelStateEntry = entry.GetModelStateForProperty(propMetadata.PropertyName);
if (propModelStateEntry != null)
{
string newName =
(!string.IsNullOrEmpty(name) ? name + "." : "") + propMetadata.Name;
Visit(propModelStateEntry, propMetadata, entries, newName);
}
}
// 対象がプロパティの場合はエントリ追加
if (!entry.IsContainerNode)
{
_logger.LogTrace($"AddEntry[{name}]: Errors={entry.Errors.Count}");
entries.Add(entry);
}
}
private static void Visit(
string parentName,
ModelStateEntry modelStateEntry,
ModelMetadata metadata,
IDictionary <string, ModelStateEntry> orderedModelStateEntries)
{
var fieldName = string.IsNullOrWhiteSpace(parentName) ? metadata.Name : $"{parentName}.{metadata.Name}";
if (metadata.ElementMetadata != null && modelStateEntry.Children != null)
{
foreach (var indexEntry in modelStateEntry.Children)
{
Visit(fieldName, indexEntry, metadata.ElementMetadata, orderedModelStateEntries);
}
}
else
{
for (var i = 0; i < metadata.Properties.Count; i++)
{
var propertyMetadata = metadata.Properties[i];
var propertyModelStateEntry = modelStateEntry.GetModelStateForProperty(propertyMetadata.PropertyName);
if (propertyModelStateEntry != null)
{
Visit(fieldName, propertyModelStateEntry, propertyMetadata, orderedModelStateEntries);
}
}
}
if (!modelStateEntry.IsContainerNode)
{
orderedModelStateEntries.Add(fieldName, modelStateEntry);
}
}
public async Task AdminController_ManualChanges_POST_Add_Organisation_Latest_Name_Fails_When_No_Parameters_Are_Provided_Async(
string nullOrEmptyParameter)
{
// Arrange
User databaseAdmin = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(databaseAdmin.UserId, null, databaseAdmin);
var manualChangesViewModel = Mock.Of <ManualChangesViewModel>();
manualChangesViewModel.Command = AddOrganisationsLatestNameCommand;
manualChangesViewModel.Parameters = nullOrEmptyParameter; // this test requires null or empty parameters to be provided
// Act
var retireOrgActionResult = await adminController.ManualChanges(manualChangesViewModel) as ViewResult;
Assert.NotNull(retireOrgActionResult);
var actualManualChangesViewModel = (ManualChangesViewModel)retireOrgActionResult.Model;
ModelStateEntry modelState = adminController.ModelState[""];
ModelError reportedError = modelState.Errors.First();
// Assert
Assert.AreEqual("ERROR: You must supply 1 or more input parameters", reportedError.ErrorMessage);
Assert.IsNull(actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("", actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.False(actualManualChangesViewModel.Tested, "Must be false as this case has failed");
}
public async Task AdminController_ManualChanges_POST_Fix_Organisation_Names_Fails_When_Parameters_Are_Provided_Async()
{
// Arrange
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, notAdminUser);
var manualChangesViewModel = Mock.Of <ManualChangesViewModel>();
manualChangesViewModel.Command = FixOrganisationNamesCommand;
manualChangesViewModel.Parameters = "invalid parameter"; // this test requires a parameter to be provided incorrectly
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModel);
// Assert
Assert.NotNull(manualChangesResult, "Expected a Result");
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult);
var actualManualChangesViewModel = (ManualChangesViewModel)manualChangesViewResult.Model;
ModelStateEntry modelState = adminController.ModelState[""];
ModelError reportedError = modelState.Errors.First();
// Assert
Assert.AreEqual("ERROR: parameters must be empty", reportedError.ErrorMessage);
Assert.IsNull(actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("", actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.False(actualManualChangesViewModel.Tested, "Must be false as this case has failed");
}
public void ValueHelpersDoNotEncodeValue()
{
// Arrange
var model = new TestModel {
StringProperty = "ModelStringPropertyValue <\"\">"
};
var helper = DefaultTemplatesUtilities.GetHtmlHelper <TestModel>(model);
var viewData = helper.ViewData;
viewData["StringProperty"] = "ViewDataValue <\"\">";
var modelState = new ModelStateEntry();
modelState.AttemptedValue = "ObjectPropertyAttemptedValue <\"\">";
modelState.RawValue = new string[] { "ObjectPropertyRawValue <\"\">" };
viewData.ModelState["ObjectProperty"] = modelState;
// Act & Assert
Assert.Equal(
"<{ StringProperty = ModelStringPropertyValue <\"\">, ObjectProperty = (null) }>",
helper.ValueForModel("<{0}>"));
Assert.Equal("<ViewDataValue <\"\">>", helper.Value("StringProperty", "<{0}>"));
Assert.Equal("<ModelStringPropertyValue <\"\">>", helper.ValueFor(m => m.StringProperty, "<{0}>"));
Assert.Equal("ObjectPropertyRawValue <\"\">", helper.ValueFor(m => m.ObjectProperty, format: null));
}
public void ValueHelpersWithErrorsGetValueFromModelState()
{
// Arrange
var model = new TestModel()
{
StringProperty = "ModelStringPropertyValue",
ObjectProperty = "ModelObjectPropertyValue",
};
var helper = DefaultTemplatesUtilities.GetHtmlHelper <TestModel>(model);
var viewData = helper.ViewData;
viewData["StringProperty"] = "ViewDataValue";
viewData.TemplateInfo.HtmlFieldPrefix = "FieldPrefix";
var modelState = new ModelStateEntry();
modelState.AttemptedValue = "StringPropertyAttemptedValue";
modelState.RawValue = new string[] { "StringPropertyRawValue" };
viewData.ModelState["FieldPrefix.StringProperty"] = modelState;
modelState = new ModelStateEntry();
modelState.AttemptedValue = "ModelAttemptedValue";
modelState.RawValue = new string[] { "ModelRawValue" };
viewData.ModelState["FieldPrefix"] = modelState;
// Act & Assert
Assert.Equal("StringPropertyRawValue", helper.Value("StringProperty", format: null));
Assert.Equal("StringPropertyRawValue", helper.ValueFor(m => m.StringProperty, format: null));
Assert.Equal("ModelRawValue", helper.ValueForModel(format: null));
}
public IActionResult Register(UserModel submission)
{
string check = submission.Email == null ? null : submission.Email.ToLower();
UserModel Query = _context.Users.Where(user => user.Email.ToLower() == check).FirstOrDefault();
if (ModelState.IsValid && Query == null)
{
PasswordHasher <UserModel> Hasher = new PasswordHasher <UserModel>();
submission.Password = Hasher.HashPassword(submission, submission.Password);
_context.Add(submission);
_context.SaveChanges();
HttpContext.Session.SetInt32("UserId", submission.UserId);
return(RedirectToAction("Result"));
}
else
{
TempData["fname"] = submission.FirstName;
TempData["lname"] = submission.LastName;
TempData["emailAddress"] = submission.Email;
foreach (string key in ModelState.Keys)
{
ModelStateEntry entry = ModelState[key];
string error = entry.Errors.Select(e => e.ErrorMessage).FirstOrDefault();
TempData[key] = error;
}
if (Query != null && TempData["Email"] == null)
{
TempData["Email"] = "Email is not unique.";
}
return(RedirectToAction("Index"));
}
}
private static void AddValidationErrors(ModelStateEntry entry, string propertyName, Type resourceType, List <ModelStateViolation> violations)
{
foreach (ModelError error in entry.Errors)
{
var violation = new ModelStateViolation("/data/attributes/", propertyName, resourceType, error);
violations.Add(violation);
}
}
public ModelStateTransferEntry(string key, ModelStateEntry entry)
{
Key = key;
AttemptedValue = entry.AttemptedValue;
RawValue = entry.RawValue;
ErrorMessages = entry.Errors == null ?
Enumerable.Empty<string>() :
entry.Errors.Select(x => x.ErrorMessage);
}
public IActionResult Create(AuthViewModel Auth)
{
int?UserId = HttpContext.Session.GetInt32("UserId");
if (UserId == null)
{
return(RedirectToAction("Dashboard"));
}
UserModel loggedIn = _context.Users.Where(u => u.UserId == UserId).SingleOrDefault();
if (!loggedIn.Admin)
{
return(RedirectToAction("Dashboard"));
}
System.Console.WriteLine(Auth.RegForm);
UserModel submission = new UserModel()
{
FirstName = Auth.RegForm.FirstName,
LastName = Auth.RegForm.LastName,
Email = Auth.RegForm.Email,
Password = Auth.RegForm.Password,
ConfirmPassword = Auth.RegForm.ConfirmPassword
};
string check = submission.Email == null ? null : submission.Email.ToLower();
UserModel Query = _context.Users.Where(user => user.Email.ToLower() == check).FirstOrDefault();
if (ModelState.IsValid && Query == null)
{
PasswordHasher <UserModel> Hasher = new PasswordHasher <UserModel> ();
submission.Password = Hasher.HashPassword(submission, submission.Password);
submission.CreatedAt = DateTime.Now;
_context.Add(submission);
_context.SaveChanges();
return(RedirectToAction("Dashboard"));
}
else
{
TempData["fname"] = submission.FirstName;
TempData["lname"] = submission.LastName;
TempData["emailAddress"] = submission.Email;
foreach (string key in ModelState.Keys)
{
string field = key.Substring(8);
System.Console.WriteLine(field);
ModelStateEntry entry = ModelState[key];
string error = entry.Errors.Select(e => e.ErrorMessage).FirstOrDefault();
System.Console.WriteLine(error);
TempData[field] = error;
}
if (Query != null && TempData["Email"] == null)
{
TempData["Email"] = "Email is not unique.";
}
return(RedirectToAction("NewUser"));
}
}
private static IEnumerable<ODataErrorDetail> ToODataErrorDetails(string key, ModelStateEntry modelStateEntry)
{
foreach (var error in modelStateEntry.Errors)
{
var detail = new ODataErrorDetail();
detail.Target = key;
detail.Message = error.ErrorMessage;
yield return detail;
}
}
override public void OnActionExecuting(ActionExecutingContext context)
{
if (!context.ModelState.IsValid)
{
ModelStateEntry entry = context.ModelState.ElementAt(0).Value;
var attemptedVal = entry.AttemptedValue;
var rawVal = entry.RawValue;
context.Result = new OkObjectResult(rawVal);
}
}
private static void AddValidationErrors(ModelStateEntry entry, string propertyName, Type resourceType, int operationIndex, List <ModelStateViolation> violations)
{
foreach (var error in entry.Errors)
{
var prefix = $"/atomic:operations[{operationIndex}]/data/attributes/";
var violation = new ModelStateViolation(prefix, propertyName, resourceType, error);
violations.Add(violation);
}
}
private ValidationError GetValidationError(string key, ModelError error, ModelStateEntry modelState)
{
string value = string.Empty;
if (!String.IsNullOrEmpty(modelState.AttemptedValue))
{
value = modelState.AttemptedValue;
}
return(new ValidationError(key, error.ErrorMessage, value));
}
void IBannedImageLogger.Log(ModelStateEntry modelStateEntry, IPAddress ip, IIpHash ipHash)
{
if (modelStateEntry != null)
{
var hasBannedImage = modelStateEntry.Errors.Select(a => a.ErrorMessage).Contains(ValidateImage.BannedImageString);
if (hasBannedImage)
{
this.logger.LogInformation($"User ip:{ip.ToString()} hash:{ipHash.Val} attempted to upload banned image.");
}
}
}
private string GetErrorMessages(ModelStateEntry child)
{
string result = GetErrorMessages(child.Errors);
if (child.Children != null)
{
result += string.Join(
", ",
child.Children.Select(innerChild => GetErrorMessages(innerChild)));
}
return(result);
}
public IActionResult UpdateProfile(UpdateProfileViewModel Update)
{
int?UserId = HttpContext.Session.GetInt32("UserId");
if (UserId == null)
{
return(RedirectToAction("Dashboard"));
}
UserModel submission = _context.Users.Where(u => u.UserId == UserId).SingleOrDefault();
UserModel Query;
if (submission.Email.ToLower() == Update.EditForm.Email)
{
Query = null;
}
else
{
string check = submission.Email == null ? null : submission.Email.ToLower();
Query = _context.Users.Where(user => user.Email.ToLower() == check).FirstOrDefault();
}
if (ModelState.IsValid && Query == null)
{
submission.FirstName = Update.EditForm.FirstName;
submission.LastName = Update.EditForm.LastName;
submission.Email = Update.EditForm.Email;
_context.SaveChanges();
return(RedirectToAction("Dashboard"));
}
else
{
TempData["fname"] = Update.EditForm.FirstName;
TempData["lname"] = Update.EditForm.LastName;
TempData["emailAddress"] = Update.EditForm.Email;
foreach (string key in ModelState.Keys)
{
if (key == "id")
{
continue;
}
string field = key.Substring(9);
System.Console.WriteLine(field);
ModelStateEntry entry = ModelState[key];
string error = entry.Errors.Select(e => e.ErrorMessage).FirstOrDefault();
System.Console.WriteLine(error);
TempData[field] = error;
}
if (Query != null && TempData["Email"] == null)
{
TempData["Email"] = "Email is not unique.";
}
return(RedirectToAction("Profile"));
}
}
private static void VisitModelState(ModelStateEntry modelStateEntry, Action <ModelStateEntry> action)
{
if (modelStateEntry.Children != null)
{
foreach (ModelStateEntry child in modelStateEntry.Children)
{
VisitModelState(child, action);
}
}
action.Invoke(modelStateEntry);
}
public void Copy(ModelStateEntry entry)
{
RawValue = entry.RawValue;
AttemptedValue = entry.AttemptedValue;
Errors.Clear();
for (var i = 0; i < entry.Errors.Count; i++)
{
Errors.Add(entry.Errors[i]);
}
ValidationState = entry.ValidationState;
}
private IEnumerable <ValidationError> EnumerateValidationErrorsFromModelState()
{
foreach (string key in ModelState.Keys)
{
ModelStateEntry entry = ModelState[key];
string[] messages = entry
.Errors
.Select(error => error.ErrorMessage)
.ToArray();
yield return(new ValidationError(key, messages));
}
}
public static void CustomErrorMessage <T>(this ModelStateDictionary modelState, string message, T instance)
{
ModelStateEntry entry = modelState.GetValueOrDefault(_key);
if (entry != null)
{
Type modelType = typeof(T);
PropertyInfo propertyInfoMessage = modelType.GetProperty("NotificationMessage");
propertyInfoMessage.SetValue(instance, message);
PropertyInfo propertyInfoMessageType = modelType.GetProperty("MessageType");
propertyInfoMessageType.SetValue(instance, EnumMessageType.Error);
}
}
public IActionResult ChangePass(UpdateViewModel Update, int id)
{
int?UserId = HttpContext.Session.GetInt32("UserId");
if (UserId == null)
{
return(RedirectToAction("Dashboard"));
}
UserModel loggedIn = _context.Users.Where(u => u.UserId == UserId).SingleOrDefault();
if (!loggedIn.Admin)
{
return(RedirectToAction("Dashboard"));
}
UserModel submission = _context.Users.Where(u => u.UserId == id).SingleOrDefault();
if (ModelState.IsValid)
{
PasswordHasher <UserModel> Hasher = new PasswordHasher <UserModel> ();
var result = Hasher.VerifyHashedPassword(submission, submission.Password, Update.ChangeForm.Password);
if (result != 0)
{
return(RedirectToAction("Dashboard"));
}
else
{
submission.Password = Update.ChangeForm.Password;
submission.Password = Hasher.HashPassword(submission, submission.Password);
_context.SaveChanges();
return(RedirectToAction("Dashboard"));
}
}
else
{
foreach (string key in ModelState.Keys)
{
if (key == "id")
{
continue;
}
string field = key.Substring(11);
System.Console.WriteLine(field);
ModelStateEntry entry = ModelState[key];
string error = entry.Errors.Select(e => e.ErrorMessage).FirstOrDefault();
System.Console.WriteLine(error);
TempData[field] = error;
}
return(RedirectToAction("EditUser"));
}
}
public static string GetModelErrorMessageOrDefault(
ModelError modelError,
ModelStateEntry containingEntry,
ModelExplorer modelExplorer)
{
Debug.Assert(modelError != null);
Debug.Assert(containingEntry != null);
Debug.Assert(modelExplorer != null);
if (!string.IsNullOrEmpty(modelError.ErrorMessage))
{
return modelError.ErrorMessage;
}
// Default in the ValidationMessage case is a fallback error message.
var attemptedValue = containingEntry.AttemptedValue ?? "null";
return modelExplorer.Metadata.ModelBindingMessageProvider.ValueIsInvalidAccessor(attemptedValue);
}
private static void Visit(
ModelStateDictionary dictionary,
ModelStateEntry modelStateEntry,
ModelMetadata metadata,
List<ModelStateEntry> orderedModelStateEntries)
{
if (metadata.ElementMetadata != null)
{
foreach (var indexEntry in modelStateEntry.Children)
{
Visit(dictionary, indexEntry, metadata.ElementMetadata, orderedModelStateEntries);
}
}
for (var i = 0; i < metadata.Properties.Count; i++)
{
var propertyMetadata = metadata.Properties[i];
var propertyModelStateEntry = modelStateEntry.GetModelStateForProperty(propertyMetadata.PropertyName);
if (propertyModelStateEntry != null)
{
Visit(dictionary, propertyModelStateEntry, propertyMetadata, orderedModelStateEntries);
}
}
if (!modelStateEntry.IsContainerNode)
{
orderedModelStateEntries.Add(modelStateEntry);
}
}
