public IView EditorFor(object itemToEdit, ICommandHistory history)
{
var typedParameters = new Parameter[] { TypedParameter.From(history) };
IView view = this.context.ResolveOptionalKeyed<IView>(itemToEdit.GetType(), typedParameters);
if (view != null)
{
return view;
}
view = this.context.ResolveOptionalKeyed<IView>(itemToEdit.GetType().BaseType, typedParameters);
if (view != null)
{
return view;
}
return new StringView();
}
protected override void Load(ContainerBuilder builder)
{
// Register resource types
var registry = new ResourceTypeRegistry();
foreach (var resourceTypeConfiguration in _jsonApiConfiguration.ResourceTypeConfigurations)
{
var resourceTypeRegistration = resourceTypeConfiguration.BuildResourceTypeRegistration();
registry.AddRegistration(resourceTypeRegistration);
var configuration = resourceTypeConfiguration;
builder.Register(c => configuration)
.Keyed<IResourceTypeConfiguration>(resourceTypeRegistration.Type)
.Keyed<IResourceTypeConfiguration>(resourceTypeRegistration.ResourceTypeName)
.SingleInstance();
if (resourceTypeConfiguration.DocumentMaterializerType != null)
builder.RegisterType(resourceTypeConfiguration.DocumentMaterializerType);
foreach (var relationship in resourceTypeRegistration.Relationships)
{
IResourceTypeRelationshipConfiguration relationshipConfiguration;
if (resourceTypeConfiguration.RelationshipConfigurations
.TryGetValue(relationship.Property.Name, out relationshipConfiguration))
{
if (relationshipConfiguration.MaterializerType != null)
{
builder.RegisterType(relationshipConfiguration.MaterializerType);
continue;
}
}
// They didn't set an explicit materializer. See if they specified a factory for this resource type.
if (configuration.RelatedResourceMaterializerTypeFactory == null) continue;
var materializerType = configuration.RelatedResourceMaterializerTypeFactory(relationship);
builder.RegisterType(materializerType);
}
}
builder.Register(c => registry).As<IResourceTypeRegistry>().SingleInstance();
builder.Register(c =>
{
var context = c.Resolve<IComponentContext>();
Func<string, IDocumentMaterializer> factory = resourceTypeName =>
{
var configuration = context.ResolveKeyed<IResourceTypeConfiguration>(resourceTypeName);
var registration = registry.GetRegistrationForResourceTypeName(resourceTypeName);
var parameters = new Parameter[] { new TypedParameter(typeof (IResourceTypeRegistration), registration) };
if (configuration.DocumentMaterializerType != null)
return (IDocumentMaterializer)context.Resolve(configuration.DocumentMaterializerType, parameters);
return context.Resolve<IDocumentMaterializer>(parameters);
};
return factory;
});
builder.Register(c =>
{
var context = c.Resolve<IComponentContext>();
Func<Type, IDocumentMaterializer> factory = clrType =>
{
var configuration = context.ResolveKeyed<IResourceTypeConfiguration>(clrType);
var registration = registry.GetRegistrationForType(clrType);
var parameters = new Parameter[] { new TypedParameter(typeof(IResourceTypeRegistration), registration) };
if (configuration.DocumentMaterializerType != null)
return (IDocumentMaterializer)context.Resolve(configuration.DocumentMaterializerType, parameters);
return context.Resolve<IDocumentMaterializer>(parameters);
};
return factory;
});
builder.Register(c =>
{
var context = c.Resolve<IComponentContext>();
Func<string, string, IRelatedResourceDocumentMaterializer> factory = (resourceTypeName, relationshipName) =>
{
var configuration = context.ResolveKeyed<IResourceTypeConfiguration>(resourceTypeName);
var registration = registry.GetRegistrationForResourceTypeName(resourceTypeName);
var relationship = registration.GetFieldByName(relationshipName) as ResourceTypeRelationship;
if (relationship == null)
throw JsonApiException.CreateForNotFound(
string.Format("No relationship `{0}` exists for the resource type `{1}`.", relationshipName, resourceTypeName));
var parameters = new Parameter[]
{
new TypedParameter(typeof(IResourceTypeRegistration), registration),
new TypedParameter(typeof(ResourceTypeRelationship), relationship)
};
// First, see if they have set an explicit materializer for this relationship
IResourceTypeRelationshipConfiguration relationshipConfiguration;
if (configuration.RelationshipConfigurations.TryGetValue(relationship.Property.Name,
out relationshipConfiguration) && relationshipConfiguration.MaterializerType != null)
return (IRelatedResourceDocumentMaterializer)context.Resolve(relationshipConfiguration.MaterializerType, parameters);
// They didn't set an explicit materializer. See if they specified a factory for this resource type.
if (configuration.RelatedResourceMaterializerTypeFactory != null)
{
var materializerType = configuration.RelatedResourceMaterializerTypeFactory(relationship);
return (IRelatedResourceDocumentMaterializer)context.Resolve(materializerType, parameters);
}
return context.Resolve<IRelatedResourceDocumentMaterializer>(parameters);
};
return factory;
});
builder.RegisterType<JsonApiHttpConfiguration>().SingleInstance();
builder.RegisterType<BaseUrlService>().As<IBaseUrlService>().SingleInstance();
builder.RegisterType<DocumentMaterializerLocator>().As<IDocumentMaterializerLocator>().InstancePerRequest();
// Serialization
builder.RegisterType<MetadataFormatter>().As<IMetadataFormatter>().SingleInstance();
builder.RegisterType<LinkFormatter>().As<ILinkFormatter>().SingleInstance();
builder.RegisterType<ResourceLinkageFormatter>().As<IResourceLinkageFormatter>().SingleInstance();
builder.RegisterType<RelationshipObjectFormatter>().As<IRelationshipObjectFormatter>().SingleInstance();
builder.RegisterType<ResourceObjectFormatter>().As<IResourceObjectFormatter>().SingleInstance();
builder.RegisterType<SingleResourceDocumentFormatter>().As<ISingleResourceDocumentFormatter>().SingleInstance();
builder.RegisterType<ResourceCollectionDocumentFormatter>().As<IResourceCollectionDocumentFormatter>().SingleInstance();
builder.RegisterType<ErrorFormatter>().As<IErrorFormatter>().SingleInstance();
builder.RegisterType<ErrorDocumentFormatter>().As<IErrorDocumentFormatter>().SingleInstance();
// Queryable transforms
builder.RegisterType<SynchronousEnumerationTransformer>().As<IQueryableEnumerationTransformer>().SingleInstance();
builder.RegisterType<DefaultFilteringTransformer>().As<IQueryableFilteringTransformer>().SingleInstance();
builder.RegisterType<DefaultSortingTransformer>().As<IQueryableSortingTransformer>().SingleInstance();
builder.RegisterType<DefaultPaginationTransformer>().As<IQueryablePaginationTransformer>().SingleInstance();
// Document building
builder.Register(c => _jsonApiConfiguration.LinkConventions).As<ILinkConventions>().SingleInstance();
builder.RegisterType<JsonApiFormatter>().SingleInstance();
builder.RegisterType<RegistryDrivenResourceCollectionDocumentBuilder>().As<IResourceCollectionDocumentBuilder>().SingleInstance();
builder.RegisterType<RegistryDrivenSingleResourceDocumentBuilder>().As<ISingleResourceDocumentBuilder>().SingleInstance();
builder.RegisterType<FallbackDocumentBuilder>().As<IFallbackDocumentBuilder>().SingleInstance();
builder.RegisterType<ErrorDocumentBuilder>().As<IErrorDocumentBuilder>().SingleInstance();
builder.RegisterType<FallbackDocumentBuilderAttribute>().SingleInstance();
builder.RegisterType<JsonApiExceptionFilterAttribute>().SingleInstance();
builder.RegisterType<DefaultQueryableResourceCollectionDocumentBuilder>().As<IQueryableResourceCollectionDocumentBuilder>();
}
/// <summary>
/// Start crawl process
/// </summary>
public virtual void Crawl()
{
using (var stream = new StreamReader(AppDomain.CurrentDomain.BaseDirectory + "OriginalWebSite.txt", Encoding.UTF8))
{
var jsonStr = stream.ReadToEnd();
var policy = new CacheItemPolicy();
policy.Priority = CacheItemPriority.NotRemovable;
policy.AbsoluteExpiration = DateTimeOffset.Now.AddDays(1);
cache.Set(AppDomain.CurrentDomain.BaseDirectory + "OriginalWebSite", jsonStr, policy);
Console.WriteLine("cache --" + AppDomain.CurrentDomain.BaseDirectory + " :" + cache.Get(AppDomain.CurrentDomain.BaseDirectory + "OriginalWebSite"));
}
if (m_OnlyOneCrawlPerInstance)
{
throw new InvalidOperationException("Crawler instance cannot be reused");
}
m_OnlyOneCrawlPerInstance = true;
Parameter[] parameters = new Parameter[]
{
new TypedParameter(typeof (Uri), m_BaseUri),
new NamedParameter("crawlStart", m_BaseUri),
new TypedParameter(typeof (Crawler), this),
};
m_CrawlerQueue = m_LifetimeScope.Resolve<ICrawlerQueue>(parameters);
parameters = parameters.AddToEnd(new TypedParameter(typeof(ICrawlerQueue), m_CrawlerQueue)).ToArray();
m_CrawlerHistory = m_LifetimeScope.Resolve<ICrawlerHistory>(parameters);
parameters = parameters.AddToEnd(new TypedParameter(typeof(ICrawlerHistory), m_CrawlerHistory)).ToArray();
m_TaskRunner = m_LifetimeScope.Resolve<ITaskRunner>(parameters);
parameters = parameters.AddToEnd(new TypedParameter(typeof(ITaskRunner), m_TaskRunner)).ToArray();
m_Logger = m_LifetimeScope.Resolve<ILog>(parameters);
parameters = parameters.AddToEnd(new TypedParameter(typeof(ILog), m_Logger)).ToArray();
m_CrawlerRules = m_LifetimeScope.Resolve<ICrawlerRules>(parameters);
m_Logger.Verbose("Crawl started @ {0}", m_BaseUri);
m_WebDownloaderFactory = m_LifetimeScope.Resolve<Func<IWebDownloader>>();
using (m_CrawlCompleteEvent = new ManualResetEvent(false))
{
m_Crawling = true;
m_Runtime = Stopwatch.StartNew();
if (m_CrawlerQueue.Count > 0)
{
// Resume enabled
ProcessQueue();
}
else
{
AddStep(m_BaseUri, 0);
}
if (!m_CrawlStopped)
{
m_CrawlCompleteEvent.WaitOne();
}
m_Runtime.Stop();
m_Crawling = false;
}
if (m_Cancelled)
{
OnCancelled();
}
m_Logger.Verbose("Crawl ended @ {0} in {1}", m_BaseUri, m_Runtime.Elapsed);
OnCrawlFinished();
}
/// <summary>
/// Start crawl process
/// </summary>
public virtual void Crawl()
{
if (m_OnlyOneCrawlPerInstance)
{
throw new InvalidOperationException("Crawler instance cannot be reused");
}
m_OnlyOneCrawlPerInstance = true;
Parameter[] parameters = new Parameter[]
{
new TypedParameter(typeof (Uri), m_BaseUri),
new NamedParameter("crawlStart", m_BaseUri),
new TypedParameter(typeof (Crawler), this),
};
m_CrawlerQueue = m_LifetimeScope.Resolve<ICrawlerQueue>(parameters);
parameters = parameters.AddToEnd(new TypedParameter(typeof (ICrawlerQueue), m_CrawlerQueue)).ToArray();
m_CrawlerHistory = m_LifetimeScope.Resolve<ICrawlerHistory>(parameters);
parameters = parameters.AddToEnd(new TypedParameter(typeof (ICrawlerHistory), m_CrawlerHistory)).ToArray();
m_TaskRunner = m_LifetimeScope.Resolve<ITaskRunner>(parameters);
parameters = parameters.AddToEnd(new TypedParameter(typeof (ITaskRunner), m_TaskRunner)).ToArray();
m_Logger = m_LifetimeScope.Resolve<ILog>(parameters);
parameters = parameters.AddToEnd(new TypedParameter(typeof (ILog), m_Logger)).ToArray();
m_CrawlerRules = m_LifetimeScope.Resolve<ICrawlerRules>(parameters);
m_Logger.Verbose("Crawl started @ {0}", m_BaseUri);
m_WebDownloaderFactory = m_LifetimeScope.Resolve<Func<IWebDownloader>>();
using (m_CrawlCompleteEvent = new ManualResetEvent(false))
{
m_Crawling = true;
m_Runtime = Stopwatch.StartNew();
if (m_CrawlerQueue.Count > 0)
{
// Resume enabled
ProcessQueue();
}
else
{
AddStep(m_BaseUri, 0);
}
if (!m_CrawlStopped)
{
m_CrawlCompleteEvent.WaitOne();
}
m_Runtime.Stop();
m_Crawling = false;
}
if (m_Cancelled)
{
OnCancelled();
}
m_Logger.Verbose("Crawl ended @ {0} in {1}", m_BaseUri, m_Runtime.Elapsed);
OnCrawlFinished();
}
/// <summary>
/// Start crawl process
/// </summary>
public virtual void Crawl()
{
if (m_Crawling)
{
throw new InvalidOperationException("Crawler already running");
}
Parameter[] parameters = new Parameter[]
{
new TypedParameter(typeof (Uri), m_BaseUri),
new NamedParameter("crawlStart", m_BaseUri),
new NamedParameter("resume", false),
new NamedParameter("crawler", this),
};
m_CrawlerQueue = m_LifetimeScope.Resolve<ICrawlerQueue>(parameters);
m_CrawlerHistory = m_LifetimeScope.Resolve<ICrawlerHistory>(parameters);
m_Robot = AdhereToRobotRules ? m_LifetimeScope.Resolve<IRobot>(parameters) : new DummyRobot();
m_TaskRunner = m_LifetimeScope.Resolve<ITaskRunner>(parameters);
m_Logger = m_LifetimeScope.Resolve<ILog>(parameters);
m_Logger.Verbose("Crawl started @ {0}", m_BaseUri);
using (m_CrawlCompleteEvent = new ManualResetEvent(false))
{
m_Crawling = true;
m_Runtime = Stopwatch.StartNew();
AddStep(m_BaseUri, 0);
if (!m_CrawlStopped)
{
m_CrawlCompleteEvent.WaitOne();
}
m_Runtime.Stop();
m_Crawling = false;
}
if (m_Cancelled)
{
OnCancelled();
}
m_Logger.Verbose("Crawl ended @ {0} in {1}", m_BaseUri, m_Runtime.Elapsed);
OnCrawlFinished();
}
public void WhenPreparingHandlerProvidesParameters_ParamsProvidedToActivator()
{
IEnumerable<Parameter> parameters = new Parameter[] { new NamedParameter("n", 1) };
IEnumerable<Parameter> actual = null;
var cb = new ContainerBuilder();
cb.RegisterType<object>()
.OnPreparing(e => e.Parameters = parameters)
.OnActivating(e => actual = e.Parameters);
var container = cb.Build();
container.Resolve<object>();
Assert.False(parameters.Except(actual).Any());
}
/// <summary>
/// The method called when a
/// <see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ContainerResolvedParameter"/>
/// object is visited.
/// </summary>
/// <param name="parameterValue">
/// The <see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ContainerResolvedParameter"/> to process.
/// </param>
/// <remarks>
/// <para>
/// If the <see cref="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ContainerResolvedParameter.Name"/>
/// is not set on the <paramref name="parameterValue" />, the value
/// is assumed to be a typed registration. If the
/// <see cref="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ContainerResolvedParameter.Name"/>
/// is present, the value is assumed to be both typed and named.
/// </para>
/// <para>
/// Either way, a <see cref="Autofac.Core.ResolvedParameter"/> will
/// be created with a lambda that resolves the typed (and possibly named,
/// as the case may be) service for the parameter passed in during construction.
/// </para>
/// </remarks>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="parameterValue" /> is <see langword="null" />.
/// </exception>
protected override void VisitResolvedParameterValue(ContainerResolvedParameter parameterValue)
{
if (parameterValue == null)
{
throw new ArgumentNullException("parameterValue");
}
if (!String.IsNullOrEmpty(parameterValue.Name))
{
this.AutofacParameter = this.CreateResolvedParameter((pi, context) => context.ResolveNamed(parameterValue.Name, parameterValue.Type));
}
else
{
this.AutofacParameter = this.CreateResolvedParameter((pi, context) => context.Resolve(parameterValue.Type));
}
}
/// <summary>
/// The method called when a
/// <see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ContainerResolvedEnumerableParameter"/>
/// object is visited.
/// </summary>
/// <param name="parameterValue">
/// The <see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ContainerResolvedEnumerableParameter"/> to process.
/// </param>
/// <remarks>
/// <para>
/// Resolved enumerables in Enterprise Library are always made up of
/// a list of individual named resolutions - there is no notion of a
/// typed auto-collection resolution the way there is in Autofac.
/// </para>
/// <para>
/// As such, the <see cref="Autofac.Core.ResolvedParameter"/> lambda
/// this method generates is a loop over the set of resolved named
/// typed registrations to build them manually into a list of the
/// type specified.
/// </para>
/// </remarks>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="parameterValue" /> is <see langword="null" />.
/// </exception>
protected override void VisitEnumerableParameterValue(ContainerResolvedEnumerableParameter parameterValue)
{
if (parameterValue == null)
{
throw new ArgumentNullException("parameterValue");
}
this.AutofacParameter = this.CreateResolvedParameter(
(pi, context) =>
{
var listType = typeof(List<>).MakeGenericType(parameterValue.ElementType);
var list = Activator.CreateInstance(listType) as IList;
foreach (var name in parameterValue.Names)
{
list.Add(context.ResolveNamed(name, parameterValue.ElementType));
}
return list;
});
}
/// <summary>
/// The method called when a
/// <see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ConstantParameterValue"/>
/// object is visited.
/// </summary>
/// <param name="parameterValue">
/// The <see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ConstantParameterValue"/> to process.
/// </param>
/// <remarks>
/// <para>
/// This method creates a <see cref="Autofac.Core.ResolvedParameter"/>
/// based on the constant value in <paramref name="parameterValue" />
/// and ties it to the parameter passed in during construction.
/// </para>
/// </remarks>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="parameterValue" /> is <see langword="null" />.
/// </exception>
protected override void VisitConstantParameterValue(ConstantParameterValue parameterValue)
{
if (parameterValue == null)
{
throw new ArgumentNullException("parameterValue");
}
this.AutofacParameter = this.CreateResolvedParameter((pi, context) => parameterValue.Value);
}
