public override IProcessingContextCollection GenerateProcessingContexts(string kraftRequestFlagsKey, ISecurityModel securityModel = null)
{
Dictionary <string, object> data = ReconstructFromMultipart();
List <InputModel> inputModels = new List <InputModel>();
if (securityModel == null)
{
if (_KraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection.RequireAuthorization)
{
securityModel = new SecurityModel(_HttpContext);
}
else
{
securityModel = new SecurityModelMock(_KraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection);
}
}
InputModelParameters inputModelParameters = CreateBaseInputModelParameters(_KraftGlobalConfigurationSettings, securityModel);
inputModelParameters = ExtendInputModelParameters(inputModelParameters);
inputModelParameters.LoaderType |= ELoaderType.DataLoader; //TODO Not override passed in flags
inputModelParameters.Data = data;
_ProcessingContextCollection = new ProcessingContextCollection(CreateProcessingContexts(new List <InputModel>()
{
new InputModel(inputModelParameters)
}));
return(_ProcessingContextCollection);
}
private IProcessingContextCollection PrepareSignals(string moduleName, string signalKey, bool isWriteOperation, InputModelParameters inputModelParametersTemplate)
{
List <IProcessingContext> resultContexts = new List <IProcessingContext>();
bool isMaintenance = false;
InputModelParameters inputModelParameters = inputModelParametersTemplate.DeepClone();
if (string.IsNullOrEmpty(moduleName) || moduleName.Equals("null", StringComparison.OrdinalIgnoreCase))//Apply for all modules
{
foreach (KraftModule kraftModule in _KraftModuleCollection.GetSortedModules())
{
KraftModuleSignal signal = FindSignal(kraftModule, signalKey);
if (signal != null)
{
isMaintenance = signal.Maintenance;
if (kraftModule.KraftModuleRootConf.Signals.Count > 0)
{
resultContexts.Add(Signal2ProcessingContext(inputModelParameters, kraftModule, signal, isWriteOperation));
}
}
}
}
else
{
KraftModule kraftModule = _KraftModuleCollection.GetSortedModules().Find(m => m.Key.Equals(moduleName, StringComparison.OrdinalIgnoreCase));
KraftModuleSignal signal = FindSignal(kraftModule, signalKey);
if (signal != null)
{
isMaintenance = signal.Maintenance;
resultContexts.Add(Signal2ProcessingContext(inputModelParameters, kraftModule, signal, isWriteOperation));
}
}
_ProcessingContextCollection = new ProcessingContextCollection(resultContexts, isMaintenance);
return(_ProcessingContextCollection);
}
protected InputModelParameters ExtendInputModelParameters(InputModelParameters inputModelParameters)
{
RouteDataPrimitives routeDataPrimitives = GetRouteData();
inputModelParameters.Module = routeDataPrimitives.Module;
inputModelParameters.Nodeset = routeDataPrimitives.Nodeset;
inputModelParameters.Nodepath = routeDataPrimitives.Nodepath;
inputModelParameters.IsWriteOperation = routeDataPrimitives.IsWriteOperation;
return(inputModelParameters);
}
protected InputModelParameters CreateBaseInputModelParameters(KraftGlobalConfigurationSettings kraftGlobalConfigurationSettings, ISecurityModel securityModel)
{
InputModelParameters inputModelParameters = new InputModelParameters();
inputModelParameters.QueryCollection = _QueryCollection;
inputModelParameters.HeaderCollection = _HeaderCollection;
inputModelParameters.FormCollection = _FormCollection;
inputModelParameters.KraftGlobalConfigurationSettings = kraftGlobalConfigurationSettings;
inputModelParameters.SecurityModel = securityModel;
return(inputModelParameters);
}
private InputModel CreateInputModel(BatchRequest request, KraftGlobalConfigurationSettings kraftGlobalConfigurationSettings, string kraftRequestFlagsKey, ISecurityModel securityModel = null)
{
if (securityModel == null)
{
if (kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection.RequireAuthorization)
{
securityModel = new SecurityModel(_HttpContext);
}
else
{
securityModel = new SecurityModelMock(kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection);
}
}
InputModelParameters inputModelParameters = CreateBaseInputModelParameters(kraftGlobalConfigurationSettings, securityModel);
//we expect the routing to be like this:
//domain.com/startnode/<read|write>/module/nodeset/<nodepath>?lang=de
string decodedUrl = WebUtility.UrlDecode(request.Url);
string pattern = @"(?:http:\/\/.+?\/|https:\/\/.+?\/|www.+?\/)(?:.+?)\/(read|write)*(?:\/)*(.+?)\/(.+?)($|\/.+?)($|\?.+)";
Regex regex = new Regex(pattern);
var match = regex.Match(decodedUrl);
if (match.Groups[1] != null)
{
inputModelParameters.IsWriteOperation = match.Groups[1].Value == "write";
}
inputModelParameters.Module = match.Groups[2].Value;
inputModelParameters.Nodeset = match.Groups[3].Value;
inputModelParameters.Nodepath = string.IsNullOrEmpty(match.Groups[4].Value) ? string.Empty : match.Groups[4].Value.Substring(1);
string paramsStr = string.IsNullOrEmpty(match.Groups[5].Value) ? string.Empty : match.Groups[5].Value.Substring(1);
if (!string.IsNullOrEmpty(paramsStr))
{
string[] parameters = paramsStr.Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var parameter in parameters)
{
string[] kvp = parameter.Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
string key = kvp[0];
string value = kvp[1];
if (key.Equals(kraftRequestFlagsKey, StringComparison.CurrentCultureIgnoreCase))
{
inputModelParameters.LoaderType = GetLoaderContent(value);
}
else
{
inputModelParameters.QueryCollection.Add(key, value);
}
}
}
return(new InputModel(inputModelParameters));
}
private IProcessingContext Signal2ProcessingContext(InputModelParameters inputModelParameters, KraftModule kraftModule, KraftModuleSignal signal, bool isWriteOperation)
{
inputModelParameters.Module = kraftModule.Key;
inputModelParameters.Nodeset = signal?.NodeSet;
inputModelParameters.Nodepath = signal?.NodePath;
inputModelParameters.IsWriteOperation = isWriteOperation;
if (inputModelParameters.LoaderType == ELoaderType.None)
{
inputModelParameters.LoaderType = ELoaderType.DataLoader;
}
IProcessingContext processingContext = new ProcessingContext(this);
processingContext.InputModel = new InputModel(inputModelParameters);
return(processingContext);
}
public override IProcessingContextCollection GenerateProcessingContexts(KraftGlobalConfigurationSettings kraftGlobalConfigurationSettings, string kraftRequestFlagsKey, ISecurityModel securityModel = null)
{
if (securityModel == null)
{
if (kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection.RequireAuthorization)
{
securityModel = new SecurityModel(_HttpContext);
}
else
{
securityModel = new SecurityModelMock(kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection);
}
}
InputModelParameters inputModelParameters = CreateBaseInputModelParameters(kraftGlobalConfigurationSettings, securityModel);
inputModelParameters = ExtendInputModelParameters(inputModelParameters);
if (_RequestContentType == ESupportedContentTypes.JSON)
{
inputModelParameters.Data = GetBodyJson <Dictionary <string, object> >(_HttpContext.Request);
}
else
{
inputModelParameters.Data = _FormCollection;
}
inputModelParameters.FormCollection = _FormCollection;
inputModelParameters.LoaderType = GetLoaderType(kraftRequestFlagsKey);
RouteData routeData = _HttpContext.GetRouteData();
if (routeData != null)
{
string routeDataKey = routeData.DataTokens["key"]?.ToString()?.ToLower();
if (!string.IsNullOrEmpty(routeDataKey))
{
string signal = routeData.Values[Constants.RouteSegmentConstants.RouteModuleSignalParameter]?.ToString();
bool isWriteOperation = routeDataKey.Equals(Constants.RouteSegmentConstants.RouteDataTokenSignalWrite);
return(PrepareSignals(inputModelParameters.Module, signal, isWriteOperation, inputModelParameters));
}
}
//Return only empty collection
return(new ProcessingContextCollection(new List <IProcessingContext>()));
}
public override IProcessingContextCollection GenerateProcessingContexts(KraftGlobalConfigurationSettings kraftGlobalConfigurationSettings, string kraftRequestFlagsKey, ISecurityModel securityModel = null)
{
Dictionary <string, object> files = ResolveMultipartAsJson();
List <InputModel> inputModels = new List <InputModel>();
if (files != null)
{
foreach (string key in files.Keys)
{
if (files[key] is IPostedFile postedFile)
{
if (securityModel == null)
{
if (kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection.RequireAuthorization)
{
securityModel = new SecurityModel(_HttpContext);
}
else
{
securityModel = new SecurityModelMock(kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection);
}
}
InputModelParameters inputModelParameters = CreateBaseInputModelParameters(kraftGlobalConfigurationSettings, securityModel);
inputModelParameters = ExtendInputModelParameters(inputModelParameters);
inputModelParameters.LoaderType |= ELoaderType.DataLoader; //TODO Not override passed in flags
foreach (string metaInfoKey in postedFile.MetaInfo.Keys)
{
inputModelParameters.Data.Add(metaInfoKey, postedFile.MetaInfo[metaInfoKey]);
}
inputModelParameters.Data.Add(key, postedFile);
inputModels.Add(new InputModel(inputModelParameters));
}
}
}
_ProcessingContextCollection = new ProcessingContextCollection(CreateProcessingContexts(inputModels));
return(_ProcessingContextCollection);
}
public IProcessingContextCollection GenerateProcessingContexts(string kraftRequestFlagsKey, ISecurityModel securityModel = null)
{
InputModelParameters inputModelParameters = new InputModelParameters();
inputModelParameters.KraftGlobalConfigurationSettings = _KraftGlobalConfigurationSettings;
inputModelParameters.SecurityModel = securityModel;
inputModelParameters.Module = _InputModel.Module;
inputModelParameters.Nodeset = _InputModel.Nodeset;
inputModelParameters.Nodepath = _InputModel.Nodepath;
inputModelParameters.IsWriteOperation = _InputModel.IsWriteOperation;
inputModelParameters.QueryCollection = _InputModel.QueryCollection;
inputModelParameters.Data = _InputModel.Data;
inputModelParameters.LoaderType = ELoaderType.DataLoader;
IProcessingContext processingContext = new ProcessingContext(this);
processingContext.InputModel = new InputModel(inputModelParameters);
List <IProcessingContext> processingContexts = new List <IProcessingContext>(1);
processingContexts.Add(processingContext);
return(new ProcessingContextCollection(processingContexts));
}
public override IProcessingContextCollection GenerateProcessingContexts(KraftGlobalConfigurationSettings kraftGlobalConfigurationSettings, string kraftRequestFlagsKey, ISecurityModel securityModel = null)
{
if (securityModel == null)
{
if (kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection.RequireAuthorization)
{
securityModel = new SecurityModel(_HttpContext);
}
else
{
securityModel = new SecurityModelMock(kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection);
}
}
InputModelParameters inputModelParameters = CreateBaseInputModelParameters(kraftGlobalConfigurationSettings, securityModel);
inputModelParameters = ExtendInputModelParameters(inputModelParameters);
inputModelParameters.Data = GetBodyJson <Dictionary <string, object> >(_HttpContext.Request);
inputModelParameters.FormCollection = _FormCollection;
inputModelParameters.LoaderType = GetLoaderType(kraftRequestFlagsKey);
if (inputModelParameters.LoaderType == ELoaderType.None)
{
inputModelParameters.LoaderType = ELoaderType.ViewLoader;
}
RouteData routeData = _HttpContext.GetRouteData();
if (routeData != null)
{
inputModelParameters.BindingKey = routeData.Values[Constants.RouteSegmentConstants.RouteBindingkey] as string;
}
IProcessingContext processingContext = new ProcessingContext(this);
processingContext.InputModel = new InputModel(inputModelParameters);
List <IProcessingContext> processingContexts = new List <IProcessingContext>(1);
processingContexts.Add(processingContext);
_ProcessingContextCollection = new ProcessingContextCollection(processingContexts);
return(_ProcessingContextCollection);
}
public override IProcessingContextCollection GenerateProcessingContexts(KraftGlobalConfigurationSettings kraftGlobalConfigurationSettings, string kraftRequestFlagsKey, ISecurityModel securityModel = null)
{
if (securityModel == null)
{
if (kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection.RequireAuthorization)
{
securityModel = new SecurityModel(_HttpContext);
}
else
{
securityModel = new SecurityModelMock(kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection);
}
}
InputModelParameters inputModelParameters = CreateBaseInputModelParameters(kraftGlobalConfigurationSettings, securityModel);
inputModelParameters = ExtendInputModelParameters(inputModelParameters);
inputModelParameters.Data = GetBodyJson <Dictionary <string, object> >(_HttpContext.Request);
inputModelParameters.FormCollection = _FormCollection;
inputModelParameters.LoaderType = GetLoaderType(kraftRequestFlagsKey);
_ProcessingContextCollection = new ProcessingContextCollection(CreateProcessingContexts(new List <InputModel> {
new InputModel(inputModelParameters)
}));
return(_ProcessingContextCollection);
}
/// <summary>
/// Calls and executes plugin.
/// </summary>
/// <param name="execContext">Data loader context.</param>
/// <param name="parameters">Dictionary or custom parameters of the Call Data Loader.</param>
/// <param name="isWriteOperation">boolean parameter - the type of operation.</param>
/// <returns>The called plugin result.</returns>
private List <Dictionary <string, object> > ExecuteOperation(IDataLoaderContext execContext, Dictionary <string, object> parameters, bool isWriteOperation)
{
List <Dictionary <string, object> > result = new List <Dictionary <string, object> >();
CustomSettings customSettings = new CustomSettings(execContext, isWriteOperation);
if (execContext.ProcessingContext.InputModel.ProcessingContextRef is RequestExecutor requestExecutor)
{
parameters = ConcatDictionaries(parameters, GetChildrenFromKeyRecursive(execContext.ProcessingContext.InputModel.Data, execContext.CurrentNode.NodeKey) as IDictionary <string, object>);
object getChildren = GetChildrenFromKeyRecursive(execContext.ProcessingContext.InputModel.Data, execContext.CurrentNode.NodeKey);
if (getChildren != null && getChildren is IDictionary <string, object> children)
{
parameters = ConcatDictionaries(parameters, children);
}
else
{
parameters = ConcatDictionaries(parameters, execContext.ProcessingContext.InputModel.Data);
KraftLogger.LogDebug($"Key '{execContext.CurrentNode.NodeKey}' was not passed in the request data. The CallDataLoader will be executed with input model's data. For the request to node '{execContext.ProcessingContext.InputModel.Module}.{execContext.ProcessingContext.InputModel.NodeSet}.{execContext.CurrentNode.NodeKey}'.");
}
InputModelParameters inputModelParameters = new InputModelParameters()
{
Module = customSettings.ModuleValue,
Nodeset = customSettings.NodesetValue,
Nodepath = customSettings.NodepathValue,
Data = parameters,
FormCollection = execContext.ParentResult,
KraftGlobalConfigurationSettings = execContext.ProcessingContext.InputModel.KraftGlobalConfigurationSettings,
IsWriteOperation = customSettings.OperationValue,
LoaderType = execContext.ProcessingContext.InputModel.LoaderType,
SecurityModel = execContext.ProcessingContext.InputModel.SecurityModel,
Server = execContext.ProcessingContext.InputModel.Server != default(ReadOnlyDictionary <string, object>) ? execContext.ProcessingContext.InputModel.Server.ToDictionary(item => item.Key, item => item.Value) : null
};
IProcessingContext processingContext = new ProcessingContext(execContext.ProcessingContext.ProcessorHandler)
{
InputModel = new InputModel(inputModelParameters)
};
requestExecutor.ExecuteReEntrance(processingContext, false);
if (!processingContext.ReturnModel.Status.IsSuccessful)
{
string message = string.Empty;
string space = " ";
execContext.ProcessingContext.ReturnModel.Status.IsSuccessful = processingContext.ReturnModel.Status.IsSuccessful;
processingContext.ReturnModel.Status.StatusResults.ForEach(statusResult =>
{
if (message.Length != 0)
{
message += space + statusResult.Message;
}
else
{
message += statusResult.Message;
}
});
throw new Exception(message);
}
if (processingContext.ReturnModel.Data is List <Dictionary <string, object> > resultListOfDictionary)
{
result = resultListOfDictionary;
}
else if (processingContext.ReturnModel.Data is Dictionary <string, object> resultDictionary)
{
result.Add(resultDictionary);
}
}
return(result);
}
