ICriterion IModelDataGateway<T>.Delete(ICriterion criterion, IContext context)
{
IRequestContext ctx = context as IRequestContext;
ctx.SetMetric(XFConstants.Metrics.Scope.DataStore, XFConstants.Metrics.DbType, DataStorePlatform);
ICriterion result = null;
try
{
result = Delete(criterion, context);
}
catch (Exception ex)
{
var message = Exceptions.ComposeGeneralExceptionError<T>(ModelActionOption.Put, ex, null, criterion, context, this.GetType().FullName);
context.SetError(500, message.ToPublish() );
EventWriter.WriteError(message, SeverityType.Error);
}
return result;
}
public static Page <ApiSession> Get(int pageSize = 20, int pageIndex = 0, int tenantId = 0, int patronId = 0, string ipAddress = "", string basicToken = "", string marker = "")
{
Page <ApiSession> page = new Page <ApiSession>();
List <ApiSession> list = new List <ApiSession>();
string schema = eXtensibleConfig.Zone.Equals("production", StringComparison.OrdinalIgnoreCase) ? DateTime.Today.ToString("MMM").ToLower() : "log";
var settings = ConfigurationProvider.ConnectionStrings[eXtensibleWebApiConfig.SqlConnectionKey];
if (settings != null && !String.IsNullOrWhiteSpace(settings.ConnectionString))
{
try
{
using (SqlConnection cn = new SqlConnection(settings.ConnectionString))
{
cn.Open();
using (SqlCommand cmd = cn.CreateCommand())
{
string sql = "select top " + pageSize + " [Id], [CreatedAt], [BasicToken], [BearerToken], [TenantId], [PatronId], [SsoPatronId]," +
" [IPAddress], [UserAgent], [PassKey], [LinesOfBusiness] from [" + schema + "].[Session] " +
" order by [Id] desc ";
cmd.CommandText = sql;
using (SqlDataReader reader = cmd.ExecuteReader())
{
BorrowReader(reader, list);
page.Items = list;
if (reader.NextResult())
{
page.Total = reader.GetInt32(0);
}
}
}
}
}
catch (Exception ex)
{
var message = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
var props = eXtensibleConfig.GetProperties();
EventWriter.WriteError(message, SeverityType.Error, "DataAccess", props);
}
}
return(page);
}
private DataPacket PassThroughRpc(DataPacket item)
{
Type modelType = Type.GetType(item.Typename);
if (modelType != null)
{
string returnTypename = item.Criteria.GetValue <string>(XFConstants.Application.ActionResultModelType);
Type returnType = Type.GetType(returnTypename);
if (returnType != null)
{
Type contracts = typeof(IRpcDataRequestService);
MethodInfo dataRequestContracts = contracts.GetMethod("ExecuteRpc");
MethodInfo standardContractMethod = dataRequestContracts.MakeGenericMethod(modelType, returnType);
var mT = typeof(Message <,>);
var closedModel = mT.MakeGenericType(new Type[] { modelType, returnType });
dynamic message = Activator.CreateInstance(closedModel, item.Items);
message.Criterion = item.Criteria;
object model = GenericSerializer.ByteArrayToItem(item.Buffer);
message.InsertContent(model);
InvokeStandardContract(RpcDataService, standardContractMethod, new object[1] {
message
}, item);
}
else
{
string message = String.Format("The RpcService could not resolve type '{0}'.\r\nMake certain the 'Model' dll is accessible", returnTypename);
item.SetError(500, message);
EventWriter.WriteError(message, SeverityType.Error);
}
}
else
{
string message = String.Format("The RpcService could not resolve type '{0}'.\r\nMake certain the 'Model' dll is accessible", item.Typename);
item.SetError(500, message);
EventWriter.WriteError(message, SeverityType.Error);
}
return(item);
}
U IRpcDatastoreService.ExecuteRpc <T, U>(T model, ICriterion criterion, IRequestContext requestContext)
{
if (eXtensibleConfig.CaptureMetrics)
{
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Scope.ModelDataGateway.Begin, DateTime.Now)
{
Domain = XFConstants.Domain.Metrics
});
}
U u = default(U);
try
{
u = ExecuteRpc <T, U>(model, criterion, requestContext);
}
catch (Exception ex)
{
var message = Exceptions.ComposeGeneralExceptionError <T>(ModelActionOption.ExecuteAction, ex, model, criterion, requestContext);
requestContext.SetError(500, message.ToPublish());
requestContext.SetStacktrace(ex.StackTrace);
var props = eXtensibleConfig.GetProperties();
props.Add(XFConstants.Context.Ticket, message.Id);
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, props);
}
if (u == null)
{
u = default(U);
requestContext.SetError(500, "Internal Server Error");
}
if (eXtensibleConfig.CaptureMetrics)
{
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Scope.ModelDataGateway.End, DateTime.Now)
{
Domain = XFConstants.Domain.Metrics
});
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Criteria, criterion.ToShortString())
{
Domain = XFConstants.Domain.Metrics
});
}
return(u);
}
T IDatastoreService.Get <T>(ICriterion criterion, IRequestContext requestContext)
{
if (eXtensibleConfig.CaptureMetrics)
{
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Scope.ModelDataGateway.Begin, DateTime.Now)
{
Domain = XFConstants.Domain.Metrics
});
}
T item = null;
try
{
item = Get <T>(criterion, requestContext);
}
catch (Exception ex)
{
var message = Exceptions.ComposeGeneralExceptionError <T>(ModelActionOption.Get, ex, null, criterion, requestContext);
requestContext.SetError(500, message.ToPublish());
requestContext.SetStacktrace(ex.StackTrace);
var props = eXtensibleConfig.GetProperties();
props.Add(XFConstants.Context.Ticket, message.Id);
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, props);
}
if (item == null && !requestContext.HasError())
{
var message = Exceptions.ComposeResourceNotFoundError <T>(ModelActionOption.Get, null, criterion, requestContext);
requestContext.SetError(404, message.ToPublish());
}
if (eXtensibleConfig.CaptureMetrics)
{
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Scope.ModelDataGateway.End, DateTime.Now)
{
Domain = XFConstants.Domain.Metrics
});
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Criteria, criterion.ToShortString())
{
Domain = XFConstants.Domain.Metrics
});
}
return(item);
}
DataSet IModelDataGateway <T> .ExecuteCommand(DataSet dataSet, ICriterion criterion, IContext context)
{
IRequestContext ctx = context as IRequestContext;
ctx.SetMetric(XFConstants.Metrics.Scope.DataStore, XFConstants.Metrics.DbType, DataStorePlatform);
DataSet result = null;
try
{
result = ExecuteCommand(dataSet, criterion, context);
}
catch (Exception ex)
{
var message = Exceptions.ComposeGeneralExceptionError <T>(ModelActionOption.ExecuteCommand, ex, null, criterion, context, this.GetType().FullName);
context.SetError(500, message.ToPublish());
context.SetStacktrace(ex.StackTrace);
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, context.ToDictionary(message.Id));
}
return(result);
}
protected virtual ICriterion Delete(ICriterion criterion, IContext context)
{
ICriterion result = new Criterion();
//WriteConcernResult writeConcern = Collection.Remove(Query.EQ("_id", new ObjectId(criterion.GetValue<string>("Id"))));
WriteConcernResult writeConcern = Collection.Remove(criterion.ToQueryDocument<T>());
//WriteConcernResult writeConcern = Collection.Remove(Query.EQ("_id", new ObjectId(criterion.GetValue<string>("Id"))));
if (writeConcern.Ok)
{
long affected = writeConcern.DocumentsAffected;
result.AddItem("documentsAffected", affected);
}
else
{
IRequestContext ctx = context as IRequestContext;
var message = Exceptions.ComposeDatastoreException<T>(ModelActionOption.Delete, writeConcern.ErrorMessage, null, criterion, context, this.GetType().FullName, "MongoDB");
ctx.SetError(500, message.ToPublish());
EventWriter.WriteError(message.ToLog(), SeverityType.Error);
}
return result;
}
T IDatastoreService.Post <T>(T model, IRequestContext requestContext)
{
if (eXtensibleConfig.CaptureMetrics)
{
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Scope.ModelDataGateway.Begin, DateTime.Now)
{
Domain = XFConstants.Domain.Metrics
});
}
T item = default(T);
try
{
item = Create <T>(model, requestContext);
}
catch (Exception ex)
{
var message = Exceptions.ComposeGeneralExceptionError <T>(ModelActionOption.Post, ex, model, null, requestContext);
var props = eXtensibleConfig.GetProperties();
props.Add(XFConstants.Context.Ticket, message.Id);
requestContext.SetError(500, message.ToPublish());
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, props);
}
if (item == null && requestContext.HasError())
{
requestContext.SetError(500, "Internal Server Error");
}
if (eXtensibleConfig.CaptureMetrics)
{
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Scope.ModelDataGateway.End, DateTime.Now)
{
Domain = XFConstants.Domain.Metrics
});
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.T, model.ToString())
{
Domain = XFConstants.Domain.Metrics
});
}
return(item);
}
T IDatastoreService.Put <T>(T model, ICriterion criterion, IRequestContext requestContext)
{
if (eXtensibleConfig.CaptureMetrics)
{
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Scope.ModelDataGateway.Begin, DateTime.Now)
{
Domain = XFConstants.Domain.Metrics
});
}
T item = null;
try
{
item = Update <T>(model, criterion, requestContext);
}
catch (Exception ex)
{
var message = Exceptions.ComposeGeneralExceptionError <T>(ModelActionOption.Put, ex, model, null, requestContext);
var props = eXtensibleConfig.GetProperties();
props.Add(XFConstants.Context.Ticket, message.Id);
requestContext.SetError(500, message.ToPublish());
requestContext.SetStacktrace(ex.StackTrace);
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, props);
}
if (eXtensibleConfig.CaptureMetrics)
{
string data = (model != null) ? model.ToString() : (criterion != null) ? criterion.ToShortString() : "{x:Null}";
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.Scope.ModelDataGateway.End, DateTime.Now)
{
Domain = XFConstants.Domain.Metrics
});
((Message <T>)requestContext).Items.Add(new TypedItem(XFConstants.Metrics.T, data)
{
Domain = XFConstants.Domain.Metrics
});
}
return(item);
}
public HttpResponseMessage Get(int version, string token, string message, bool log = false)
{
HttpResponseMessage response = null;
var logmessage = String.Format("test {0} token={1} log={2} message={3}", "GET", token, log, message);
if (log)
{
var props = eXtensibleConfig.GetProperties();
EventWriter.WriteError(logmessage, SeverityType.Error, "TEST", props);
}
int i;
HttpStatusCode statusCode;
if (Int32.TryParse(token, out i) && Enum.TryParse <HttpStatusCode>(token, out statusCode))
{
response = (statusCode.IsOkay()) ? Request.GenerateResponse(statusCode, logmessage) : Request.GenerateErrorResponse(statusCode, logmessage);
}
else
{
response = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, logmessage);
}
return(response);
}
protected virtual ICriterion Delete(ICriterion criterion, IContext context)
{
ICriterion result = new Criterion();
if (Collection != null)
{
WriteConcernResult writeConcern = Collection.Remove(criterion.ToQueryDocument <T>());
if (writeConcern.Ok)
{
long affected = writeConcern.DocumentsAffected;
result.AddItem("documentsAffected", affected);
}
else
{
IRequestContext ctx = context as IRequestContext;
var message = Exceptions.ComposeDatastoreException <T>(ModelActionOption.Delete, writeConcern.ErrorMessage, null, criterion, context, this.GetType().FullName, "MongoDB");
ctx.SetError(500, message.ToPublish());
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, context.ToDictionary(message.Id));
}
}
return(result);
}
U IModelDataGateway<T>.ExecuteMany<U>(IEnumerable<T> list, ICriterion criterion, IContext context)
{
IRequestContext ctx = context as IRequestContext;
ctx.SetMetric(XFConstants.Metrics.Scope.DataStore, XFConstants.Metrics.DbType, DataStorePlatform);
U u = default(U);
object o = null;
try
{
o = ExecuteMany<U>(list, criterion, context);
}
catch (Exception ex)
{
var message = Exceptions.ComposeGeneralExceptionError<T>(ModelActionOption.ExecuteAction, ex, null, criterion, context, this.GetType().FullName);
context.SetError(500, message.ToPublish());
EventWriter.WriteError(message.ToLog(), SeverityType.Error);
}
if (o is U)
{
u = (U)o;
}
return u;
}
private static void InitializeCodes()
{
try
{
var xml = Contracts.HttpResources.httpstatuscodes;
XDocument xdoc = XDocument.Parse(xml);
statusCodes = (from x in xdoc.Descendants("HttpCode")
let y = x
select new ApiHttpStatusCode()
{
Code = Int32.Parse(x.Attribute("code").Value),
Name = x.Attribute("name").Value,
Summary = (x.Attribute("sys.net").Value).Trim(),
IsSuccess = Boolean.Parse(x.Attribute("success").Value)
}).ToList();
}
catch (Exception ex)
{
string message = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
var props = eXtensibleConfig.GetProperties();
EventWriter.WriteError(message, SeverityType.Critical, "Initialization", props);
}
string candidates = ConfigurationManager.AppSettings["api.httpcodes.whitelist"];
List <int> codes = new List <int>();
if (!String.IsNullOrWhiteSpace(candidates))
{
string[] t = candidates.Split(new char[] { ',', ';', '.' });
foreach (var item in t)
{
int j;
if (Int32.TryParse(item, out j))
{
codes.Add(j);
}
}
}
else
{
codes.Add(200);
codes.Add(201);
codes.Add(202);
codes.Add(400);
codes.Add(401);
codes.Add(403);
codes.Add(404);
codes.Add(409);
codes.Add(500);
}
_ErrorCodeWhitelist = new List <ApiHttpStatusCode>();
foreach (var code in statusCodes)
{
if (codes.Contains(code.Code))
{
code.IsAvailable = true;
}
_ErrorCodeWhitelist.Add(code);
maps.TryAdd(code.Code, code);
}
}
protected async override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpResponseMessage errorMessage = null;
Guid xfId = Guid.Empty;
var principal = CreateClaimsPrincipal();
eXtensibleClaimsPrincipal exPrincipal = principal as eXtensibleClaimsPrincipal;
if (exPrincipal != null)
{
exPrincipal.Start(request);
}
Thread.CurrentPrincipal = exPrincipal;
var currentContext = System.Web.HttpContext.Current;
if (currentContext != null)
{
currentContext.User = exPrincipal;
}
HttpResponseMessage resultMessage = null;
try
{
resultMessage = ((errorMessage != null) ? errorMessage : await base.SendAsync(request, cancellationToken));
}
catch (Exception ex)
{
string message = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
var props = eXtensibleConfig.GetProperties();
EventWriter.WriteError(message, SeverityType.Critical, "api.routing", props);
request.GenerateErrorResponse(HttpStatusCode.NotFound, "resource not found");
}
// now perform any required profiling
if (exPrincipal != null)
{
exPrincipal.Stop(request);
var d = exPrincipal.Items.ToDictionary().Merge(eXtensibleConfig.GetProperties());
HttpStatusCode statuscode = resultMessage.StatusCode;
var reason = resultMessage.ReasonPhrase;
if (!resultMessage.IsSuccessStatusCode)
{
if (!d.ContainsKey("xf-id"))
{
xfId = Guid.NewGuid();
d.Add("xf-id", xfId);
}
else
{
object o = d["xf-id"];
if (o != null && o is Guid)
{
xfId = (Guid)o;
}
}
if (((HttpContent)resultMessage.Content).GetType().GetGenericArguments()[0].Name.Equals("HttpError"))
{
var httpError = ((ObjectContent <HttpError>)resultMessage.Content).Value as HttpError;
if (httpError != null)
{
if (httpError.ContainsKey("message"))
{
reason = httpError["message"].ToString();
}
if (errorCodeMapsReverse.ContainsKey(resultMessage.StatusCode.ToString()))
{
int code = errorCodeMapsReverse[resultMessage.StatusCode.ToString()];
if (d.ContainsKey("xf-request.response.status-code"))
{
d["xf-request.response.status-code"] = code.ToString();
}
else
{
d.Add("xf-request.response.status-code", code.ToString());
}
}
if (d.ContainsKey("xf-request.response.status-description"))
{
d["xf-request.response.status-description"] = reason;
}
else
{
d.Add("xf-request.response.status-description", reason);
}
}
}
else
{
}
}
else
{
string responsemessage = resultMessage.StatusCode.ToString();
int code = (int)resultMessage.StatusCode;
if (d.ContainsKey("xf-request.response.status-code"))
{
d["xf-request.response.status-code"] = code.ToString();
}
else
{
d.Add("xf-request.response.status-code", code.ToString());
}
if (d.ContainsKey("xf-request.response.status-description"))
{
d["xf-request.response.status-description"] = responsemessage;
}
else
{
d.Add("xf-request.response.status-description", responsemessage);
}
}
d.Add("api.extensible.list", "xf.api.request");
string basicToken;
string bearerToken;
if (!d.ContainsKey("xf-request.message.basic-token") && exPrincipal.Identity.TryGetValue <string>("source", out basicToken))
{
d.Add("xf-request.message.basic-token", basicToken);
}
if (!d.ContainsKey("xf-request.message.bearer-token") && exPrincipal.Identity.TryGetValue <string>(ClaimTypes.Authentication, out bearerToken))
{
d.Add("xf-request.message.bearer-token", bearerToken);
}
bool b = false;
if (eXtensibleWebApiConfig.LoggingMode.Equals(LoggingModeOption.All))
{
b = true;
}
else if (eXtensibleWebApiConfig.LoggingMode.Equals(LoggingModeOption.Sparse) && exPrincipal != null)
{
b = exPrincipal.HasError;
}
if (b)
{
Writer.Invoke(d);
}
}
resultMessage.Headers.Add(eXtensibleWebApiConfig.MessageIdHeaderKey, xfId.ToString());
return(resultMessage);
}
private IModelDataGateway <T> ResolveImplementor <T>(ModelActionOption option, IContext context, T t, ICriterion criterion) where T : class, new()
{
IModelDataGateway <T> implementor = null;
Type type = _TypeCache.ResolveType <T>();
if (type == null)
{
// if not, create one and add the model. then add sproc based if exists, otherwise add inline on appcontext-model by appcontext-model basis;
if (_DbConfigs.Contains(context.ApplicationContextKey))
{
var modelType = typeof(T);
string modelKey = modelType.FullName;
var found = _DbConfigs[context.ApplicationContextKey].Models.Find(x => x.Key.Equals(modelKey));
if (found == null)
{
XF.Common.Db.Model model = new Common.Db.Model()
{
Key = modelKey, modelType = modelType.AssemblyQualifiedName, ModelActions = new List <Common.Db.ModelAction>(), Commands = new List <Common.Db.DbCommand>(), DataMaps = new List <Common.Db.DataMap>()
};
_DbConfigs[context.ApplicationContextKey].Models.Add(model);
found = _DbConfigs[context.ApplicationContextKey].Models.Find(x => x.Key.Equals(modelKey));
}
if (found != null)
{
implementor = new ConfigModelDataGateway <T>(found);
}
else
{
}
}
else if (eXtensibleConfig.Infer)
{
implementor = new GenericModelDataGateway <T>();
}
//if (implementor == null)
//{
// var message = Exceptions.ComposeImplementorResolutionError<T>(option, t, context);
// context.SetError(500, message.ToPublish());
// EventWriter.WriteError(message.ToLog(), SeverityType.Error);
//}
}
else
{
implementor = Activator.CreateInstance(type) as IModelDataGateway <T>;
}
if (implementor == null)
{
if (type != null)
{
var message = Exceptions.ComposeImplementorInstantiationError <T>(option, t, context, type.FullName);
context.SetError(500, message.ToPublish());
var props = eXtensibleConfig.GetProperties();
props.Add(XFConstants.Context.Ticket, message.Id);
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, props);
}
else
{
var message = Exceptions.ComposeImplementorResolutionError <T>(option, t, context);
context.SetError(500, message.ToPublish());
var props = eXtensibleConfig.GetProperties();
props.Add(XFConstants.Context.Ticket, message.Id);
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, props);
}
}
else
{
if (eXtensibleConfig.Inform)
{
EventWriter.Inform(String.Format("MDG selected: {0}", implementor.GetType().FullName));
}
implementor.DataService = this as IDatastoreService;
implementor.Context = context;
ICacheable <T> cacheable = implementor as ICacheable <T>;
if (cacheable != null)
{
cacheable.Cache = Cache;
}
// TODO, outsource this
IModelDataGatewayInitializeable initializable = implementor as IModelDataGatewayInitializeable;
if (initializable != null)
{
initializable.Initialize <T>(option, context, t, criterion, ResolveDbKey <T>);
}
}
return(implementor);
}
void IModelDataGatewayInitializeable.Initialize <T>(ModelActionOption option, IContext context, T t, ICriterion criterion, ResolveDbKey <T> dbkeyResolver)
{
string key = ResolveConnectionStringKey(context);
if (String.IsNullOrWhiteSpace(key))
{
key = dbkeyResolver.Invoke(context);
}
if (String.IsNullOrEmpty(key))
{
var message = Exceptions.ComposeDbConnectionStringKeyResolutionError <T>(option, t, context);
context.SetError(500, message.ToPublish());
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, context.ToDictionary(message.Id));
}
else
{
var cn = ConfigurationProvider.ConnectionStrings[key];
if (cn != null)
{
MongoConnectionInfo info = new MongoConnectionInfo();
try
{
if (info.Initialize(cn))
{
MongoDb = info.GetDatabase();
}
if (MongoDb == null)
{
var message = Exceptions.ComposeDbConnectionCreationError <T>(option, t, context, key);
context.SetError(500, message.ToPublish());
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, context.ToDictionary(message.Id));
}
else
{
Collection = GetCollection();
if (Collection == null)
{
context.SetError(500, "MongoDB.Collection is Null");
}
else if (eXtensibleConfig.CaptureMetrics)
{
IRequestContext ctx = context as IRequestContext;
ctx.SetMetric(XFConstants.Metrics.Scope.DataStore, XFConstants.Metrics.Database.Datasource, String.Format("server:{0};database:{1};", cn.ConnectionString, key));;
}
}
}
catch (Exception ex)
{
var message = Exceptions.ComposeDbConnectionCreationError <T>(option, t, context, key);
context.SetError(500, message.ToPublish());
context.SetStacktrace(ex.StackTrace);
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, context.ToDictionary(message.Id));
}
}
else
{
var message = Exceptions.ComposeDbConnectionCreationError <T>(option, t, context, key);
context.SetError(500, message.ToPublish());
EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, context.ToDictionary(message.Id));
}
}
}
