public Task HandleRequest(string url, RequestHandler.RequestMethods method, string formData, HttpContext context, ISecureSession session, IsValidCall securityCheck)
{
IModel model = null;
lock (_constructors)
{
if (_constructors.ContainsKey(url))
{
model = (IModel)_constructors[url].Invoke(new object[] { });
}
}
if (model == null)
{
throw new CallNotFoundException("Model Not Found");
}
else
{
MethodInfo mi = null;
lock (_saveMethods)
{
if (_saveMethods.ContainsKey(url))
{
mi = _saveMethods[url];
}
}
if (mi != null)
{
if (!securityCheck.Invoke(mi.DeclaringType, mi, session, null, url, (Hashtable)JSON.JsonDecode(formData)))
{
throw new InsecureAccessException();
}
Utility.SetModelValues(formData, ref model, true);
if ((bool)mi.Invoke(model, new object[] { }))
{
context.Response.ContentType = "text/json";
context.Response.StatusCode = 200;
return(context.Response.WriteAsync(JSON.JsonEncode(new Hashtable()
{
{ "id", model.id }
})));
}
throw new Exception("Failed");
}
throw new CallNotFoundException();
}
}
public Task HandleRequest(string url, RequestHandler.RequestMethods method, string formData, HttpContext context, ISecureSession session, IsValidCall securityCheck)
{
IModel model = null;
lock (_loadMethods)
{
if (_loadMethods.ContainsKey(url.Substring(0, url.LastIndexOf("/"))))
{
if (!securityCheck.Invoke(_loadMethods[url.Substring(0, url.LastIndexOf("/"))].DeclaringType, _loadMethods[url.Substring(0, url.LastIndexOf("/"))], session, null, url, new Hashtable()
{
{ "id", url.Substring(0, url.LastIndexOf("/")) }
}))
{
throw new InsecureAccessException();
}
model = (IModel)_loadMethods[url.Substring(0, url.LastIndexOf("/"))].Invoke(null, new object[] { url.Substring(url.LastIndexOf("/") + 1) });
}
}
if (model == null)
{
throw new CallNotFoundException("Model Not Found");
}
else
{
MethodInfo mi = null;
lock (_updateMethods)
{
if (_updateMethods.ContainsKey(url.Substring(0, url.LastIndexOf("/"))))
{
mi = _updateMethods[url.Substring(0, url.LastIndexOf("/"))];
}
}
if (mi != null)
{
if (!securityCheck.Invoke(mi.DeclaringType, mi, session, model, url, (Hashtable)JSON.JsonDecode(formData)))
{
throw new InsecureAccessException();
}
context.Response.ContentType = "text/json";
context.Response.StatusCode = 200;
Utility.SetModelValues(formData, ref model, false);
return(context.Response.WriteAsync(JSON.JsonEncode(mi.Invoke(model, new object[] { }))));
}
throw new CallNotFoundException();
}
}
public Task HandleRequest(string url, RequestHandler.RequestMethods method, string formData, HttpContext context, ISecureSession session, IsValidCall securityCheck)
{
Match m = _reg.Match(url);
string id = m.Groups[1].Value;
string smethod = m.Groups[2].Value;
IModel model = (IModel)_loadMethod.Invoke(null, new object[] { id });
if (model == null)
{
throw new CallNotFoundException("Model Not Found");
}
MethodInfo mi;
object[] pars;
Utility.LocateMethod(formData, _methods[smethod], out mi, out pars);
if (mi == null)
{
throw new CallNotFoundException("Unable to locate requested method to invoke");
}
else
{
if (!securityCheck.Invoke(mi.DeclaringType, mi, session, model, url, (Hashtable)JSON.JsonDecode(formData)))
{
throw new InsecureAccessException();
}
context.Response.ContentType = "text/json";
context.Response.StatusCode = 200;
try
{
if (mi.ReturnType == typeof(void))
{
mi.Invoke(model, pars);
return(context.Response.WriteAsync(""));
}
else
{
return(context.Response.WriteAsync(JSON.JsonEncode(mi.Invoke(model, pars))));
}
}
catch (Exception ex)
{
throw new Exception("Execution Error");
}
}
}
public Task HandleRequest(string url, RequestHandler.RequestMethods method, string formData, HttpContext context, ISecureSession session, IsValidCall securityCheck)
{
IModel model = null;
lock (_loadMethods)
{
if (_loadMethods.ContainsKey(url.Substring(0, url.LastIndexOf("/"))))
{
model = (IModel)_loadMethods[url.Substring(0, url.LastIndexOf("/"))].Invoke(null, new object[] { url.Substring(url.LastIndexOf("/") + 1) });
}
}
if (model == null)
{
throw new CallNotFoundException("Model Not Found");
}
else
{
MethodInfo mi = null;
lock (_deleteMethods)
{
if (_deleteMethods.ContainsKey(url.Substring(0, url.LastIndexOf("/"))))
{
mi = _deleteMethods[url.Substring(0, url.LastIndexOf("/"))];
}
}
if (mi != null)
{
if (!securityCheck(mi.DeclaringType, mi, session, model, url, null))
{
throw new UnauthorizedAccessException();
}
else
{
context.Response.ContentType = "text/json";
context.Response.StatusCode = 200;
return(context.Response.WriteAsync(JSON.JsonEncode(mi.Invoke(model, new object[] { }))));
}
}
else
{
throw new CallNotFoundException("Method Not Found");
}
}
}
public bool HandlesRequest(string url, RequestHandler.RequestMethods method)
{
if (method == RequestHandler.RequestMethods.GET)
{
bool ret = false;
lock (_calls)
{
foreach (sModelListCall call in _calls)
{
if (call.IsValid(url))
{
ret = true;
break;
}
}
}
return(ret);
}
return(false);
}
public bool HandlesRequest(string url, RequestHandler.RequestMethods method)
{
bool ret = false;
if (method == RequestHandler.RequestMethods.METHOD)
{
lock (_patterns)
{
foreach (sMethodPatterns smp in _patterns)
{
if (smp.IsValid(url))
{
ret = true;
break;
}
}
}
}
return(ret);
}
public Task HandleRequest(string url, RequestHandler.RequestMethods method, Hashtable formData, HttpContext context, ISecureSession session, IsValidCall securityCheck)
{
if (!securityCheck.Invoke(_method.DeclaringType, _method, session, null, url, formData))
{
throw new InsecureAccessException();
}
context.Response.ContentType = "text/json";
context.Response.StatusCode = 200;
ParameterInfo[] pars = _method.GetParameters();
object[] opars = new object[] { };
if (pars.Length > 0)
{
opars = new object[pars.Length];
if (_usesSession)
{
opars[_sessionIndex] = session;
}
if (pars.Length > 1 || !_usesSession)
{
Match m = _reg.Match(url);
foreach (int x in _groupIndexes.Keys)
{
opars[x] = _ConvertParameterValue(m.Groups[_groupIndexes[x] + 1].Value, pars[x].ParameterType);
}
}
}
object ret = _method.Invoke(null, opars);
if (_isPaged)
{
return(context.Response.WriteAsync(JSON.JsonEncode(new Hashtable()
{
{ "response", ret },
{ "TotalPages", opars[opars.Length - 1] }
})));
}
else
{
return(context.Response.WriteAsync(JSON.JsonEncode(ret)));
}
}
public Task HandleRequest(string url, RequestHandler.RequestMethods method, Hashtable formData, HttpContext context, ISecureSession session, IsValidCall securityCheck)
{
sModelListCall?mlc = null;
lock (_calls)
{
foreach (sModelListCall call in _calls)
{
if (call.IsValid(url))
{
mlc = call;
break;
}
}
}
if (mlc.HasValue)
{
return(mlc.Value.HandleRequest(url, method, formData, context, session, securityCheck));
}
throw new CallNotFoundException();
}
public Task HandleRequest(string url, RequestHandler.RequestMethods method, string formData, HttpContext context, ISecureSession session, IsValidCall securityCheck)
{
sMethodPatterns?patt = null;
lock (_patterns)
{
foreach (sMethodPatterns smp in _patterns)
{
if (smp.IsValid(url))
{
patt = smp;
break;
}
}
}
if (patt.HasValue)
{
return(patt.Value.HandleRequest(url, method, formData, context, session, securityCheck));
}
throw new CallNotFoundException();
}
public Task HandleRequest(string url, RequestHandler.RequestMethods method, Hashtable formData, HttpContext context, ISecureSession session, IsValidCall securityCheck)
{
if (!HandlesRequest(url, method))
{
throw new CallNotFoundException();
}
else
{
List <Type> models = new List <Type>();
if (_types != null)
{
foreach (Type t in _types)
{
foreach (ModelJSFilePath mjsfp in t.GetCustomAttributes(typeof(ModelJSFilePath), false))
{
if (mjsfp.IsMatch(url))
{
models.Add(t);
}
}
}
foreach (Type model in models)
{
if (!securityCheck.Invoke(model, null, session, null, url, null))
{
throw new InsecureAccessException();
}
}
}
DateTime modDate = DateTime.MinValue;
foreach (Type model in models)
{
try
{
FileInfo fi = new FileInfo(model.Assembly.Location);
if (fi.Exists)
{
modDate = new DateTime(Math.Max(modDate.Ticks, fi.LastWriteTime.Ticks));
}
}
catch (Exception e) { }
}
if (modDate == DateTime.MinValue)
{
modDate = RequestHandler.StartTime;
}
if (context.Request.Headers.ContainsKey("If-Modified-Since"))
{
DateTime lastModified = DateTime.Parse(context.Request.Headers["If-Modified-Since"]);
if (modDate.ToString() == lastModified.ToString())
{
context.Response.StatusCode = 304;
return(Task.CompletedTask);
}
}
string ret = null;
context.Response.ContentType = "text/javascript";
context.Response.StatusCode = 200;
lock (_cache)
{
if (_cache.ContainsKey(url))
{
ret = _cache[url];
}
}
if (ret == null && models.Count > 0)
{
WrappedStringBuilder builder = new WrappedStringBuilder(url.ToLower().EndsWith(".min.js"));
foreach (IBasicJSGenerator gen in _oneTimeInitialGenerators)
{
gen.GeneratorJS(ref builder);
}
foreach (Type model in models)
{
foreach (IJSGenerator gen in _instanceGenerators)
{
gen.GeneratorJS(ref builder, model);
}
foreach (IJSGenerator gen in _globalGenerators)
{
gen.GeneratorJS(ref builder, model);
}
}
foreach (IBasicJSGenerator gen in _oneTimeFinishGenerators)
{
gen.GeneratorJS(ref builder);
}
ret = builder.ToString();
lock (_cache)
{
if (!_cache.ContainsKey(url))
{
_cache.Add(url, ret);
}
}
}
context.Response.Headers.Add("Last-Modified", modDate.ToUniversalTime().ToString("R"));
context.Response.Headers.Add("Cache-Control", "public");
return(context.Response.WriteAsync(ret));
}
}
