public static string TraceDbException(System.Data.Entity.Validation.DbEntityValidationException e)
{
try
{
StringBuilder sb = new StringBuilder();
sb.Append("___Loi tuong tac CDSL (DbEntityValidationException)").Append("{");
foreach (var eve in e.EntityValidationErrors)
{
foreach (var ve in eve.ValidationErrors)
{
sb.Append(string.Format("{0}:{1}; ", ve.PropertyName, ve.ErrorMessage));
}
}
sb.Append("}___");
return(sb.ToString());
}
catch (Exception)
{
try
{
StringBuilder sb = new StringBuilder();
sb.Append("___Loi tuong tac CSDL").Append("{...LogUtil.TraceDbException. Co exception khi logging...}___");
return(sb.ToString());
}
catch (Exception)
{
return("");
}
}
}
/// <summary>
/// Metoda pobierająca informacje o błędach bazodanowych
/// </summary>
/// <param name="entityException"></param>
public DbValidationErrorHandler(System.Data.Entity.Validation.DbEntityValidationException entityException)
{
validationErrors = new List <ApiValidationErrorItem>();
if (entityException.EntityValidationErrors.Count() > 0)
{
foreach (var v in entityException.EntityValidationErrors)
{
if (v.ValidationErrors.Count > 0)
{
foreach (var vv in v.ValidationErrors)
{
validationErrors.Add(new ApiValidationErrorItem
{
Message = vv.ErrorMessage,
Property = vv.PropertyName
});
}
}
}
}
else
{
validationErrors.Add(new ApiValidationErrorItem
{
Message = entityException.Message
});
}
}
public string ObterMensagemErroDetalhada(System.Data.Entity.Validation.DbEntityValidationException ex)
{
string mensagemErro = ObterMensagemErroDetalhada((Exception)ex);
if (ex.EntityValidationErrors == null)
{
return(mensagemErro);
}
if (ex.EntityValidationErrors.Count() == 0)
{
return(mensagemErro);
}
mensagemErro += Environment.NewLine;
foreach (var erro in ex.EntityValidationErrors)
{
foreach (var erroValidacao in erro.ValidationErrors)
{
mensagemErro += erroValidacao.ErrorMessage + Environment.NewLine;
}
}
return(mensagemErro);
}
public static void WriteLog(System.Data.Entity.Validation.DbEntityValidationException aa)
{
string path = HttpContext.Current.Server.MapPath("~/App_Data/error.txt");
var dataFile = HttpContext.Current.Server.MapPath("~/App_Data/error.txt");
var e = aa;
File.AppendAllText(@dataFile, "\r\n" + DateTime.Now.ToString("dd/MM/yyyy hh:mm tt") + ": " + aa.ToString());
foreach (var eve in e.EntityValidationErrors)
{
File.AppendAllText(@dataFile, "\r\n" + string.Format("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State));
//Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
// eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
File.AppendAllText(@dataFile, "\r\n" + string.Format("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage));
}
}
//foreach (var a in aa.EntityValidationErrors)
//{
// File.AppendAllText(@dataFile, a.ToString());
//}
File.AppendAllText(@dataFile, "\r\n-------- end of " + DateTime.Now.ToString("dd/MM/yyyy hh:mm tt") + "---------\n");
}
/// <summary>
/// Get TempDataDictionary with database entity exception messages
/// </summary>
/// <param name="pE">DbEntityValidationException</param>
/// <returns>TempDataDictionary</returns>
public TempDataDictionary TempDataEntityExceptionMessage(System.Data.Entity.Validation.DbEntityValidationException pE)
{
TempDataDictionary vError = new TempDataDictionary();
vError["error"] = Titiushko.Utilities.Constants.Basic.TRUE;
vError["error_message"] = Titiushko.Utilities.Constants.Errors.BaseError.DEFAULT(pE.GetEntityExceptionMessage());
return(vError);
}
/// <summary>
/// Add User
/// </summary>
/// <param name="FirstName"></param>
/// <param name="LastName"></param>
/// <param name="Email"></param>
/// <param name="EmpresaId"></param>
/// <param name="Password"></param>
public static UserCreateResult AddUser(string UserName, string Password, string FirstName, string LastName, string Email, int EmpresaId)
{
try
{
var user = new ApplicationUser();
user.UserName = UserName;
user.FirstName = string.IsNullOrEmpty(FirstName) ? UserName : FirstName;
user.LastName = string.IsNullOrEmpty(LastName) ? UserName : LastName;
user.Email = string.IsNullOrEmpty(Email) ? "*****@*****.**" : Email;
user.EmpresaID = EmpresaId;
IdentityManager idManager = new IdentityManager();
var chkUser = idManager.CreateUser(user, Password);
if (chkUser.Succeeded)
{
SecurityDbContext Db = new SecurityDbContext();
var group = Db.Groups.Where(gr => gr.Name.Equals(Startup.AdminName)).FirstOrDefault();
if (group != null)
{
idManager.AddUserToGroup(user.Id, group.Id);
}
return(new UserCreateResult()
{
Succeeded = true
});
}
else
{
return(new UserCreateResult()
{
Succeeded = false, Errors = chkUser.Errors.ToList()
});
}
}
catch (Exception eX)
{
List <string> iErrors = new List <string>();
iErrors.Add(eX.Message);
System.Data.Entity.Validation.DbEntityValidationException EntityErrors = eX as System.Data.Entity.Validation.DbEntityValidationException;
if (EntityErrors != null && EntityErrors.EntityValidationErrors != null && EntityErrors.EntityValidationErrors.Count() > 0)
{
EntityErrors.EntityValidationErrors.ToList().ForEach(err =>
{
if (!err.IsValid && err.ValidationErrors != null && err.ValidationErrors.Count > 0)
{
err.ValidationErrors.ToList().ForEach(vE => iErrors.Add($"Propiedad: {vE.PropertyName} - Error: {vE.ErrorMessage}"));
}
});
}
return(new UserCreateResult()
{
Succeeded = false, Errors = iErrors
});
}
}
static async Task ShowExceptionDetails(Exception Ex)
{
while (Ex != null && Ex.Message == " occurred while updating the entries. See the inner exception for details.")
{
Ex = Ex.InnerException;
}
string ValidationError = "";
if (Ex.GetType() == typeof(System.Data.Entity.Validation.DbEntityValidationException))
{
ValidationError = "Database Entity Validation Errors : \r\n\r\n";
System.Data.Entity.Validation.DbEntityValidationException ValidationException = (System.Data.Entity.Validation.DbEntityValidationException)Ex;
foreach (System.Data.Entity.Validation.DbEntityValidationResult ValidRes in ValidationException.EntityValidationErrors)
{
foreach (System.Data.Entity.Validation.DbValidationError ValidError in ValidRes.ValidationErrors)
{
ValidationError += ValidError.PropertyName + " = " + ValidError.ErrorMessage + "\r\n";
}
ValidationError += "\r\n";
}
}
var message =
//"<h2>Registration Info:</h2></br>" +
//$"<h3>Registered Firm : {Model.CommonProperties.CurrentRegistration.CompanyName}, {Model.CommonProperties.CurrentRegistration.CityName}</h3></br>" +
//$"<h3>Contact Details : Phone : {Model.CommonProperties.CurrentRegistration.PhoneNo}, Mobile : {Model.CommonProperties.CurrentRegistration.MobileNo}, Email : {Model.CommonProperties.CurrentRegistration.EMailID} </h3></br></br></br>" +
"<h2>Login Details : </h2>" +
$"</br><h3>User : {(Model.CommonProperties.LoginInfo.LoggedinUser != null ? Model.CommonProperties.LoginInfo.LoggedinUser.UserName : "")}</h3>" +
$"</br><h3>Company Name : {(Model.CommonProperties.LoginInfo.LoggedInCompany != null ? Model.CommonProperties.LoginInfo.LoggedInCompany.CompanyName : "")}</h3>" +
$"</br><h3>Financial Period : {(Model.CommonProperties.LoginInfo.LoggedInFinPeriod != null ? Model.CommonProperties.LoginInfo.LoggedInFinPeriod.FinPeriodName : "")}</h3>" +
"<h2>Error details :</h2>" +
$"<h3>Validation Error : {ValidationError}.</h3></br><h3>Exception : {Ex.Message}</h3></br><h3>Stack Trace </h3></br></p>{Ex.StackTrace}</p>";
//Model.CommonFunctions.SendEmailFromNoReply("*****@*****.**",
// $"Error occured in {Model.CommonProperties.DevelopmentCompanyInfo.ProductName}",
// message,
// TakeScreenShotPrimaryScreen());
Model.CommonFunctions.SendEmailFromNoReply("*****@*****.**",
$"Error in {Model.CommonProperties.DevelopmentCompanyInfo.ProductName}, {(Model.CommonProperties.LoginInfo.LoggedInCompany != null ? Model.CommonProperties.LoginInfo.LoggedInCompany.CompanyName : "")}",
message);
Task sendEmail = Model.CommonFunctions.SendEmailFromNoReplyAsync("*****@*****.**",
$"Screen shot : Error occured in {Model.CommonProperties.DevelopmentCompanyInfo.ProductName}",
message,
new System.Net.Mail.Attachment(TakeScreenShotPrimaryScreen(), "screenshot.jpg"));
MessageBox.Show(Ex.Message, @"Unexpected error", MessageBoxButtons.OK, MessageBoxIcon.Error);
await sendEmail;
}
public static void AdminException(ByARpt byaRpt, System.Data.Entity.Validation.DbEntityValidationException ex)
{
foreach (var eve in ex.EntityValidationErrors)
{
foreach (var valErr in eve.ValidationErrors)
{
byaRpt.Mensaje += valErr.PropertyName + ":" + valErr.ErrorMessage + "<br/>";
}
}
byaRpt.Error = true;
}
internal string Return(Exception ex)
{
//return ex.InnerException.InnerException.ToString();
string exMsg = ex.Message;
//Если есть кириллица, то возвращаем её!
if (function.IsStringLatin(exMsg))
{
return(exMsg);
}
if (ex.Message != null || (ex.InnerException != null && ex.InnerException.Message != null))
{
if (ex.Message != null)
{
exMsg = ex.Message;
}
else
{
exMsg = ex.InnerException.Message;
if (ex.InnerException.InnerException != null && ex.InnerException.InnerException.Message != null)
{
exMsg = ex.InnerException.InnerException.Message;
}
}
}
else if (((System.Data.Entity.Validation.DbEntityValidationException)ex).EntityValidationErrors != null)
{
System.Data.Entity.Validation.DbEntityValidationException ex2 = ((System.Data.Entity.Validation.DbEntityValidationException)ex); //.EntityValidationErrors;
if (ex2.EntityValidationErrors.Count() > 0)
{
exMsg +=
"<br>" +
"Найдено ошибок в: " + ex2.EntityValidationErrors.Count().ToString() + " записях<br>" +
"Ошибки:<br>";
foreach (var eve in ex2.EntityValidationErrors)
{
//string Name = eve.Entry.Entity.GetType().Name; string State = eve.Entry.State.ToString();
foreach (var ve in eve.ValidationErrors)
{
//string PropertyName = ve.PropertyName; string ErrorMessage = ve.ErrorMessage;
exMsg += "Поле: " + ve.ErrorMessage + " (" + ve.PropertyName + ")" + "<br>";
}
}
}
}
//return Replacement(exMsg) +"<br />"+ exMsg;
//return Replacement(exMsg) + " - " + exMsg;
return(exMsg);
}
static void Main(string[] args)
{
if (!APITaskDictionaryInitialize(out ScraperFunctions))
{
throw new ScraperFunctionInitializationException("Program.cs");
}
try
{
if (ScraperFunctions.Count > 0)
{
foreach (var scraperFunction in ScraperFunctions)
{
//TaskList.Add(scraperFunction.Value(args));
//Upon second thought it's probably not best for both functions to run
//simultaneously because the Match Info is dependent on the results of the match Ids
Task t = scraperFunction.Value(args);
t.Wait();
}
//Task.WaitAll(TaskList.ToArray());
}
}
catch (AggregateException ex)
{
foreach (Exception exception in ex.InnerExceptions)
{
if (exception.InnerException is System.Data.Entity.Validation.DbEntityValidationException)
{
System.Data.Entity.Validation.DbEntityValidationException dbException =
(System.Data.Entity.Validation.DbEntityValidationException)exception.InnerException;
foreach (var eve in dbException.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
}
else
{
Console.WriteLine(exception.Message);
if (exception.InnerException != null)
{
Console.WriteLine(exception.InnerException.Message);
}
}
}
}
Console.WriteLine("Done");
}
public void LogMessage(LogModel log, Exception ex, LogLevel logLevel = LogLevel.Error, string requestObject = "", string eventName = "")
{
try
{
// Adjust user and application information (if needed)
var userName = log.UserName.GetValueOrDefault((UserIdentity != null) ? UserIdentity.UserName : string.Empty);
var evironment = log.Environment.GetValueOrDefault((UserIdentity != null) ? UserIdentity.EnvironmentName : "NA");
var applicationIdentifier = log.ApplicationIdentifier.GetValueOrDefault((UserIdentity != null) ? UserIdentity.ApplicationName : null);
var stackTrace = log.StackTrace.GetValueOrDefault((ex != null) ? ex.StackTrace : string.Empty);
log4net.LogicalThreadContext.Properties["User"] = userName;
log4net.LogicalThreadContext.Properties["Environment"] = evironment;
log4net.LogicalThreadContext.Properties["UrlReferrer"] = log.UrlReferrer.GetValueOrDefault(string.Empty);
log4net.LogicalThreadContext.Properties["ClientBrowser"] = log.ClientBrowser.GetValueOrDefault(string.Empty);
log4net.LogicalThreadContext.Properties["ClientIP"] = log.ClientIP.GetValueOrDefault(string.Empty);
log4net.LogicalThreadContext.Properties["URL"] = log.Url.GetValueOrDefault(string.Empty);
log4net.LogicalThreadContext.Properties["ApplicationIdentifier"] = applicationIdentifier;
log4net.LogicalThreadContext.Properties["Source"] = log.Source.GetValueOrDefault(string.Empty);
log4net.LogicalThreadContext.Properties["RequestObject"] = log.RequestObject.GetValueOrDefault(requestObject);
log4net.LogicalThreadContext.Properties["EventName"] = log.EventName.GetValueOrDefault(string.Empty);
log4net.LogicalThreadContext.Properties["StackTrace"] = stackTrace;
string exceptionMessage = string.Empty;
if (ex != null)
{
switch (ex.GetType().FullName)
{
case "System.Data.Entity.Validation.DbEntityValidationException":
System.Data.Entity.Validation.DbEntityValidationException validation = ex as System.Data.Entity.Validation.DbEntityValidationException;
exceptionMessage = "ExceptionMessage-";
if (validation != null && validation.EntityValidationErrors != null)
{
foreach (var validationErrors in validation.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
exceptionMessage += string.Format(" Property: {0} Error: {1} ", validationError.PropertyName, validationError.ErrorMessage);
}
}
}
break;
}
}
LogController.Log(new LogItem(logLevel, String.Format(CultureInfo.CurrentCulture, "{0} {1}", log.Message, exceptionMessage), ex, stackTrace)
{
UserIdentity = UserIdentity
});
}
catch (Exception)
{
}
}
/// <summary>
/// Convert a DbEntityValidationException to a string
/// </summary>
/// <param name="ex"></param>
/// <returns></returns>
public static string DbContextValidationErrorsToString(System.Data.Entity.Validation.DbEntityValidationException ex)
{
var sb = new StringBuilder();
foreach (var err in ex.EntityValidationErrors.Where(e => !e.IsValid))
{
foreach (var v in err.ValidationErrors)
{
sb.Append(v.PropertyName).Append(": ").AppendLine(v.ErrorMessage);
}
}
return(sb.ToString());
}
public static string MsgErro(System.Data.Entity.Validation.DbEntityValidationException e)
{
string Retorno = "";
foreach (var eve in e.EntityValidationErrors)
{
Retorno += "A entidade do tipo " + eve.Entry.Entity.GetType().Name + " no estado " + eve.Entry.State + " apresentou os seguintes erros:";
foreach (var ve in eve.ValidationErrors)
{
Retorno += "- Propriedade: " + ve.PropertyName + "|Erro: " + ve.ErrorMessage;
}
}
return(Retorno);
}
/// <summary>
/// Método que filtra os erros lançados por validação de campos do
/// Entity Framework
/// </summary>
/// <param name="ex">Exceção do Entity</param>
/// <returns>String contendo a lista de erros detalhada</returns>
internal static string ViewEntityException(System.Data.Entity.Validation.DbEntityValidationException ex)
{
var sb = new StringBuilder();
foreach (var failure in ex.EntityValidationErrors)
{
sb.AppendFormat("{0} falha na validação\n", failure.Entry.Entity.GetType());
foreach (var error in failure.ValidationErrors)
{
sb.AppendFormat("- {0} : {1}", error.PropertyName, error.ErrorMessage);
sb.AppendLine();
}
}
return(sb.ToString());
}
/// <summary>取得Entity欄位資料驗證錯誤訊息</summary>
/// <param name="ex"></param>
/// <returns></returns>
public string GetDbEntityValidationExceptionMessage(System.Data.Entity.Validation.DbEntityValidationException ex)
{
var errMsg = string.Empty;
foreach (var eve in ex.EntityValidationErrors)
{
errMsg = string.Format("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:", eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
errMsg += "<br />" + string.Format("- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage);
}
}
return(errMsg);
}
public static string FormatToString(System.Data.Entity.Validation.DbEntityValidationException ms)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
int i = 1;
foreach (var modelStateVal in ms.EntityValidationErrors)
{
foreach (var error in modelStateVal.ValidationErrors)
{
sb.AppendFormat(i + "." + error.ErrorMessage + "<br/>");
i++;
}
}
return(sb.ToString());
}
public static void LogDatabaseException(System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
raise = new InvalidOperationException(message, raise);
Instance.Fatal(raise);
}
}
}
private string GetEntityValidationErrors(System.Data.Entity.Validation.DbEntityValidationException ex)
{
var sb = new System.Text.StringBuilder();
foreach (var failure in ex.EntityValidationErrors)
{
sb.AppendFormat("{0} failed validation\n", failure.Entry.Entity.GetType());
foreach (var error in failure.ValidationErrors)
{
sb.AppendFormat("- {0} : {1}", error.PropertyName, error.ErrorMessage);
sb.AppendLine();
}
}
return(sb.ToString());
}
public static string GetValidationErrorMessages(
this System.Data.Entity.Validation.DbEntityValidationException
exception)
{
var stringBuilder = new System.Text.StringBuilder();
foreach (var entityValidationError in exception
.EntityValidationErrors)
{
foreach (var validationError in entityValidationError
.ValidationErrors)
{
stringBuilder.AppendLine(validationError.ErrorMessage);
}
}
return(stringBuilder.ToString());
}
public static string ValidationErrors(
System.Data.Entity.Validation.DbEntityValidationException ex, string message = "")
{
string validationErrors = string.Empty;
foreach (var eve in ex.EntityValidationErrors)
{
validationErrors += string.Format(
"Entity of type \"{0}\" in state \"{1}\" has the following validation errors:\n",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
validationErrors += string.Format("- Property: \"{0}\", Error: \"{1}\"\n",
ve.PropertyName, ve.ErrorMessage);
}
}
return(string.Format("{0} {1}", validationErrors, message));
}
private void SetExcepton(System.Data.Entity.Validation.DbEntityValidationException ex)
{
foreach (System.Data.Entity.Validation.DbEntityValidationResult vr in ex.EntityValidationErrors)
{
var dte = new DbTransException();
dte.Type = "DbEntityValidationException";
dte.Lable = vr.Entry.Entity.ToString();
foreach (System.Data.Entity.Validation.DbValidationError ve in vr.ValidationErrors)
{
dte.Exception.Add(new DbTransExceptionError
{
Message = ve.ErrorMessage,
Reference = ve.PropertyName
});
}
Exception.Add(dte);
}
}
/// <summary>
/// Delete Iser
/// </summary>
/// <param name="User"></param>
public static UserDeleteResult ClearUserGroups(ApplicationUser User)
{
try
{
if (User != null)
{
IdentityManager idManager = new IdentityManager();
idManager.ClearGroups(User);
return(new UserDeleteResult()
{
Succeeded = true
});
}
}
catch (Exception eX)
{
List <string> iErrors = new List <string>();
iErrors.Add(eX.Message);
System.Data.Entity.Validation.DbEntityValidationException EntityErrors = eX as System.Data.Entity.Validation.DbEntityValidationException;
if (EntityErrors != null && EntityErrors.EntityValidationErrors != null && EntityErrors.EntityValidationErrors.Count() > 0)
{
EntityErrors.EntityValidationErrors.ToList().ForEach(err =>
{
if (!err.IsValid && err.ValidationErrors != null && err.ValidationErrors.Count > 0)
{
err.ValidationErrors.ToList().ForEach(vE => iErrors.Add($"Propiedad: {vE.PropertyName} - Error: {vE.ErrorMessage}"));
}
});
}
return(new UserDeleteResult()
{
Succeeded = false, Errors = iErrors
});
}
return(new UserDeleteResult()
{
Succeeded = true
});
}
public static dto.DataLogging ToDataLogging(this System.Data.Entity.Validation.DbEntityValidationException obj)
{
dto.DataLogging ret = new dto.DataLogging();
StringBuilder sb = new StringBuilder();
foreach (var failure in obj.EntityValidationErrors)
{
string entityName = failure.Entry.Entity.GetType().Name;
sb.AppendFormat("Erro na entidade {0}. ", entityName);
foreach (var error in failure.ValidationErrors)
{
sb.AppendFormat("{0} : {1}", error.PropertyName, error.ErrorMessage);
sb.AppendLine();
}
}
ret.Message = sb.ToString();
ret.Source = "EntityFramework - " + obj.Source;
ret.StackTrace = obj.StackTrace;
return(ret);
}
private void ShowEntityErrors(System.Data.Entity.Validation.DbEntityValidationException e)
{
StringBuilder Errors = new StringBuilder();
foreach (var eve in e.EntityValidationErrors)
{
Errors.AppendLine($"Entity Type: \"{eve.Entry.Entity.GetType().Name}\", State: \"{eve.Entry.State}\"");
foreach (var ve in eve.ValidationErrors)
{
Errors.AppendLine($"- Property: \"{ve.PropertyName}\", Error: \"{ve.ErrorMessage}\"");
}
}
WriteToLog(Errors.ToString());
txtExceptions.Invoke(new Action(() => {
if (txtExceptions.Text.Length > 50000)
{
txtExceptions.ResetText();
}
txtExceptions.AppendText(Errors.ToString());
}));
}
/// <summary>
/// Formats the exception aux.
/// </summary>
/// <param name="ex">The ex.</param>
/// <param name="indentation">The indentation.</param>
/// <returns>System.String.</returns>
private static string formatExceptionAux(Exception ex, int indentation)
{
string ind = new string('#', indentation);
StringBuilder str = new StringBuilder();
//
// Known Exception types
System.Data.Entity.Validation.DbEntityValidationException dbEx = (ex as System.Data.Entity.Validation.DbEntityValidationException);
if (dbEx != null)
{
string dbErrorMessages = string.Join($@";{Environment.NewLine}", dbEx.EntityValidationErrors.Select(_ => $@"Entity:{_.Entry.Entity}. Errors:{string.Join(", ", _.ValidationErrors.SelectMany(_2 => $@"[{_2.PropertyName}]: {_2.ErrorMessage}"))}"));
str.AppendLine($@"Validation errors: {dbErrorMessages}");
}
//
str.AppendLine(string.Format(@"{0}{1}: {2}", ind, ex.GetType().FullName, ex.Message));
str.AppendLine(string.Format(@"{0}{1}: {2}", ind, ex.GetType().FullName, ex.Message));
str.AppendLine(string.Format(@"{0}Stack: {1}", ind, ex.StackTrace));
if (ex.Data != null && ex.Data.Count > 0)
{
int i = 0;
string[] keyDataPairs = new string[ex.Data.Count];
foreach (object key in ex.Data.Keys)
{
object val = ex.Data[key];
keyDataPairs[i++] = string.Format("{0}:{1}", key, val);
}
str.AppendLine(string.Format(@"{0}Data: {{{1}}}", ind, string.Join(",", keyDataPairs)));
}
SoapException sEx = (ex as SoapException);
if (sEx != null && sEx.Detail != null)
{
str.AppendLine(string.Format(@"{0}DetailXml: {1}", ind, sEx.Detail.OuterXml));
}
if (ex.InnerException != null)
{
str.AppendLine(string.Format(@"{0}InnerException: {1}", ind, formatExceptionAux(ex.InnerException, indentation + 1)));
}
return(str.ToString());
}
public static void ReformatDBConstraintError(System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
var builder = new StringBuilder(string.Empty);
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format(
"{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
builder.Append(message + "\n");
// raise a new exception nesting
// the current instance as InnerException
TraceManager.Error("DBUtil", "ReformatDBConstraintError", message);
}
}
raise = new InvalidOperationException(builder.ToString(), raise);
throw raise;
}
public RepositoryException(System.Data.Entity.Validation.DbEntityValidationException innerException) :
base(null, innerException)
{
}
private static void fnOnDbEntityException(System.Data.Entity.Validation.DbEntityValidationException e)
{
OnDbEntityException?.Invoke(e);
}
public static void Log(System.Exception ex)
{
string strTab = "\t";
string strTabs = strTab;
System.Exception exception = ex;
string errorMessage =
System.Environment.NewLine + System.Environment.NewLine + "***** BEGIN *****";
while (exception != null)
{
errorMessage +=
System.Environment.NewLine + exception.Message;
System.Data.Entity.Validation.DbEntityValidationException
dbEntityValidationException = exception as System.Data.Entity.Validation.DbEntityValidationException;
if (dbEntityValidationException != null)
{
errorMessage += System.Environment.NewLine;
foreach (var entityValidationError in dbEntityValidationException.EntityValidationErrors)
{
errorMessage +=
System.Environment.NewLine + strTabs +
string.Format("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
entityValidationError.Entry.Entity.GetType().Name, entityValidationError.Entry.State);
foreach (var validationError in entityValidationError.ValidationErrors)
{
errorMessage +=
System.Environment.NewLine + strTabs + strTab +
string.Format("- Property: \"{0}\", Error: \"{1}\"",
validationError.PropertyName, validationError.ErrorMessage);
}
}
}
strTabs += strTab;
exception = exception.InnerException;
}
errorMessage += System.Environment.NewLine + "***** END *****";
string strPathName = "Application.log";
System.IO.StreamWriter oStream = null;
try
{
oStream =
new System.IO.StreamWriter
(strPathName, true, System.Text.Encoding.UTF8);
oStream.WriteLine(errorMessage);
}
catch
{
}
finally
{
if (oStream != null)
{
//oStream.Close();
oStream.Dispose();
oStream = null;
}
}
}
public static Responses.JsonResponse EXCEPCION(System.Data.Entity.Validation.DbEntityValidationException pEntityException)
{
return(EXCEPCION(pEntityException.GetEntityExceptionMessage()));
}
