public virtual SubmitResult CustomizeException(Exception ex, string failMessage = null)
{
var res = new SubmitResult
{
Code = 101,
Message = failMessage
};
res.SetException(ex);
var sqlException = GetSqlException(ex);
if (sqlException != null)
{
if (sqlException.Number == 547)
{
DeleteResult deleteResult = res.MapToResult <DeleteResult>();
deleteResult.Code = 547;
deleteResult.CanDelete = false;
deleteResult.TableName = SqlInterpreter.N00547(sqlException.Message)[5].Split('.')[1];
return(deleteResult);
}
}
return(res);
}
public virtual void AppendLog(Exception ex, string message = "Local Server Error")
{
if (LogToFile == null)
{
return;
}
List <string> lst = new List <string>();
SubmitResult res = new SubmitResult(1, message);
res.SetException(ex);
lst.Add(" ");
lst.Add("--------------------------------------------------------------------");
lst.Add(" ");
lst.Add(res.Message);
lst.Add(res.ExceptionMessage);
lst.Add(" ");
lst.Add("--------------------------------------------------------------------");
lst.Add(" ");
lst.AddRange(res.StackTrace);
File.AppendAllLines(LogToFile, lst);
}
public override void OnException(HttpActionExecutedContext actionExecutedContext)
{
SubmitResult res = new SubmitResult(1, "Error");
res.SetException(actionExecutedContext.Exception);
actionExecutedContext.Response = actionExecutedContext.Request.CreateResponse(HttpStatusCode.InternalServerError, res);
Logger.WriteException(actionExecutedContext.Exception);
}
protected SubmitResult ExecuteBatchNonQuery(string sql, string connectionString)
{
string sqlBatch = string.Empty;
sql += "\nGO"; // make sure last batch is executed.
SubmitResult res = new SubmitResult();
foreach (string line in sql.Split(new string[2] {
"\n", "\r"
}, StringSplitOptions.RemoveEmptyEntries))
{
if (line.ToUpperInvariant().Trim() == "GO" && !string.IsNullOrEmpty(sqlBatch))
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
try
{
conn.Open();
SqlCommand cmd = new SqlCommand(sqlBatch, conn);
if (CommandTimeout != 0)
{
cmd.CommandTimeout = CommandTimeout;
}
res.AffectedRows = cmd.ExecuteNonQuery();
sqlBatch = string.Empty;
conn.Close();
}
catch (Exception ex)
{
conn.Close();
res.SetException(ex);
res.Code = 1;
res.Data["SQL"] = sqlBatch;
break;
}
}
}
else
{
sqlBatch += line + "\n";
}
}
return(res);
}
/// <summary>
/// Attempts to submit changes to the data source
/// </summary>
/// <returns>if success <see cref="SubmitResult.Code"/> is 0</returns>
public override SubmitResult SaveChanges(string successMessage = null, string failMessage = null)
{
SubmitResult res = new SubmitResult();
string def = Strings.Word(MessageIds.success_message);
string defFail = Strings.Word(MessageIds.fail_message);
successMessage = successMessage ?? def;
failMessage = failMessage ?? defFail;
ChangeLists lst = null;
if (OnBeforeSave != null || OnSaveSuccess != null || Saving != null || UseChangeColumns)
{
lst = GetChangeSet();
OnBeforeSave?.Invoke(lst);
Saving?.Invoke(this, lst);
FillChangeColumns(lst);
}
try
{
int rows = DbContext.SaveChanges();
res = new SubmitResult
{
AffectedRows = rows,
Code = 0,
Message = successMessage
};
try
{
OnSaveSuccess?.Invoke(lst);
}
catch (Exception ex)
{
res.SetException(ex);
res.Code = 0;
}
}
catch (Exception ex)
{
res = CustomizeException(ex, failMessage);
}
return(res);
}
protected Task ConsumeEvent <T>(ConsumeContext <T> context, Func <T, SubmitResult> action) where T : class
{
return(Task.Run(() =>
{
try
{
var res = action(context.Message);
RecordResult(res, context.Message);
}
catch (Exception ex)
{
SubmitResult re = new SubmitResult(1);
re.SetException(ex);
RecordResult(re, context.Message);
throw;
}
}));
}
protected Task Respond <T, TR>(ConsumeContext <T> context, Func <T, TR> action) where T : class where TR : class
{
try
{
var res = action(context.Message);
return(context.RespondAsync <TR>(res));
}
catch (Exception ex)
{
return(Task.Run(() =>
{
SubmitResult re = new SubmitResult(1);
re.SetException(ex);
RecordResult(re, context.Message);
}));
throw;
}
}
public virtual Task Handle <TObject>(CrudEvent <TObject> item) where TObject : class
{
return(Task.Run(() =>
{
try
{
var res = Store.GetInstance <IEntityHandler <TObject> >().Handle(item);
RecordResult(res, item);
}
catch (Exception ex)
{
SubmitResult re = new SubmitResult(1);
re.SetException(ex);
RecordResult(re, item);
Logger.WriteException(ex);
throw;
}
}));
}
protected void GetSelectionFromUser(string name, Dictionary <int, string> functions)
{
while (true)
{
string data = GenerateChoices(functions);
Console.Write(string.Format(@"
Select a {0} from the List
{1}
Enter Your Choice : ", name, data));
int function = 0;
string l = Console.ReadLine();
if (!int.TryParse(l, out function) || function > Functions.Count || function < 1)
{
Console.WriteLine("Invalid Choice");
continue;
}
MethodInfo info = GetType().GetMethod(Functions[function]);
OnMethodSelected(Functions[function]);
CurrentMethod = Functions[function];
try
{
info.Invoke(this, new object[] { });
}
catch (Exception ex)
{
SubmitResult res = new SubmitResult(1);
res.SetException(ex);
Console.WriteLine(res.Message);
Console.WriteLine(res.ExceptionMessage);
foreach (string s in res.StackTrace)
{
Console.WriteLine(s);
}
}
}
}
protected async Task Handle()
{
try
{
HttpClient client = new HttpClient();
string url = Utils.CombineUrl(BaseUrl, _context.Request.Url.AbsolutePath);
client.Timeout = new TimeSpan(0, 5, 0);
var encoding = _context.Request.ContentEncoding;
var contentType = "application/json";
foreach (var head in _context.Request.Headers.AllKeys)
{
var elem = _context.Request.Headers[head];
if (head.Contains("Content"))
{
if (head.ToLower() == "content-type")
{
contentType = _processContentType(_context.Request.Headers[head]);
}
}
else
{
client.DefaultRequestHeaders.Add(head, elem);
}
}
if (!string.IsNullOrEmpty(_context.Request.Url.Query))
{
url += _context.Request.Url.Query;
}
string data = null;
string method = _context.Request.HttpMethod.ToLower();
HttpResponseMessage mes = new HttpResponseMessage(HttpStatusCode.OK);
HttpContent content = new StringContent("", Encoding.UTF8, contentType);
if (method != "get" && method != "delete")
{
if (contentType.Contains("multipart"))
{
var files = _context.Request.Files;
content = ConvertToMultipartContent(files);
}
else
{
using (StreamReader readStream = new StreamReader(_context.Request.InputStream, encoding))
{
data = readStream.ReadToEnd();
}
content = new StringContent(data, encoding, contentType);
}
}
switch (method)
{
case "get":
mes = await client.GetAsync(url);
break;
case "post":
mes = await client.PostAsync(url, content);
break;
case "put":
mes = await client.PutAsync(url, content);
break;
case "delete":
mes = await client.DeleteAsync(url);
break;
}
var headers = mes.Content.Headers as HttpContentHeaders;
foreach (var h in headers)
{
_context.Response.Headers[h.Key] = h.Value.FirstOrDefault();
}
_context.Response.ContentType = headers.ContentType?.ToString();
await mes.Content.CopyToAsync(_context.Response.OutputStream);
_context.Response.StatusCode = (int)mes.StatusCode;
_complete = true;
_callback(this);
}
catch (Exception ex)
{
SubmitResult res = new SubmitResult(1, "Error");
res.SetException(ex);
_context.Response.Write(res.ToJson());
_context.Response.StatusCode = (int)HttpStatusCode.ExpectationFailed;
_complete = true;
_callback(this);
}
}
/// <summary>
/// Attempts to submit changes to the data source
/// </summary>
/// <returns>if success <see cref="SubmitResult.Code"/> is 0</returns>
public virtual SubmitResult SaveChanges(string successMessage = null, string failMessage = null)
{
SubmitResult res = new SubmitResult();
successMessage = successMessage == null?Strings.Word(MessageIds.success_message) : successMessage;
failMessage = failMessage == null?Strings.Word(MessageIds.fail_message) : failMessage;
ChangeLists lst = null;
if (OnBeforeSave != null || OnSaveSuccess != null)
{
lst = GetChangeSet();
OnBeforeSave?.Invoke(lst);
}
try
{
int rows = DbContext.SaveChanges();
OnSaveSuccess?.Invoke(lst);
res = new SubmitResult
{
AffectedRows = rows,
Code = 0,
Message = successMessage
};
}
catch (DbEntityValidationException dbEx)
{
OnExceptionHandling?.Invoke(dbEx);
var msg = string.Empty;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
msg += Environment.NewLine +
string.Format("Property: {0} Error: {1}", validationError.PropertyName,
validationError.ErrorMessage);
}
}
res = new SubmitResult
{
Message = failMessage,
Code = 102,
};
res.SetException(dbEx);
res.ExceptionMessage = msg;
}
catch (SqlException ex)
{
OnExceptionHandling?.Invoke(ex);
res = new SubmitResult
{
Code = ex.Number,
Message = failMessage
};
res.SetException(ex);
}
catch (Exception ex)
{
OnExceptionHandling?.Invoke(ex);
res = new SubmitResult
{
Code = 101,
Message = failMessage
};
res.SetException(ex);
}
return(res);
}