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); }