public static Basics.Execution.Bind RenderBind(Basics.Execution.Bind bind, IController parent, Global.ArgumentInfoCollection contentArguments, string requesterUniqueID)
{
if (bind == null)
{
return(null);
}
if (bind.Parameters.Count == 0)
{
return(bind);
}
string[] parameters = new string[bind.Parameters.Count];
// Render Params One By One (this render process is mainly controls with bind which fired when a control get interaction with user)
// The aim is rendering static values comes from dinamic ones like =$#SomeID$
for (int pC = 0; pC < bind.Parameters.Count; pC++)
{
parameters[pC] = ControllerHelper.RenderSingleContent(
bind.Parameters[pC].Query,
parent,
contentArguments,
requesterUniqueID
);
}
bind.Parameters.Override(parameters);
return(bind);
}
private void HandlexSocketRequest()
{
this.Context.Response.Header.AddOrUpdate("Content-Type", this._DomainControl.ServiceMimeType);
this.Context.Response.Header.AddOrUpdate("Content-Encoding", "identity");
// Decode Encoded Call Function to Readable
Basics.Execution.Bind bind =
this._DomainControl.GetxSocketBind();
bind.Parameters.Prepare(
(parameter) =>
{
Property property = new Property(0, parameter.Query, null);
property.InstanceRequested += (ref Basics.Domain.IDomain instance) => instance = this._DomainControl.Domain;
property.Setup();
property.Render(null);
return(property.ObjectResult);
}
);
List <KeyValuePair <string, object> > keyValueList = new List <KeyValuePair <string, object> >();
foreach (Basics.Execution.ProcedureParameter item in bind.Parameters)
{
keyValueList.Add(new KeyValuePair <string, object>(item.Key, item.Value));
}
IHttpContext context = this.Context;
SocketObject xSocketObject =
new SocketObject(ref context, keyValueList.ToArray());
bind.Parameters.Override(new string[] { "xso" });
bind.Parameters.Prepare(
(parameter) => xSocketObject
);
Basics.Execution.InvokeResult <object> invokeResult =
Manager.AssemblyCore.InvokeBind <object>(Helpers.Context.Request.Header.Method, bind, Manager.ExecuterTypes.Undefined);
if (invokeResult.Exception != null)
{
throw new Exception.ServiceSocketException(invokeResult.Exception.ToString());
}
if (invokeResult.Result is Message)
{
Message MessageResult =
(Message)invokeResult.Result;
if (MessageResult.Type == Message.Types.Error)
{
throw new Exception.ServiceSocketException(MessageResult.Content);
}
}
}
private void HandlexSocketRequest()
{
this.Context.Response.Header.AddOrUpdate("Content-Type", this._DomainControl.ServiceMimeType);
this.Context.Response.Header.AddOrUpdate("Content-Encoding", "identity");
// Decode Encoded Call Function to Readable
Basics.Execution.Bind bind =
this._DomainControl.GetxSocketBind();
bind.Parameters.Prepare(
parameter => Property.Render(null, parameter.Query).Item2
);
List <KeyValuePair <string, object> > keyValueList = new List <KeyValuePair <string, object> >();
foreach (Basics.Execution.ProcedureParameter item in bind.Parameters)
{
keyValueList.Add(new KeyValuePair <string, object>(item.Key, item.Value));
}
IHttpContext context = this.Context;
SocketObject xSocketObject =
new SocketObject(ref context, keyValueList.ToArray());
bind.Parameters.Override(new [] { "xso" });
bind.Parameters.Prepare(
parameter => xSocketObject
);
Basics.Execution.InvokeResult <object> invokeResult =
Web.Manager.Executer.InvokeBind <object>(Helpers.Context.Request.Header.Method, bind, Web.Manager.ExecuterTypes.Undefined);
if (invokeResult.Exception != null)
{
throw new Exceptions.ServiceSocketException(invokeResult.Exception.ToString());
}
if (!(invokeResult.Result is Message messageResult))
{
return;
}
if (messageResult.Type == Message.Types.Error)
{
throw new Exceptions.ServiceSocketException(messageResult.Content);
}
}
private Basics.TranslationResult Translate(string translationId)
{
if (string.IsNullOrEmpty(this._Owner.Settings.Configurations.LanguageExecutable))
{
return(new Basics.TranslationResult(false, string.Empty));
}
Basics.Execution.Bind translatorBind =
Basics.Execution.Bind.Make($"{this._Owner.Settings.Configurations.LanguageExecutable}?Translate,p1|p2");
translatorBind.Parameters.Prepare(
parameter =>
{
return(parameter.Key switch
{
"p1" => this._Language.Info.Id,
"p2" => translationId,
_ => string.Empty
});
}
public Basics.RenderResult Render(string executeIn, string serviceId)
{
// call = Calling Function Providing in Query String
Basics.Execution.Bind bind =
Basics.Execution.Bind.Make(
string.Format(
"{0}?{1}.{2},~xParams",
executeIn,
serviceId,
Basics.Helpers.Context.Request.QueryString["call"]
)
);
bind.Parameters.Prepare(
parameter =>
{
Basics.X.ServiceParameterCollection serviceParameterCol =
new Basics.X.ServiceParameterCollection();
try
{
serviceParameterCol.ParseXml(
Basics.Helpers.Context.Request.Body.Form[parameter.Key]);
}
catch
{ /* Just handle Exceptions */ }
return(serviceParameterCol);
}
);
Basics.Execution.InvokeResult <object> invokeResult =
Manager.Executer.InvokeBind <object>(Basics.Helpers.Context.Request.Header.Method, bind, Manager.ExecuterTypes.Undefined);
return(this.GenerateXml(invokeResult.Result));
}
private PermissionResult EnsurePermission()
{
this.Mother.RequestInstance(out IDomain instance);
if (string.IsNullOrEmpty(instance.Settings.Configurations.SecurityExecutable))
{
return(new PermissionResult(PermissionResult.Results.Forbidden));
}
Basics.Execution.Bind permissionBind =
Basics.Execution.Bind.Make($"{instance.Settings.Configurations.SecurityExecutable}?EnsurePermission,p1");
permissionBind.Parameters.Prepare(parameter => this.DirectiveId);
permissionBind.InstanceExecution = true;
Basics.Execution.InvokeResult <PermissionResult> permissionInvokeResult =
Manager.Executer.InvokeBind <PermissionResult>(Helpers.Context.Request.Header.Method, permissionBind, Manager.ExecuterTypes.Undefined);
if (permissionInvokeResult.Result == null || permissionInvokeResult.Exception != null)
{
return(new PermissionResult(PermissionResult.Results.Forbidden));
}
return(permissionInvokeResult.Result);
}
private void HandleTemplateRequest()
{
Message messageResult = null;
string methodResult = string.Empty;
string encryptedBindInformation =
this.Context.Request.Body.Form[$"_sys_bind_{this.Context.HashCode}"];
if (this.Context.Request.Header.Method == HttpMethod.POST &&
!string.IsNullOrEmpty(encryptedBindInformation))
{
// Decode Encoded Call Function to Readable
string bindInformation =
this._DomainControl.Cryptography.Decrypt(encryptedBindInformation);
if (string.IsNullOrEmpty(bindInformation))
{
this.Context.AddOrUpdate(
"RedirectLocation",
Helpers.CreateUrl(
false,
this._DomainControl.Domain.Settings.Configurations.DefaultTemplate
)
);
return;
}
Basics.Execution.Bind bind =
Basics.Execution.Bind.Make(bindInformation);
bind.Parameters.Prepare(
parameter => Property.Render(null, parameter.Query).Item2
);
Basics.Execution.InvokeResult <object> invokeResult =
Web.Manager.Executer.InvokeBind <object>(Helpers.Context.Request.Header.Method, bind, Web.Manager.ExecuterTypes.Undefined);
if (invokeResult.Exception != null)
{
messageResult = new Message(invokeResult.Exception.ToString());
}
else if (invokeResult.Result is Message message)
{
messageResult = message;
}
else if (invokeResult.Result is RedirectOrder redirectOrder)
{
this.Context.AddOrUpdate("RedirectLocation", redirectOrder.Location);
}
else
{
methodResult = Web.Manager.Executer.GetPrimitiveValue(invokeResult.Result);
}
}
if (!string.IsNullOrEmpty((string)this.Context["RedirectLocation"]))
{
return;
}
// Create HashCode for request and apply to Url
if (this.Context.Request.Header.Method == HttpMethod.GET)
{
string applicationRootPath =
Configurations.Xeora.Application.Main.ApplicationRoot.BrowserImplementation;
string currentUrl = this.Context.Request.Header.Url.RelativePath;
currentUrl = currentUrl.Remove(0, currentUrl.IndexOf(applicationRootPath, StringComparison.InvariantCulture));
Match mR =
Regex.Match(currentUrl, $"{applicationRootPath}\\d+/");
// Not assigned, so assign!
if (!mR.Success)
{
string tailUrl = this.Context.Request.Header.Url.RelativePath;
tailUrl = tailUrl.Remove(0, tailUrl.IndexOf(applicationRootPath, StringComparison.InvariantCulture) + applicationRootPath.Length);
string rewrittenPath =
$"{applicationRootPath}{this.Context.HashCode}/{tailUrl}";
if (!string.IsNullOrEmpty(this.Context.Request.Header.Url.QueryString))
{
rewrittenPath = $"{rewrittenPath}?{this.Context.Request.Header.Url.QueryString}";
}
this.Context.Request.RewritePath(rewrittenPath);
}
}
this.CreateTemplateResult(messageResult, methodResult);
}
private void HandleTemplateRequest()
{
Message messageResult = null;
string methodResult = string.Empty;
string bindInformation =
this.Context.Request.Body.Form[string.Format("_sys_bind_{0}", this.Context.HashCode)];
if (this.Context.Request.Header.Method == HttpMethod.POST &&
!string.IsNullOrEmpty(bindInformation))
{
// Decode Encoded Call Function to Readable
Basics.Execution.Bind bind =
Basics.Execution.Bind.Make(
Manager.AssemblyCore.DecodeFunction(bindInformation));
bind.Parameters.Prepare(
(parameter) =>
{
Property property = new Property(0, parameter.Query, null);
property.InstanceRequested += (ref Basics.Domain.IDomain instance) => instance = this._DomainControl.Domain;
property.Setup();
property.Render(null);
return(property.ObjectResult);
}
);
Basics.Execution.InvokeResult <object> invokeResult =
Manager.AssemblyCore.InvokeBind <object>(Helpers.Context.Request.Header.Method, bind, Manager.ExecuterTypes.Undefined);
if (invokeResult.Exception != null)
{
messageResult = new Message(invokeResult.Exception.ToString());
}
else if (invokeResult.Result != null && invokeResult.Result is Message)
{
messageResult = (Message)invokeResult.Result;
}
else if (invokeResult.Result != null && invokeResult.Result is RedirectOrder)
{
this.Context.AddOrUpdate("RedirectLocation", ((RedirectOrder)invokeResult.Result).Location);
}
else
{
methodResult = Manager.AssemblyCore.GetPrimitiveValue(invokeResult.Result);
}
}
if (string.IsNullOrEmpty((string)this.Context["RedirectLocation"]))
{
// Create HashCode for request and apply to URL
if (this.Context.Request.Header.Method == HttpMethod.GET)
{
string applicationRootPath =
Configurations.Xeora.Application.Main.ApplicationRoot.BrowserImplementation;
string currentURL = this.Context.Request.Header.URL.RelativePath;
currentURL = currentURL.Remove(0, currentURL.IndexOf(applicationRootPath));
System.Text.RegularExpressions.Match mR =
System.Text.RegularExpressions.Regex.Match(currentURL, string.Format("{0}\\d+/", applicationRootPath));
// Not assigned, so assign!
if (!mR.Success)
{
string tailURL = this.Context.Request.Header.URL.RelativePath;
tailURL = tailURL.Remove(0, tailURL.IndexOf(applicationRootPath) + applicationRootPath.Length);
string rewrittenPath =
string.Format("{0}{1}/{2}", applicationRootPath, this.Context.HashCode, tailURL);
if (!string.IsNullOrEmpty(this.Context.Request.Header.URL.QueryString))
{
rewrittenPath = string.Format("{0}?{1}", rewrittenPath, this.Context.Request.Header.URL.QueryString);
}
this.Context.Request.RewritePath(rewrittenPath);
}
}
this.CreateTemplateResult(messageResult, methodResult);
}
}
public static Basics.Execution.InvokeResult <T> InvokeBind <T>(Basics.Context.Request.HttpMethod httpMethod, Basics.Execution.Bind bind, ExecuterTypes executerType)
{
if (bind == null)
{
throw new NoNullAllowedException("Requires bind!");
}
// Check if BindInfo Parameters has been parsed!
if (!bind.Ready)
{
throw new Exception("Bind Parameters should be parsed first!");
}
DateTime executionBegins = DateTime.Now;
Basics.Execution.InvokeResult <T> rInvokeResult =
new Basics.Execution.InvokeResult <T>(bind);
object invokedObject =
ApplicationFactory.Prepare(bind.Executable).Invoke(
httpMethod,
bind.Classes,
bind.Procedure,
bind.Parameters.Values,
bind.InstanceExecution,
executerType
);
if (invokedObject is Exception exception)
{
rInvokeResult.Exception = exception;
}
else
{
rInvokeResult.Result = (T)invokedObject;
}
if (!Basics.Configurations.Xeora.Application.Main.PrintAnalysis)
{
return(rInvokeResult);
}
double totalMs =
DateTime.Now.Subtract(executionBegins).TotalMilliseconds;
Basics.Console.Push(
"analysed - execution duration",
$"{totalMs}ms - {bind}",
string.Empty, false, groupId: Basics.Helpers.Context.UniqueId,
type: totalMs > Basics.Configurations.Xeora.Application.Main.AnalysisThreshold ? Basics.Console.Type.Warn: Basics.Console.Type.Info);
return(rInvokeResult);
}
// This function is for external call out side of the project DO NOT DISABLE IT public static Basics.Execution.InvokeResult <T> InvokeBind <T>(Basics.Context.Request.HttpMethod httpMethod, Basics.Execution.Bind bind) => Executer.InvokeBind <T>(httpMethod, bind, ExecuterTypes.Undefined);
private void RenderInternal(string requesterUniqueID)
{
string[] controlValueSplitted = this.Value.Split(':');
// Call Related Function and Exam It
IController leveledController = this;
int level = this.Leveling.Level;
do
{
if (level == 0)
{
break;
}
leveledController = leveledController.Parent;
if (leveledController is Renderless)
{
leveledController = leveledController.Parent;
}
level -= 1;
} while (leveledController != null);
Basics.Execution.Bind bind =
Basics.Execution.Bind.Make(string.Join(":", controlValueSplitted, 1, controlValueSplitted.Length - 1));
// Execution preparation should be done at the same level with it's parent. Because of that, send parent as parameters
bind.Parameters.Prepare(
(parameter) =>
{
Property property = new Property(0, parameter.Query, (leveledController.Parent == null ? null : leveledController.Parent.ContentArguments));
property.Mother = leveledController.Mother;
property.Parent = leveledController.Parent;
property.InstanceRequested += (ref Basics.Domain.IDomain instance) => InstanceRequested?.Invoke(ref instance);
property.Setup();
property.Render(requesterUniqueID);
return(property.ObjectResult);
}
);
Basics.Execution.InvokeResult <object> invokeResult =
Manager.AssemblyCore.InvokeBind <object>(Basics.Helpers.Context.Request.Header.Method, bind, Manager.ExecuterTypes.Other);
if (invokeResult.Exception != null)
{
throw new Exception.ExecutionException(invokeResult.Exception.Message, invokeResult.Exception.InnerException);
}
if (invokeResult.Result != null && invokeResult.Result is Basics.ControlResult.RedirectOrder)
{
Helpers.Context.AddOrUpdate("RedirectLocation",
((Basics.ControlResult.RedirectOrder)invokeResult.Result).Location);
this.RenderedValue = string.Empty;
return;
}
this.RenderedValue = Manager.AssemblyCore.GetPrimitiveValue(invokeResult.Result);
}
public static Basics.Execution.InvokeResult <T> InvokeBind <T>(Basics.Context.HttpMethod httpMethod, Basics.Execution.Bind bind, ExecuterTypes executerType)
{
if (bind == null)
{
throw new NoNullAllowedException("Requires bind!");
}
// Check if BindInfo Parameters has been parsed!
if (!bind.Ready)
{
throw new System.Exception("Bind Parameters shoud be parsed first!");
}
Basics.Execution.InvokeResult <T> rInvokeResult =
new Basics.Execution.InvokeResult <T>(bind);
try
{
object invokedObject =
Application.Prepare(bind.Executable).Invoke(
httpMethod,
bind.Classes,
bind.Procedure,
bind.Parameters.Values,
bind.InstanceExecution,
executerType
);
if (invokedObject is System.Exception)
{
throw (System.Exception)invokedObject;
}
rInvokeResult.Result = (T)invokedObject;
}
catch (System.Exception ex)
{
Helper.EventLogger.Log(ex);
rInvokeResult.Exception = ex;
}
return(rInvokeResult);
}
