private string GetUrlForCdn(ScriptManager scriptManager, string resourceName, Assembly assembly, bool hasDebugResource)
{
// if EnableCdn, then url always comes from mapping.Cdn[Debug]Path or WRA.CdnPath, if available.
// first see if the script description mapping has a cdn path defined
bool isDebuggingEnabled = IsDebuggingEnabled(scriptManager);
bool isAssemblyResource = !String.IsNullOrEmpty(resourceName);
bool secureConnection = scriptManager.IsSecureConnection;
isDebuggingEnabled = isDebuggingEnabled && (hasDebugResource || !isAssemblyResource);
string cdnPath = isDebuggingEnabled ?
(secureConnection ? ScriptInfo.CdnDebugPathSecureConnection : ScriptInfo.CdnDebugPath) :
(secureConnection ? ScriptInfo.CdnPathSecureConnection : ScriptInfo.CdnPath);
// then see if the WebResourceAttribute for the resource has one
// EXCEPT when the ScriptInfo has a cdnpath but it wasn't selected due to this being a secure connection
// and it does not support secure connections. Avoid having the HTTP cdn path come from the mapping and the
// HTTPS path come from the WRA.
if (isAssemblyResource && String.IsNullOrEmpty(cdnPath) && String.IsNullOrEmpty(isDebuggingEnabled ? ScriptInfo.CdnDebugPath : ScriptInfo.CdnPath))
{
ScriptResourceInfo scriptResourceInfo = ScriptResourceInfo.GetInstance(assembly, resourceName);
if (scriptResourceInfo != null)
{
cdnPath = secureConnection ? scriptResourceInfo.CdnPathSecureConnection : scriptResourceInfo.CdnPath;
}
}
return(String.IsNullOrEmpty(cdnPath) ? null : ClientUrlResolver.ResolveClientUrl(AddCultureName(scriptManager, cdnPath)));
}
private string GetUrlFromPath(ScriptManager scriptManager, string releasePath, string predeterminedDebugPath)
{
string path = GetPath(scriptManager, releasePath, predeterminedDebugPath, IsDebuggingEnabled(scriptManager));
if (IsBundleReference)
{
return(scriptManager.BundleReflectionHelper.GetBundleUrl(path));
}
return(ClientUrlResolver.ResolveClientUrl(path));
}
protected internal override string GetUrl(ScriptManager scriptManager, bool zip)
{
bool isDebuggingEnabled = !scriptManager.DeploymentSectionRetail &&
((ScriptMode == ScriptMode.Debug) ||
(((ScriptMode == ScriptMode.Inherit) || (ScriptMode == ScriptMode.Auto)) &&
(scriptManager.IsDebuggingEnabled)));
if (!String.IsNullOrEmpty(Path))
{
string path = Path;
if (isDebuggingEnabled)
{
path = GetDebugPath(path);
}
if (scriptManager.EnableScriptLocalization &&
(ResourceUICultures != null) && (ResourceUICultures.Length != 0))
{
CultureInfo currentCulture = CultureInfo.CurrentUICulture;
string cultureName = null;
bool found = false;
while (!currentCulture.Equals(CultureInfo.InvariantCulture))
{
cultureName = currentCulture.ToString();
foreach (string uiCulture in ResourceUICultures)
{
if (String.Equals(cultureName, uiCulture.Trim(), StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
if (found)
{
break;
}
currentCulture = currentCulture.Parent;
}
if (found)
{
path = (path.Substring(0, path.Length - 2) + cultureName + ".js");
}
}
// ResolveClientUrl is appropriate here because the path is consumed by the page it was declared within
return(ClientUrlResolver.ResolveClientUrl(path));
}
List <Tuple <Assembly, List <Tuple <string, CultureInfo> > > > resources =
new List <Tuple <Assembly, List <Tuple <string, CultureInfo> > > >();
Tuple <Assembly, List <Tuple <string, CultureInfo> > > resourceList = null;
foreach (ScriptReference reference in Scripts)
{
if ((scriptManager.AjaxFrameworkMode == AjaxFrameworkMode.Explicit) &&
reference.IsAjaxFrameworkScript(scriptManager) &&
reference.EffectiveResourceName.StartsWith("MicrosoftAjax.", StringComparison.Ordinal))
{
continue;
}
bool hasPath = !String.IsNullOrEmpty(reference.EffectivePath);
#pragma warning disable 618
// ScriptPath is obsolete but still functional
bool hasScriptPath = (!String.IsNullOrEmpty(scriptManager.ScriptPath) && !reference.IgnoreScriptPath);
#pragma warning restore 618
// cacheAssembly will be null if ScriptPath is set, but we still need the resource assembly in that case
Assembly resourceAssembly = null;
string resourceName = null;
Assembly cacheAssembly = null;
ScriptMode effectiveScriptModeForReference = reference.EffectiveScriptMode;
bool isDebuggingEnabledForReference =
(effectiveScriptModeForReference == ScriptMode.Inherit) ?
isDebuggingEnabled :
(effectiveScriptModeForReference == ScriptMode.Debug);
if (!hasPath)
{
resourceAssembly = reference.GetAssembly(scriptManager);
resourceName = reference.EffectiveResourceName;
reference.DetermineResourceNameAndAssembly(scriptManager, isDebuggingEnabledForReference,
ref resourceName, ref resourceAssembly);
if ((resourceAssembly != scriptManager.AjaxFrameworkAssembly) &&
(resourceAssembly != AssemblyCache.SystemWebExtensions) &&
AssemblyCache.IsAjaxFrameworkAssembly(resourceAssembly))
{
// if it is coming from an assembly that is not the current ajax script assembly, make sure the assembly
// is not meant to be an ajax script assembly.
// it isnt an AjaxFrameworkScript but it might be from an assembly that is meant to
// be an ajax script assembly, in which case we should throw an error.
throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture,
AtlasWeb.ScriptReference_ResourceRequiresAjaxAssembly, resourceName, resourceAssembly));
}
if (!hasScriptPath)
{
// The resource requested in the composite url will only contain the assembly name if it
// will ultimately come from the assembly -- if ScriptPath is set, it doesn't.
// We do still need to know the resource assembly in that case though, hence the separate
// assembly variables.
cacheAssembly = resourceAssembly;
}
}
CultureInfo culture = reference.DetermineCulture(scriptManager);
if ((resourceList == null) || (resourceList.Item1 != cacheAssembly))
{
resourceList = new Tuple <Assembly, List <Tuple <string, CultureInfo> > >(
cacheAssembly, new List <Tuple <string, CultureInfo> >());
resources.Add(resourceList);
}
if (hasPath || hasScriptPath)
{
if (hasPath)
{
if (String.IsNullOrEmpty(reference.Path))
{
// the Path is coming from a script mapping, so its debug path applies
resourceName = reference.GetPath(scriptManager, reference.EffectivePath, reference.ScriptInfo.DebugPath,
isDebuggingEnabledForReference);
}
else
{
// path explicitly set, even if a mapping has a DebugPath it does not apply
resourceName = reference.GetPath(scriptManager, reference.Path, null,
isDebuggingEnabledForReference);
}
}
else
{
#pragma warning disable 618
// ScriptPath is obsolete but still functional
resourceName = ScriptReference.GetScriptPath(resourceName, resourceAssembly,
culture, scriptManager.ScriptPath);
#pragma warning restore 618
}
// ResolveClientUrl not appropriate here because the handler that will serve the response is not
// in the same directory as the page that is generating the url. Instead, an absolute url is needed
// as with ResolveUrl(). However, ResolveUrl() would prepend the entire application root name. For
// example, ~/foo.js would be /TheApplicationRoot/foo.js. If there are many path based scripts the
// app root would be repeated many times, which for deep apps or long named apps could cause the url
// to reach the maximum 2048 characters very quickly. So, the path is combined with the control's
// AppRelativeTemplateSourceDirectory manually, so that ~/foo.js remains ~/foo.js, and foo/bar.js
// becomes ~/templatesource/foo/bar.js. Absolute paths can remain as is. The ScriptResourceHandler will
// resolve the ~/ with the app root using VirtualPathUtility.ToAbsolute().
if (UrlPath.IsRelativeUrl(resourceName) && !UrlPath.IsAppRelativePath(resourceName))
{
resourceName = UrlPath.Combine(ClientUrlResolver.AppRelativeTemplateSourceDirectory, resourceName);
}
}
resourceList.Item2.Add(new Tuple <string, CultureInfo>(resourceName, culture));
}
return(ScriptResourceHandler.GetScriptResourceUrl(resources, zip));
}
