/// <summary>
/// Attempt to get a specific configuration from the request url
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
internal static EmbeddedResourceItem GetEmbeddedResourceItem(string url)
{
url = EmbeddedResourceService.EnsureUrlAppRelative(url);
if (url != null)
{
return(EmbeddedResourceService.GetEmbeddedResourceItems().SingleOrDefault(x => x.ResourceUrl == url));
}
return(null);
}
/// <summary>
/// Gets the full dataset of registered emebedded resource POCOs (either from cache, or by reflecting for assembly attributes)
/// </summary>
/// <returns>POCO array of all registered emebedded resources</returns>
internal static EmbeddedResourceItem[] GetEmbeddedResourceItems()
{
var embeddedResourceItems = new List <EmbeddedResourceItem>(); // the return value
// TODO: add caching here to avoid attribute reflection
// for each of the attributes, get the resrouce & the url it should be served on, and put this table data somewhere
foreach (var assembly in EmbeddedResourceService.GetAssemblies())
{
var attributes = ((IEmbeddedResourceAttribute[])assembly.GetCustomAttributes <EmbeddedResourceAttribute>())
.Union((IEmbeddedResourceAttribute[])assembly.GetCustomAttributes <EmbeddedResourceProtectedAttribute>());
foreach (var attribute in attributes)
{
if (!assembly.GetManifestResourceNames().Any(x => x == attribute.ResourceNamespace))
{
LogHelper.Warn(typeof(EmbeddedResourceService), $"Embedded Resource: '{ attribute.ResourceNamespace }', not found in Assembly: '{ assembly.FullName }'");
}
else
{
var url = EmbeddedResourceService.EnsureUrlAppRelative(attribute.ResourceUrl);
if (url == null)
{
LogHelper.Warn(typeof(EmbeddedResourceService), $"Invalid Relative Url: '{ attribute.ResourceUrl }'");
}
else
{
var backOfficeUserOnly = attribute is EmbeddedResourceProtectedAttribute;
// add to collection, as item known to be valid
embeddedResourceItems.Add(
new EmbeddedResourceItem(
assembly.FullName,
attribute.ResourceNamespace,
url,
backOfficeUserOnly));
}
}
}
}
return(embeddedResourceItems.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="url">The (app relative) resource url (passed in to avoid using the http context)</param>
/// <returns></returns>
public ActionResult GetEmbeddedResource(string url)
{
var embeddedResourceItem = EmbeddedResourceService.GetEmbeddedResourceItem(url);
if (embeddedResourceItem != null)
{
if (!embeddedResourceItem.BackOfficeUserOnly || this.IsBackOfficeUser())
{
var resourceStream = EmbeddedResourceService.GetResourceStream(embeddedResourceItem);
if (resourceStream != null)
{
return(new FileStreamResult(resourceStream, this.GetMimeType(url)));
}
}
}
return(this.HttpNotFound());
}
/// <summary>
///
/// </summary>
/// <param name="embeddedResourceItem"></param>
/// <returns></returns>
internal static Stream GetResourceStream(EmbeddedResourceItem embeddedResourceItem)
{
if (embeddedResourceItem != null)
{
var assembly = EmbeddedResourceService
.GetAssemblies()
.Single(x => x.FullName == embeddedResourceItem.AssemblyFullName); // expected to exist
var resourceName = assembly
.GetManifestResourceNames()
.FirstOrDefault(x => x == embeddedResourceItem.ResourceNamespace);
if (resourceName != null)
{
return(assembly.GetManifestResourceStream(resourceName));
}
}
return(null);
}
/// <summary>
/// The main startup method
/// </summary>
private void Startup()
{
foreach (var embeddedResourceItem in EmbeddedResourceService.GetEmbeddedResourceItems())
{
// register with mvc
RouteTable
.Routes
.MapRoute(
name: "EmbeddedResource" + Guid.NewGuid().ToString(),
url: embeddedResourceItem.ResourceUrl.TrimStart("~/"), // forward slash always expected
defaults: new
{
controller = "EmbeddedResource",
action = "GetEmbeddedResource",
url = embeddedResourceItem.ResourceUrl
},
namespaces: new[] { "Our.Umbraco.EmbeddedResource" });
// register with client depenedency
FileWriters.AddWriterForFile(embeddedResourceItem.ResourceUrl.TrimStart('~'), new EmbeddedResourceVirtualFileWriter());
}
}
/// <summary>
///
/// </summary>
/// <param name="virtualFile"></param>
/// <returns></returns>
public bool FileExists(string virtualFile)
{
return(EmbeddedResourceService.ResourceExists(virtualFile));
}
/// <summary>
/// When overridden in a derived class, returns a read-only stream to the virtual resource.
/// </summary>
/// <returns>
/// A read-only stream to the virtual file.
/// </returns>
public Stream Open()
{
return(EmbeddedResourceService.GetResourceStream(this.virtualFile));
}
/// <summary>
///
/// </summary>
/// <param name="url">Either the full url (that can be converted to app relative) or an app relative url</param>
/// <returns>a stream or null</returns>
internal static Stream GetResourceStream(string url)
{
return(EmbeddedResourceService.GetResourceStream(EmbeddedResourceService.GetEmbeddedResourceItem(url)));
}
/// <summary>
/// Returns true if the supplied url maps to an embedded resource
/// </summary>
/// <param name="url">Either the full url (that can be converted to app relative) or an app relative url</param>
/// <returns></returns>
internal static bool ResourceExists(string url)
{
return(EmbeddedResourceService.GetEmbeddedResourceItem(url) != null);
}
