public static bool TryTransform(IComponentContext ctx, IContext context, out ITransform transform)
{
transform = null;
var success = true;
if (ctx.IsRegisteredWithName <ITransform>(context.Operation.Method))
{
var t = ctx.ResolveNamed <ITransform>(context.Operation.Method, new PositionalParameter(0, context));
foreach (var warning in t.Warnings())
{
context.Warn(warning);
}
if (t.Errors().Any())
{
foreach (var error in t.Errors())
{
context.Error(error);
}
success = false;
}
else
{
transform = t;
}
}
else
{
if (ctx.IsRegisteredWithName <ITransform>(context.Operation.Key))
{
var t = ctx.ResolveNamed <ITransform>(context.Operation.Key, new PositionalParameter(0, context));
foreach (var warning in t.Warnings())
{
context.Warn(warning);
}
if (t.Errors().Any())
{
foreach (var error in t.Errors())
{
context.Error(error);
}
success = false;
}
else
{
transform = t;
}
}
else
{
context.Error($"The {context.Operation.Method} method used in the {context.Field.Alias} field is not registered.");
success = false;
}
}
return(success);
}
public GojekBasePageView ResolvePage <T>(string name, NavigationParameters parameters = null)
where T : GojekBasePageViewModel
{
var viewName = _namingConventions.GetViewName(name);
if (!_componentContext.IsRegisteredWithName <GojekBasePageView>(viewName))
{
return(null);
}
var page = _componentContext.ResolveNamed <GojekBasePageView>(viewName);
var viewModelName = _namingConventions.GetViewModelName(name);
if (!_componentContext.IsRegisteredWithName <GojekBasePageViewModel>(viewModelName))
{
return(page);
}
var viewModel = _componentContext.ResolveNamed <GojekBasePageViewModel>(viewModelName);
//assign current page navigator, dialoger
viewModel.Navigator = _componentContext.Resolve <ICrossNavigator>();
viewModel.Dialoger = _componentContext.Resolve <ICrossDialogProvider>();
#region title
//set an toan truong hop quen dat title cho mot trang nao do trong resource
if (!string.IsNullOrEmpty(viewModel.Title))
{
viewModel.Title = viewModel.Title;
}
NavigationPage.SetHasNavigationBar(page, viewModel.HasNavigationBar);
NavigationPage.SetHasBackButton(page, viewModel.HasBackButton);
NavigationPage.SetBackButtonTitle(page, viewModel.BackButtonTitle);
#endregion
//call init before page appearing only if parameter not null
if (parameters != null)
{
page.OnInitializeView(parameters: parameters);
viewModel.OnInitializeViewModel(parameters: parameters);
}
//extension bind viewmodel => view (page)
page.BindCrossPageViewModel <T>(viewModel);
return(page);
}
public static bool TryValidator(IComponentContext ctx, IContext context, out IValidate validator)
{
validator = null;
var result = true;
if (ctx.IsRegisteredWithName <IValidate>(context.Operation.Method))
{
var v = ShouldRunValidator(ctx, context);
foreach (var warning in v.Warnings())
{
context.Warn(warning);
}
if (v.Errors().Any())
{
foreach (var error in v.Errors())
{
context.Error(error);
}
result = false;
}
else
{
validator = v;
}
}
else
{
context.Error($"The {context.Operation.Method} method used in the {context.Field.Alias} field is not registered.");
result = false;
}
return(result);
}
public void Run(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
if (args != null && args.Length > 1)
{
if (_container.IsRegisteredWithName <IPlugin>(args[0]))
{
var plugin = _container.ResolveNamed <IPlugin>(args[0]);
plugin.Run(
args
.Select(a => a)
.Skip(1)
.ToArray()
);
}
else
{
var msg = String.Format("Das Plugin {0} ist im DI-Container nicht (als IPlugin) registriert (Tippfehler?).",
args[0]);
_logger.Log(LogLevel.Error, msg);
}
}
else
{
_logger.Log(LogLevel.Warn,
args == null
? "Es wurden keine auswertbaren Parameter angegeben."
: args.Length < 2
? "Es wurden weniger als zwei Argumente angegeben (TaskRunner <Plugin> <Task>)."
: "");
}
}
// this is confusing, refactor
private static Process GetProcess(IComponentContext ctx, IEnumerable <Parameter> p, IEnumerable <IDependency> dependencies, string cfg = null)
{
var process = new Process(dependencies.ToArray());
if (cfg != null)
{
process.Load(cfg);
return(process);
}
switch (p.Count())
{
case 2:
process.Load(
p.Named <string>("cfg"),
p.Named <Dictionary <string, string> >("parameters")
);
return(process);
case 1:
process.Load(p.Named <string>("cfg"));
return(process);
default:
if (ctx.IsRegisteredWithName <string>("cfg"))
{
process.Load(ctx.ResolveNamed <string>("cfg"));
return(process);
}
return(process); // unloaded
}
}
public static bool TryTransform(IComponentContext ctx, IContext context, out ITransform transform)
{
transform = null;
var success = true;
if (ctx.IsRegisteredWithName <ITransform>(context.Operation.Method))
{
var t = ShouldRunTransform(ctx, context);
foreach (var warning in t.Warnings())
{
context.Warn(warning);
}
if (t.Errors().Any())
{
foreach (var error in t.Errors())
{
context.Error(error);
}
success = false;
}
else
{
transform = t;
}
}
else
{
context.Error(string.Format("The {0} method used in the {1} field is not registered.", context.Operation.Method, context.Field.Alias));
success = false;
}
return(success);
}
// this is confusing, refactor
private static Process GetProcess(IComponentContext ctx, IEnumerable <Parameter> p, IEnumerable <IDependency> dependencies, string cfg = null)
{
var process = new Process(dependencies.ToArray());
if (cfg != null)
{
process.Load(cfg);
return(process);
}
switch (p.Count())
{
case 2:
process.Load(
p.Named <string>("cfg"),
p.Named <Dictionary <string, string> >("parameters")
);
return(process);
case 1:
process.Load(p.Named <string>("cfg"));
return(process);
default:
if (ctx.IsRegisteredWithName <string>("cfg"))
{
process.Load(ctx.ResolveNamed <string>("cfg"));
return(process);
}
throw new Exception("Configuration Container could not find the configuration! Pass in or register a `cfg` string.");
}
}
public object GetService(Type serviceType, string alias)
{
if (!_componentContext.IsRegisteredWithName(alias, serviceType))
{
return(null);
}
return(_componentContext.ResolveNamed(alias, serviceType));
}
/// <summary>
/// Resolve a <see cref="Page"/> from <see cref="_context"/> for <paramref name="segmentName"/>
/// </summary>
/// <param name="segmentName">Page to resolve</param>
/// <returns>A <see cref="Page"/></returns>
protected override Page CreatePage(string segmentName)
{
if (!_context.IsRegisteredWithName <Page>(segmentName))
{
throw new NullReferenceException($"The requested page '{segmentName}' has not been registered.");
}
return(_context.ResolveNamed <Page>(segmentName));
}
public virtual bool IsRegistered(Type type, string name = null)
{
if (string.IsNullOrEmpty(name))
{
return(context.IsRegistered(type));
}
else
{
return(context.IsRegisteredWithName(name, type));
}
}
public static IEnumerable <ITransform> GetTransforms(IComponentContext ctx, IContext context, IEnumerable <Field> fields)
{
var transforms = new List <ITransform>();
foreach (var f in fields.Where(f => f.Transforms.Any() || f.Validators.Any()))
{
var field = f;
foreach (var t in field.Transforms)
{
// Javascript Switcher supports limited types, use Jint if unsupported types and jint is registered (it's a plugin)
if (JsMethods.Contains(t.Method) && JsEngines.Contains(field.Engine))
{
if (ctx.IsRegisteredWithName <ITransform>("jint"))
{
var types = context.Entity.GetFieldMatches(t.Script).Select(mf => mf.Type).Distinct();
if (types.Any(type => !JsStrictTypeSet.Contains(type)))
{
t.Method = "jint";
context.Warn($"Un-supported types found. Switching javascript engine to jint for field {field.Alias}");
}
}
}
if (t.Method == "convert" && t.Type == "string" && t.Format != string.Empty)
{
t.Method = "tostring";
}
var transformContext = new PipelineContext(ctx.Resolve <IPipelineLogger>(), context.Process, context.Entity, field, t);
if (TryTransform(ctx, transformContext, out var add))
{
transforms.Add(add);
}
}
// add conversion if necessary
if (transforms.Any())
{
var lastType = transforms.Last().Returns;
if (lastType != null && lastType != "object" && field.Type != lastType)
{
context.Warn($"The output field {field.Alias} is not setup to receive a {lastType} type. It expects a {field.Type}. Adding conversion.");
transforms.Add(new ConvertTransform(new PipelineContext(ctx.Resolve <IPipelineLogger>(), context.Process, context.Entity, field, new Operation {
Method = "convert"
})));
}
}
}
return(transforms);
}
public Page ResolvePage(string pageName)
{
string viewName = GetViewName(pageName);
if (!_componentContext.IsRegisteredWithName <Page>(viewName))
{
return(null);
}
var page = _componentContext.ResolveNamed <Page>(viewName);
string viewModelName = GetViewModelName(pageName);
if (_componentContext.IsRegisteredWithName <ViewModelBase>(viewModelName))
{
var viewModel = _componentContext.ResolveNamed <ViewModelBase>(viewModelName);
viewModel.Navigator = _componentContext.Resolve <INavigator>();
viewModel.Title = GetViewModelTitle(pageName);
page.BindingContext = viewModel;
}
return(page);
}
public override Boolean CanSupplyValue(ParameterInfo pi,
IComponentContext context,
out Func <Object> valueProvider)
{
if (pi.ParameterType.IsValueType &&
context.IsRegisteredWithName(pi.Name, pi.ParameterType))
{
valueProvider = () => context.ResolveNamed(pi.Name, pi.ParameterType);
return(true);
}
else
{
valueProvider = null;
return(false);
}
}
private static void Executing(ILogger logger, IComponentContext componentContext, string serviceName)
{
try
{
//var openType = typeof(IRequestHandler); // Generic open type.
var type = typeof(IRequestHandler); // Type is your runtime type.
if (!componentContext.IsRegisteredWithName <IRequestHandler>(serviceName))
{
logger.LogError("Execute: " + type.FullName + " - " + serviceName + " not registered!");
return;
}
try
{
var requestHandler = componentContext.ResolveNamed <IRequestHandler>(serviceName);
var methodInfo = type.GetMethod("Execute");
//logger.LogTrace("Execute: " + type.Name + " - " + serviceName + " Response: void");
if (methodInfo != null)
{
methodInfo.Invoke(requestHandler, null);
}
}
catch (Exception ex)
{
throw LogExceptionManager.LogException(logger, ex);
}
}
catch (Exception eex)
{
if (eex.InnerException != null)
{
throw eex.InnerException;
}
throw;
}
}
private static async ValueTask ExecutingAsync(ILogger logger, IComponentContext componentContext, string serviceName, CancellationToken cancellationToken = default)
{
try
{
var type = typeof(IRequestHandlerAsync); // Type is your runtime type.
if (!componentContext.IsRegisteredWithName <IRequestHandlerAsync>(serviceName))
{
logger.LogError("ExecuteAsync: " + type.FullName + " - " + serviceName + " not registered!");
return;
}
try
{
var requestHandler = componentContext.ResolveNamed <IRequestHandlerAsync>(serviceName);
var methodInfo = type.GetMethod("ExecuteAsync");
//logger.LogTrace("ExecuteAsync: " + type.Name + " - " + serviceName + " Response: ValueTask");
if (methodInfo != null)
{
await((ValueTask)methodInfo.Invoke(requestHandler, new[] { (object)cancellationToken })).ConfigureAwait(false);
}
}
catch (Exception ex)
{
throw LogExceptionManager.LogException(logger, ex);
}
}
catch (Exception eex)
{
if (eex.InnerException != null)
{
throw eex.InnerException;
}
throw;
}
}
public static void AssertRegisteredNamed <TService>(this IComponentContext context, string service, string message = "Expected named component was not registered.")
{
Assert.True(context.IsRegisteredWithName(service, typeof(TService)), message);
}
public static void AssertRegistered <TService>(this IComponentContext context, string service)
{
Assert.IsTrue(context.IsRegisteredWithName(service, typeof(TService)));
}
public bool IsRegistered <T>(string name)
{
return(_container.IsRegisteredWithName <T>(name));
}
private static string TransformConfiguration(IComponentContext ctx)
{
// short hand for parameters is defined, try to transform parameters in advance
if (!ctx.IsRegisteredWithName <IDependency>("shorthand-p"))
{
return(null);
}
if (!ctx.IsRegisteredWithName <string>("cfg"))
{
return(null);
}
var dependencies = new List <IDependency> {
ctx.Resolve <IReader>(),
new DateMathModifier(),
new EnvironmentModifier(new NullPlaceHolderReplacer()),
ctx.ResolveNamed <IDependency>("shorthand-p")
};
var preCfg = ctx.ResolveNamed <string>("cfg");
var preProcess = new ConfigurationFacade.Process(preCfg, new Dictionary <string, string>(), dependencies.ToArray());
var parameters = preProcess.GetActiveParameters();
if (!parameters.Any(pr => pr.Transforms.Any()))
{
return(null);
}
var fields = parameters.Select(pr => new Field {
Name = pr.Name,
Alias = pr.Name,
Default = pr.Value,
Type = pr.Type,
Transforms = pr.Transforms.Select(o => o.ToOperation()).ToList()
}).ToList();
var len = fields.Count;
var entity = new Entity {
Name = "Parameters", Alias = "Parameters", Fields = fields
};
var mini = new Process {
Name = "ParameterTransform",
ReadOnly = true,
Entities = new List <Entity> {
entity
},
Maps = preProcess.Maps.Select(m => m.ToMap()).ToList(), // for map transforms
Scripts = preProcess.Scripts.Select(s => s.ToScript()).ToList() // for transforms that use scripts (e.g. js)
};
mini.Check(); // very important to check after creating, as it runs validation and even modifies!
if (!mini.Errors().Any())
{
// modification in Check() do not make it out to local variables so overwrite them
fields = mini.Entities.First().Fields;
entity = mini.Entities.First();
var transforms = TransformFactory.GetTransforms(ctx, new PipelineContext(ctx.Resolve <IPipelineLogger>(), mini, entity), fields);
// make an input out of the parameters
var input = new List <IRow>();
var row = new MasterRow(len);
for (var i = 0; i < len; i++)
{
row[fields[i]] = parameters[i].Value;
}
input.Add(row);
var output = transforms.Aggregate(input.AsEnumerable(), (rows, t) => t.Operate(rows)).ToList().First();
for (var i = 0; i < len; i++)
{
var parameter = parameters[i];
parameter.Value = output[fields[i]].ToString();
parameter.T = string.Empty;
parameter.Transforms.Clear();
}
return(preProcess.Serialize());
}
var context = new PipelineContext(ctx.Resolve <IPipelineLogger>(), mini, entity);
foreach (var error in mini.Errors())
{
context.Error(error);
}
return(null);
}
