protected void InitializeServiceApi(Type interfaceType) { ConcurrentDictionary <string, ActionWrapper> wrapper; if (cache.TryGetValue(interfaceType, out wrapper)) { return; } var newWrapper = new ConcurrentDictionary <string, ActionWrapper>(); foreach (var methodInfo in interfaceType.GetMethods()) { var template = ExtensionsFactory.GetServiceTemplate(methodInfo); var actionName = GetActionName(methodInfo); var action = new ActionWrapper { Name = actionName, ReturnType = methodInfo.ReturnType, RouteTemplate = template, Parameters = new List <ParameterWrapper>() }; var actions = methodInfo.GetCustomAttributes(true).OfType <IActionHttpMethodProvider>(); var methods = ExtensionsFactory.GetHttpMethods(actions.ToList(), methodInfo); var handlers = ExtensionsFactory.GetHeaderInspectors(methodInfo); action.CustomHandlers = handlers; action.Actions = methods; BuildParameterInfo(methodInfo, action); newWrapper.TryAdd(action.Name, action); } if (cache.TryGetValue(interfaceType, out wrapper)) { return; } cache.TryAdd(interfaceType, newWrapper); }
internal IEnumerable <string> RetrieveUsedExtensions() { // retrieve ALL the property based objects of the whole model. var allObjects = GetLogicalChildrenFlattened(); // check all the extensions used by each object var used = new HashSet <string>(); // search for known extensions foreach (var c in allObjects) { var ids = c.Extensions .Select(item => ExtensionsFactory.Identify(c.GetType(), item.GetType())) .Where(item => !string.IsNullOrWhiteSpace(item)); used.UnionWith(ids); } // search for unknown extensions foreach (var unk in allObjects.SelectMany(item => item.Extensions).OfType <UnknownNode>()) { used.Add(unk.Name); } return(used); }
public static GridViewExtension GridViewReport <TModel>(this ExtensionsFactory extensionsFactory, ECOM.Models.GridViewConfig gridConfig, Action <GridViewSettings <TModel> > action, bool IsExportData = true) { var gridViewSettings = GetGridViewReportSetting <TModel>(gridConfig, IsExportData); action(gridViewSettings); return(new GridViewExtension(gridViewSettings)); }
public static GridViewExtension GridViewCustom <TModel>(this ExtensionsFactory extensionsFactory, ECOM.Models.GridViewConfig gridConfig, Action <GridViewSettings <TModel> > action, bool IsGenerateColumn = true) { var gridViewSettings = GetGridViewSetting <TModel>(gridConfig, IsGenerateColumn); action(gridViewSettings); return(new GridViewExtension(gridViewSettings)); }
/// <summary> /// Generate extension GridView from specify class config /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="extensionsFactory"></param> /// <param name="gridConfig"></param> /// <param name="viewContext"></param> /// <param name="action"></param> /// <returns></returns> public static GridViewExtension GridViewCustom <TModel>(this ExtensionsFactory extensionsFactory, ECOM.Models.GridViewConfig gridConfig, ViewContext viewContext, Action <GridViewSettings <TModel> > action) { var gridViewSettings = GetGridViewSetting <TModel>(gridConfig); action(gridViewSettings); return(new GridViewExtension(gridViewSettings, viewContext)); }
private PositionViewModel GetTarget() { PositionViewModel target = new PositionViewModel(); target.OknaDocument = _oknaDoc; ExtensionsFactory.Nacist(target); return(target); }
public static MvcHtmlString GetScriptsEx(this ExtensionsFactory factory, params Script[] scriptItems) { try { return(factory.GetScripts(scriptItems)); } finally { MvcUtils.RenderScriptsCalled = false; } }
internal void UsingExtension(Type parentType, Type extensionType) { var id = ExtensionsFactory.Identify(parentType, extensionType); if (string.IsNullOrWhiteSpace(id)) { return; } if (this._extensionsUsed.Contains(id)) { return; } this._extensionsUsed.Add(id); }
protected static IWorkflowService GetWfService(IUnityContainer container, Activity outerActivity, WorkflowIdentity innerIdentity, Activity innerActivity) { var mockWfStorage = new Mock <IWorkflowStorage>(); mockWfStorage.Setup(i => i.Load(OuterWfidentity)).Returns(outerActivity); mockWfStorage.Setup(i => i.Load(innerIdentity)).Returns(innerActivity); var wfAppFactory = new WorkflowApplicationFactory(null as InstanceStore, mockWfStorage.Object); container.RegisterInstance <IWorkflowApplicationFactory>(wfAppFactory); container.RegisterType <IWorkflowChildContainerConfigurator, StubWorkflowChildContainerConfigurator>(); var extensionsFactory = new ExtensionsFactory(container); return(new WorkflowService(wfAppFactory, extensionsFactory)); }
private void CopyFromDocument(bool copyColors, bool copyComponents, bool copyComponentFlagsOnly = false) { var docData = GetDocumentData(); if (docData == null) { return; } DocumentViewModel docVM = new DocumentViewModel(); ExtensionsFactory.Nacist(docVM); docVM.SetModel(docData); CopyFromDocumentCore(copyColors, copyComponents, copyComponentFlagsOnly, docVM); }
public static RoundPanelExtension RoundPanelCustom(this ExtensionsFactory extensionsFactory, string name, string headerText, Action <RoundPanelSettings> action) { RoundPanelSettings settings = new RoundPanelSettings(); settings.View = DevExpress.Web.View.GroupBox; settings.Name = name; settings.HeaderText = headerText; settings.Width = System.Web.UI.WebControls.Unit.Percentage(100); settings.ShowHeader = true; settings.CornerRadius = System.Web.UI.WebControls.Unit.Pixel(0); //Collapsing Options //settings.View = View.Standard; settings.AllowCollapsingByHeaderClick = true; settings.ShowCollapseButton = true; settings.EnableAnimation = true; action(settings); return(new RoundPanelExtension(settings)); }
public static void RegisterWcfAdapters() { ExtensionsFactory.SetServiceLocator(new WcfRouteResolver()); }
private static MethodBuilder DefineMethod(TypeBuilder type, MethodInfo implementationMethod, out List <ParameterWrapper> methodParams, out Type[] pTypes, IServiceLocator serviceLocator) { // Declaring method builder // Method attributes const MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot; var method = type.DefineMethod(implementationMethod.Name, methodAttributes); // Preparing Reflection instances var route = typeof(RouteAttribute).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(String) }, null); var httpGet = httpMethodAttribute(implementationMethod, serviceLocator); var uriAttrib = typeof(FromRouteAttribute).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { }, null); var queryAttib = typeof(FromQueryAttribute).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { }, null); var bodyAttrib = typeof(FromBodyAttribute).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { }, null); method.SetReturnType(typeof(Task).IsAssignableFrom(implementationMethod.ReturnType) ? typeof(Task <IActionResult>) : typeof(IActionResult)); // Adding parameters methodParams = GetMethodParams(implementationMethod, serviceLocator); pTypes = methodParams.Where(p => p.In != InclutionTypes.Header).Select(p => p.Type).ToArray(); method.SetParameters(pTypes.ToArray()); var obsolete = implementationMethod.GetCustomAttribute <ObsoleteAttribute>(); if (obsolete != null) { method.SetCustomAttribute(new CustomAttributeBuilder(obsolete.GetType().GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(string), typeof(bool) }, null), new object[] { obsolete.Message, obsolete.IsError })); } // Parameter id var template = implementationMethod.GetCustomAttribute <RouteAttribute>()?.Template ?? implementationMethod.GetCustomAttribute <VerbAttribute>()?.Route; if (template == null) { template = ExtensionsFactory.GetServiceTemplate(implementationMethod, serviceLocator); } if (template == null) { template = ""; } int pid = 1; foreach (var parameterWrapper in methodParams.Where(p => p.In != InclutionTypes.Header)) { try { var p = method.DefineParameter(pid, ParameterAttributes.None, parameterWrapper.Name); if (parameterWrapper.In == InclutionTypes.Path && template.Contains("{" + parameterWrapper.Name + "}")) { p.SetCustomAttribute(new CustomAttributeBuilder(uriAttrib, new Type[] { })); } else if (parameterWrapper.In == InclutionTypes.Path) { p.SetCustomAttribute(new CustomAttributeBuilder(queryAttib, new Type[] { })); } else if (parameterWrapper.In == InclutionTypes.Body) { p.SetCustomAttribute(new CustomAttributeBuilder(bodyAttrib, new Type[] { })); } pid++; } catch (Exception ex) { throw; } } DefineAuthorizeAttributes(implementationMethod, method); if (_apiControllerAttributeType != null) { var ctor = _apiControllerAttributeType.GetConstructor( BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { }, null); method.SetCustomAttribute(new CustomAttributeBuilder(ctor, new object[0])); } // Adding custom attributes to method // [RouteAttribute] //method.SetCustomAttribute(new CustomAttributeBuilder(typeof(ApiControllerAttribute),new object[0])); method.SetCustomAttribute(new CustomAttributeBuilder(route, new[] { template })); // [HttpGetAttribute] method.SetCustomAttribute(new CustomAttributeBuilder(httpGet, new Type[] { })); var defaultResponse = implementationMethod.GetCustomAttribute <SuccessStatusCodeAttribute>(); if (defaultResponse != null) { var returnType = implementationMethod.ReturnType; if (returnType.IsGenericType && typeof(Task).IsAssignableFrom(returnType)) { returnType = returnType.GetGenericArguments().First(); } else if (returnType == typeof(Task)) { method.SetCustomAttribute(defaultResponse.CreateAttribute()); } else if (returnType != typeof(void)) { method.SetCustomAttribute(defaultResponse.CreateAttribute(returnType)); } else { method.SetCustomAttribute(defaultResponse.CreateAttribute()); } } else { ConstructorInfo ctor5 = typeof(ProducesResponseTypeAttribute).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(Type), typeof(int) }, null); method.SetCustomAttribute(new CustomAttributeBuilder(ctor5, new object[] { GetReturnType(implementationMethod), 200 })); try { var attributeCreators = implementationMethod.GetCustomAttributes().OfType <ICreateImplementationAttribute>(); foreach (var createImplementationAttribute in attributeCreators) { method.SetCustomAttribute(createImplementationAttribute.CreateAttribute()); } } catch (Exception ex) { Logging.Exception(ex); } } BuildServiceDescriptionAttribute(implementationMethod, method); return(method); }
public void InitializeClient(Type interfaceType) { ConcurrentDictionary <string, ActionWrapper> concurrentDictionary1; if (RestWrapper.cache.TryGetValue(interfaceType, out concurrentDictionary1)) { return; } ConcurrentDictionary <string, ActionWrapper> concurrentDictionary2 = new ConcurrentDictionary <string, ActionWrapper>(); IRoutePrefix routePrefix = RestWrapper.GetRoutePrefix(interfaceType); this._errorInterceptor = interfaceType.GetCustomAttribute <ErrorHandlerAttribute>(); this._serviceLocator.GetService <ILogger>()?.Message("Initializing client " + interfaceType.Name); RetryAttribute customAttribute = interfaceType.GetCustomAttribute <RetryAttribute>(); if (interfaceType.GetCustomAttribute <CircuitBreakerAttribute>() != null) { CircuitBreakerContainer.Register(interfaceType, (ICircuitBreaker) new Stardust.Interstellar.Rest.Client.CircuitBreaker.CircuitBreaker(interfaceType.GetCustomAttribute <CircuitBreakerAttribute>(), this._serviceLocator) { ServiceName = interfaceType.FullName }); } else { CircuitBreakerContainer.Register(interfaceType, (ICircuitBreaker) new NullBreaker()); } foreach (MethodInfo methodInfo in interfaceType.GetMethods().Length == 0 ? ((IEnumerable <Type>)interfaceType.GetInterfaces()).First <Type>().GetMethods() : interfaceType.GetMethods()) { try { RetryAttribute retryAttribute = methodInfo.GetCustomAttribute <RetryAttribute>() ?? customAttribute; this._serviceLocator.GetService <ILogger>()?.Message("Initializing client action " + interfaceType.Name + "." + methodInfo.Name); IRoute template = (IRoute)methodInfo.GetCustomAttribute <IRouteAttribute>() ?? (IRoute)methodInfo.GetCustomAttribute <VerbAttribute>(); string actionName = this.GetActionName(methodInfo); List <VerbAttribute> list = methodInfo.GetCustomAttributes(true).OfType <VerbAttribute>().ToList <VerbAttribute>(); ActionWrapper action = new ActionWrapper() { Name = actionName, ReturnType = methodInfo.ReturnType, RouteTemplate = ExtensionsFactory.GetRouteTemplate(routePrefix, template, methodInfo, this._serviceLocator), Parameters = new List <ParameterWrapper>() }; MethodInfo method = methodInfo; IServiceProvider serviceLocator = this._serviceLocator; List <HttpMethod> httpMethods = ExtensionsFactory.GetHttpMethods(list, method, serviceLocator); List <IHeaderInspector> headerInspectors = ExtensionsFactory.GetHeaderInspectors(methodInfo, this._serviceLocator); action.UseXml = methodInfo.GetCustomAttributes().OfType <UseXmlAttribute>().Any <UseXmlAttribute>(); action.CustomHandlers = headerInspectors.Where <IHeaderInspector>((Func <IHeaderInspector, bool>)(h => this.headerHandlers.All <IHeaderHandler>((Func <IHeaderHandler, bool>)(parent => parent.GetType() != h.GetType())))).ToList <IHeaderInspector>(); action.ErrorHandler = this._errorInterceptor; action.Actions = httpMethods; if (retryAttribute != null) { action.Retry = true; action.Interval = retryAttribute.RetryInterval; action.NumberOfRetries = retryAttribute.NumberOfRetries; action.IncrementalRetry = retryAttribute.IncremetalWait; if (retryAttribute.ErrorCategorizer != (Type)null) { action.ErrorCategorizer = (IErrorCategorizer)Activator.CreateInstance(retryAttribute.ErrorCategorizer, (object)this._serviceLocator); } } ExtensionsFactory.BuildParameterInfo(methodInfo, action, this._serviceLocator); concurrentDictionary2.TryAdd(action.Name, action); } catch (Exception ex) { this._logger?.Error(ex); throw; } } if (RestWrapper.cache.TryGetValue(interfaceType, out concurrentDictionary1)) { return; } RestWrapper.cache.TryAdd(interfaceType, concurrentDictionary2); }