/// <summary>
/// Creates a cache dependency based on the specified virtual paths.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The path to the primary virtual resource.</param>
/// <returns>
/// A <see cref="T:System.Web.Caching.CacheDependency"/> object for the specified virtual resources.
/// </returns>
public virtual CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
CacheDependency result = this.GetCurrentCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);
//If the requested file does not exist in the current resolver then keep these dependencies and add dependencies of the next resolver.
//This will allow the resolvers higher in the chain to be pinged again when the file might be available to them.
if (this.Next != null && !this.CurrentExists(definition, virtualPath))
{
var nextDependencies = this.Next.GetCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);
if (nextDependencies != null)
{
if (result != null)
{
var aggr = new AggregateCacheDependency();
aggr.Add(result, nextDependencies);
result = aggr;
}
else
{
result = nextDependencies;
}
}
}
return result;
}
/// <summary>
/// Determines whether a file with the specified virtual path exists.
/// </summary>
/// <param name="virtualPath">The virtual path to check.</param>
public virtual bool Exists(PathDefinition definition, string virtualPath)
{
virtualPath = this.RemoveParams(virtualPath);
var resolverStrategy = ObjectFactory.Resolve<IResourceResolverStrategy>();
return resolverStrategy.Exists(definition, virtualPath);
}
/// <summary>
/// Opens the the file with the specified virtual path.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The virtual path of the file to open.</param>
/// <returns></returns>
public virtual Stream Open(PathDefinition definition, string virtualPath)
{
if (this.Next != null && !this.CurrentExists(definition, virtualPath))
return this.Next.Open(definition, virtualPath);
return this.CurrentOpen(definition, virtualPath);
}
/// <summary>
/// Opens the the file with the specified virtual path.
/// </summary>
/// <param name="virtualPath">The virtual path of the file to open.</param>
public virtual Stream Open(PathDefinition definition, string virtualPath)
{
virtualPath = this.virtualPathBuilder.RemoveParams(virtualPath);
var resolverStrategy = ObjectFactory.Resolve<IResourceResolverStrategy>();
return resolverStrategy.Open(definition, virtualPath);
}
/// <summary>
/// Gets the control presentation that contains the requested resource from the database.
/// </summary>
/// <param name="virtualPathDefinition">The definition.</param>
/// <param name="virtualPath">The virtual path.</param>
/// <returns></returns>
protected override ControlPresentation GetControlPresentation(PathDefinition virtualPathDefinition, string virtualPath)
{
if (this.ControlPresentationResult.ContainsKey(virtualPath))
return this.ControlPresentationResult[virtualPath];
else
return null;
}
/// <summary>
/// Creates a cache dependency based on the specified virtual paths.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The path to the primary virtual resource.</param>
/// <returns>
/// A <see cref="T:System.Web.Caching.CacheDependency"/> object for the specified virtual resources.
/// </returns>
public virtual CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
virtualPath = this.virtualPathBuilder.RemoveParams(virtualPath);
var resolverStrategy = ObjectFactory.Resolve<IResourceResolverStrategy>();
return resolverStrategy.GetCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);
}
/// <inheritdoc />
protected override Stream CurrentOpen(PathDefinition definition, string virtualPath)
{
Assembly assembly = this.GetAssembly(definition);
var resourceName = this.GetResourceName(definition, virtualPath);
var resources = assembly.GetManifestResourceNames();
var caseSensitiveName = resources.First(r => string.Equals(resourceName, r, StringComparison.OrdinalIgnoreCase));
var stream = assembly.GetManifestResourceStream(caseSensitiveName);
return stream;
}
/// <inheritdoc />
protected override Stream CurrentOpen(PathDefinition definition, string virtualPath)
{
var controlPresentation = this.GetControlPresentation(definition, virtualPath);
if (controlPresentation != null && !controlPresentation.Data.IsNullOrEmpty())
{
var bytes = RouteHelper.GetContentWithPreamble(controlPresentation.Data);
return new MemoryStream(bytes);
}
throw new ArgumentException("Could not find resource at " + virtualPath + " in the database.");
}
/// <inheritdoc />
public override CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
if (this.GetCacheDependencyMock != null)
{
return this.GetCacheDependencyMock(definition, virtualPath, virtualPathDependencies, utcStart);
}
else
{
return base.GetCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);
}
}
/// <inheritdoc />
protected override bool CurrentExists(PathDefinition definition, string virtualPath)
{
if (definition.ResourceLocation.IsNullOrEmpty())
return false;
Assembly assembly = this.GetAssembly(definition);
var resourceName = this.GetResourceName(definition, virtualPath);
var resources = assembly.GetManifestResourceNames();
return resources.Contains(resourceName, StringComparer.OrdinalIgnoreCase);
}
/// <inheritdoc />
protected override CacheDependency GetCurrentCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
var controlPresentation = this.GetControlPresentation(definition, virtualPath);
if (controlPresentation != null)
{
return new ControlPresentationCacheDependency(controlPresentation.Id.ToString());
}
// Change to any ControlPresentation record will invalidate the cache for this virtual path.
return new ControlPresentationCacheDependency(typeof(ControlPresentation));
}
/// <inheritdoc />
protected override IEnumerable<string> GetCurrentFiles(PathDefinition definition, string path)
{
var mappedPath = this.GetFileName(definition, path);
if (mappedPath != null && Directory.Exists(mappedPath))
{
return Directory.GetFiles(mappedPath)
.Select(f => f.Replace(mappedPath, path));
}
return null;
}
/// <summary>
/// Gets the control presentation that contains the requested resource from the database.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The virtual path.</param>
protected virtual ControlPresentation GetControlPresentation(PathDefinition definition, string virtualPath)
{
var resourceName = VirtualPathUtility.ToAppRelative(virtualPath);
var areaName = VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.ToAppRelative(definition.VirtualPath));
var extension = VirtualPathUtility.GetExtension(virtualPath).ToLower();
var controlPresentation = PageManager.GetManager().GetPresentationItems<ControlPresentation>()
.FirstOrDefault(cp => cp.AreaName == areaName && cp.NameForDevelopers == resourceName
&& cp.DataType == extension);
return controlPresentation;
}
/// <inheritdoc />
public override bool Exists(PathDefinition definition, string virtualPath)
{
if (this.ExistsMock != null)
{
return this.ExistsMock(definition, virtualPath);
}
else
{
return base.Exists(definition, virtualPath);
}
}
public System.Web.Caching.CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
var id = this.ResolveFormDescriptionId(virtualPath);
if (id != null && this.DescriptionExists(id.Value))
{
return new DataItemSystemCacheDependency(typeof(FormDescription), itemId: id.Value.ToString("D"));
}
else
{
return new DataItemSystemCacheDependency(typeof(FormDescription));
}
}
/// <inheritdoc />
protected override IEnumerable<string> GetCurrentFiles(PathDefinition definition, string path)
{
var resourceName = this.GetResourceName(definition, path);
if (resourceName != null)
{
var assembly = this.GetAssembly(definition);
return assembly.GetManifestResourceNames()
.Where(r => r.StartsWith(resourceName, StringComparison.OrdinalIgnoreCase))
.Select(r => r.Replace(resourceName, path));
}
return null;
}
public void GetLayoutName_WithoutMasterSuffix_ReturnsNull()
{
// Arrange
var testVirtualPath = "~/TestPrefix/TestTitle.test";
var pathDefinition = new PathDefinition();
pathDefinition.VirtualPath = "~/TestPrefix";
// Act
var layoutVirtualPathBuilder = new LayoutVirtualPathBuilder();
var resultLayoutName = layoutVirtualPathBuilder.GetLayoutName(pathDefinition, testVirtualPath);
// Assert
Assert.IsNull(resultLayoutName, "The result layout name should be null if the virtual path doesn't end with 'master'.");
}
public void GetLayoutName_VirtualPath_ResolvesLayoutFileName()
{
// Arrange
var expectedLayoutName = "TestTitle";
var testVirtualPath = "~/TestPrefix/TestTitle....master";
var pathDefinition = new PathDefinition { VirtualPath = "~/TestPrefix" };
// Act
var layoutVirtualPathBuilder = new LayoutVirtualPathBuilder();
var resultLayoutName = layoutVirtualPathBuilder.GetLayoutName(pathDefinition, testVirtualPath);
// Assert
Assert.AreEqual(expectedLayoutName, resultLayoutName, "The layout name is not extracted correctly.");
}
/// <summary>
/// Creates a cache dependency based on the specified virtual paths.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The path to the primary virtual resource.</param>
/// <returns>
/// A <see cref="T:System.Web.Caching.CacheDependency"/> object for the specified virtual resources.
/// </returns>
public CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
virtualPath = this.virtualPathBuilder.RemoveParams(virtualPath);
virtualPath = VirtualPathUtility.ToAppRelative(virtualPath);
var layoutVirtualPathBuilder = new LayoutVirtualPathBuilder();
string viewName = layoutVirtualPathBuilder.GetLayoutName(definition, virtualPath);
var layoutTemplateBuilder = new LayoutRenderer();
if (string.IsNullOrEmpty(viewName))
return null;
var viewPath = layoutTemplateBuilder.LayoutViewPath(viewName);
return HostingEnvironment.VirtualPathProvider.GetCacheDependency(viewPath, virtualPathDependencies, utcStart);
}
/// <summary>
/// Determines whether a file with the specified virtual path exists.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The virtual path to check.</param>
public virtual bool Exists(PathDefinition definition, string virtualPath)
{
virtualPath = VirtualPathUtility.ToAppRelative(virtualPath);
var vpBuilder = new LayoutVirtualPathBuilder();
string viewName = vpBuilder.GetLayoutName(definition, virtualPath);
var layoutTemplateBuilder = new LayoutRenderer();
if (string.IsNullOrEmpty(viewName))
return false;
if (virtualPath.StartsWith(string.Format("~/{0}", LayoutVirtualFileResolver.ResolverPath)))
return layoutTemplateBuilder.LayoutExists(viewName);
else
return false;
}
/// <summary>
/// Gets the path definition for the given assembly that is used by the virtual file resolvers.
/// </summary>
/// <param name="assembly">The assembly.</param>
public PathDefinition GetPathDefinition(Assembly assembly)
{
if (assembly == null)
throw new ArgumentNullException("assembly");
var name = assembly.GetName().Name;
var result = new PathDefinition()
{
IsWildcard = true,
ResolverName = name,
ResourceLocation = assembly.CodeBase,
VirtualPath = "~/" + VirtualPathBuilder.frontendAssemblyBasePath.Arrange(name),
};
result.Items.Add("Assembly", assembly);
return result;
}
/// <summary>
/// Gets the layout file name from virtual path.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The virtual path.</param>
/// <returns></returns>
public virtual string GetLayoutName(PathDefinition definition, string virtualPath)
{
if (!virtualPath.EndsWith(LayoutVirtualPathBuilder.LayoutSuffix, StringComparison.OrdinalIgnoreCase))
return null;
var definitionVp = VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.ToAppRelative(definition.VirtualPath));
var pageTemplateNameLength = virtualPath.Length - definitionVp.Length - LayoutVirtualPathBuilder.LayoutSuffix.Length - 1;
string pageTemplateName = virtualPath.Substring(definitionVp.Length, pageTemplateNameLength);
while (!string.IsNullOrEmpty(pageTemplateName) && pageTemplateName.EndsWith(".", StringComparison.Ordinal))
{
pageTemplateName = pageTemplateName.Substring(0, pageTemplateName.Length - 1);
}
return pageTemplateName;
}
/// <summary>
/// Gets the assembly which is specified in the PathDefinition.
/// </summary>
/// <param name="definition">The path definition.</param>
/// <exception cref="System.InvalidOperationException">Invalid PathDefinition.</exception>
protected virtual Assembly GetAssembly(PathDefinition definition)
{
object assembly;
if (!definition.Items.TryGetValue("Assembly", out assembly))
{
lock (this)
{
if (!definition.Items.TryGetValue("Assembly", out assembly))
{
assembly = Assembly.LoadFrom(definition.ResourceLocation);
definition.Items.Add("Assembly", assembly);
}
}
}
return (Assembly)assembly;
}
public Stream Open(PathDefinition definition, string virtualPath)
{
var formManager = FormsManager.GetManager();
var id = this.ResolveFormDescriptionId(virtualPath);
var form = formManager.GetForm(id.Value);
var output = new MemoryStream();
var writer = new StreamWriter(output);
FrontendModule.Current.DependencyResolver.Get<IFormRenderer>().Render(writer, form);
writer.Flush();
output.Seek(0, SeekOrigin.Begin);
return output;
}
/// <summary>
/// Determines whether a file with the specified virtual path exists.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The virtual path to check.</param>
public virtual bool Exists(PathDefinition definition, string virtualPath)
{
virtualPath = this.virtualPathBuilder.RemoveParams(virtualPath);
virtualPath = VirtualPathUtility.ToAppRelative(virtualPath);
var layoutVirtualPathBuilder = new LayoutVirtualPathBuilder();
string viewName = layoutVirtualPathBuilder.GetLayoutName(definition, virtualPath);
var layoutTemplateBuilder = new LayoutRenderer();
if (string.IsNullOrEmpty(viewName))
return false;
if (virtualPath.StartsWith(string.Format(System.Globalization.CultureInfo.InvariantCulture, "~/{0}", LayoutVirtualFileResolver.ResolverPath), StringComparison.Ordinal))
return layoutTemplateBuilder.LayoutExists(viewName);
else
return false;
}
public void Start()
{
Path = GameObject.FindGameObjectWithTag ("waterPath").GetComponent<PathDefinition> ();
if (Path == null)
{
Debug.LogError("Path cannot be null", gameObject);
return;
}
_currentPoint = Path.GetPathsEnumerator ();
_currentPoint.MoveNext ();
if (_currentPoint.Current == null)
return;
//transform.position = _currentPoint.Current.position;
}
/// <summary>
/// Gets the path definition for the given assembly that is used by the virtual file resolvers.
/// </summary>
/// <param name="assembly">The assembly.</param>
public PathDefinition GetPathDefinition(Assembly assembly)
{
if (assembly == null)
throw new ArgumentNullException("assembly");
var name = assembly.GetName().Name;
var result = new PathDefinition
{
IsWildcard = true,
ResolverName = name,
ResourceLocation = assembly.CodeBase,
VirtualPath = string.Format(CultureInfo.InvariantCulture, "~/{0}", VirtualPathBuilder.FrontendAssemblyBasePath.Arrange(name))
};
result.Items.Add("Assembly", assembly);
return result;
}
/// <summary>
/// Opens the the file with the specified virtual path.
/// </summary>
/// <param name="virtualPath">The virtual path of the file to open.</param>
public virtual Stream Open(PathDefinition definition, string virtualPath)
{
virtualPath = this.virtualPathBuilder.RemoveParams(virtualPath);
MemoryStream outPutStream = null;
virtualPath = VirtualPathUtility.ToAppRelative(virtualPath);
var virtualBuilder = new LayoutVirtualPathBuilder();
var viewName = virtualBuilder.GetLayoutName(definition, virtualPath);
var layoutHtmlString = this.RenderLayout(viewName);
if (!string.IsNullOrEmpty(layoutHtmlString))
{
var layoutBytes = Encoding.Default.GetBytes(layoutHtmlString.ToCharArray());
outPutStream = new MemoryStream(layoutBytes);
}
return outPutStream;
}
/// <summary>
/// Gets the resource name based on the virtual path.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The virtual path.</param>
protected virtual string GetResourceName(PathDefinition definition, string virtualPath)
{
string assemblyName = this.GetAssembly(definition).GetName().Name;
string path;
if (definition.IsWildcard)
{
var definitionVp = VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.ToAppRelative(definition.VirtualPath));
var vp = VirtualPathUtility.ToAppRelative(virtualPath);
var dir = VirtualPathUtility.GetDirectory(vp);
vp = Regex.Replace(dir, @"[ \-]", "_") + Path.GetFileName(vp);
path = assemblyName + "." + vp.Substring(definitionVp.Length).Replace('/', '.');
}
else
{
path = assemblyName;
}
return path;
}
/// <summary>
/// Opens the the file with the specified virtual path.
/// </summary>
/// <param name="virtualPath">The virtual path of the file to open.</param>
public virtual Stream Open(PathDefinition definition, string virtualPath)
{
var placeholdersOnly = virtualPath.EndsWith(".master", StringComparison.OrdinalIgnoreCase);
virtualPath = this.virtualPathBuilder.RemoveParams(virtualPath);
MemoryStream outPutStream = null;
virtualPath = VirtualPathUtility.ToAppRelative(virtualPath);
var virtualBuilder = new LayoutVirtualPathBuilder();
var viewName = virtualBuilder.GetLayoutName(definition, virtualPath);
var layoutHtmlString = this.RenderLayout(viewName, placeholdersOnly);
if (!string.IsNullOrEmpty(layoutHtmlString))
{
var layoutBytes = Encoding.UTF8.GetBytes(layoutHtmlString.ToCharArray());
outPutStream = new MemoryStream(layoutBytes);
}
return outPutStream;
}
private IDisposableNodeViewProvider Create(IValue value, PathDefinition path) => _nodeFactory.Create(value, path);
protected override string CurrentGetFileHash(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies)
{
var assembly = this.GetAssembly(definition);
return(assembly.GetName().Version.ToString());
}
/// <inheritdoc />
public System.IO.Stream Open(PathDefinition definition, string virtualPaht)
{
throw new NotImplementedException();
}
public bool AffectsPath(PathDefinition path) => _rule(path);
/// <summary> /// Determines whether a file with the specified virtual path exists in the current resolver node. /// </summary> /// <param name="definition">The definition.</param> /// <param name="virtualPath">The virtual path to check.</param> protected abstract bool CurrentExists(PathDefinition definition, string virtualPath);
/// <inheritdoc />
protected override bool CurrentExists(PathDefinition definition, string virtualPath)
{
var fn = this.GetFileName(definition, virtualPath);
return(fn != null && File.Exists(fn));
}
public TrackingValueCalculationContext(INodeRepository nodeRepository, PathDefinition currentPath)
{
_nodeRepository = nodeRepository;
CurrentPath = currentPath;
}
private string GetFilesCacheKey(PathDefinition definition, string virtualPath)
{
return("{0}_{1}_GetFiles_{2}".Arrange(this.GetType().Name, definition.ResolverName, virtualPath.GetHashCode()));
}
/// <inheritdoc />
protected override System.Web.Caching.CacheDependency GetCurrentCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
bool isValidControlPresentationPath;
string name;
IEnumerable <string> controllers;
string[] areaNames;
ControlPresentationCacheDependency cacheDependency = null;
if (this.TryResolveControlPresentationParams(definition, virtualPath, out isValidControlPresentationPath, out name, out controllers, out areaNames) &&
isValidControlPresentationPath)
{
foreach (string areaName in areaNames)
{
var item = this.GetControlPresentationItem(controllers, name, areaName);
if (item != null)
{
cacheDependency = new ControlPresentationCacheDependency(item.Id.ToString());
break;
}
}
if (cacheDependency == null)
{
List <CacheDependencyKey> keys = new List <CacheDependencyKey>();
foreach (string areaName in areaNames)
{
foreach (var controller in controllers)
{
var key = string.Concat(name, controller, areaName);
if (cacheDependency == null)
{
cacheDependency = new ControlPresentationCacheDependency(key);
}
else
{
cacheDependency.AddAdditionalKey(key);
}
}
}
}
}
return(cacheDependency);
}
public Transformable(PathDefinition path, IValueTransformable transformable)
{
_path = path;
_transformable = transformable;
}
/// <inheritdoc />
protected override System.Web.Caching.CacheDependency GetCurrentCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
bool isValidControlPresentationPath;
ControlPresentation controlPresentation = this.GetControlPresentation(definition, virtualPath, out isValidControlPresentationPath);
if (!isValidControlPresentationPath)
{
// Return null for virtual paths that are not ControlPresentation paths since they do not depend on Control Presentations.
return(null);
}
if (controlPresentation != null)
{
return(new ControlPresentationCacheDependency(controlPresentation.Id.ToString()));
}
// Change to any ControlPresentation record will invalidate the cache for this virtual path.
return(new ControlPresentationCacheDependency(typeof(ControlPresentation)));
}
/// <inheritdoc />
protected override CacheDependency GetCurrentCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
// Embedded resources cannot change therefore no dependency is needed.
return(null);
}
private static ConvertedBaseValue CreateSut(PathDefinition path = null) => new ConvertedBaseValue(path);
/// <summary> /// Gets the available files in the given path using the current resolver node. /// </summary> /// <param name="definition">The definition.</param> /// <param name="path">The path.</param> protected abstract IEnumerable <string> GetCurrentFiles(PathDefinition definition, string path);
public bool Exists(PathDefinition definition, string virtualPath)
{
var id = this.ResolveFormDescriptionId(virtualPath);
return(id != null && this.DescriptionExists(id.Value));
}
/// <summary> /// Creates a cache dependency based on the specified virtual path and on the current resolver node. /// </summary> /// <param name="definition">The definition.</param> /// <param name="virtualPath">The path to the virtual resource.</param> /// <param name="virtualPathDependencies">The virtual path dependencies.</param> /// <param name="utcStart">The UTC start.</param> /// <returns> /// A <see cref="T:System.Web.Caching.CacheDependency" /> object for the specified virtual resources. /// </returns> protected abstract CacheDependency GetCurrentCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart);
/// <summary>
/// Determines whether a file with the specified virtual path exists.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The virtual path to check.</param>
public virtual bool Exists(PathDefinition definition, string virtualPath)
{
return(this.CurrentExists(definition, virtualPath) ||
(this.Next != null && this.Next.Exists(definition, virtualPath)));
}
/// <summary>
/// Simulates that resource always exists on the searched location.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The virtual path.</param>
/// <returns></returns>
public bool Exists(PathDefinition definition, string virtualPath)
{
return(true);
}
/// <summary> /// Opens the the file with the specified virtual path using the current resolver node. /// </summary> /// <param name="definition">The definition.</param> /// <param name="virtualPath">The virtual path of the file to open.</param> /// <returns></returns> protected abstract Stream CurrentOpen(PathDefinition definition, string virtualPath);
private string GetFilesCacheKey(PathDefinition definition, string virtualPath)
{
string moduleName = definition.Parameters[ModuleNameParam];
return("{0}_{1}_{2}_GetFiles_{3}".Arrange(this.GetType().Name, moduleName, definition.ResolverName, virtualPath.GetHashCode()));
}
public BaseValue(IStat stat, PathDefinition path)
{
_stat = stat;
_path = path;
}
/// <summary>
/// Returns a hash of the specified virtual paths.
/// </summary>
/// <param name="definition">The file resolver definition.</param>
/// <param name="virtualPath">The path to the primary virtual resource.</param>
/// <param name="virtualPathDependencies">An array of paths to other virtual resources required by the primary virtual resource.</param>
/// <returns>
/// A hash of the specified virtual paths.
/// </returns>
public string GetFileHash(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies)
{
return(Guid.NewGuid().ToString());
}
private ModifierNodeCollection GetModifierNodeCollection(Modifier modifier)
{
var path = new PathDefinition(modifier.Source);
return(GetModifierNodeCollection(new FormNodeSelector(modifier.Form, path)));
}
/// <summary>
/// Creates a cache dependency based on the specified virtual paths.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The path to the primary virtual resource.</param>
/// <returns>
/// A <see cref="T:System.Web.Caching.CacheDependency"/> object for the specified virtual resources.
/// </returns>
public CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
return(null);
}
/// <inheritdoc />
protected override Stream CurrentOpen(PathDefinition definition, string virtualPath)
{
return(File.OpenRead(this.GetFileName(definition, virtualPath)));
}
/// <inheritdoc />
public System.Web.Caching.CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, System.Collections.IEnumerable virtualPathDependencies, DateTime utcStart)
{
throw new NotImplementedException();
}
public override bool AffectsPath(PathDefinition path) => path.ConversionStats.IsEmpty();
/// <inheritdoc />
protected override IEnumerable <string> GetCurrentFiles(PathDefinition definition, string path)
{
return(null);
}
/// <inheritdoc />
protected override bool CurrentExists(PathDefinition definition, string virtualPath)
{
var controlPresentation = this.GetControlPresentation(definition, virtualPath);
return(controlPresentation != null && !controlPresentation.Data.IsNullOrEmpty());
}
public abstract bool AffectsPath(PathDefinition path);