private static IComponentRegistration CreateMetaRegistration <T, TMetadata>(Service providedService, ServiceRegistration valueRegistration) { var rb = RegistrationBuilder .ForDelegate((c, p) => new Meta <T, TMetadata>( (T)c.ResolveComponent(new ResolveRequest(providedService, valueRegistration, p)), AttributedModelServices.GetMetadataView <TMetadata>(valueRegistration.Registration.Target.Metadata))) .As(providedService); return(rb.CreateRegistration()); }
// ReSharper disable UnusedMember.Local static IComponentRegistration CreateMetaRegistration <T, TMetadata>(Service providedService, IComponentRegistration valueRegistration) // ReSharper restore UnusedMember.Local { var rb = RegistrationBuilder .ForDelegate((c, p) => new Meta <T, TMetadata>( (T)c.ResolveComponent(providedService, valueRegistration, p), AttributedModelServices.GetMetadataView <TMetadata>(valueRegistration.Target.Metadata))) .As(providedService) .Targeting(valueRegistration); return(rb.CreateRegistration()); }
private object CreateStronglyTypedExportFactoryOfTM <T, M>(Export export) { Type[] typeArgs = { typeof(T), typeof(M) }; Type constructed = _exportFactoryType.MakeGenericType(typeArgs); Func <Tuple <T, Action> > exportLifetimeContextCreator = () => LifetimeContext.GetExportLifetimeContextFromExport <T>(export); var metadataView = AttributedModelServices.GetMetadataView <M>(export.Metadata); object?[] args = { exportLifetimeContextCreator, metadataView }; var instance = Activator.CreateInstance(constructed, args); return(instance !); }
private static IComponentRegistration CreateLazyRegistration <T, TMetadata>(Service providedService, ServiceRegistration valueRegistration) { var rb = RegistrationBuilder.ForDelegate( (c, p) => { var context = c.Resolve <IComponentContext>(); return(new Lazy <T, TMetadata>( () => (T)context.ResolveComponent(new ResolveRequest(providedService, valueRegistration, p)), AttributedModelServices.GetMetadataView <TMetadata>(valueRegistration.Registration.Target.Metadata))); }) .As(providedService); return(rb.CreateRegistration()); }
// ReSharper disable UnusedMember.Local static IComponentRegistration CreateLazyRegistration <T, TMeta>(Service providedService, IComponentRegistration valueRegistration) // ReSharper restore UnusedMember.Local { var rb = RegistrationBuilder.ForDelegate( (c, p) => { var context = c.Resolve <IComponentContext>(); return(new Lazy <T, TMeta>( () => (T)context.ResolveComponent(valueRegistration, p), AttributedModelServices.GetMetadataView <TMeta>(valueRegistration.Target.Metadata))); }) .As(providedService) .Targeting(valueRegistration); return(rb.CreateRegistration()); }
/// <summary> /// Checks the metadata to see if isolation is required. /// </summary> /// <param name="metadata">The metadata.</param> /// <param name="isolationMetadata">The isolation metadata.</param> /// <returns> /// <c>true</c> if isolation is required, otherwise <c>false</c> /// </returns> private static bool RequiresIsolation(IDictionary <string, object> metadata, out IIsolationMetadata isolationMetadata) { if (metadata.ContainsKey("Isolation")) { isolationMetadata = AttributedModelServices.GetMetadataView <IIsolationMetadata>(metadata); if (isolationMetadata != null && isolationMetadata.Isolation != IsolationLevel.None) { return(true); } } isolationMetadata = null; return(false); }
public IController CreateController(RequestContext requestContext, string controllerName) { IController ret = null; if (StringComparer.OrdinalIgnoreCase.Equals(requestContext.RouteData.DataTokens["area"], this._areaName)) { ImportDefinition importDefinition = this._importBuilder .WithValue(c => c.Name, controllerName) .WithValue(c => c.PackageId, requestContext.RouteData.Values["packageId"]) .WithValue(c => c.PackageVersion, requestContext.RouteData.Values["packageVersion"]); Export export = this._container.GetExports(importDefinition).SingleOrDefault(); if (export != null) { ret = (IController)export.Value; requestContext.HttpContext.Items[this._key] = this; // store this for later as we already went throuh the trouble of resolving the Export requestContext.HttpContext.Items[MetadataKey] = AttributedModelServices.GetMetadataView <IControllerMetadata>(export.Metadata); // how bad is this? ((Controller)ret).ActionInvoker = new AddInActionInvoker(); } } if (ret == null) { // TODO maybe make this throw a 404/return null/something else ret = this._nestedFactory.CreateController(requestContext, controllerName); if (ret != null) { requestContext.HttpContext.Items[this._key] = this._nestedFactory; } } return(ret); }
private static Lazy <T, TMetadataView> Create <T, TMetadataView>(Func <T> exportedValueGetter, IDictionary <string, object> metadata) { return(new Lazy <T, TMetadataView>(exportedValueGetter, AttributedModelServices.GetMetadataView <TMetadataView>(metadata), false)); }
/// <summary> /// Creates a part factory with metadata. /// </summary> /// <typeparam name="TPart">The type of part.</typeparam> /// <typeparam name="TMetadata">The type of metadata.</typeparam> /// <param name="importDefinition">The import definition.</param> /// <param name="provider">The export provider.</param> /// <param name="exportDefinition">The export definition.</param> /// <returns>A part factory with metadata.</returns> protected static PartFactory <TPart> CreatePartCreatorOfTWithMetadata <TPart, TMetadata>(ImportDefinition importDefinition, ExportProvider provider, ExportDefinition exportDefinition) { Func <PartLifetimeContext <TPart> > creator = CreatePartlifeTimeContext <TPart>(importDefinition, provider, exportDefinition); return(new PartFactory <TPart, TMetadata>(creator, AttributedModelServices.GetMetadataView <TMetadata>(exportDefinition.Metadata))); }
private static IDataTemplateMetadata GetMetadataView([CanBeNull] Lazy <object, object> item) { return(item?.Metadata is IDictionary <string, object> metadataDictionary?AttributedModelServices.GetMetadataView <IDataTemplateMetadata>(metadataDictionary) : null); }
public void OnActionExecuted(ActionExecutedContext filterContext) { ViewResult viewResult = filterContext.Result as ViewResult; if (viewResult != null && viewResult.Model != null) { IAdminModel model = viewResult.Model as IAdminModel; if (model == null) { throw new InvalidOperationException(string.Format("Model ({0}) does not implement IAdminModel", viewResult.GetType().Name)); } model.Notifications = App.Instance.Notifications.Get(filterContext.HttpContext.User); // this was populated by the AddInControllerFactory IControllerMetadata metadata = (IControllerMetadata) filterContext.RequestContext.HttpContext.Items[AddInControllerFactory.MetadataKey]; string actionText = string.Empty; // TODO FIX THIS SOMEHOW, this is pretty crappy var allControllerExports = App.Instance.Container.GetExports( new ContractBasedImportDefinition( ContractNames.AdminController, AttributedModelServices.GetTypeIdentity(typeof(IController)), Enumerable.Empty <KeyValuePair <string, Type> >(), ImportCardinality.ZeroOrMore, false, false, CreationPolicy.NonShared)); List <Navigation> menu = new List <Navigation>(); foreach (Export export in allControllerExports) { IControllerMetadata controllerMetadata = AttributedModelServices.GetMetadataView <IControllerMetadata>(export.Metadata); ReflectedControllerDescriptor descriptor = new ReflectedControllerDescriptor(export.Value.GetType()); var controllerAttr = descriptor.GetCustomAttributes(typeof(AdminControllerAttribute), true).FirstOrDefault() as AdminControllerAttribute; if (controllerAttr == null) { continue; } UrlHelper urlHelper = new UrlHelper(filterContext.RequestContext); Uri defaultTargetUrl = null; List <Navigation> children = new List <Navigation>(); foreach (var actionDescriptor in descriptor.GetCanonicalActions()) { var actionAttr = actionDescriptor.GetCustomAttributes(typeof(AdminActionAttribute), true).FirstOrDefault() as AdminActionAttribute; if (actionAttr == null) { continue; } // TODO replace anon class with concrete type? string targetUrl = urlHelper.Action(actionAttr.Name, controllerAttr.Name, new { packageId = controllerMetadata.PackageId, packageVersion = controllerMetadata.PackageVersion }); Uri target = new Uri(targetUrl, UriKind.RelativeOrAbsolute); if (defaultTargetUrl == null || actionAttr.IsDefault) { defaultTargetUrl = target; } bool isActive = filterContext.ActionDescriptor.ActionName == actionDescriptor.ActionName && filterContext.ActionDescriptor.ControllerDescriptor.ControllerType == descriptor.ControllerType; if (isActive) { actionText = actionAttr.Text; } Navigation navigation = new Navigation(null, actionAttr.Order, actionAttr.Text, target, isActive, Enumerable.Empty <Navigation>()); children.Add(navigation); } bool isAnyChildActive = children.Any(n => n.IsActive); // if there's only one child, ignore it if (children.Count == 1) { children.Clear(); } menu.Add(new Navigation(controllerAttr.Group, controllerAttr.Order, controllerAttr.Text, defaultTargetUrl, isAnyChildActive, children)); } model.Navigation = menu.OrderBy(n => n.Order).ToArray(); model.PageTitle = "LostDoc Administration " + metadata.Text; if (!string.IsNullOrWhiteSpace(actionText)) { model.PageTitle += string.Format(" - {0}", actionText); } } }
static ExportFactoryInternal <T> CreatePartCreatorOfTWithMetadata <T, TMetadata>(ImportDefinition productImport, ExportProvider sourceProvider, ExportDefinition productDefinition) { Func <ExportLifetimeContext <T> > creator = CreatePartLifetimeContextCreator <T>(productImport, sourceProvider, productDefinition); return(new ExportFactory <T, TMetadata>(creator, AttributedModelServices.GetMetadataView <TMetadata>(productDefinition.Metadata))); }
private void UpdateWebApiRegistry(ComposablePartCatalogChangeEventArgs eventArg) { using (TraceSources.AddInManager.TraceActivity("Updating WebApi routes.")) { // TODO this could be cleaned up a bit foreach (var partDefinition in eventArg.RemovedDefinitions) { IEnumerable <ExportDefinition> exports = partDefinition.ExportDefinitions; var apiExport = exports.SingleOrDefault(export => StringComparer.Ordinal.Equals(export.ContractName, Extensibility.ContractNames.ApiController)); if (apiExport == null) { continue; } IApiControllerMetadata controllerMetadata = AttributedModelServices.GetMetadataView <IApiControllerMetadata>(apiExport.Metadata); Type controllerType = AddInModelServices.GetPartType(partDefinition).Value; string routeName = string.Format("{0}_{1}", controllerMetadata.PackageId, controllerType.FullName.Replace('.', '_')); TraceSources.AddInManager.TraceInformation("Removing route: {0} (Source: {1}, Version: {2})", routeName, controllerMetadata.PackageId, controllerMetadata.PackageVersion); RouteBase route = RouteTable.Routes[routeName]; using (RouteTable.Routes.GetWriteLock()) { RouteTable.Routes.Remove(route); } } foreach (var partDefinition in eventArg.AddedDefinitions) { IEnumerable <ExportDefinition> exports = partDefinition.ExportDefinitions; var apiExport = exports.SingleOrDefault(export => StringComparer.Ordinal.Equals(export.ContractName, Extensibility.ContractNames.ApiController)); if (apiExport == null) { continue; } IApiControllerMetadata controllerMetadata = AttributedModelServices.GetMetadataView <IApiControllerMetadata>(apiExport.Metadata); Type controllerType = AddInModelServices.GetPartType(partDefinition).Value; // Pacakge version explicitly ignored in order to remain backwards compatible string urlTemplate = string.Format("api/{0}/{1}/", controllerMetadata.PackageId, controllerMetadata.UrlFragment.Trim('/')); string routeName = string.Format("{0}_{1}", controllerMetadata.PackageId, controllerType.FullName.Replace('.', '_')); string controllerName = controllerType.Name.Substring(0, controllerType.Name.Length - "Controller".Length); TraceSources.AddInManager.TraceInformation( "Adding route: {0} (Template: '{1}', Controller: {2}, Source: {3}, Version: {4})", routeName, urlTemplate, controllerName, controllerMetadata.PackageId, controllerMetadata.PackageVersion); using (RouteTable.Routes.GetWriteLock()) { RouteTable.Routes.MapHttpRoute( routeName, urlTemplate, new { Controller = controllerName, }); } } } }
public LooseMetadataLazy(Func <T> factory, IDictionary <string, object> looseMetadata) : base(factory, AttributedModelServices.GetMetadataView <TMetadata>(looseMetadata)) { LooseMetadata = looseMetadata; }
private static IDataTemplateMetadata GetMetadataView([CanBeNull] Lazy <object, object> item) { var metadataDictionary = item?.Metadata as IDictionary <string, object>; return(metadataDictionary == null ? null : AttributedModelServices.GetMetadataView <IDataTemplateMetadata>(metadataDictionary)); }