/// <summary>
/// Custom validation of the entities. Called by GetValidationErrors.
/// </summary>
/// <param name="entityEntry">DbEntityEntry instance to be validated.</param>
/// <param name="items">User-defined dictionary containing additional info for custom validation. It will be passed to ValidationContext and will be exposed as Items.
/// This parameter is optional and can be null.</param>
/// <returns>Entity validation result</returns>
protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, IDictionary <object, object> items)
{
var result = new DbEntityValidationResult(entityEntry, new List <DbValidationError>());
if ((entityEntry.State == EntityState.Added) ||
(entityEntry.State == EntityState.Modified))
{
if (entityEntry.Entity is Account)
{
ValidateAccountEntry(entityEntry, result);
}
if (entityEntry.Entity is Category)
{
ValidateCategoryEntry(entityEntry, result);
}
if (entityEntry.Entity is Payee)
{
ValidatePayeeEntry(entityEntry, result);
}
}
if (result.ValidationErrors.Count > 0)
{
return(result);
}
else
{
return(base.ValidateEntity(entityEntry, items));
}
}
public void CustomValidate(CFAPContext ctx)
{
List <DbEntityValidationResult> validationResults = new List <DbEntityValidationResult>();
var rateResult = ctx.Entry(this).GetValidationResult();
if (!rateResult.IsValid)
{
validationResults.Add(rateResult);
}
if (this.DateRate == default(DateTime))
{
DbValidationError validationError = new DbValidationError(typeof(DateTime).ToString(), "Значениие не определено");
DbEntityValidationResult dbEntityValidationResult = new DbEntityValidationResult(ctx.Entry(this), new DbValidationError[] { validationError });
validationResults.Add(dbEntityValidationResult);
}
if (validationResults.Count > 0)
{
throw new DbEntityValidationException(
"Ошибка при проверке данных. Данные могут остутствовать или указаны не верно. Проверте внесенные данные и повторите попытку"
, validationResults);
}
}
protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, IDictionary <object, object> items)
{
var result = new DbEntityValidationResult(entityEntry, new List <DbValidationError>());
if (entityEntry.Entity is Incidencia &&
(entityEntry.State == EntityState.Added ||
entityEntry.State == EntityState.Modified)
)
{
Incidencia incidencia = entityEntry.Entity as Incidencia;
Tecnic tecnic = incidencia.TecnicQueObreLaIncidencia;
bool ja_te_3_incidencies = this.
Incidencies.
Where(x => x.IdTecnicQueObreLaIncidencia == incidencia.IdTecnicQueObreLaIncidencia)
.Where(x => x.IdTecnicQueTancaLaIncidencia == null)
.Count() >= 3;
if (ja_te_3_incidencies)
{
result.ValidationErrors.Add(
new System.Data.Entity.Validation.DbValidationError("IdTecnicQueTancaLaIncidencia",
"Amb compte! Aquest tècnic ja té 3 incidències obertes"));
}
}
return(base.ValidateEntity(entityEntry, items));
}
protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry,
IDictionary <object, object> items)
{
if (entityEntry.State != EntityState.Added)
{
return(base.ValidateEntity(entityEntry,
items));
}
var user = entityEntry.Entity as User;
// Check for uniqueness of user name
if (user == null || !Users.Any(u => String.Equals(u.UserName,
user.UserName,
StringComparison.CurrentCultureIgnoreCase)))
{
return(base.ValidateEntity(entityEntry,
items));
}
var result = new DbEntityValidationResult(entityEntry,
new List <DbValidationError>());
result.ValidationErrors.Add(new DbValidationError("User",
"User name must be unique."));
return(result);
}
public override void OnException(HttpActionExecutedContext actionExecutedContext)
{
if (actionExecutedContext.Exception is DbEntityValidationException)
{
DbEntityValidationException dbException
= (DbEntityValidationException)actionExecutedContext.Exception;
DbEntityValidationResult dbValidationResult
= dbException.EntityValidationErrors.FirstOrDefault();
DbValidationError dbFirstValidationError
= dbValidationResult.ValidationErrors.FirstOrDefault();
string responseText
= string.Format(
CultureInfo.CurrentCulture,
"{0}:{1}",
dbFirstValidationError.PropertyName,
dbFirstValidationError.ErrorMessage
);
actionExecutedContext.Response
= new HttpResponseMessage(HttpStatusCode.BadRequest);
actionExecutedContext.Response.Content
= new StringContent(responseText);
}
}
private static void TestValidationEntity()
{
using (var context = new InstituteEntities())
{
//create entity
var student = context.Students.Create();
student.GradePointAverage = 2;
student.IsOutStanding = true;
var department = context.Departments.Create();
department.DepartmentName = "Electrical Engineering";
//add it to context
context.Students.Add(student);
context.Departments.Add(department);
//validate only student entity
DbEntityValidationResult validationResult =
context.Entry <Student>(student).GetValidationResult();
string errorMessage =
DbEntityValidationMessageParser.GetErrorMessage(validationResult);
//Print Message
Console.WriteLine(errorMessage);
}
}
ValidateEntity(System.Data.Entity.Infrastructure.DbEntityEntry entityEntry, IDictionary <object, object> items)
{
var result = new DbEntityValidationResult(entityEntry,
new List <DbValidationError>());
if (entityEntry.Entity is TestObject && entityEntry.State == EntityState.Added)
{
TestObject obj = entityEntry.Entity as TestObject;
//check for uniqueness of post title
if (TestObjects.Any(m => m.Name == obj.Name))
{
result.ValidationErrors.Add(
new System.Data.Entity.Validation.DbValidationError(
"Name", "TestObject Name 必须唯一。"));
}
}
if (result.ValidationErrors.Count > 0)
{
return(result);
}
else
{
return(base.ValidateEntity(entityEntry, items));
}
}
public void AddContact(Contact c)
{
try
{
DbEntityValidationResult vresult = _enitites.Entry(c).GetValidationResult();
if (vresult.IsValid)
{
_enitites.Contacts.Add(c);
_enitites.SaveChanges();
}
else
{
//Console.WriteLine(vresult.ValidationErrors.First().ErrorMessage);
foreach (DbValidationError item in vresult.ValidationErrors)
{
Console.WriteLine(item.ErrorMessage);
}
}
}
catch (DbEntityValidationException ex)
{
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
throw new Exception("Errue générale " + ex.Message);
}
finally
{
Trace.Write("tentative d'ajout");
}
}
ValidateApplicationUser(
this UrfIdentityDataContext dbContext,
DbEntityValidationResult result)
{
var entity = result.Entry.Entity as ApplicationUser;
if (entity == null)
{
return;
}
ApplicationUser temp = dbContext
.ApplicationUsers.FirstOrDefault(x => x.UserName == entity.UserName);
if ((temp != null) && (temp.Id != entity.Id))
{
result.ValidationErrors.Add(
new DbValidationError(
// A {0} with the {1} of '{2}' is already registered ({3})
"UserName",
String.Format(
ModelValidationResources.NonUniqueField_NoReference,
AccountResources.User_Account,
AccountResources.UserName, entity.UserName)));
}
}
private static string GetDbEntityValidationExceptionMessage(DbEntityValidationException ex)
{
StringBuilder builder = new StringBuilder();
ICollection <DbEntityValidationResult> validationResults = ex.EntityValidationErrors.ToList();
for (int i = 0; i < validationResults.Count; i++)
{
DbEntityValidationResult result = validationResults.ElementAt(i);
ICollection <DbValidationError> validationErrors = result.ValidationErrors;
for (int j = 0; j < validationErrors.Count; j++)
{
DbValidationError error = validationErrors.ElementAt(j);
builder.Append(error.ErrorMessage);
if (j != validationErrors.Count - 1)
{
builder.Append("; ");
}
}
if (i != validationResults.Count - 1)
{
builder.AppendLine();
}
}
return(builder.ToString());
}
protected override DbEntityValidationResult ValidateEntity(System.Data.Entity.Infrastructure.DbEntityEntry entityEntry, IDictionary <object, object> items)
{
if (typeof(System.ComponentModel.DataAnnotations.IValidatableObject).IsAssignableFrom(entityEntry.Entity.GetType()))
{
var type = entityEntry.Entity.GetType();
if (IsProxy(type))
{
type = entityEntry.Entity.GetType().BaseType;
}
MethodInfo method = this.GetType().GetMethod("GetNavigationProperties");
MethodInfo generic = method.MakeGenericMethod(type);
var navigationProperties = generic.Invoke(this, new object[] { entityEntry.Entity }) as List <PropertyInfo>;
foreach (var property in navigationProperties)
{
if (typeof(System.Collections.IEnumerable).IsAssignableFrom(property.PropertyType))
{
this.Entry(entityEntry.Entity).Collection(property.Name);
}
else
{
this.Entry(entityEntry.Entity).Reference(property.Name);
}
}
var result = new DbEntityValidationResult(entityEntry, ((IValidatableObject)entityEntry.Entity).Validate(new System.ComponentModel.DataAnnotations.ValidationContext(entityEntry.Entity)).Select(x => new DbValidationError(x.MemberNames.FirstOrDefault(), x.ErrorMessage)));
if (!result.IsValid)
{
return(result);
}
}
return(base.ValidateEntity(entityEntry, items));
}
public Result Update(Users user)
{
Result result = new Result();
if (user == null)
{
return(result);
}
try
{
using (DatabaseINNOCVEntities context = FactoriaIOC.Patterns.IoCFactoryBase.Resolve <DatabaseINNOCVEntities>())
{
Users userNew = context.Users.Where(x => x.Id == user.Id).FirstOrDefault();
userNew.Id = user.Id;
userNew.Name = user.Name;
userNew.Birthdate = user.Birthdate;
context.SaveChanges();
context.Dispose();
}
}
catch (OptimisticConcurrencyException ex)
{
result.Error = ex.Message;
}
catch (InvalidOperationException ex)
{
result.Error = ex.Message;
}
catch (UpdateException ex)
{
result.Error = ex.Message;
}
catch (DbEntityValidationException ex)
{
DbEntityValidationResult validationResult = ex.EntityValidationErrors.FirstOrDefault();
if (validationResult != null && validationResult.ValidationErrors.Count > 0)
{
result.Error = string.Empty;
foreach (var ve in validationResult.ValidationErrors)
{
result.Error += ve.ErrorMessage + Environment.NewLine;
}
throw new Exception(result.Error);
}
}
catch (Exception ex)
{
result.Error = ex.Message;
}
return(result);
}
public DataNotValidException(DbEntityValidationResult validationresults)
{
this.ValidationErrors = new Dictionary <string, string>();
foreach (var er in validationresults.ValidationErrors)
{
this.ValidationErrors.Add(er.PropertyName, er.ErrorMessage);
}
}
/// <summary>
/// A DbEntityValidationResult extension method that to strings database validation errors.
/// </summary>
/// <param name="dbEntityValidationResult">The database entity validation result.</param>
/// <param name="dbValidationErrors">The database validation errors.</param>
/// <returns></returns>
public static string DbValidationErrorsToString(this DbEntityValidationResult dbEntityValidationResult, IEnumerable <DbValidationError> dbValidationErrors)
{
var entityName = $"[{dbEntityValidationResult.Entry.Entity.GetType().Name}]";
var aggregatedValidationErrorMessages = dbValidationErrors.Select(error => string.Format("[{0} - {1}]", error.PropertyName, error.ErrorMessage))
.Aggregate(string.Empty, (current, validationErrorMessage) => current + (Environment.NewLine + validationErrorMessage));
return($"{entityName}{aggregatedValidationErrorMessages}");
}
private object AsError(DbEntityValidationResult dbError, DbValidationError dbErrorEntry)
{
var status = "422";
var detail = dbErrorEntry.ErrorMessage;
var source = new { pointer = "/data/attributes/" + dbErrorEntry.PropertyName };
return(new { status = status, detail = detail, source = source });
}
public static EFValidationResult ToEFValidationResult(this DbEntityValidationResult dbResult)
{
var errors = (from e in dbResult.ValidationErrors
select new EFValidationError(e.PropertyName, e.ErrorMessage))
.ToList <IValidationError>() as ICollection <IValidationError>;
return(new EFValidationResult(dbResult.Entry.Entity, errors));
}
/// <summary>
/// A DbEntityValidationResult extension method that to strings database validation errors.
/// </summary>
public static string DbValidationErrorsToString(this DbEntityValidationResult dbEntityValidationResult, IEnumerable <DbValidationError> dbValidationErrors)
{
var entityName = string.Format("[{0}]", dbEntityValidationResult.Entry.Entity.GetType().Name);
const string indentation = "\t - ";
var aggregatedValidationErrorMessages = dbValidationErrors.Select(error => string.Format("[{0} - {1}]", error.PropertyName, error.ErrorMessage))
.Aggregate(string.Empty, (current, validationErrorMessage) => current + (Environment.NewLine + indentation + validationErrorMessage));
return(string.Format("{0}{1}", entityName, aggregatedValidationErrorMessages));
}
private void button1_Click(object sender, EventArgs e)
{
SoruContext ctx = new SoruContext();
if (button1.Text == "EKLE")
{
Soru s = new Soru();
s.Konu = textBox1.Text;
s.SoruCumlesi = richTextBox1.Text;
s.Cevap = textBox2.Text;
DbEntityValidationResult d = ctx.Entry(s).GetValidationResult();
if (d.IsValid)
{
ctx.Sorular.Add(s);
MessageBox.Show("Başarıyla eklendi.");
EskiHali();
}
else
{
string hata = "";
foreach (var item in d.ValidationErrors)
{
hata += item.ErrorMessage + "\n";
}
MessageBox.Show(hata);
}
ctx.SaveChanges();
}
else
{
//** UZUN HALİ **//
//Soru duzenlenecek = (from x in ctx.Sorular where x.SoruID == (int)listBox1.SelectedValue select x).FirstOrDefault();
Soru duzenlecek = ctx.Sorular.Find(listBox1.SelectedValue);
//Find metodu verilen id deki elemanı getirir.
duzenlecek.Konu = textBox1.Text;
duzenlecek.Cevap = textBox2.Text;
duzenlecek.SoruCumlesi = richTextBox1.Text;
//** Düzenlenen şey modele uygunluğunu kontrol etmek için **//
DbEntityValidationResult d = ctx.Entry(duzenlecek).GetValidationResult();
if (d.IsValid) //modele uygunsa
{
ctx.Entry(duzenlecek).State = System.Data.Entity.EntityState.Modified; //Kayıtta değişiklik yapıldığının belirtilmesi gerekiyor.State ile.
ctx.SaveChanges();
MessageBox.Show("Kaydedildi.");
}
else
{
MessageBox.Show("Bir hata oluştu");
}
EskiHali();
}
Yenile();
}
/// <summary>
/// 通用打印验证错误信息方法
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
private static string ConsoleValidationResults(DbEntityValidationResult result)
{
string a = "";
foreach (DbValidationError error in result.ValidationErrors)
{
a = a + "\r\n" + error.ErrorMessage;
}
return(a);
}
public static void WriteValiationResults(DbEntityValidationResult result)
{
Console.WriteLine("Type: {0}", result.Entry.Entity.GetType().Name);
Console.WriteLine("Passed Validation: {0}", result.IsValid);
foreach (DbValidationError dbValidationError in result.ValidationErrors)
{
Console.WriteLine("{0}: {1}", dbValidationError.PropertyName, dbValidationError.ErrorMessage);
}
}
private void button1_Click(object sender, EventArgs e)
{
SoruContext ctx = new SoruContext();
if (button1.Text == "Ekle")
{
Soru s = new Soru();
s.Konu = textBox1.Text;
s.SoruCumlesi = richTextBox1.Text;
s.Cevap = textBox2.Text;
//using System.Data.Entity.Validation;
DbEntityValidationResult d = ctx.Entry(s).GetValidationResult();
if (d.IsValid) //geçerliyse
{
ctx.Sorular.Add(s);
MessageBox.Show("Başarıyla eklendi");
EskiHali();
}
else
{
string hata = "";
foreach (var item in d.ValidationErrors)
{
hata += item.ErrorMessage + " \n";
}
MessageBox.Show(hata);
}
ctx.SaveChanges();
}
else //düzenle
//Soru duzenlenecek = (from x in ctx.Sorular where x.SoruID == (int)listBox1.SelectedValue select x).FirstOrDefault();
{
Soru duzenlenecek = ctx.Sorular.Find(listBox1.SelectedValue);
//Find metodu verilen id deki elemanı getirir
duzenlenecek.Konu = textBox1.Text;
duzenlenecek.Cevap = textBox2.Text;
duzenlenecek.SoruCumlesi = richTextBox1.Text;
DbEntityValidationResult d = ctx.Entry(duzenlenecek).GetValidationResult(); //modele uygun mu, varsa hatalar bu değişkende
if (d.IsValid) //model geçerliyse hata yoksa
{
ctx.Entry(duzenlenecek).State = System.Data.Entity.EntityState.Modified; //kayıtta değişiklik yapıldı
ctx.SaveChanges();
MessageBox.Show("Kaydedildi");
}
else
{
MessageBox.Show("Bir hata oluştu");
}
EskiHali();
}
Yenile();
}
private static string GetExceptionMessage(
DbEntityValidationResult entityValidationError,
DbValidationError databaseValidationError)
{
return(string.Format(
ErrorEntityValidation,
entityValidationError.Entry.Entity.GetType().Name,
entityValidationError.Entry.State,
databaseValidationError.PropertyName,
databaseValidationError.ErrorMessage));
}
/// <summary>
/// Obtiene el resultado de validación para un objeto
/// </summary>
/// <param name="model">Objeto Entity a validar</param>
/// <returns>Resultado de la validación</returns>
public static ModelStateDictionary GetModelState(object model)
{
ModelStateDictionary modelState = new ModelStateDictionary();
DbEntityValidationResult validResult = DbContext.Entry(model).GetValidationResult();
foreach (DbValidationError error in validResult.ValidationErrors)
{
modelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
return(modelState);
}
/// <summary>
/// 自定义验证：每一个目的地类Destination下不能有同名的住宿类Lodging
/// </summary>
/// <param name="result"></param>
private void ValidateLodging(DbEntityValidationResult result)
{
var lodging = result.Entry.Entity as DbContexts.Model.Lodging;
if (lodging != null && lodging.DestinationId != 0)
{
if (Lodgings.Any(l => l.Name == lodging.Name && l.DestinationId == lodging.DestinationId))
{
result.ValidationErrors.Add(new DbValidationError("Lodging", "There is already a lodging named " + lodging.Name + " at this destination."));
}
}
}
/// <summary>
/// 多个验证规则
/// </summary>
private void ValidateReservation(DbEntityValidationResult result)
{
var reservation = result.Entry.Entity as DbContexts.Model.Reservation;
if (reservation != null)
{
if (result.Entry.State == EntityState.Added && reservation.Payments.Count == 0)
{
result.ValidationErrors.Add(new DbValidationError("Reservation", "New reservation must have a payment."));
}
}
}
/// <summary>
/// Validate a Payee entity
/// </summary>
/// <param name="entityEntry">The Payee entity to be validated.</param>
/// <param name="result">The collection of results to add new errors to.</param>
private void ValidatePayeeEntry(DbEntityEntry entityEntry, DbEntityValidationResult result)
{
Payee payee = entityEntry.Entity as Payee;
// Check for uniqueness of Name
if ((entityEntry.State == EntityState.Added && Payees.Count(p => (p.Name == payee.Name)) > 0) ||
(entityEntry.State == EntityState.Modified && Payees.Count(p => p.Name == payee.Name && (p.Id != payee.Id)) >= 1))
{
result.ValidationErrors.Add(
new DbValidationError("Name", "Payee name must be unique."));
}
}
/// <summary>
/// Validate an Account entity
/// </summary>
/// <param name="entityEntry">The Account entity to be validated.</param>
/// <param name="result">The collection of results to add new errors to.</param>
private void ValidateAccountEntry(DbEntityEntry entityEntry, DbEntityValidationResult result)
{
Account account = entityEntry.Entity as Account;
// Check for uniqueness of Name
if ((entityEntry.State == EntityState.Added && Accounts.Count(a => (a.Name == account.Name)) > 0) ||
(entityEntry.State == EntityState.Modified && Accounts.Count(a => a.Name == account.Name && (a.Id != account.Id)) >= 1))
{
result.ValidationErrors.Add(
new DbValidationError("Name", "Account name must be unique."));
}
}
/// <summary>
/// Validate a Category entity
/// </summary>
/// <param name="entityEntry">The Category entity to be validated.</param>
/// <param name="result">The collection of results to add new errors to.</param>
private void ValidateCategoryEntry(DbEntityEntry entityEntry, DbEntityValidationResult result)
{
Category category = entityEntry.Entity as Category;
// Check for uniqueness of Name
if ((entityEntry.State == EntityState.Added && Categories.Count(c => (c.Name == category.Name)) > 0) ||
(entityEntry.State == EntityState.Modified && Categories.Count(c => c.Name == category.Name && (c.Id != category.Id)) >= 1))
{
result.ValidationErrors.Add(
new DbValidationError("Name", "Category name must be unique."));
}
}
/// <summary>
/// Appends dbEntityValidationResult2 <see cref="DbEntityValidationResult.ValidationErrors"/> property to the caller's prop.
/// </summary>
/// <param name="dbEntityValidationResult1"></param>
/// <param name="dbEntityValidationResult2"></param>
public static void AppendWith(this DbEntityValidationResult dbEntityValidationResult1, DbEntityValidationResult dbEntityValidationResult2)
{
if (dbEntityValidationResult1.Entry.Entity != dbEntityValidationResult2.Entry.Entity)
{
throw new Exception("Trying to append ValidationErrors with different db Entries!");
}
foreach (var error in dbEntityValidationResult2.ValidationErrors)
{
dbEntityValidationResult1.ValidationErrors.Add(error);
}
}
internal void AddErrorsToModelState(DbEntityValidationResult validation, ModelStateDictionary state)
{
if (validation == null || state == null || validation.IsValid)
{
return;
}
var errors = validation.ValidationErrors.Select(r => new { Property = r.PropertyName, ErrorMessage = r.ErrorMessage });
foreach (var error in errors)
{
ModelState.AddModelError(error.Property, error.ErrorMessage);
}
}
