/// <summary>
/// Returns the data which will be served to client depending on minification and compression settings.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="resource">Data container with the data to serve</param>
/// <param name="minificationEnabled">True, if the data should be minified, otherwise false</param>
/// <param name="contentCoding">The content coding to use when sending a response</param>
/// <returns>Data to serve in a form of a byte block</returns>
private static byte[] GetOutputData(HttpContext context, CMSOutputResource resource, bool minificationEnabled, out string contentCoding)
{
// minification must be allowed by the server and minified data must be available
bool minified = minificationEnabled && resource.ContainsMinifiedData;
// compression must be allowed by server, supported by client and compressed data must be available
bool compressed = RequestHelper.AllowResourceCompression && RequestHelper.IsGZipSupported() && resource.ContainsCompressedData;
// Set deafult content encoding
contentCoding = ContentCodingEnum.IDENTITY;
// Get the proper version of resource to serve based on the settings
if (!minified && !compressed)
{
return(Encoding.UTF8.GetBytes(resource.Data));
}
else if (minificationEnabled && !compressed)
{
return(Encoding.UTF8.GetBytes(resource.MinifiedData));
}
else if (!minified && compressed)
{
contentCoding = ContentCodingEnum.DEFLATE;
return(resource.CompressedData);
}
else if (minified && compressed)
{
contentCoding = ContentCodingEnum.DEFLATE;
return(resource.MinifiedCompressedData);
}
else
{
return(new byte[0]);
}
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputResource file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
Response.Cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
// Send the file
if ((file != null) && (file.Data != null))
{
// Prepare response
Response.ContentType = "text/css";
// Client caching - only on the live site
if (useClientCache && AllowCache && CacheHelper.CacheImageEnabled(CurrentSiteName) && ETagsMatch(file.Etag, file.LastModified))
{
RespondNotModified(file.Etag);
return;
}
if (useClientCache && AllowCache && CacheHelper.CacheImageEnabled(CurrentSiteName))
{
SetTimeStamps(file.LastModified);
Response.Cache.SetETag(file.Etag);
}
// Add the file data
Response.Write(file.Data);
}
CompleteRequest();
}
/// <summary>
/// Retrieves the stylesheets of the page template from the database.
/// </summary>
/// <param name="templateName">Template name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetTemplate(string templateName)
{
// Try to get global one
PageTemplateInfo templateInfo = PageTemplateInfoProvider.GetPageTemplateInfo(templateName);
// Try to get site one (ad-hoc) if not found
if (templateInfo == null)
{
templateInfo = PageTemplateInfoProvider.GetPageTemplateInfo(templateName, CMSContext.CurrentSiteID);
}
if (templateInfo == null)
{
return(null);
}
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(templateInfo.PageTemplateCSS, URLHelper.ApplicationPath),
LastModified = templateInfo.PageTemplateLastModified,
Etag = templateInfo.PageTemplateVersionGUID
};
return(resource);
}
/// <summary>
/// Minify supplied source according to settings.
/// </summary>
/// <param name="resource">Resource to minifz</param>
/// <param name="minifier">Minifier to use when creating minified version of the data</param>
/// <param name="minificationEnabled">True, if the data should be minified, otherwise false</param>
/// <param name="compressionEnabled">True, if data should be compressed, otherwise false</param>
private static void MinifyResource(CMSOutputResource resource, IResourceMinifier minifier, bool minificationEnabled, bool compressionEnabled)
{
if (resource == null)
{
return;
}
// Set up the settings
if (minificationEnabled && (minifier != null))
{
resource.MinifiedData = minifier.Minify(resource.Data);
}
// Compress
if (RequestHelper.AllowResourceCompression && compressionEnabled)
{
resource.CompressedData = Compress(resource.Data);
}
// Compress and minify
if (minificationEnabled && RequestHelper.AllowResourceCompression && compressionEnabled)
{
resource.MinifiedCompressedData = Compress(resource.MinifiedData);
}
}
/// <summary>
/// Wraps a piece of text in a data container.
/// </summary>
/// <param name="resource">Text to wrap</param>
/// <param name="name">Identifier for the file</param>
/// <param name="etag">Etag to use for versioning</param>
/// <param name="lastModified">Timestamp of the last modification of data</param>
/// <param name="minifier">Minifier to use when creating minified version of the data</param>
/// <param name="minificationEnabled">True, if the data should be minified, otherwise false</param>
/// <returns>Data container containing the piece of text</returns>
private static CMSOutputResource WrapObject(string resource, string name, string etag, DateTime lastModified, IResourceMinifier minifier, bool minificationEnabled)
{
if (resource == null)
{
return(null);
}
// Prepare new output resource object
CMSOutputResource wrapper = new CMSOutputResource()
{
Name = name,
Etag = etag,
LastModified = lastModified,
Data = resource,
};
// Set up the settings
if (minificationEnabled)
{
wrapper.MinifiedData = minifier.Minify(wrapper.Data);
}
if (RequestHelper.AllowResourceCompression)
{
wrapper.CompressedData = Compress(resource);
}
if (minificationEnabled && RequestHelper.AllowResourceCompression)
{
wrapper.MinifiedCompressedData = Compress(wrapper.MinifiedData);
}
return(wrapper);
}
/// <summary>
/// Combines the given list of resources into a single resource
/// </summary>
/// <param name="resources">Resources to combine</param>
private static CMSOutputResource CombineResources(List <CMSOutputResource> resources)
{
StringBuilder data = new StringBuilder();
StringBuilder etag = new StringBuilder();
DateTime lastModified = DateTimeHelper.ZERO_TIME;
// Build single resource
foreach (CMSOutputResource resource in resources)
{
if (resource != null)
{
string newData = resource.Data;
// Join the data into a single string
if ((data.Length > 0) && !String.IsNullOrEmpty(newData))
{
// Trim the charset
newData = CSSHelper.TrimCharset(newData);
if (String.IsNullOrEmpty(newData))
{
continue;
}
data.AppendLine();
data.AppendLine();
}
data.Append(newData);
// Join e-tags
if (etag.Length > 0)
{
etag.Append('|');
}
etag.Append(resource.Etag);
// Remember the largest last modified
if (resource.LastModified > lastModified)
{
lastModified = resource.LastModified;
}
}
}
// Build the result
CMSOutputResource result = new CMSOutputResource()
{
Data = data.ToString(),
Etag = etag.ToString(),
LastModified = lastModified
};
return(result);
}
/// <summary>
/// Checks if this is a revalidation request for a physical file that did not change since the last time.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="path">Full physical path to the file</param>
private static void CheckRevalidation(HttpContext context, string path)
{
// Virtual resource, used only to check if revalidation can be short-circuited
CMSOutputResource fileResource = new CMSOutputResource()
{
Etag = GetFileEtag(path),
LastModified = File.GetLastWriteTime(path)
};
if (IsResourceUnchanged(context, fileResource))
{
SendNotModifiedResponse(context, fileResource.LastModified, fileResource.Etag, PhysicalFilesCacheMinutes, true);
}
}
/// <summary>
/// Processes the given request.
/// </summary>
/// <param name="context">Http context</param>
/// <param name="settings">CSS Settings</param>
private static void ProcessRequest(HttpContext context, CMSCssSettings settings)
{
CMSOutputResource resource = null;
// Get cache setting for physical files
int cacheMinutes = PhysicalFilesCacheMinutes;
int clientCacheMinutes = cacheMinutes;
bool hasVirtualContent = settings.HasVirtualContent();
if (hasVirtualContent)
{
// Use specific cache settings if DB resources are requested
cacheMinutes = CacheMinutes;
clientCacheMinutes = ClientCacheMinutes;
}
// Try to get data from cache (or store them if not found)
using (CachedSection <CMSOutputResource> cachedSection = new CachedSection <CMSOutputResource>(ref resource, cacheMinutes, true, null, "getresource", CMSContext.CurrentSiteName, context.Request.QueryString, URLHelper.IsSSL))
{
// Not found in cache; load the data
if (cachedSection.LoadData)
{
// Load the data
resource = GetResource(settings, URLHelper.Url.ToString(), cachedSection.Cached);
// Cache the file
if ((resource != null) && (cachedSection.Cached))
{
cachedSection.CacheDependency = resource.CacheDependency;
cachedSection.Data = resource;
}
}
}
// Send response if there's something to send
if (resource != null)
{
bool allowCache = (!hasVirtualContent || ClientCacheEnabled) && CacheHelper.AlwaysCacheResources;
SendResponse(context, resource, MimeTypeHelper.GetMimetype(CSS_FILE_EXTENSION), allowCache, CSSHelper.StylesheetMinificationEnabled, clientCacheMinutes);
}
else
{
SendNotFoundResponse(context);
}
}
/// <summary>
/// Retrieve the stylesheet either from the database or file if checked out.
/// </summary>
/// <param name="stylesheetName">Stylesheet's unique name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetStylesheet(string stylesheetName)
{
// Get the stylesheet
CssStylesheetInfo stylesheetInfo = CssStylesheetInfoProvider.GetCssStylesheetInfo(stylesheetName);
if (stylesheetInfo == null)
{
return(null);
}
// Determine if the stylesheet is checked out or not
string checkedOutFile = URLHelper.GetPhysicalPath(stylesheetInfo.StylesheetCheckedOutFilename);
string stylesheet;
DateTime lastModified;
if ((stylesheetInfo.StylesheetCheckedOutByUserID > 0) &&
(string.Equals(stylesheetInfo.StylesheetCheckedOutMachineName, HTTPHelper.MachineName, StringComparison.OrdinalIgnoreCase)) &&
(File.Exists(checkedOutFile)))
{
// Read the stylesheet and timestamp from the checked out file
using (StreamReader reader = StreamReader.New(checkedOutFile))
{
stylesheet = reader.ReadToEnd();
}
lastModified = File.GetLastWriteTime(checkedOutFile);
}
else
{
// Read the stylesheet and timestamp from database
stylesheet = stylesheetInfo.StylesheetText;
lastModified = stylesheetInfo.StylesheetLastModified;
}
// Build the output
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(stylesheet, URLHelper.ApplicationPath),
Name = stylesheetInfo.StylesheetName,
LastModified = lastModified,
Etag = stylesheetName,
};
return(resource);
}
/// <summary>
/// Retrieves the stylesheets of the web part layout from the database.
/// </summary>
/// <param name="layoutFullName">Layout full name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetTransformation(string transformationFullName)
{
TransformationInfo transformationInfo = TransformationInfoProvider.GetTransformation(transformationFullName);
if (transformationInfo == null)
{
return(null);
}
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(transformationInfo.TransformationCSS, URLHelper.ApplicationPath),
LastModified = transformationInfo.TransformationLastModified,
Etag = transformationInfo.TransformationVersionGUID
};
return(resource);
}
/// <summary>
/// Retrieves the stylesheet of the web part from the database.
/// </summary>
/// <param name="webPartName">Web part name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetWebPart(string webPartName)
{
WebPartInfo webPartInfo = WebPartInfoProvider.GetWebPartInfo(webPartName);
if (webPartInfo == null)
{
return(null);
}
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(webPartInfo.WebPartCSS, URLHelper.ApplicationPath),
LastModified = webPartInfo.WebPartLastModified,
Etag = webPartInfo.WebPartName
};
return(resource);
}
/// <summary>
/// Retrieves the stylesheets of the layout from the database.
/// </summary>
/// <param name="layoutName">Layout name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetLayout(string layoutName)
{
LayoutInfo layoutInfo = LayoutInfoProvider.GetLayoutInfo(layoutName);
if (layoutInfo == null)
{
return(null);
}
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(layoutInfo.LayoutCSS, URLHelper.ApplicationPath),
LastModified = layoutInfo.LayoutLastModified,
Etag = layoutInfo.LayoutVersionGUID
};
return(resource);
}
/// <summary>
/// Retrieves the stylesheets of the web part container from the database.
/// </summary>
/// <param name="containerName">Container name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetContainer(string containerName)
{
WebPartContainerInfo containerInfo = WebPartContainerInfoProvider.GetWebPartContainerInfo(containerName);
if (containerInfo == null)
{
return(null);
}
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(containerInfo.ContainerCSS, URLHelper.ApplicationPath),
LastModified = containerInfo.ContainerLastModified,
Etag = containerInfo.ContainerName
};
return(resource);
}
/// <summary>
/// Checks if resource in the client cache matches the server version.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="resource">Resource to check</param>
/// <returns>true, if resource is unchanged, otherwise false</returns>
private static bool IsResourceUnchanged(HttpContext context, CMSOutputResource resource)
{
// Determine the last modified date and etag sent from the browser
string currentETag = RequestHelper.GetHeader("If-None-Match", string.Empty);
string ifModified = RequestHelper.GetHeader("If-Modified-Since", string.Empty);
// If resources match, compare last modification timestamps
if ((ifModified != string.Empty) && (currentETag == resource.Etag))
{
// Get first part of header (colons can delimit additional data)
DateTime modifiedStamp;
if (DateTime.TryParse(ifModified.Split(";".ToCharArray())[0], out modifiedStamp))
{
return(resource.LastModified <= modifiedStamp.AddSeconds(1));
}
}
return(false);
}
/// <summary>
/// Processes the stylesheet.
/// </summary>
protected void ProcessStylesheet()
{
// Newsletter template stylesheet
if (!string.IsNullOrEmpty(newsletterTemplateName))
{
// Get the template
et = EmailTemplateInfoProvider.GetEmailTemplateInfo(newsletterTemplateName, SiteContext.CurrentSiteID);
if (et != null)
{
// Create the output file
outputFile = new CMSOutputResource()
{
Name = RequestContext.URL.ToString(),
Data = HTMLHelper.ResolveCSSUrls(et.TemplateStylesheetText, SystemContext.ApplicationPath),
Etag = et.TemplateName
};
}
}
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputResource file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
Response.Cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
// Send the file
if ((file != null) && (file.Data != null))
{
// Prepare response
Response.ContentType = "text/css";
// Client caching - only on the live site
if (useClientCache && PortalContext.ViewMode.IsLiveSite() && (CacheHelper.CacheImageEnabled(CurrentSiteName)) && ETagsMatch(file.Etag, file.LastModified))
{
RespondNotModified(file.Etag, true);
return;
}
if (useClientCache && PortalContext.ViewMode.IsLiveSite() && (CacheHelper.CacheImageEnabled(CurrentSiteName)))
{
DateTime expires = DateTime.Now;
// Send last modified header to allow client caching
Response.Cache.SetLastModified(file.LastModified);
Response.Cache.SetCacheability(HttpCacheability.Public);
if (DocumentBase.AllowClientCache())
{
expires = DateTime.Now.AddMinutes(CacheHelper.CacheImageMinutes(CurrentSiteName));
}
Response.Cache.SetExpires(expires);
Response.Cache.SetETag(file.Etag);
}
// Add the file data
Response.Write(file.Data);
}
CompleteRequest();
}
/// <summary>
/// Retrieves the stylesheet from file
/// </summary>
/// <param name="url">File URL</param>
/// <param name="extension">File extension</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetFile(string url, string extension)
{
string path = URLHelper.GetPhysicalPath(URLHelper.GetVirtualPath(url));
// Get the file content
string fileContent = ReadFile(path, extension);
fileContent = HTMLHelper.ResolveCSSClientUrls(fileContent, URLHelper.GetAbsoluteUrl(url));
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = fileContent,
Name = path,
Etag = GetFileEtag(path),
LastModified = File.GetLastWriteTime(path)
};
return(resource);
}
/// <summary>
/// Processes a request for a file.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="queryArgument">Name of the argument whose value specifies the location of the data</param>
/// <param name="fileExtension">File extension to check against (to prevent serving unauthorized content)</param>
/// <param name="minifier">Minifier that should be used to transform the original data</param>
/// <param name="contentType">Content type to use when sending a response</param>
/// <param name="minificationEnabled">True, if the data should be minified, otherwise false</param>
private static void ProcessFileRequest(HttpContext context, string queryArgument, string fileExtension, IResourceMinifier minifier, string contentType, bool minificationEnabled)
{
// Get URL to the resource file, resolve it in case it's virtual and map to physical path
string url = QueryHelper.GetString(queryArgument, string.Empty);
string path = URLHelper.GetPhysicalPath(URLHelper.GetVirtualPath(url));
// If this is revalidation request, try quick revalidation check before reading the file
CheckRevalidation(context, path);
CMSOutputResource resource = null;
// Try to get data from cache (or store them if not found)
using (CachedSection <CMSOutputResource> cachedSection = new CachedSection <CMSOutputResource>(ref resource, PhysicalFilesCacheMinutes, true, null, "getresource", path, URLHelper.IsSSL))
{
// Not found in cache; load the data
if (cachedSection.LoadData)
{
// Retrieve the file resource, rebase client URLs and wrap it in output container
resource = GetFile(url, fileExtension);
MinifyResource(resource, minifier, minificationEnabled, true);
// Cache the file
if ((resource != null) && (cachedSection.Cached))
{
cachedSection.CacheDependency = new CMSCacheDependency(path);
cachedSection.Data = resource;
}
}
}
// Send response if there's something to send
if (resource != null)
{
bool allowCache = CacheHelper.AlwaysCacheResources;
SendResponse(context, resource, contentType, allowCache, minificationEnabled, PhysicalFilesCacheMinutes);
}
else
{
SendNotFoundResponse(context);
}
}
/// <summary>
/// Sends a response containing the requested data.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="resource">Container with the data to serve</param>
/// <param name="contentType">Content type to use when sending a response</param>
/// <param name="allowCache">True, if client caching is enabled, otherwise false</param>
/// <param name="minificationEnabled">True, if the data can be served minified, otherwise false</param>
/// <param name="clientCacheMinutes">Number of minutes after which the content in the client cache expires</param>
private static void SendResponse(HttpContext context, CMSOutputResource resource, string contentType, bool allowCache, bool minificationEnabled, int clientCacheMinutes)
{
// Set client cache revalidation
SetRevalidation(context);
// Let client use data cached in browser if versions match and there was no change in data
if (allowCache && IsResourceUnchanged(context, resource))
{
SendNotModifiedResponse(context, resource.LastModified, resource.Etag, clientCacheMinutes, true);
return;
}
else
{
// Otherwise get content to send
string contentCoding;
byte[] content = GetOutputData(context, resource, minificationEnabled, out contentCoding);
// Set client caching
if (allowCache)
{
SetClientCaching(context, allowCache, resource.LastModified, resource.Etag, clientCacheMinutes);
}
if (contentCoding != ContentCodingEnum.IDENTITY)
{
context.Response.AppendHeader("Content-Encoding", contentCoding);
context.Response.AppendHeader("Vary", "Content-Encoding");
}
context.Response.ContentType = contentType;
// Do not send output if there's none
if (content.Length > 0)
{
context.Response.OutputStream.Write(content, 0, content.Length);
}
}
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputResource file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
Response.Cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
// Send the file
if ((file != null) && (file.Data != null))
{
// Prepare response
Response.ContentType = "text/css";
// Client caching - only on the live site
if (useClientCache && AllowCache && CacheHelper.CacheImageEnabled(CurrentSiteName) && ETagsMatch(file.Etag, file.LastModified))
{
RespondNotModified(file.Etag);
return;
}
if (useClientCache && AllowCache && CacheHelper.CacheImageEnabled(CurrentSiteName))
{
SetTimeStamps(file.LastModified);
Response.Cache.SetETag(file.Etag);
}
// Add the file data
Response.Write(file.Data);
}
CompleteRequest();
}
/// <summary>
/// Combines the given list of resources into a single resource
/// </summary>
/// <param name="resources">Resources to combine</param>
private static CMSOutputResource CombineResources(List<CMSOutputResource> resources)
{
StringBuilder data = new StringBuilder();
StringBuilder etag = new StringBuilder();
DateTime lastModified = DateTimeHelper.ZERO_TIME;
// Build single resource
foreach (CMSOutputResource resource in resources)
{
if (resource != null)
{
string newData = resource.Data;
// Join the data into a single string
if ((data.Length > 0) && !String.IsNullOrEmpty(newData))
{
// Trim the charset
newData = CSSHelper.TrimCharset(newData);
if (String.IsNullOrEmpty(newData))
{
continue;
}
data.AppendLine();
data.AppendLine();
}
data.Append(newData);
// Join e-tags
if (etag.Length > 0)
{
etag.Append('|');
}
etag.Append(resource.Etag);
// Remember the largest last modified
if (resource.LastModified > lastModified)
{
lastModified = resource.LastModified;
}
}
}
// Build the result
CMSOutputResource result = new CMSOutputResource()
{
Data = data.ToString(),
Etag = etag.ToString(),
LastModified = lastModified
};
return result;
}
/// <summary>
/// Retrieves the stylesheet from file
/// </summary>
/// <param name="item">File item</param>
/// <param name="extension">File extension</param>
/// <param name="resolveCSSUrls">If true, the CSS URLs are resolved in the output</param>
/// <param name="binary">If true, the file is a binary file</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetFile(CMSItem item, string extension, bool resolveCSSUrls, bool binary)
{
string url = item.Name;
string path = URLHelper.GetPhysicalPath(URLHelper.GetVirtualPath(url));
// Get the file content
string fileContent = null;
byte[] binaryData = null;
if (binary)
{
// Binary file
binaryData = ReadBinaryFile(path, extension);
}
else
{
// Text file
fileContent = ReadFile(path, extension);
if (resolveCSSUrls)
{
fileContent = HTMLHelper.ResolveCSSClientUrls(fileContent, URLHelper.GetAbsoluteUrl(url));
}
}
var lastModified = File.GetLastWriteTime(path);
// Build the result
var resource = new CMSOutputResource()
{
Data = fileContent,
BinaryData = binaryData,
Name = path,
Etag = "file|" + lastModified.ToString(),
LastModified = lastModified,
ContentType = MimeTypeHelper.GetMimetype(extension),
FileName = Path.GetFileName(path),
Extension = extension
};
return resource;
}
/// <summary>
/// Returns the data which will be served to client depending on minification and compression settings.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="resource">Data container with the data to serve</param>
/// <param name="minificationEnabled">True, if the data should be minified, otherwise false</param>
/// <param name="contentCoding">The content coding to use when sending a response</param>
/// <returns>Data to serve in a form of a byte block</returns>
private static byte[] GetOutputData(HttpContext context, CMSOutputResource resource, bool minificationEnabled, out string contentCoding)
{
// minification must be allowed by the server and minified data must be available
bool minified = minificationEnabled && resource.ContainsMinifiedData;
// compression must be allowed by server, supported by client and compressed data must be available
bool allowCompression = false;
if (CMSAppBase.ConnectionAvailable)
{
allowCompression = RequestHelper.AllowResourceCompression;
}
bool compressed = allowCompression && RequestHelper.IsGZipSupported() && resource.ContainsCompressedData;
// Set default content encoding
contentCoding = ContentCodingEnum.IDENTITY;
// Get the proper version of resource to serve based on the settings
if (!minified && !compressed)
{
return Encoding.UTF8.GetBytes(resource.Data);
}
else if (minificationEnabled && !compressed)
{
return Encoding.UTF8.GetBytes(resource.MinifiedData);
}
else if (!minified && compressed)
{
contentCoding = ContentCodingEnum.DEFLATE;
return resource.CompressedData;
}
else if (minified && compressed)
{
contentCoding = ContentCodingEnum.DEFLATE;
return resource.MinifiedCompressedData;
}
else
{
return new byte[0];
}
}
/// <summary>
/// Checks if this is a revalidation request for a physical file that did not change since the last time.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="path">Full physical path to the file</param>
private static void CheckRevalidation(HttpContext context, string path)
{
var lastModified = File.GetLastWriteTime(path);
// Virtual resource, used only to check if revalidation can be short-circuited
CMSOutputResource fileResource = new CMSOutputResource()
{
Etag = lastModified.ToString(),
LastModified = lastModified
};
if (IsResourceUnchanged(context, fileResource))
{
SendNotModifiedResponse(context, fileResource.LastModified, fileResource.Etag, PhysicalFilesCacheMinutes, true);
}
}
/// <summary>
/// Retrieves the stylesheets of the web part container from the database.
/// </summary>
/// <param name="item">Container item</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetContainer(CMSItem item)
{
WebPartContainerInfo containerInfo = null;
if (item.Name != null)
{
containerInfo = WebPartContainerInfoProvider.GetWebPartContainerInfo(item.Name);
}
else
{
containerInfo = WebPartContainerInfoProvider.GetWebPartContainerInfo(item.ID);
}
if (containerInfo == null)
{
return null;
}
DateTime lastModified = containerInfo.ContainerLastModified;
// Build the result
var resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(containerInfo.ContainerCSS, URLHelper.ApplicationPath),
LastModified = lastModified,
Etag = "webpartcontainer|" + lastModified.ToString(),
FileName = ValidationHelper.GetSafeFileName(containerInfo.ContainerName),
Extension = ".css"
};
return resource;
}
/// <summary>
/// Wraps a piece of text in a data container.
/// </summary>
/// <param name="resource">Text to wrap</param>
/// <param name="name">Identifier for the file</param>
/// <param name="etag">Etag to use for versioning</param>
/// <param name="lastModified">Timestamp of the last modification of data</param>
/// <param name="minifier">Minifier to use when creating minified version of the data</param>
/// <param name="minificationEnabled">True, if the data should be minified, otherwise false</param>
/// <returns>Data container containing the piece of text</returns>
private static CMSOutputResource WrapObject(string resource, string name, string etag, DateTime lastModified, IResourceMinifier minifier, bool minificationEnabled)
{
if (resource == null)
{
return null;
}
// Prepare new output resource object
CMSOutputResource wrapper = new CMSOutputResource()
{
Name = name,
Etag = etag,
LastModified = lastModified,
Data = resource,
};
// Set up the settings
if (minificationEnabled)
{
wrapper.MinifiedData = minifier.Minify(wrapper.Data);
}
if (RequestHelper.AllowResourceCompression)
{
wrapper.CompressedData = Compress(resource);
}
if (minificationEnabled && RequestHelper.AllowResourceCompression)
{
wrapper.MinifiedCompressedData = Compress(wrapper.MinifiedData);
}
return wrapper;
}
/// <summary>
/// Retrieves the specified resources and wraps them in an data container.
/// </summary>
/// <param name="settings">CSS settings</param>
/// <param name="name">Resource name</param>
/// <param name="cached">If true, the result will be cached</param>
/// <returns>The data container with the resulting stylesheet data</returns>
private static CMSOutputResource GetResource(CMSCssSettings settings, string name, bool cached)
{
List <CMSOutputResource> resources = new List <CMSOutputResource>();
// Add files
if (settings.Files != null)
{
foreach (string item in settings.Files)
{
// Get the resource
CMSOutputResource resource = GetFile(item, CSS_FILE_EXTENSION);
resources.Add(resource);
}
}
// Add stylesheets
if (settings.Stylesheets != null)
{
foreach (string item in settings.Stylesheets)
{
// Get the resource
CMSOutputResource resource = GetStylesheet(item);
resources.Add(resource);
}
}
// Add web part containers
if (settings.Containers != null)
{
foreach (string item in settings.Containers)
{
// Get the resource
CMSOutputResource resource = GetContainer(item);
resources.Add(resource);
}
}
// Add web parts
if (settings.WebParts != null)
{
foreach (string item in settings.WebParts)
{
// Get the resource
CMSOutputResource resource = GetWebPart(item);
resources.Add(resource);
}
}
// Add templates
if (settings.Templates != null)
{
foreach (string item in settings.Templates)
{
// Get the resource
CMSOutputResource resource = GetTemplate(item);
resources.Add(resource);
}
}
// Add layouts
if (settings.Layouts != null)
{
foreach (string item in settings.Layouts)
{
// Get the resource
CMSOutputResource resource = GetLayout(item);
resources.Add(resource);
}
}
// Add transformation containers
if (settings.Transformations != null)
{
foreach (string item in settings.Transformations)
{
// Get the resource
CMSOutputResource resource = GetTransformation(item);
resources.Add(resource);
}
}
// Add web part layouts
if (settings.WebPartLayouts != null)
{
foreach (string item in settings.WebPartLayouts)
{
// Get the resource
CMSOutputResource resource = GetWebPartLayout(item);
resources.Add(resource);
}
}
// Combine to a single output
CMSOutputResource result = CombineResources(resources);
// Resolve the macros
if (CSSHelper.ResolveMacrosInCSS)
{
MacroContext context = new MacroContext()
{
TrackCacheDependencies = cached
};
if (cached)
{
// Add the default dependencies
context.AddCacheDependencies(settings.GetCacheDependencies());
context.AddFileCacheDependencies(settings.GetFileCacheDependencies());
}
result.Data = CMSContext.ResolveMacros(result.Data, context);
if (cached)
{
// Add cache dependency
result.CacheDependency = CacheHelper.GetCacheDependency(context.FileCacheDependencies, context.CacheDependencies);
}
}
else if (cached)
{
// Only the cache dependency from settings
result.CacheDependency = settings.GetCacheDependency();
}
// Minify
MinifyResource(result, mCssMinifier, CSSHelper.StylesheetMinificationEnabled && settings.EnableMinification, settings.EnableMinification);
return(result);
}
/// <summary>
/// Retrieves the stylesheet from file
/// </summary>
/// <param name="url">File URL</param>
/// <param name="extension">File extension</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetFile(string url, string extension)
{
string path = URLHelper.GetPhysicalPath(URLHelper.GetVirtualPath(url));
// Get the file content
string fileContent = ReadFile(path, extension);
fileContent = HTMLHelper.ResolveCSSClientUrls(fileContent, URLHelper.GetAbsoluteUrl(url));
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = fileContent,
Name = path,
Etag = GetFileEtag(path),
LastModified = File.GetLastWriteTime(path)
};
return resource;
}
/// <summary>
/// Minify supplied source according to settings.
/// </summary>
/// <param name="resource">Resource to minifz</param>
/// <param name="minifier">Minifier to use when creating minified version of the data</param>
/// <param name="minificationEnabled">True, if the data should be minified, otherwise false</param>
/// <param name="compressionEnabled">True, if data should be compressed, otherwise false</param>
private static void MinifyResource(CMSOutputResource resource, IResourceMinifier minifier, bool minificationEnabled, bool compressionEnabled)
{
if (resource == null)
{
return;
}
// Set up the settings
if (minificationEnabled && (minifier != null))
{
resource.MinifiedData = minifier.Minify(resource.Data);
}
// Compress
if (RequestHelper.AllowResourceCompression && compressionEnabled)
{
resource.CompressedData = Compress(resource.Data);
}
// Compress and minify
if (minificationEnabled && RequestHelper.AllowResourceCompression && compressionEnabled)
{
resource.MinifiedCompressedData = Compress(resource.MinifiedData);
}
}
/// <summary>
/// Retrieve the stylesheet either from the database or file if checked out.
/// </summary>
/// <param name="stylesheetName">Stylesheet's unique name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetStylesheet(string stylesheetName)
{
// Get the stylesheet
CssStylesheetInfo stylesheetInfo = CssStylesheetInfoProvider.GetCssStylesheetInfo(stylesheetName);
if (stylesheetInfo == null)
{
return null;
}
// Determine if the stylesheet is checked out or not
string checkedOutFile = URLHelper.GetPhysicalPath(stylesheetInfo.StylesheetCheckedOutFilename);
string stylesheet;
DateTime lastModified;
if ((stylesheetInfo.StylesheetCheckedOutByUserID > 0) &&
(string.Equals(stylesheetInfo.StylesheetCheckedOutMachineName, HTTPHelper.MachineName, StringComparison.OrdinalIgnoreCase)) &&
(File.Exists(checkedOutFile)))
{
// Read the stylesheet and timestamp from the checked out file
using (StreamReader reader = StreamReader.New(checkedOutFile))
{
stylesheet = reader.ReadToEnd();
}
lastModified = File.GetLastWriteTime(checkedOutFile);
}
else
{
// Read the stylesheet and timestamp from database
stylesheet = stylesheetInfo.StylesheetText;
lastModified = stylesheetInfo.StylesheetLastModified;
}
// Build the output
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(stylesheet, URLHelper.ApplicationPath),
Name = stylesheetInfo.StylesheetName,
LastModified = lastModified,
Etag = stylesheetName,
};
return resource;
}
/// <summary>
/// Retrieves the stylesheets of the page template from the database.
/// </summary>
/// <param name="templateName">Template name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetTemplate(string templateName)
{
// Try to get global one
PageTemplateInfo templateInfo = PageTemplateInfoProvider.GetPageTemplateInfo(templateName);
// Try to get site one (ad-hoc) if not found
if (templateInfo == null)
{
templateInfo = PageTemplateInfoProvider.GetPageTemplateInfo(templateName, CMSContext.CurrentSiteID);
}
if (templateInfo == null)
{
return null;
}
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(templateInfo.PageTemplateCSS, URLHelper.ApplicationPath),
LastModified = templateInfo.PageTemplateLastModified,
Etag = templateInfo.PageTemplateVersionGUID
};
return resource;
}
/// <summary>
/// Retrieves the stylesheets of the web part layout from the database.
/// </summary>
/// <param name="layoutFullName">Layout full name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetTransformation(string transformationFullName)
{
TransformationInfo transformationInfo = TransformationInfoProvider.GetTransformation(transformationFullName);
if (transformationInfo == null)
{
return null;
}
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(transformationInfo.TransformationCSS, URLHelper.ApplicationPath),
LastModified = transformationInfo.TransformationLastModified,
Etag = transformationInfo.TransformationVersionGUID
};
return resource;
}
/// <summary>
/// Minify supplied source according to settings.
/// </summary>
/// <param name="resource">Resource to minifz</param>
/// <param name="minifier">Minifier to use when creating minified version of the data</param>
/// <param name="minificationEnabled">True, if the data should be minified, otherwise false</param>
/// <param name="compressionEnabled">True, if data should be compressed, otherwise false</param>
private static void MinifyResource(CMSOutputResource resource, IResourceMinifier minifier, bool minificationEnabled, bool compressionEnabled)
{
if (resource == null)
{
return;
}
// Set up the settings
if (minificationEnabled && (minifier != null))
{
resource.MinifiedData = minifier.Minify(resource.Data);
}
// Check whether the compression is enabled
if (compressionEnabled && CMSAppBase.ConnectionAvailable)
{
compressionEnabled &= RequestHelper.AllowResourceCompression;
}
// Compress
if (compressionEnabled)
{
resource.CompressedData = Compress(resource.Data);
}
// Compress and minify
if (minificationEnabled && compressionEnabled)
{
resource.MinifiedCompressedData = Compress(resource.MinifiedData);
}
}
/// <summary>
/// Retrieves the stylesheets of the web part container from the database.
/// </summary>
/// <param name="containerName">Container name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetContainer(string containerName)
{
WebPartContainerInfo containerInfo = WebPartContainerInfoProvider.GetWebPartContainerInfo(containerName);
if (containerInfo == null)
{
return null;
}
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(containerInfo.ContainerCSS, URLHelper.ApplicationPath),
LastModified = containerInfo.ContainerLastModified,
Etag = containerInfo.ContainerName
};
return resource;
}
/// <summary>
/// Sends a response containing the requested data.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="resource">Container with the data to serve</param>
/// <param name="allowCache">True, if client caching is enabled, otherwise false</param>
/// <param name="minificationEnabled">True, if the data can be served minified, otherwise false</param>
/// <param name="clientCacheMinutes">Number of minutes after which the content in the client cache expires</param>
/// <param name="staticContent">If true, the content is static</param>
private static void SendResponse(HttpContext context, CMSOutputResource resource, bool allowCache, bool minificationEnabled, int clientCacheMinutes, bool staticContent)
{
// Set client cache revalidation
SetRevalidation(context, staticContent);
// Let client use data cached in browser if versions match and there was no change in data
if (allowCache && IsResourceUnchanged(context, resource))
{
SendNotModifiedResponse(context, resource.LastModified, resource.Etag, clientCacheMinutes, true);
return;
}
else
{
byte[] content = null;
if (resource.Data == null)
{
// Binary content
content = resource.BinaryData;
}
else
{
// Text content
string contentCoding = null;
content = GetOutputData(context, resource, minificationEnabled, out contentCoding);
if (contentCoding != ContentCodingEnum.IDENTITY)
{
context.Response.AppendHeader("Content-Encoding", contentCoding);
context.Response.AppendHeader("Vary", "Content-Encoding");
}
}
if (content == null)
{
// 404 if no content found
RequestHelper.Respond404();
}
// Set client caching
if (allowCache)
{
SetClientCaching(context, allowCache, resource.LastModified, resource.Etag, clientCacheMinutes);
}
context.Response.ContentType = resource.ContentType;
// Set the file name and extension if defined
if (!String.IsNullOrEmpty(resource.FileName) && !String.IsNullOrEmpty(resource.Extension))
{
HTTPHelper.SetFileDisposition(resource.FileName, resource.Extension);
}
// Do not send output if there's none
if ((content != null) && (content.Length > 0))
{
context.Response.OutputStream.Write(content, 0, content.Length);
}
}
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputResource file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
Response.Cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
// Send the file
if ((file != null) && (file.Data != null))
{
// Client caching - only on the live site
if (useClientCache && (CMSContext.ViewMode == ViewModeEnum.LiveSite) && (CacheHelper.CacheImageEnabled(CurrentSiteName)) && ETagsMatch(file.Etag, file.LastModified))
{
RespondNotModified(file.Etag, true);
return;
}
// Prepare response
Response.ContentType = "text/css";
if (useClientCache && (CMSContext.ViewMode == ViewModeEnum.LiveSite) && (CacheHelper.CacheImageEnabled(CurrentSiteName)))
{
DateTime expires = DateTime.Now;
// Send last modified header to allow client caching
Response.Cache.SetLastModified(file.LastModified);
Response.Cache.SetCacheability(HttpCacheability.Public);
if (DocumentBase.AllowClientCache() && DocumentBase.UseFullClientCache)
{
expires = DateTime.Now.AddMinutes(CacheHelper.CacheImageMinutes(CurrentSiteName));
}
Response.Cache.SetExpires(expires);
Response.Cache.SetETag(file.Etag);
}
// Add the file data
Response.Write(file.Data);
}
CompleteRequest();
}
/// <summary>
/// Combines the given list of resources into a single resource
/// </summary>
/// <param name="resources">Resources to combine</param>
private static CMSOutputResource CombineResources(IEnumerable<CMSOutputResource> resources)
{
StringBuilder data = new StringBuilder();
StringBuilder etag = new StringBuilder();
DateTime lastModified = DateTimeHelper.ZERO_TIME;
List<string> files = new List<string>();
int count = 0;
string fileName = null;
// Build single resource
foreach (CMSOutputResource resource in resources)
{
if (resource != null)
{
string newData = resource.Data;
// Join the data into a single string
if ((data.Length > 0) && !String.IsNullOrEmpty(newData))
{
// Trim the charset
newData = CSSHelper.TrimCharset(newData);
if (String.IsNullOrEmpty(newData))
{
continue;
}
data.AppendLine();
data.AppendLine();
}
data.Append(newData);
// Join e-tags
if (etag.Length > 0)
{
etag.Append('|');
}
etag.Append(resource.Etag);
// Remember the largest last modified
if (resource.LastModified > lastModified)
{
lastModified = resource.LastModified;
}
files.AddRange(resource.ComponentFiles);
fileName = resource.Name;
}
count++;
}
// Build the result
CMSOutputResource result = new CMSOutputResource()
{
Data = data.ToString(),
Etag = etag.ToString(),
LastModified = lastModified,
ComponentFiles = files,
Extension = ".css"
};
// Set the file name
if (count == 1)
{
result.FileName = ValidationHelper.GetSafeFileName(fileName) + ".css";
}
else
{
result.FileName = "components.css";
}
return result;
}
/// <summary>
/// Retrieve the stylesheet either from the database or file if checked out.
/// </summary>
/// <param name="item">Stylesheet item</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetStylesheet(CMSItem item)
{
// Get the stylesheet
CssStylesheetInfo stylesheetInfo = null;
if (item.Name != null)
{
stylesheetInfo = CssStylesheetInfoProvider.GetCssStylesheetInfo(item.Name);
}
else
{
stylesheetInfo = CssStylesheetInfoProvider.GetCssStylesheetInfo(item.ID);
}
if (stylesheetInfo == null)
{
return null;
}
// Get last modified date with dependency on external storage
DateTime lastModified = stylesheetInfo.StylesheetLastModified;
FileInfo fi = stylesheetInfo.GetFileInfo(CssStylesheetInfo.EXTERNAL_COLUMN_CSS);
if (fi != null)
{
lastModified = fi.LastWriteTime.ToUniversalTime();
}
string stylesheetName = stylesheetInfo.StylesheetName;
// Build the output
var resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(stylesheetInfo.StylesheetText, URLHelper.ApplicationPath),
Name = stylesheetName,
LastModified = lastModified,
Etag = "cssstylesheet|" + stylesheetInfo.StylesheetVersionGUID.ToString(),
FileName = stylesheetName + ".css",
Extension = ".css"
};
// Add file dependency on component css file
if (fi != null)
{
resource.ComponentFiles.Add(stylesheetInfo.GetVirtualFileRelativePath(CssStylesheetInfo.EXTERNAL_COLUMN_CSS));
}
return resource;
}
/// <summary>
/// Retrieves the stylesheets of the device layout from the database.
/// </summary>
/// <param name="item">Device layout item</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetDeviceLayout(CMSItem item)
{
PageTemplateDeviceLayoutInfo layoutInfo = null;
if (item.Name != null)
{
// Not supported, device layout doesn't contain name
}
else
{
layoutInfo = PageTemplateDeviceLayoutInfoProvider.GetTemplateDeviceLayoutInfo(item.ID);
}
if (layoutInfo == null)
{
return null;
}
// Get last modified date with dependency on external storage
DateTime lastModified = layoutInfo.LayoutLastModified;
FileInfo fi = layoutInfo.GetFileInfo(PageTemplateDeviceLayoutInfo.EXTERNAL_COLUMN_CSS);
if (fi != null)
{
lastModified = fi.LastWriteTime.ToUniversalTime();
}
// Build the result
var resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(layoutInfo.LayoutCSS, URLHelper.ApplicationPath),
LastModified = lastModified,
Etag = "layout|" + layoutInfo.LayoutVersionGUID,
FileName = Convert.ToString(layoutInfo.LayoutID),
Extension = ".css"
};
// Add file dependency on component css file
if (fi != null)
{
resource.ComponentFiles.Add(layoutInfo.GetVirtualFileRelativePath(PageTemplateDeviceLayoutInfo.EXTERNAL_COLUMN_CSS));
}
return resource;
}
/// <summary>
/// Retrieves the stylesheets of the page template from the database.
/// </summary>
/// <param name="item">Template item</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetTemplate(CMSItem item)
{
// Try to get global one
PageTemplateInfo templateInfo = null;
if (item.Name != null)
{
string templateName = item.Name;
templateInfo = PageTemplateInfoProvider.GetPageTemplateInfo(templateName);
// Try to get site one (ad-hoc) if not found
if (templateInfo == null)
{
templateInfo = PageTemplateInfoProvider.GetPageTemplateInfo(templateName, CMSContext.CurrentSiteID);
}
}
else
{
templateInfo = PageTemplateInfoProvider.GetPageTemplateInfo(item.ID);
}
if (templateInfo == null)
{
return null;
}
// Get last modified date with dependency on external storage
DateTime lastModified = templateInfo.PageTemplateLastModified;
FileInfo fi = templateInfo.GetFileInfo(PageTemplateInfo.EXTERNAL_COLUMN_CSS);
if (fi != null)
{
lastModified = fi.LastWriteTime.ToUniversalTime();
}
// Build the result
var resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(templateInfo.PageTemplateCSS, URLHelper.ApplicationPath),
LastModified = lastModified,
Etag = "template|" + templateInfo.PageTemplateVersionGUID,
FileName = ValidationHelper.GetSafeFileName(templateInfo.CodeName),
Extension = ".css"
};
// Add file dependency on component css file
if (fi != null)
{
resource.ComponentFiles.Add(templateInfo.GetVirtualFileRelativePath(PageTemplateInfo.EXTERNAL_COLUMN_CSS));
}
return resource;
}
/// <summary>
/// Retrieves the stylesheets of the layout from the database.
/// </summary>
/// <param name="item">Layout item</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetLayout(CMSItem item)
{
LayoutInfo layoutInfo = null;
if (item.Name != null)
{
layoutInfo = LayoutInfoProvider.GetLayoutInfo(item.Name);
}
else
{
layoutInfo = LayoutInfoProvider.GetLayoutInfo(item.ID);
}
if (layoutInfo == null)
{
return null;
}
// Get last modified date with dependency on external storage
DateTime lastModified = layoutInfo.LayoutLastModified;
FileInfo fi = layoutInfo.GetFileInfo(LayoutInfo.EXTERNAL_COLUMN_CSS);
if (fi != null)
{
lastModified = fi.LastWriteTime.ToUniversalTime();
}
// Build the result
var resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(layoutInfo.LayoutCSS, URLHelper.ApplicationPath),
LastModified = lastModified,
Etag = "layout|" + layoutInfo.LayoutVersionGUID,
FileName = ValidationHelper.GetSafeFileName(layoutInfo.LayoutCodeName),
Extension = ".css"
};
// Add file dependency on component css file
if (fi != null)
{
resource.ComponentFiles.Add(layoutInfo.GetVirtualFileRelativePath(LayoutInfo.EXTERNAL_COLUMN_CSS));
}
return resource;
}
/// <summary>
/// Retrieves the stylesheets of the web part layout from the database.
/// </summary>
/// <param name="item">Layout item</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetTransformation(CMSItem item)
{
TransformationInfo transformationInfo = null;
if (item.Name != null)
{
transformationInfo = TransformationInfoProvider.GetTransformation(item.Name);
}
else
{
transformationInfo = TransformationInfoProvider.GetTransformation(item.ID);
}
if (transformationInfo == null)
{
return null;
}
// Get last modified date with dependency on external storage
DateTime lastModified = transformationInfo.TransformationLastModified;
FileInfo fi = transformationInfo.GetFileInfo(TransformationInfo.EXTERNAL_COLUMN_CSS);
if (fi != null)
{
lastModified = fi.LastWriteTime.ToUniversalTime();
}
// Build the result
var resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(transformationInfo.TransformationCSS, URLHelper.ApplicationPath),
LastModified = lastModified,
Etag = "transformation|" + transformationInfo.TransformationVersionGUID,
FileName = ValidationHelper.GetSafeFileName(transformationInfo.TransformationFullName) + ".css",
Extension = ".css"
};
// Add file dependency on component css file
if (fi != null)
{
resource.ComponentFiles.Add(transformationInfo.GetVirtualFileRelativePath(TransformationInfo.EXTERNAL_COLUMN_CSS));
}
return resource;
}
/// <summary>
/// Generates the QR code
/// </summary>
/// <param name="code">Code to generate by the QR code</param>
/// <param name="size">Image size, image is rendered with recommended resolution for the QR code</param>
/// <param name="encoding">Encoding, possible options (B - Byte, AN - Alphanumeric, N - Numeric)</param>
/// <param name="version">QR code version (by default supported 1 to 10), additional data templates may be put into ~/App_Data/CMS_Modules/QRCode/Resources.zip</param>
/// <param name="correction">Correction type, possible options (L, M, Q, H)</param>
/// <param name="maxSideSize">Maximum size of the code in pixels, the code will be resized if larger than this size</param>
/// <param name="fgColor">Foreground color</param>
/// <param name="bgColor">Background color</param>
private static CMSOutputResource GetQRCode(string code, string encoding, int size, int version, string correction, int maxSideSize, Color fgColor, Color bgColor)
{
QRCodeEncoder qrCodeEncoder = new QRCodeEncoder();
try
{
// Set encoding
switch (encoding.ToLowerCSafe())
{
case "an":
qrCodeEncoder.QRCodeEncodeMode = QRCodeEncoder.ENCODE_MODE.ALPHA_NUMERIC;
break;
case "n":
qrCodeEncoder.QRCodeEncodeMode = QRCodeEncoder.ENCODE_MODE.NUMERIC;
break;
default:
qrCodeEncoder.QRCodeEncodeMode = QRCodeEncoder.ENCODE_MODE.BYTE;
break;
}
// Set scale
try
{
qrCodeEncoder.QRCodeScale = size;
}
catch
{
qrCodeEncoder.QRCodeScale = 4;
}
// Set error correction
switch (correction.ToLowerCSafe())
{
case "l":
qrCodeEncoder.QRCodeErrorCorrect = QRCodeEncoder.ERROR_CORRECTION.L;
break;
case "q":
qrCodeEncoder.QRCodeErrorCorrect = QRCodeEncoder.ERROR_CORRECTION.Q;
break;
case "h":
qrCodeEncoder.QRCodeErrorCorrect = QRCodeEncoder.ERROR_CORRECTION.H;
break;
default:
qrCodeEncoder.QRCodeErrorCorrect = QRCodeEncoder.ERROR_CORRECTION.M;
break;
}
// Set colors
qrCodeEncoder.QRCodeForegroundColor = fgColor;
qrCodeEncoder.QRCodeBackgroundColor = bgColor;
Image image = null;
// Attempt to process all versions
while (version <= 40)
{
if (!QRVersionSupported(version))
{
// Move to higher version
version++;
if (version > 40)
{
throw new Exception("Version higher than 40 is not supported.");
}
continue;
}
try
{
// Try to get requested version
qrCodeEncoder.QRCodeVersion = version;
image = qrCodeEncoder.Encode(code);
break;
}
catch (IndexOutOfRangeException ex)
{
// Try next version to fit the data
version++;
if (version > 40)
{
throw ex;
}
}
}
byte[] bytes = ImageHelper.GetBytes(image, ImageFormat.Png);
// Resize to a proper size
if (maxSideSize > 0)
{
// Resize the image by image helper to a proper size
ImageHelper ih = new ImageHelper(bytes);
image = ih.GetResizedImage(maxSideSize);
bytes = ImageHelper.GetBytes(image, ImageFormat.Png);
}
// Build the result
var resource = new CMSOutputResource()
{
BinaryData = bytes,
Name = code,
Etag = "QRCode",
LastModified = new DateTime(2012, 1, 1),
ContentType = MimeTypeHelper.GetMimetype(".png"),
FileName = "QRCode.png",
Extension = ".png"
};
return resource;
}
catch (Exception ex)
{
// Report too long text
string message = "[GetResource.GetQRCode]: Failed to generate QR code with text '" + code + "', this may be caused by the text being too long. Original message: " + ex.Message;
var newEx = new Exception(message, ex);
EventLogProvider.LogException("GetResource", "QRCODE", newEx);
throw newEx;
}
}
/// <summary>
/// Retrieves the stylesheet of the web part from the database.
/// </summary>
/// <param name="item">Web part item</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetWebPart(CMSItem item)
{
WebPartInfo webPartInfo = null;
if (item.Name != null)
{
webPartInfo = WebPartInfoProvider.GetWebPartInfo(item.Name);
}
else
{
webPartInfo = WebPartInfoProvider.GetWebPartInfo(item.ID);
}
if (webPartInfo == null)
{
return null;
}
// Build the result
var resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(webPartInfo.WebPartCSS, URLHelper.ApplicationPath),
LastModified = webPartInfo.WebPartLastModified,
Etag = "webpart|" + webPartInfo.WebPartName,
FileName = ValidationHelper.GetSafeFileName(webPartInfo.WebPartName) + ".css",
Extension = ".css"
};
return resource;
}
/// <summary>
/// Processes the stylesheet.
/// </summary>
protected void ProcessStylesheet()
{
// Newsletter template stylesheet
if (!string.IsNullOrEmpty(newsletterTemplateName))
{
// Get the template
et = EmailTemplateInfoProvider.GetEmailTemplateInfo(newsletterTemplateName, SiteContext.CurrentSiteID);
if (et != null)
{
// Create the output file
outputFile = new CMSOutputResource
{
Name = RequestContext.URL.ToString(),
Data = HTMLHelper.ResolveCSSUrls(et.TemplateStylesheetText, SystemContext.ApplicationPath),
Etag = et.TemplateName
};
}
}
}
/// <summary>
/// Checks if resource in the client cache matches the server version.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="resource">Resource to check</param>
/// <returns>true, if resource is unchanged, otherwise false</returns>
private static bool IsResourceUnchanged(HttpContext context, CMSOutputResource resource)
{
// Determine the last modified date and etag sent from the browser
string currentETag = RequestHelper.GetHeader("If-None-Match", string.Empty);
string ifModified = RequestHelper.GetHeader("If-Modified-Since", string.Empty);
// If resources match, compare last modification timestamps
if ((ifModified != string.Empty) && (currentETag == resource.Etag))
{
// Get first part of header (colons can delimit additional data)
DateTime modifiedStamp;
if (DateTime.TryParse(ifModified.Split(";".ToCharArray())[0], out modifiedStamp))
{
return (resource.LastModified.ToUniversalTime() <= modifiedStamp.ToUniversalTime().AddSeconds(1));
}
}
return false;
}
/// <summary>
/// Sends a response containing the requested data.
/// </summary>
/// <param name="context">An HTTPContext object that provides references to the intrinsic server objects used to service HTTP requests</param>
/// <param name="resource">Container with the data to serve</param>
/// <param name="contentType">Content type to use when sending a response</param>
/// <param name="allowCache">True, if client caching is enabled, otherwise false</param>
/// <param name="minificationEnabled">True, if the data can be served minified, otherwise false</param>
/// <param name="clientCacheMinutes">Number of minutes after which the content in the client cache expires</param>
private static void SendResponse(HttpContext context, CMSOutputResource resource, string contentType, bool allowCache, bool minificationEnabled, int clientCacheMinutes)
{
// Set client cache revalidation
SetRevalidation(context);
// Let client use data cached in browser if versions match and there was no change in data
if (allowCache && IsResourceUnchanged(context, resource))
{
SendNotModifiedResponse(context, resource.LastModified, resource.Etag, clientCacheMinutes, true);
return;
}
else
{
// Otherwise get content to send
string contentCoding;
byte[] content = GetOutputData(context, resource, minificationEnabled, out contentCoding);
// Set client caching
if (allowCache)
{
SetClientCaching(context, allowCache, resource.LastModified, resource.Etag, clientCacheMinutes);
}
if (contentCoding != ContentCodingEnum.IDENTITY)
{
context.Response.AppendHeader("Content-Encoding", contentCoding);
context.Response.AppendHeader("Vary", "Content-Encoding");
}
context.Response.ContentType = contentType;
// Do not send output if there's none
if (content.Length > 0)
{
context.Response.OutputStream.Write(content, 0, content.Length);
}
}
}
/// <summary>
/// Retrieves the stylesheets of the web part layout from the database.
/// </summary>
/// <param name="layoutFullName">Layout full name</param>
/// <returns>The stylesheet data (plain version only)</returns>
private static CMSOutputResource GetWebPartLayout(string layoutFullName)
{
WebPartLayoutInfo layoutInfo = WebPartLayoutInfoProvider.GetWebPartLayoutInfo(layoutFullName);
if (layoutInfo == null)
{
return null;
}
// Build the result
CMSOutputResource resource = new CMSOutputResource()
{
Data = HTMLHelper.ResolveCSSUrls(layoutInfo.WebPartLayoutCSS, URLHelper.ApplicationPath),
LastModified = layoutInfo.WebPartLayoutLastModified,
Etag = layoutInfo.WebPartLayoutFullName
};
return resource;
}
