public MockHttpResponse(IRequest request = null)
{
this.Request = request;
this.Headers = PclExportClient.Instance.NewNameValueCollection();
this.OutputStream = new MemoryStream();
this.TextWritten = new StringBuilder();
this.Cookies = HostContext.AssertAppHost().GetCookies(this);
this.Items = new Dictionary <string, object>();
}
public MockHttpResponse(IRequest request = null)
{
this.Request = request;
this.Headers = new Dictionary <string, string>();
this.OutputStream = new MemoryStream();
this.TextWritten = new StringBuilder();
this.Cookies = HostContext.AssertAppHost().GetCookies(this);
this.Items = new Dictionary <string, object>();
}
public virtual async Task <object> ExecuteAsync(IRequest req, object instance, TRequest requestDto)
{
try
{
BeforeEachRequest(req, requestDto, instance);
var res = req.Response;
var appHost = HostContext.AssertAppHost();
var container = appHost.Container;
if (RequestFilters != null)
{
foreach (var requestFilter in RequestFilters)
{
var attrInstance = requestFilter.Copy();
container.AutoWire(attrInstance);
if (attrInstance is IHasRequestFilter filterSync)
{
filterSync.RequestFilter(req, res, requestDto);
}
else if (attrInstance is IHasRequestFilterAsync filterAsync)
{
await filterAsync.RequestFilterAsync(req, res, requestDto).ConfigAwait();
}
AppHost.Release(attrInstance);
if (res.IsClosed)
{
return(null);
}
}
}
var response = AfterEachRequest(req, requestDto, ServiceAction(instance, requestDto), instance);
if (appHost.Config.StrictMode == true)
{
if (response != null && response.GetType().IsValueType)
{
throw new StrictModeException(
$"'{requestDto.GetType().Name}' Service cannot return Value Types for its Service Responses. " +
$"You can embed its '{response.GetType().Name}' return value in a Response DTO or return as raw data in a string or byte[]",
StrictModeCodes.ReturnsValueType);
}
}
if (response is Task taskResponse)
{
if (taskResponse.Status == TaskStatus.Created)
{
taskResponse.Start();
}
await taskResponse.ConfigAwait();
response = taskResponse.GetResult();
}
LogRequest(req, requestDto, response);
if (response is IHttpError error)
{
var ex = (Exception)error;
var result = await HandleExceptionAsync(req, requestDto, ex, instance).ConfigAwait();
if (result == null)
{
throw ex;
}
return(result);
}
if (ResponseFilters != null)
{
foreach (var responseFilter in ResponseFilters)
{
var attrInstance = responseFilter.Copy();
container.AutoWire(attrInstance);
if (attrInstance is IHasResponseFilter filter)
{
filter.ResponseFilter(req, res, response);
}
else if (attrInstance is IHasResponseFilterAsync filterAsync)
{
await filterAsync.ResponseFilterAsync(req, res, response).ConfigAwait();
}
AppHost.Release(attrInstance);
if (res.IsClosed)
{
return(null);
}
}
}
return(response);
}
catch (Exception ex)
{
//Sync Exception Handling
var result = await HandleExceptionAsync(req, requestDto, ex, instance).ConfigAwait();
if (result == null)
{
throw;
}
return(result);
}
}
public async Task Any(ModifyValidationRules request)
{
var appHost = HostContext.AssertAppHost();
var feature = appHost.AssertPlugin <ValidationFeature>();
await RequestUtils.AssertAccessRoleAsync(base.Request, accessRole : feature.AccessRole, authSecret : request.AuthSecret);
var utcNow = DateTime.UtcNow;
var userName = (await base.GetSessionAsync()).GetUserAuthName();
var rules = request.SaveRules;
if (!rules.IsEmpty())
{
foreach (var rule in rules)
{
if (rule.Type == null)
{
throw new ArgumentNullException(nameof(rule.Type));
}
var existingType = appHost.Metadata.FindDtoType(rule.Type);
if (existingType == null)
{
throw new ArgumentException(@$ "{rule.Type} does not exist", nameof(rule.Type));
}
if (rule.Validator == "")
{
rule.Validator = null;
}
if (rule.Condition == "")
{
rule.Condition = null;
}
if (rule.Field == "")
{
rule.Field = null;
}
if (rule.ErrorCode == "")
{
rule.ErrorCode = null;
}
if (rule.Message == "")
{
rule.Message = null;
}
if (rule.Notes == "")
{
rule.Notes = null;
}
if (rule.Field != null && TypeProperties.Get(existingType).GetAccessor(rule.Field) == null)
{
throw new ArgumentException(@$ "{rule.Field} does not exist on {rule.Type}", nameof(rule.Field));
}
if (rule.Validator != null)
{
object validator;
try
{
validator = appHost.EvalExpression(rule.Validator);
if (validator == null)
{
throw new ArgumentException(@$ "Validator does not exist", nameof(rule.Validator));
}
}
catch (Exception e)
{
throw new ArgumentException(@$ "Invalid Validator: " + e.Message, nameof(rule.Validator));
}
var validators = (validator as List <object>) ?? TypeConstants.EmptyObjectList;
var firstValidator = validator is IPropertyValidator pv
? pv
: validator is ITypeValidator tv
? tv
: validators?.FirstOrDefault() ?? validator;
if (rule.Field != null && !(firstValidator is IPropertyValidator && validators.All(v => v is IPropertyValidator)))
{
throw new ArgumentException(@$ "{nameof(IPropertyValidator)} is expected but was {(validators?.FirstOrDefault(v => !(v is IPropertyValidator)) ?? firstValidator).GetType().Name}", nameof(rule.Validator));
}
if (rule.Field == null && !(firstValidator is ITypeValidator && validators.All(v => v is ITypeValidator)))
{
throw new ArgumentException(@$ "{nameof(ITypeValidator)} is expected but was {(validators?.FirstOrDefault(v => !(v is IPropertyValidator)) ?? firstValidator).GetType().Name}", nameof(rule.Validator));
}
if (rule.Condition != null)
{
throw new ArgumentException(@$ "Only {nameof(rule.Validator)} or {nameof(rule.Condition)} can be specified, not both", nameof(rule.Condition));
}
}
else
{
if (rule.Condition == null)
{
throw new ArgumentNullException(nameof(rule.Validator), @$ "{nameof(rule.Validator)} or {nameof(rule.Condition)} is required");
}
try
{
var ast = Validators.ParseCondition(appHost.ScriptContext, rule.Condition);
await ast.Init().ConfigAwait();
}
catch (Exception e)
{
var useEx = e is ScriptException se ? se.InnerException ?? e : e;
throw new ArgumentException(useEx.Message, nameof(rule.Condition));
}
}
if (rule.CreatedBy == null)
{
rule.CreatedBy = userName;
rule.CreatedDate = utcNow;
}
rule.ModifiedBy = userName;
rule.ModifiedDate = utcNow;
}
await ValidationSource.SaveValidationRulesAsync(rules).ConfigAwait();
}
if (!request.SuspendRuleIds.IsEmpty())
{
var suspendRules = await ValidationSource.GetValidateRulesByIdsAsync(request.SuspendRuleIds).ConfigAwait();
foreach (var suspendRule in suspendRules)
{
suspendRule.SuspendedBy = userName;
suspendRule.SuspendedDate = utcNow;
}
await ValidationSource.SaveValidationRulesAsync(suspendRules).ConfigAwait();
}
if (!request.UnsuspendRuleIds.IsEmpty())
{
var unsuspendRules = await ValidationSource.GetValidateRulesByIdsAsync(request.UnsuspendRuleIds).ConfigAwait();
foreach (var unsuspendRule in unsuspendRules)
{
unsuspendRule.SuspendedBy = null;
unsuspendRule.SuspendedDate = null;
}
await ValidationSource.SaveValidationRulesAsync(unsuspendRules).ConfigAwait();
}
if (!request.DeleteRuleIds.IsEmpty())
{
await ValidationSource.DeleteValidationRulesAsync(request.DeleteRuleIds.ToArray()).ConfigAwait();
}
if (request.ClearCache.GetValueOrDefault())
{
await ValidationSource.ClearCacheAsync().ConfigAwait();
}
}
public async Task Any(ModifyValidationRules request)
{
var appHost = HostContext.AssertAppHost();
var container = appHost.GetContainer();
var feature = appHost.AssertPlugin <ValidationFeature>();
RequestUtils.AssertAccessRole(base.Request, accessRole: feature.AccessRole, authSecret: request.AuthSecret);
var utcNow = DateTime.UtcNow;
var userName = base.GetSession().GetUserAuthName();
var rules = request.SaveRules;
if (!rules.IsEmpty())
{
foreach (var rule in rules)
{
if (rule.Type == null)
{
throw new ArgumentNullException(nameof(rule.Type));
}
if (rule.CreatedBy == null)
{
rule.CreatedBy = userName;
rule.CreatedDate = utcNow;
}
rule.ModifiedBy = userName;
rule.ModifiedDate = utcNow;
}
await ValidationSource.SaveValidationRulesAsync(rules);
}
if (!request.SuspendRuleIds.IsEmpty())
{
var suspendRules = await ValidationSource.GetValidateRulesByIdsAsync(request.SuspendRuleIds);
foreach (var suspendRule in suspendRules)
{
suspendRule.SuspendedBy = userName;
suspendRule.SuspendedDate = utcNow;
}
await ValidationSource.SaveValidationRulesAsync(suspendRules);
}
if (!request.UnsuspendRuleIds.IsEmpty())
{
var unsuspendRules = await ValidationSource.GetValidateRulesByIdsAsync(request.UnsuspendRuleIds);
foreach (var unsuspendRule in unsuspendRules)
{
unsuspendRule.SuspendedBy = null;
unsuspendRule.SuspendedDate = null;
}
await ValidationSource.SaveValidationRulesAsync(unsuspendRules);
}
if (!request.DeleteRuleIds.IsEmpty())
{
await ValidationSource.DeleteValidationRulesAsync(request.DeleteRuleIds.ToArray());
}
}