public object Any(TemplatesAdmin request)
{
var feature = HostContext.AssertPlugin<TemplatePagesFeature>();
RequiredRoleAttribute.AssertRequiredRoles(Request, feature.TemplatesAdminRole);
if (string.IsNullOrEmpty(request.Actions))
return new TemplatesAdminResponse { Results = new[]{ "Available actions: " + string.Join(",", Actions) } };
var actions = request.Actions.Split(',');
var results = new List<string>();
using (var ms = MemoryStreamFactory.GetStream())
{
var scope = new TemplateScopeContext(new PageResult(feature.EmptyPage), ms, new Dictionary<string, object>());
if (actions.Any(x => x.EqualsIgnoreCase(nameof(TemplateProtectedFilters.invalidateAllCaches))))
results.Add(nameof(TemplateProtectedFilters.invalidateAllCaches) + ": " + feature.ProtectedFilters.invalidateAllCaches(scope).ToJsv());
if (actions.Any(x => x.EqualsIgnoreCase(nameof(TemplatePagesFeature.RunInitPage))))
results.Add(nameof(TemplatePagesFeature.RunInitPage) + ": " + feature.RunInitPage());
if (results.Count > 0)
return new TemplatesAdminResponse { Results = results.ToArray() };
}
throw new NotSupportedException("Unknown Action. Available actions: " + string.Join(",", Actions));
}
public object Get(Authenticate request)
{
var allowGetAuthRequests = HostContext.AssertPlugin <AuthFeature>().AllowGetAuthenticateRequests;
// null == allow all Auth Requests or
if (allowGetAuthRequests != null && !allowGetAuthRequests(Request))
{
throw new NotSupportedException("GET Authenticate requests are disabled, to enable set AuthFeature.AllowGetAuthenticateRequests = req => true");
}
return(Post(request));
}
public static PageResult GetPageResult(this IRequest request, string virtualPath, Dictionary <string, object> args = null)
{
var page = HostContext.AssertPlugin <SharpPagesFeature>().GetPage(virtualPath);
var pageResult = new PageResult(page).BindRequest(request);
if (args != null)
{
foreach (var entry in args)
{
pageResult.Args[entry.Key] = entry.Value;
}
}
return(pageResult);
}
public async Task <object> Any(GetValidationRules request)
{
var feature = HostContext.AssertPlugin <ValidationFeature>();
await RequestUtils.AssertAccessRoleAsync(base.Request, accessRole : feature.AccessRole, authSecret : request.AuthSecret);
var type = HostContext.Metadata.FindDtoType(request.Type);
if (type == null)
{
throw HttpError.NotFound(request.Type);
}
return(new GetValidationRulesResponse {
Results = await ValidationSource.GetAllValidateRulesAsync(request.Type).ConfigAwait(),
});
}
public static PageResult GetPageResult(this IRequest request, string virtualPath, Dictionary<string,object> args=null)
{
var page = HostContext.AssertPlugin<TemplatePagesFeature>().GetPage(virtualPath);
var pageResult = new PageResult(page) {
Args = {
["Request"] = request
}
};
if (args != null)
{
foreach (var entry in args)
{
pageResult.Args[entry.Key] = entry.Value;
}
}
return pageResult;
}
public async Task Any(EvalScript request)
{
var feature = HostContext.AssertPlugin <DesktopFeature>();
RequestUtils.AssertAccessRole(base.Request, accessRole: feature.AccessRole, authSecret: request.AuthSecret);
var appHost = HostContext.AppHost;
string script;
var method = ((script = request.EvaluateScript) != null
? nameof(request.EvaluateScript)
: (script = request.EvaluateCode) != null
? nameof(request.EvaluateCode)
: (script = request.EvaluateLisp) != null
? nameof(request.EvaluateLisp)
: (script = request.RenderScript) != null
? nameof(request.RenderScript)
: (script = request.RenderCode) != null
? nameof(request.RenderCode)
: (script = request.RenderLisp) != null
? nameof(request.RenderLisp)
: null) ??
((script = request.EvaluateScriptAsync) != null
? nameof(request.EvaluateScriptAsync)
: (script = request.EvaluateCodeAsync) != null
? nameof(request.EvaluateCodeAsync)
: (script = request.EvaluateLispAsync) != null
? nameof(request.EvaluateLispAsync)
: (script = request.RenderScriptAsync) != null
? nameof(request.RenderScriptAsync)
: (script = request.RenderCodeAsync) != null
? nameof(request.RenderCodeAsync)
: (script = request.RenderLispAsync) != null
? nameof(request.RenderLispAsync)
: null)
?? throw new ArgumentNullException(nameof(request.EvaluateCode));
async Task HandleExceptionAsync(Exception e)
{
log.Error(e.Message, e);
base.Response.StatusCode = 500;
base.Response.StatusDescription = e.GetType().Name;
base.Response.ContentType = MimeTypes.PlainText;
await base.Response.OutputStream.WriteAsync(MemoryProvider.Instance.ToUtf8(e.ToString().AsSpan()));
await base.Response.EndRequestAsync(skipHeaders : true);
}
async Task SetResult(object value, string resultType = " result")
{
base.Response.ContentType = MimeTypes.Json;
base.Response.StatusCode = 200;
base.Response.StatusDescription = method + resultType;
await base.Response.EndRequestAsync(skipHeaders : false, async res => {
using var ms = MemoryStreamFactory.GetStream();
JsonSerializer.SerializeToStream(value, ms);
ms.Position = 0;
await ms.CopyToAsync(base.Response.OutputStream);
});
}
async Task SetOutput(PageResult result)
{
base.Response.StatusCode = 200;
base.Response.StatusDescription = method + " result";
base.Response.ContentType = MimeTypes.PlainText;
await base.Response.EndRequestAsync(skipHeaders : false, async res => {
using var ms = MemoryStreamFactory.GetStream();
await result.RenderToStreamAsync(ms);
ms.Position = 0;
await ms.CopyToAsync(res.OutputStream);
});
}
var args = new Dictionary <string, object> {
[ScriptConstants.Request] = base.Request,
};
if (method.EqualsIgnoreCase(nameof(ScriptTemplateUtils.EvaluateScript)))
{
await SetResult(await appHost.ScriptContext.EvaluateAsync(script, args));
}
else if (method.EqualsIgnoreCase(nameof(ScriptTemplateUtils.RenderScript)))
{
await SetOutput(new PageResult(appHost.ScriptContext.SharpScriptPage(script)).AssignArgs(args));
}
else if (method.EqualsIgnoreCase(nameof(ScriptCodeUtils.EvaluateCode)))
{
await SetResult(await appHost.ScriptContext.EvaluateCodeAsync(ScriptCodeUtils.EnsureReturn(script), args));
}
else if (method.EqualsIgnoreCase(nameof(ScriptCodeUtils.RenderCode)))
{
await SetOutput(new PageResult(appHost.ScriptContext.CodeSharpPage(script)).AssignArgs(args));
}
else if (method.EqualsIgnoreCase(nameof(ScriptLispUtils.EvaluateLisp)))
{
await SetResult(await appHost.ScriptContext.EvaluateLispAsync(ScriptLispUtils.EnsureReturn(script), args));
}
else if (method.EqualsIgnoreCase(nameof(ScriptLispUtils.RenderLisp)))
{
await SetOutput(new PageResult(appHost.ScriptContext.LispSharpPage(script)).AssignArgs(args));
}
if (base.Response.IsClosed)
{
return;
}
async Task setResultAsync(Task <object> valueTask, string resultType = " result")
{
try
{
base.Response.ContentType = MimeTypes.Json;
base.Response.StatusCode = 200;
base.Response.StatusDescription = method + resultType;
await base.Response.EndRequestAsync(skipHeaders : false, async res => {
using var ms = MemoryStreamFactory.GetStream();
JsonSerializer.SerializeToStream(await valueTask, ms);
await ms.CopyToAsync(base.Response.OutputStream);
});
}
catch (Exception e)
{
await HandleExceptionAsync(e);
}
}
async Task setOutputAsync(PageResult result)
{
try
{
base.Response.StatusCode = 200;
base.Response.StatusDescription = method + " async result";
base.Response.ContentType = MimeTypes.PlainText;
await base.Response.EndRequestAsync(skipHeaders : false, async res => {
using var ms = MemoryStreamFactory.GetStream();
await result.RenderToStreamAsync(ms);
await ms.CopyToAsync(res.OutputStream);
});
}
catch (Exception e)
{
await HandleExceptionAsync(e);
}
}
if (method.EqualsIgnoreCase(nameof(ScriptTemplateUtils.EvaluateScriptAsync)))
{
await Task.Run(async() => await setResultAsync(appHost.ScriptContext.EvaluateAsync(script, args), " async result"));
}
else if (method.EqualsIgnoreCase(nameof(ScriptTemplateUtils.RenderScriptAsync)))
{
await Task.Run(async() => await setOutputAsync(new PageResult(appHost.ScriptContext.SharpScriptPage(script)).AssignArgs(args)));
}
else if (method.EqualsIgnoreCase(nameof(ScriptCodeUtils.EvaluateCodeAsync)))
{
await Task.Run(async() => await setResultAsync(appHost.ScriptContext.EvaluateCodeAsync(ScriptCodeUtils.EnsureReturn(script), args), " async result"));
}
else if (method.EqualsIgnoreCase(nameof(ScriptCodeUtils.RenderCodeAsync)))
{
await Task.Run(async() => await setOutputAsync(new PageResult(appHost.ScriptContext.CodeSharpPage(script)).AssignArgs(args)));
}
else if (method.EqualsIgnoreCase(nameof(ScriptLispUtils.EvaluateLispAsync)))
{
await Task.Run(async() => await setResultAsync(appHost.ScriptContext.EvaluateLispAsync(ScriptLispUtils.EnsureReturn(script), args), " async result"));
}
else if (method.EqualsIgnoreCase(nameof(ScriptLispUtils.RenderLispAsync)))
{
await Task.Run(async() => await setOutputAsync(new PageResult(appHost.ScriptContext.LispSharpPage(script)).AssignArgs(args)));
}
else
{
throw new NotSupportedException($"Unsupported script API '{method}', supported: " +
"EvaluateScript/Async, EvaluateCode/Async, EvaluateLisp/Async");
}
}
public static string SvgBaseUrl(this IHtmlHelper html) => html.GetRequest().ResolveAbsoluteUrl(HostContext.AssertPlugin <SvgFeature>().RoutePath);
public static TemplatePage OneTimePage(this IRequest request, string contents, string ext = null)
{
return(HostContext.AssertPlugin <TemplatePagesFeature>().OneTimePage(contents, ext));
}
public static TemplatePage GetPage(this IRequest request, string virtualPath)
{
return(HostContext.AssertPlugin <TemplatePagesFeature>().GetPage(virtualPath));
}
public static SharpCodePage GetCodePage(this IRequest request, string virtualPath)
{
return(HostContext.AssertPlugin <SharpPagesFeature>().GetCodePage(virtualPath).With(request));
}
public GrpcProtoGenerator(MetadataTypesConfig config)
{
Config = config;
feature = HostContext.AssertPlugin <NativeTypesFeature>();
grpc = HostContext.AssertPlugin <GrpcFeature>();
}
public async Task <object> AnyAsync(RegisterDevice request)
{
string userAuthName = GetSession().UserAuthName;
string userAuthId = GetSession().UserAuthId;
var utcNow = DateTime.UtcNow;
var existings = await Db.SelectAsync <Device>(d => d.DeviceId.ToLower() == request.DeviceId.ToLower());
if (existings.FirstOrDefault() is { } existing)
{
if (existing.DeletedDate is not null)
{
return(new RegisterDeviceResponse()
{
DeviceBlocked = true
});
}
existing.LastActiveBy = userAuthName;
existing.LastActiveDate = utcNow;
existing.Meta = request.Meta;
await Db.SaveAsync(existing);
return(new RegisterDeviceResponse()
{
DeviceBlocked = false
});
}
var deviceFeature = HostContext.AssertPlugin <DevicesFeature>();
if (deviceFeature.LimitActiveDevicesForUser)
{
var limit = await deviceFeature.GetUserDeviceCountLimitAsync(Request);
var deviceCount = await Db.CountAsync <Device>(d => d.UserAuthId == userAuthId && d.DeletedDate == null);
if (deviceCount >= limit)
{
throw new HttpError(HttpStatusCode.Forbidden, "Device Limit Reached");
}
}
var device = new Device()
{
UserAuthId = userAuthId,
DeviceId = request.DeviceId,
Description = request.Description,
ModifiedBy = userAuthName,
CreatedBy = userAuthName,
CreatedDate = utcNow,
ModifiedDate = utcNow,
LastActiveBy = userAuthName,
LastActiveDate = utcNow,
Meta = request.Meta,
DeviceKindId = request.DeviceKindId
};
await Db.InsertAsync(device);
return(new RegisterDeviceResponse()
{
DeviceBlocked = false
});
}