public void AddValidationError(ClientFault error)
{
if (ValidationFaults == null)
{
ValidationFaults = new List <ClientFault>();
}
ValidationFaults.Add(error);
Session.Context.AddClientFault(error);
}
static void ThrowClientFault(string code, string message, params object[] args)
{
message = StringHelper.SafeFormat(message, args);
var fault = new ClientFault()
{
Code = code, Message = message
};
var ex = new ClientFaultException(new [] { fault });
throw ex;
}
public ClientFault AddValidationError(string code, string message, object[] messageArgs, string targetProperty, object invalidValue = null)
{
var msg = Util.SafeFormat(message, messageArgs);
var recId = GetRecordRef();
var err = new ClientFault()
{
Code = code, Message = msg, Tag = targetProperty, Path = recId
};
if (invalidValue != null)
{
err.Parameters["InvalidValue"] = invalidValue.ToString();
}
AddValidationError(err);
return(err);
}
public ClientFault AddValidationError(string code, string message, object[] messageArgs, string targetProperty, object invalidValue = null)
{
var msg = StringHelper.SafeFormat(message, messageArgs);
var recPath = EntityInfo.Name + "/" + PrimaryKey.ToString();
var err = new ClientFault()
{
Code = code, Message = msg, Tag = targetProperty, Path = recPath
};
if (invalidValue != null)
{
err.Parameters["InvalidValue"] = invalidValue.ToString();
}
AddValidationError(err);
return(err);
}
public static string ToLogString(this ClientFault fault)
{
try {
if (fault == null)
{
return(null);
}
var result = StringHelper.SafeFormat(" Fault: {0} Code={1} Tag ={2} Path={3}.", fault.Message, fault.Code, fault.Tag, fault.Path);
if (fault.Parameters.Count > 0)
{
result += string.Join(";", fault.Parameters.Select(kv => StringHelper.SafeFormat("{0}: {1}", kv.Key, kv.Value.TrimMiddle())));
}
return(result);
} catch (Exception ex) {
//had been burned by this
return("LoggingExtensions - catastrophic failure in ToLogString(): " + ex.ToString());
}
}
//Sequences set of records in a looped non-trivial entity group. Assigns record.SortSubIndex value after sequencing
private void SequenceSubGroup(IEnumerable <EntityRecord> records)
{
var graph = new Graph();
foreach (var rec in records)
{
var ent = rec.EntityInfo;
foreach (var refMember in ent.RefMembers)
{
var targetEnt = rec.GetValue(refMember);
//If reference is not modified or not set, then nothing to do
if (targetEnt == null)
{
continue;
}
var targetRec = EntityHelper.GetRecord(targetEnt);
// we are interested only in case when both records are inserted, or both are deleted.
if (targetRec.Status != rec.Status)
{
continue;
}
// finally, the target record's table must be in the same SCC group - i.e. have the same SccIndex
if (targetRec.EntityInfo.TopologicalIndex != rec.EntityInfo.TopologicalIndex)
{
continue;
}
// We have potential conflict; add vertexes and link for the conflict
var thisV = graph.FindOrAdd(rec);
var targetV = graph.FindOrAdd(targetRec);
thisV.AddLink(targetV);
}
}//foreach cmd
//Check if any conflicts found
if (graph.Vertexes.Count == 0)
{
return;
}
//Build SCC graph
graph.BuildScc();
// Once SCC is built, we have SCC indexes in Vertexes; use them to assign Record's TopologicalIndex
bool hasNonTrivialGroups = false;
foreach (var v in graph.Vertexes)
{
var rec = (EntityRecord)v.Tag;
rec.SortSubIndex = rec.Status == EntityStatus.New ? -v.SccIndex : v.SccIndex;
hasNonTrivialGroups |= v.NonTrivialGroup;
}
//if there are non-trivial groups, it means we have circular references in the set.
if (hasNonTrivialGroups)
{
var entList = string.Join(",", records.Select(r => r.PrimaryKey.ToString()));
var msg = StringHelper.SafeFormat("Detected circular references between entities in an update set. Cannot commit group update. Entities: [{0}].", entList);
var fault = new ClientFault()
{
Code = ClientFaultCodes.CircularEntityReference, Message = msg
};
var faultEx = new ClientFaultException(new[] { fault });
faultEx.LogAsError = true;
throw faultEx;
}
}
public void AddValidationFault(ClientFault fault)
{
ValidationFaults = ValidationFaults ?? new List <ClientFault>();
ValidationFaults.Add(fault);
Session.Context.AddClientFault(fault);
}
private async Task HandleExceptionAsync(HttpContext context, Exception exception, ILogger <ExceptionHandlingMiddleware> logger)
{
var statusCode = default(HttpStatusCode);
object message = null;
switch (exception)
{
case SecurityException security:
logger.LogWarning($"EXCEPTION HANDLING 403 | { security.Message }");
statusCode = HttpStatusCode.Forbidden;
message = new ServerFault
{
Message = "You shall not pass!"
};
break;
case ValidationException validation:
logger.LogDebug($"EXCEPTION HANDLING 400 | { message }");
statusCode = HttpStatusCode.BadRequest;
message = new ClientFault
{
Message = "Your request contains bad syntax or cannot be fulfiled",
Faults = validation.Errors.Select(x => new Fault()
{
Error = x.ErrorMessage,
Property = x.PropertyName,
Value = x.AttemptedValue == null ? "null" : x.AttemptedValue.ToString()
}).ToList()
};
break;
case Newtonsoft.Json.JsonReaderException jsonReader:
logger.LogDebug($"EXCEPTION HANDLING 400 | { message }");
statusCode = HttpStatusCode.BadRequest;
message = new ClientFault
{
Message = "Our server failed to fulfill an apparently valid request",
Faults = new List <Fault>()
{
new Fault()
{
Error = "Could not cast value on property",
Property = jsonReader.Path,
Value = jsonReader.Message
}
}
};
break;
default:
logger.LogError($"EXCEPTION HANDLING 500 | { exception }");
statusCode = HttpStatusCode.InternalServerError;
message = new ServerFault
{
Message = "Something happend"
};
break;
}
var result = JsonSerializer.Serialize(message);
context.Response.ContentType = "application/json; charset=utf-8";
context.Response.StatusCode = (int)statusCode;
await context.Response.WriteAsync(result, Encoding.UTF8);
}
public ClientFault AddValidationError(string code, string message, object[] messageArgs, string targetProperty, object invalidValue = null)
{
var msg = StringHelper.SafeFormat(message, messageArgs);
var recPath = EntityInfo.Name + "/" + PrimaryKey.ToString();
var err = new ClientFault() { Code = code, Message = msg, Tag = targetProperty, Path = recPath};
if (invalidValue != null) {
err.Parameters["InvalidValue"] = invalidValue.ToString();
}
AddValidationError(err);
return err;
}
public void AddValidationError(ClientFault error)
{
if(ValidationErrors == null)
ValidationErrors = new List<ClientFault>();
ValidationErrors.Add(error);
Session.Context.ClientFaults.Add(error);
}
private async Task HandleExceptionAsync(HttpContext context, Exception exception, ILogger <ExceptionHandlingMiddleware> logger)
{
var statusCode = default(HttpStatusCode);
object message = null;
switch (exception)
{
case SecurityException security:
statusCode = HttpStatusCode.Forbidden;
var securityex = new ServerFault();
securityex.message = "You shall not pass!";
message = securityex;
logger.LogWarning($"EXCEPTION HANDLING 403 | { security.Message }");
break;
case ArgumentNullException argumentNull:
statusCode = HttpStatusCode.NotFound;
var argumentex = new ServerFault();
argumentex.message = "These aren't the droids you're looking for...";;
message = argumentex;
logger.LogInformation($"EXCEPTION HANDLING 404 | { argumentNull.Message }");
break;
case ValidationException validation:
statusCode = HttpStatusCode.BadRequest;
var client = new ClientFault();
client.message = "Something is not right...";
foreach (var erro in validation.Errors)
{
var fault = new Fault()
{
code = erro.ErrorCode,
error = erro.ErrorMessage,
property = erro.PropertyName,
value = erro.AttemptedValue == null ? "null" : erro.AttemptedValue.ToString()
};
client.faults.Add(fault);
}
message = client;
logger.LogInformation($"EXCEPTION HANDLING 400 | { message }");
break;
case ArgumentOutOfRangeException argumentOutOfRange:
case TaskCanceledException taskCanceled:
default:
statusCode = HttpStatusCode.InternalServerError;
var defaultex = new ServerFault();
defaultex.message = "Something is not right... Please, call one of our monkeys at [email protected]";
#if (DEBUG)
defaultex.message = $"Exception: {exception.Message} - Inner: {exception.InnerException?.Message} - Stacktrace: {exception.StackTrace}";
#endif
message = defaultex;
logger.LogError($"EXCEPTION HANDLING 500 | { exception }");
break;
}
var result = JsonConvert.SerializeObject(message);
context.Response.ContentType = "application/json; charset=utf-8";
context.Response.StatusCode = (int)statusCode;
await context.Response.WriteAsync(result, Encoding.UTF8);
}
private async Task <HttpResponseMessage> ProcessOperationAbortException(WebCallInfo callInfo)
{
var request = callInfo.Request;
var webContext = callInfo.WebContext;
var abortExc = webContext.Exception as OperationAbortException;
if (abortExc.LogAsError)
{
webContext.OperationContext.LogLevel = LogLevel.Details;
webContext.ErrorLogId = LogError(abortExc, webContext);
}
HttpResponseMessage errResp;
switch (abortExc.ReasonCode)
{
case OperationAbortReasons.ClientFault:
var cfExc = (ClientFaultException)abortExc;
errResp = new HttpResponseMessage(HttpStatusCode.BadRequest);
var formatter = request.GetResponseFormatter(typeof(List <ClientFault>));
errResp.Content = new ObjectContent(typeof(List <ClientFault>), cfExc.Faults, formatter);
return(errResp);
case OperationAbortReasons.ConcurrencyViolation:
errResp = new HttpResponseMessage(HttpStatusCode.Conflict);
return(errResp);
case ClientFaultCodes.AuthenticationRequired:
if (Settings.Options.IsSet(WebHandlerOptions.ReturnBadRequestOnAuthenticationRequired))
{
errResp = new HttpResponseMessage(HttpStatusCode.BadRequest);
var fault = new ClientFault()
{
Code = ClientFaultCodes.AuthenticationRequired, Message = "Authentication required."
};
var fmt = request.GetResponseFormatter(typeof(IList <ClientFault>));
errResp.Content = new ObjectContent(typeof(IList <ClientFault>), new [] { fault }, fmt);
return(errResp);
}
else
{
errResp = new HttpResponseMessage(HttpStatusCode.Unauthorized);
return(errResp);
}
case ModelStateException.ReasonBadRequestBody:
//Return BadRequest, and include detailed information about the deserializer failure
errResp = new HttpResponseMessage(HttpStatusCode.BadRequest);
var msExc = (ModelStateException)abortExc;
var errors = msExc.ModelStateErrors;
var reqContent = await WebHelper.SafeReadContent(request.Content);
var requestContentTrimmed = reqContent.TrimMiddle(512);
var flt = new ClientFault()
{
Code = ClientFaultCodes.BadContent, Message = "Failure to deserialize body or parameters: " + errors
};
//Serialize it as json
var errFmt = request.GetResponseFormatter(typeof(IList <ClientFault>));
errResp.Content = new ObjectContent(typeof(IList <ClientFault>), new [] { flt }, errFmt);
return(errResp);
default:
// Should never happen, currently other codes are not used.
errResp = new HttpResponseMessage(HttpStatusCode.BadRequest);
errResp.Content = new StringContent(abortExc.ReasonCode);
return(errResp);
} //switch
} //method
