protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, XObjectAuthorizationRequirement requirement)
{
bool success = false;
if (context.User != null && context.Resource is AuthorizationFilterContext authContext && authContext.ModelState.IsValid)
{
XType xtype = _XTypeModel.XFromRoute(authContext.RouteData, x);
if (xtype != null)
{
_XThisCache xthis = _XThisModel.XAuthenticate(context.User, cache, authContext.HttpContext.Session);
if (xthis != null)
{
XObject xobject = _XThisModel.XFromRoute(authContext.RouteData, xthis, x);
if (xobject != null && xthis != null)
{
success = true;
}
}
}
}
if (success)
{
context.Succeed(requirement);
}
return(Task.CompletedTask);
}
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, XConstructorInfoAuthorizationRequirement requirement)
{
bool success = false;
if (context.User != null && context.Resource is AuthorizationFilterContext authContext && authContext.ModelState.IsValid)
{
XType xtype = _XTypeModel.XFromRoute(authContext.RouteData, x);
if (xtype != null)
{
_XThisCache xthis = _XThisModel.XAuthenticate(context.User, cache, authContext.HttpContext.Session);
if (xthis != null)
{
success = _XThisModel.XAuthorize(xthis.XThis.XGetType(), xtype);
if (success == false)
{
List <XType> xtypes = _XTypeModel.XFromQuery(authContext.HttpContext.Request.Query, x);
XConstructorInfo xconstructor = xtype.XGetConstructor(xtypes.ToArray());
if (xconstructor != null)
{
success = _XThisModel.XAuthorize(xthis.XThis.XGetType(), xconstructor);
}
}
}
}
}
if (success)
{
context.Succeed(requirement);
}
return(Task.CompletedTask);
}
public async Task <ActionResult <XObject> > XObject([FromQuery] string key)
{
_XThisCache xthis = _XThisModel.XFromCache(cache, HttpContext.Session);
XObject xobject = _XObjectModel.XFromCache(xthis, key);
return(Ok(xobject));
}
public async Task <ActionResult <bool> > XParams([FromForm] string key, [FromForm] string objectKey)
{
_XThisCache xthis = _XThisModel.XFromCache(cache, HttpContext.Session);
bool res = _XParamsModel.XToCache(xthis, key, objectKey);
return(Ok(res));
}
public async Task <ActionResult <XObject[]> > XParams([FromQuery] string key, [FromQuery] int?index, [FromQuery] int?count)
{
_XThisCache xthis = _XThisModel.XFromCache(cache, HttpContext.Session);
List <XObject> xparams = null;
_XParamsModel.XFromCache(xthis, key, out xparams, index, count);
return(Ok(xparams.ToArray()));
}
public static XObject XFromCache(_XThisCache xthis, string key)
{
XObject xobject = null;
if (xthis.XObjects.ContainsKey(key))
{
xthis.XObjects.TryGetValue(key, out xobject);
}
return(xobject);
}
public static XObject XFromCache(_XThisCache xthis, XType xtype, int hashCode)
{
XObject xobject = null;
string key = xtype.XFullName + "@" + hashCode;
if (xthis.XObjects.ContainsKey(key))
{
xthis.XObjects.TryGetValue(key, out xobject);
}
return(xobject);
}
public async Task <IViewComponentResult> InvokeAsync(XAssembly xassembly, _XThisCache xthis)
{
_XAssemblyModel xmodel = new _XAssemblyModel();
XType xtype = xthis.XThis.XGetType();
List <XType> xtypes = _XThisModel.XAuthorize(xtype, xassembly.XExportedTypes);
Dictionary <string, List <string> > childNSs;
Dictionary <string, List <XType> > childTypes;
XToHiearchyTypes(xtypes, out childNSs, out childTypes);
xmodel.XNamespaces = childNSs;
xmodel.XTypes = childTypes;
xmodel.XInformation = _XAssemblyModel.XToAbout(xassembly, xthis.XString);
xmodel.XString = xthis.XString;
return(View(xmodel));
}
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, XAssemblyAuthorizationRequirement requirement)
{
bool success = false;
if (context.User != null && context.Resource is AuthorizationFilterContext authContext && authContext.ModelState.IsValid)
{
XAssembly xassembly = _XAssemblyModel.XFromRoute(authContext.RouteData, x);
if (xassembly != null)
{
_XThisCache xthis = _XThisModel.XAuthenticate(context.User, cache, authContext.HttpContext.Session);
if (xthis != null)
{
success = _XThisModel.XAuthorize(xthis.XThis.XGetType(), xassembly);
}
}
}
if (success)
{
context.Succeed(requirement);
}
return(Task.CompletedTask);
}
public async Task <IViewComponentResult> InvokeAsync(_XThisCache xthis)
{
_XThisModel xmodel = new _XThisModel(xthis);
xmodel.XObjects = new Dictionary <string, List <XObject> >();
foreach (XObject xobject in xmodel.XObjects.Values)
{
string key = xobject.XGetType().XFullName;
if (xmodel.XObjects.ContainsKey(key))
{
List <XObject> list = xmodel.XObjects[key];
list.Add(xobject);
}
else
{
List <XObject> list = xmodel.XObjects[key];
list.Add(xobject);
xmodel.XObjects.Add(key, list);
}
}
return(View(xmodel));
}
public async Task <IViewComponentResult> InvokeAsync(XType xtype, _XThisCache xthis)
{
_XTypeModel xmodel = new _XTypeModel(xtype, xthis);
xmodel.XConstructors = xtype.XGetConstructors();
xmodel.XFields = new Dictionary <string, List <XFieldInfo> >();
xmodel.XFieldTypes = new List <XType>();
foreach (XFieldInfo xfield in xtype.XGetFields())
{
if (xfield.XIsStatic)
{
XType xfieldType = xfield.XDeclaringType;
string fieldKey = xfieldType.XFullName;
if (xmodel.XFields.ContainsKey(fieldKey))
{
xmodel.XFields[fieldKey].Add(xfield);
}
else
{
xmodel.XFieldTypes.Add(xfieldType);
List <XFieldInfo> xfields = new List <XFieldInfo>();
xfields.Add(xfield);
xmodel.XFields.Add(fieldKey, xfields);
}
}
}
xmodel.XProperties = new Dictionary <string, List <XPropertyInfo> >();
xmodel.XPropertyTypes = new List <XType>();
foreach (XPropertyInfo xprop in xtype.XGetProperties())
{
if (xprop.XIsStatic)
{
XType xpropType = xprop.XDeclaringType;
string propKey = xpropType.XFullName;
if (xmodel.XProperties.ContainsKey(propKey))
{
xmodel.XProperties[propKey].Add(xprop);
}
else
{
xmodel.XPropertyTypes.Add(xpropType);
List <XPropertyInfo> xprops = new List <XPropertyInfo>();
xprops.Add(xprop);
xmodel.XProperties.Add(propKey, xprops);
}
}
}
List <XMethodInfo> xmethods = new List <XMethodInfo>();
foreach (XMethodInfo xmethod in xtype.XGetMethods())
{
if (xmethod.XIsStatic)
{
xmethods.Add(xmethod);
}
}
xmodel.XMethods = xmethods.ToArray();
Dictionary <string, char> accessKeyMap = new Dictionary <string, char>();
List <char> accessKeys = new List <char>();
_XTypeModel.XToAccessKeyMap(xmodel.XFields, xmodel.XProperties, out accessKeyMap, out accessKeys);
xmodel.XAccessKeys = accessKeyMap;
return(View(xmodel));
}
protected void XBuild(_XInModel xmodel, out string view, _XThisCache xthis, bool ximplicit)
{
xmodel.DefaultValue = "";
xmodel.Disabled = "";
xmodel.Id = "";
xmodel.ReadOnly = "";
xmodel.Required = "";
xmodel.SpellCheck = "";
xmodel.AccessKeyIndex = xmodel.Text.IndexOf(xmodel.AccessKey, StringComparison.OrdinalIgnoreCase);
xmodel.Type = "";
xmodel.Size = (int)(XConst.XRATIO * xmodel.Text.Length);
view = null;
if (xmodel.XType.XIsEnum)
{
view = "Enum";
}
else if (xmodel.XType.XFullName == (typeof(string[])).FullName)
{
view = "StringArray";
}
else if (xmodel.XType.XIsArray)
{
view = "Array";
}
else
{
view = "Default";
if (ximplicit)
{
xmodel.Type = "password";
}
else if (xmodel.XType.XFullName == (typeof(bool)).FullName)
{
xmodel.Type = "checkbox";
}
else if (xmodel.XType.XFullName == (typeof(Color)).FullName)
{
xmodel.Type = "color";
}
else if (xmodel.XType.XFullName == (typeof(DateTime)).FullName)
{
xmodel.Type = "datetime";
}
else if (xmodel.XType.XFullName == (typeof(File)).FullName)
{
xmodel.Type = "file";
}
else if (xmodel.XType.XFullName == (typeof(float)).FullName)
{
xmodel.Type = "number";
}
else if (xmodel.XType.XFullName == (typeof(int)).FullName)
{
xmodel.Type = "number";
}
else if (xmodel.XType.XFullName == (typeof(string)).FullName)
{
xmodel.SpellCheck = "spellcheck";
xmodel.Type = "text";
}
else if (xmodel.XType.XFullName == (typeof(Uri)).FullName)
{
xmodel.Type = "url";
}
else
{
view = "Ref";
xmodel.XObjects = new Dictionary <string, XObject>();
foreach (var keyValue in xthis.XObjects)
{
XType xtype2 = keyValue.Value.XGetType();
if (xmodel.XType.XIsAssignableFrom(xtype2))
{
xmodel.XObjects.Add(keyValue.Key, keyValue.Value);
}
}
}
}
}
public async Task <IViewComponentResult> InvokeAsync(object model, char accessKey, int tabIndex, _XThisCache xthis)
{
if (xthis != null)
{
xstring = xthis.XString;
}
if (model is XParameterInfo xparam)
{
return(await xparameter(xparam, accessKey, tabIndex, xthis));
}
else if (model is XFieldInfo xfield)
{
return(await xfieldInfo(xfield, accessKey, tabIndex, xthis));
}
else if (model is XPropertyInfo xprop)
{
return(await xpropertyInfo(xprop, accessKey, tabIndex, xthis));
}
return(View());
}
protected async Task <IViewComponentResult> xpropertyInfo(XPropertyInfo xproperty, char accessKey, int tabIndex, _XThisCache xthis)
{
_XInModel xmodel = new _XInModel();
xmodel.AccessKey = accessKey;
xmodel.Class = _XPropertyInfoModel.XToClass(xproperty);
xmodel.Name = xproperty.XName;
xmodel.TabIndex = tabIndex;
xmodel.Text = _XStringModel.XToString(xproperty, xstring);
//xmodel.Title = _XStringModel.XToTitle(x, xproperty, xstring);
xmodel.XString = xstring;
xmodel.XType = xproperty.XPropertyType;
bool ximplicit = _XPropertyInfoModel.XIsImplicit(xproperty, x);
string view = null;
XBuild(xmodel, out view, xthis, ximplicit);
if (view != null)
{
return(View(view, xmodel));
}
return(View(xmodel));
}
public static XObject[] XFromForm(X x, XParameterInfo[] xparams, XTypeConverter xtypeConverter, IFormCollection form, _XThisCache cache)
{
List <XObject> values = new List <XObject>();
if (xtypeConverter.XCanConvertFrom(typeof(string)))
{
XType _this = x.XTypeOf(typeof(_XThis));
foreach (XParameterInfo xparameter in xparams)
{
StringValues value = form[xparameter.XName];
XObject xobject = null;
if (xtypeConverter.XCanConvertTo(xparameter.XParameterType))
{
xobject = xtypeConverter.XConvertTo(value.ToString(), xparameter.XParameterType);
}
else if (cache != null)
{
if (xparameter.XParameterType.XIsAssignableFrom(cache.XThis.XGetType()))
{
XObject[] xattrs = xparameter.XGetCustomAttributes(_this, true);
if (xattrs != null && xattrs.Length > 0)
{
xobject = cache.XThis;
}
}
if (xobject == null)
{
if (value.ToString() == "")
{
xobject = x.XNULL;
}
else
{
xobject = _XObjectModel.XFromCache(cache, value.ToString());
}
}
}
values.Add(xobject);
}
}
return(values.ToArray());
}
public async Task <ActionResult> XString([FromQuery] string lang)
{
_XThisCache xthis = _XThisModel.XFromCache(cache, HttpContext.Session);
return(Ok());
}
public static void XToCache(_XThisCache cache, XObject xobject)
{
string key = XToKey(xobject);
cache.XObjects.Add(key, xobject);
}
public _XObjectModel(XObject xobj, _XThisCache xthis) : base(xthis)
{
XObject = xobj;
}
public async Task <ActionResult> XAwait([FromQuery] string type, int hashCode)
{
_XThisCache xthis = _XThisModel.XFromCache(cache, HttpContext.Session);
return(Ok());
}
public _XTypeModel(XType type, _XThisCache xthis) : base(xthis)
{
XType = type;
}
