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