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