protected void Page_Load(object sender, EventArgs e)
{
DebugHelper.SetContext("GetAvatar");
// Prepare the cache key
fileGuid = QueryHelper.GetGuid("avatarguid", Guid.Empty);
int cacheMinutes = CacheMinutes;
// Try to get data from cache
using (CachedSection <CMSOutputAvatar> cs = new CachedSection <CMSOutputAvatar>(ref outputFile, cacheMinutes, true, null, "getavatar", GetBaseCacheKey(), Request.QueryString))
{
if (cs.LoadData)
{
// Process the file
ProcessFile();
// Ensure the cache settings
if (cs.Cached)
{
// Add cache dependency
CacheDependency cd = null;
if (outputFile != null)
{
if (outputFile.Avatar != null)
{
cd = CacheHelper.GetCacheDependency(outputFile.Avatar.GetDependencyCacheKeys());
// Do not cache if too big file which would be stored in memory
if ((outputFile.Avatar != null) && !CacheHelper.CacheImageAllowed(CurrentSiteName, outputFile.Avatar.AvatarFileSize) && !AvatarInfoProvider.StoreFilesInFileSystem())
{
cacheMinutes = largeFilesCacheMinutes;
}
}
}
if ((cd == null) && (cacheMinutes > 0))
{
// Set default dependency based on GUID
cd = GetCacheDependency(new List <string>()
{
"avatarfile|" + fileGuid.ToString().ToLowerCSafe()
});
}
// Cache the data
cs.CacheMinutes = cacheMinutes;
cs.CacheDependency = cd;
}
cs.Data = outputFile;
}
}
// Send the data
SendFile(outputFile);
DebugHelper.ReleaseContext();
}
protected void Page_Load(object sender, EventArgs e)
{
// Check the site
if (CurrentSiteName == "")
{
throw new Exception("[GetSharePointFile.aspx]: Site not running.");
}
int cacheMinutes = CacheMinutes;
// Try to get data from cache
using (var cs = new CachedSection <CMSOutputSharePointFile>(ref outputFile, cacheMinutes, true, null, "getsharepointfile", Request.QueryString))
{
if (cs.LoadData)
{
// Process the file
ProcessAttachment();
// Ensure the cache settings
if (cs.Cached)
{
// Check the file size for caching
if ((outputFile != null) && (outputFile.OutputData != null))
{
// Do not cache if too big file which would be stored in memory
if (!CacheHelper.CacheImageAllowed(CurrentSiteName, outputFile.OutputData.Length))
{
cacheMinutes = largeFilesCacheMinutes;
}
}
// Cache the data
cs.CacheMinutes = cacheMinutes;
}
cs.Data = outputFile;
}
}
// Send the data
SendFile(outputFile);
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputAvatar file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
// Set the revalidation
SetRevalidation();
// Send the file
if (file != null)
{
// Redirect if the file should be redirected
if (file.RedirectTo != "")
{
URLHelper.Redirect(file.RedirectTo, true, CurrentSiteName);
}
// Prepare etag
string etag = file.LastModified.ToString();
// Client caching - only on the live site
if (useClientCache && AllowCache && AllowClientCache && ETagsMatch(etag, file.LastModified))
{
RespondNotModified(etag, true);
return;
}
// If physical file not present, try to load
if (file.PhysicalFile == null)
{
EnsurePhysicalFile(outputFile);
}
// Ensure the file data if physical file not present
if (!file.DataLoaded && (file.PhysicalFile == ""))
{
byte[] cachedData = GetCachedOutputData();
if (file.EnsureData(cachedData))
{
if ((cachedData == null) && (this.CacheMinutes > 0))
{
SaveOutputDataToCache(file.OutputData, GetOutputDataDependency(file.Avatar));
}
}
}
// Send the file
if ((file.OutputData != null) || (file.PhysicalFile != ""))
{
// Setup the mime type - Fix the special types
string mimetype = file.MimeType;
string extension = file.Avatar.AvatarFileExtension;
switch (extension.ToLower())
{
case ".flv":
mimetype = "video/x-flv";
break;
}
// Prepare response
Response.ContentType = mimetype;
SetDisposition(file.Avatar.AvatarFileName, extension);
ETag = etag;
// Set if resumable downloads should be supported
AcceptRange = !IsExtensionExcludedFromRanges(extension);
if (useClientCache && AllowCache)
{
DateTime expires = DateTime.Now;
// Send last modified header to allow client caching
Response.Cache.SetLastModified(file.LastModified);
Response.Cache.SetCacheability(HttpCacheability.Public);
if (AllowClientCache)
{
expires = DateTime.Now.AddMinutes(this.ClientCacheMinutes);
}
Response.Cache.SetExpires(expires);
Response.Cache.SetETag(etag);
}
// Add the file data
if ((file.PhysicalFile != "") && (file.OutputData == null))
{
// If the output data should be cached, return the output data
bool cacheOutputData = false;
if (file.Avatar != null)
{
cacheOutputData = CacheHelper.CacheImageAllowed(CurrentSiteName, file.Avatar.AvatarFileSize);
}
// Stream the file from the file system
file.OutputData = WriteFile(file.PhysicalFile, cacheOutputData);
}
else
{
// Use output data of the file in memory if present
WriteBytes(file.OutputData);
}
}
else
{
Response.Write("<html></html>");
}
}
else
{
Response.Write("<html></html>");
}
CompleteRequest();
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputFile file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
// Set the revalidation
SetRevalidation();
// Send the file
if ((file != null) && file.IsValid)
{
// Redirect if the file should be redirected
if (file.RedirectTo != "")
{
// Log hit or activity before redirecting
LogEvent(file);
if (StorageHelper.IsExternalStorage)
{
string url = File.GetFileUrl(file.RedirectTo, CurrentSiteName);
if (!string.IsNullOrEmpty(url))
{
URLHelper.Redirect(url, true, CurrentSiteName);
}
}
URLHelper.Redirect(file.RedirectTo, true, CurrentSiteName);
}
// Check authentication if secured file
if (file.IsSecured)
{
URLRewriter.CheckSecured(CurrentSiteName, ViewMode);
}
// Prepare etag
string etag = file.CultureCode.ToLower();
if (file.Attachment != null)
{
etag += "|" + file.Attachment.AttachmentGUID + "|" + file.Attachment.AttachmentLastModified.ToUniversalTime();
}
if (file.IsSecured)
{
// For secured files, add user name to etag
etag += "|" + HttpContext.Current.User.Identity.Name;
}
// Put etag into ""
etag = "\"" + etag + "\"";
// Client caching - only on the live site
if (useClientCache && AllowCache && AllowClientCache && ETagsMatch(etag, file.LastModified))
{
// Set the file time stamps to allow client caching
SetTimeStamps(file);
RespondNotModified(etag, !file.IsSecured);
return;
}
// If physical file not present, try to load
if (file.PhysicalFile == null)
{
EnsurePhysicalFile(outputFile);
}
// If the output data should be cached, return the output data
bool cacheOutputData = false;
if (file.Attachment != null)
{
// Cache data if allowed
if (!LatestVersion && (CacheMinutes > 0))
{
cacheOutputData = CacheHelper.CacheImageAllowed(CurrentSiteName, file.Attachment.AttachmentSize);
}
}
// Ensure the file data if physical file not present
if (!file.DataLoaded && (file.PhysicalFile == ""))
{
byte[] cachedData = GetCachedOutputData();
if (file.EnsureData(cachedData))
{
if ((cachedData == null) && cacheOutputData)
{
SaveOutputDataToCache(file.OutputData, GetOutputDataDependency(file.Attachment));
}
}
}
// Send the file
if ((file.OutputData != null) || (file.PhysicalFile != ""))
{
// Setup the mime type - Fix the special types
string mimetype = file.MimeType;
if (file.Attachment != null)
{
string extension = file.Attachment.AttachmentExtension;
switch (extension.ToLower())
{
case ".flv":
mimetype = "video/x-flv";
break;
}
// Prepare response
Response.ContentType = mimetype;
SetDisposition(file.Attachment.AttachmentName, extension);
// Setup Etag property
ETag = etag;
// Set if resumable downloads should be supported
AcceptRange = !IsExtensionExcludedFromRanges(extension);
}
if (useClientCache && AllowCache)
{
// Set the file time stamps to allow client caching
SetTimeStamps(file);
Response.Cache.SetETag(etag);
}
else
{
SetCacheability();
}
// Log hit or activity
LogEvent(file);
// Add the file data
if ((file.PhysicalFile != "") && (file.OutputData == null))
{
// Stream the file from the file system
file.OutputData = WriteFile(file.PhysicalFile, cacheOutputData);
}
else
{
// Use output data of the file in memory if present
WriteBytes(file.OutputData);
}
}
else
{
NotFound();
}
}
else
{
NotFound();
}
CompleteRequest();
}
protected void Page_Load(object sender, EventArgs e)
{
DebugHelper.SetContext("GetFile");
// Load the site name
LoadSiteName();
// Check the site
if (CurrentSiteName == "")
{
throw new Exception("[GetFile.aspx]: Site not running.");
}
// Validate the culture
PreferredCultureOnDemand culture = new PreferredCultureOnDemand();
URLRewriter.ValidateCulture(CurrentSiteName, culture, null);
// Set campaign
if (IsLiveSite)
{
// Store campaign name if present
string campaign = AnalyticsHelper.CurrentCampaign(CurrentSiteName);
if (!String.IsNullOrEmpty(campaign))
{
PageInfo pi = CMSContext.CurrentPageInfo;
// Log campaign
if ((pi != null) && AnalyticsHelper.IsLoggingEnabled(CurrentSiteName, pi.NodeAliasPath) && AnalyticsHelper.SetCampaign(campaign, CurrentSiteName, pi.NodeAliasPath))
{
CMSContext.Campaign = campaign;
}
}
}
int cacheMinutes = CacheMinutes;
// Try to get data from cache
using (CachedSection <CMSOutputFile> cs = new CachedSection <CMSOutputFile>(ref outputFile, cacheMinutes, true, null, "getfile", CurrentSiteName, CacheHelper.BaseCacheKey, Request.QueryString))
{
if (cs.LoadData)
{
// Store current value and temporarly disable caching
bool cached = cs.Cached;
cs.Cached = false;
// Process the file
ProcessAttachment();
// Restore cache settings - data were loaded
cs.Cached = cached;
if (cs.Cached)
{
// Do not cache if too big file which would be stored in memory
if ((outputFile != null) &&
(outputFile.Attachment != null) &&
!CacheHelper.CacheImageAllowed(CurrentSiteName, outputFile.Attachment.AttachmentSize) &&
!AttachmentManager.StoreFilesInFileSystem(CurrentSiteName))
{
cacheMinutes = largeFilesCacheMinutes;
}
if (cacheMinutes > 0)
{
// Prepare the cache dependency
CacheDependency cd = null;
if (outputFile != null)
{
string[] dependencies = new string[] {
"node|" + CurrentSiteName.ToLower() + "|" + outputFile.AliasPath.ToLower(),
""
};
// Do not cache if too big file which would be stored in memory
if (outputFile.Attachment != null)
{
if (!CacheHelper.CacheImageAllowed(CurrentSiteName, outputFile.Attachment.AttachmentSize) && !AttachmentManager.StoreFilesInFileSystem(CurrentSiteName))
{
cacheMinutes = largeFilesCacheMinutes;
}
dependencies[1] = "attachment|" + outputFile.Attachment.AttachmentGUID.ToString().ToLower();
}
cd = CacheHelper.GetCacheDependency(dependencies);
}
if (cd == null)
{
// Set default dependency
if (guid != Guid.Empty)
{
// By attachment GUID
cd = CacheHelper.GetCacheDependency(new string[] { "attachment|" + guid.ToString().ToLower() });
}
else if (nodeGuid != Guid.Empty)
{
// By node GUID
cd = CacheHelper.GetCacheDependency(new string[] { "nodeguid|" + CurrentSiteName.ToLower() + "|" + nodeGuid.ToString().ToLower() });
}
else if (aliasPath != null)
{
// By node alias path
cd = CacheHelper.GetCacheDependency(new string[] { "node|" + CurrentSiteName.ToLower() + "|" + aliasPath.ToLower() });
}
}
cs.CacheDependency = cd;
}
// Cache the data
cs.CacheMinutes = cacheMinutes;
cs.Data = outputFile;
}
}
}
// Do not cache images in the browser if cache is not allowed
if (LatestVersion)
{
useClientCache = false;
}
// Send the data
SendFile(outputFile);
DebugHelper.ReleaseContext();
}
protected void Page_Load(object sender, EventArgs e)
{
DebugHelper.SetContext("GetMediaFile");
// Load the site name
LoadSiteName();
// Check the site
if (string.IsNullOrEmpty(CurrentSiteName))
{
throw new Exception("[GetMediaFile.aspx]: Site not running.");
}
int cacheMinutes = CacheMinutes;
// Try to get data from cache
using (CachedSection <CMSOutputMediaFile> cs = new CachedSection <CMSOutputMediaFile>(ref outputFile, cacheMinutes, true, null, "getmediafile", CurrentSiteName, CacheHelper.GetBaseCacheKey(true, false), Request.QueryString))
{
if (cs.LoadData)
{
// Process the file
ProcessFile();
// Ensure the cache settings
if (cs.Cached)
{
// Prepare the cache dependency
CacheDependency cd = null;
if (outputFile != null)
{
if (outputFile.MediaFile != null)
{
// Do not cache too big files
if ((outputFile.MediaFile != null) && !CacheHelper.CacheImageAllowed(CurrentSiteName, (int)outputFile.MediaFile.FileSize))
{
cacheMinutes = largeFilesCacheMinutes;
}
// Set dependency on this particular file
if (cacheMinutes > 0)
{
string[] dependencies = MediaFileInfoProvider.GetDependencyCacheKeys(outputFile.MediaFile, Preview);
cd = CacheHelper.GetCacheDependency(dependencies);
}
}
}
if ((cd == null) && (cacheMinutes > 0))
{
// Set default cache dependency by file GUID
cd = CacheHelper.GetCacheDependency(new string[] { "mediafile|" + fileGuid.ToString().ToLower(), "mediafilepreview|" + fileGuid.ToString().ToLower() });
}
// Cache the data
cs.CacheMinutes = cacheMinutes;
cs.CacheDependency = cd;
cs.Data = outputFile;
}
}
}
// Send the data
SendFile(outputFile);
DebugHelper.ReleaseContext();
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputMediaFile file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
// Set the revalidation
SetRevalidation();
// Send the file
if (file != null)
{
#region "Security"
// Check if user is allowed to see the library file content if required
bool checkPermissions = SettingsKeyProvider.GetBoolValue(CMSContext.CurrentSiteName + ".CMSCheckMediaFilePermissions");
if (checkPermissions)
{
// Check the library access for the current user and stop file processing if not allowed
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(file.MediaFile.FileLibraryID);
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "LibraryAccess"))
{
URLHelper.Redirect(URLRewriter.AccessDeniedPageURL(CurrentSiteName));
return;
}
}
#endregion
// Prepare etag
string etag = "";
if (file.MediaFile != null)
{
etag += file.MediaFile.FileModifiedWhen.ToUniversalTime();
}
// Put etag into ""
etag = String.Format("\"{0}\"", etag);
// Client caching - only on the live site
if (useClientCache && AllowCache && AllowClientCache && ETagsMatch(etag, file.LastModified))
{
// Set the file time stamps to allow client caching
SetTimeStamps(file);
RespondNotModified(etag, true);
return;
}
// If physical file not present, try to load
EnsurePhysicalFile(outputFile);
// If the output data should be cached, return the output data
bool cacheOutputData = false;
if ((file.MediaFile != null) && (CacheMinutes > 0))
{
cacheOutputData = CacheHelper.CacheImageAllowed(CurrentSiteName, (int)file.MediaFile.FileSize);
}
// Ensure the file data if physical file not present
if (!file.DataLoaded && (file.PhysicalFile == ""))
{
byte[] cachedData = GetCachedOutputData();
if (file.EnsureData(cachedData))
{
if ((cachedData == null) && cacheOutputData)
{
SaveOutputDataToCache(file.OutputData, GetOutputDataDependency(file.MediaFile));
}
}
}
// Send the file
if ((file.OutputData != null) || (file.PhysicalFile != ""))
{
// Setup the mime type - Fix the special types
string mimetype = file.MimeType;
string extension = file.FileExtension;
switch (extension.ToLower())
{
case ".flv":
mimetype = "video/x-flv";
break;
}
// Prepare response
Response.ContentType = mimetype;
SetDisposition(file.FileName + extension, extension);
// Setup Etag property
ETag = etag;
// Set if resumable downloads should be supported
AcceptRange = !IsExtensionExcludedFromRanges(extension);
if (useClientCache && AllowCache)
{
// Set the file time stamps to allow client caching
SetTimeStamps(file);
Response.Cache.SetETag(etag);
}
// Add the file data
if ((file.PhysicalFile != "") && (file.OutputData == null))
{
// Stream the file from the file system
file.OutputData = WriteFile(file.PhysicalFile, cacheOutputData);
}
else
{
// Use output data of the file in memory if present
WriteBytes(file.OutputData);
}
}
else
{
this.NotFound();
}
}
else
{
this.NotFound();
}
CompleteRequest();
}
protected void Page_Load(object sender, EventArgs e)
{
DebugHelper.SetContext("GetMetaFile");
// Load the site name
LoadSiteName();
int cacheMinutes = CacheMinutes;
// Try to get data from cache
using (var cs = new CachedSection <CMSOutputMetaFile>(ref outputFile, cacheMinutes, true, null, "getmetafile", CurrentSiteName, GetBaseCacheKey(), Request.QueryString))
{
if (cs.LoadData)
{
// Process the file
ProcessFile();
if (cs.Cached)
{
// Do not cache if too big file which would be stored in memory
if ((outputFile != null) &&
(outputFile.MetaFile != null) &&
!CacheHelper.CacheImageAllowed(CurrentSiteName, outputFile.MetaFile.MetaFileSize) &&
!AttachmentInfoProvider.StoreFilesInFileSystem(CurrentSiteName))
{
cacheMinutes = largeFilesCacheMinutes;
}
if (cacheMinutes > 0)
{
// Prepare the cache dependency
CMSCacheDependency cd = null;
if (outputFile != null)
{
if (outputFile.MetaFile != null)
{
// Add dependency on this particular meta file
cd = GetCacheDependency(outputFile.MetaFile.GetDependencyCacheKeys());
}
}
if (cd == null)
{
// Set default dependency based on GUID
cd = CacheHelper.GetCacheDependency(new string[] { "metafile|" + fileGuid.ToString().ToLowerCSafe() });
}
cs.CacheDependency = cd;
}
// Cache the data
cs.CacheMinutes = cacheMinutes;
}
cs.Data = outputFile;
}
}
// Send the data
SendFile(outputFile);
DebugHelper.ReleaseContext();
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputMetaFile file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
// Set the revalidation
SetRevalidation();
// Send the file
if (file != null)
{
// Redirect if the file should be redirected
if (file.RedirectTo != "")
{
URLHelper.RedirectPermanent(file.RedirectTo, CurrentSiteName);
}
string etag = GetFileETag(file);
// Client caching - only on the live site
if (useClientCache && AllowCache && AllowClientCache && ETagsMatch(etag, file.LastModified))
{
// Set correct response content type
SetResponseContentType(file);
// Set the file time stamps to allow client caching
SetTimeStamps(file);
RespondNotModified(etag, true);
return;
}
// If physical file not present, try to load
if (file.PhysicalFile == null)
{
EnsurePhysicalFile(outputFile);
}
// If the output data should be cached, return the output data
bool cacheOutputData = false;
if ((CacheMinutes > 0) && (file.MetaFile != null))
{
cacheOutputData = CacheHelper.CacheImageAllowed(CurrentSiteName, file.MetaFile.MetaFileSize);
}
// Ensure the file data if physical file not present
if (!file.DataLoaded && (file.PhysicalFile == ""))
{
byte[] cachedData = GetCachedOutputData();
if (file.EnsureData(cachedData))
{
if ((cachedData == null) && cacheOutputData)
{
SaveOutputDataToCache(file.OutputData, GetOutputDataDependency(file.MetaFile));
}
}
}
// Send the file
if ((file.OutputData != null) || (file.PhysicalFile != ""))
{
// Set correct response content type
SetResponseContentType(file);
string extension = file.MetaFile.MetaFileExtension;
SetDisposition(file.MetaFile.MetaFileName, extension);
// Setup Etag property
ETag = etag;
// Set if resumable downloads should be supported
AcceptRange = !IsExtensionExcludedFromRanges(extension);
if (useClientCache && AllowCache)
{
// Set the file time stamps to allow client caching
SetTimeStamps(file);
Response.Cache.SetETag(etag);
}
else
{
SetCacheability();
}
// Add the file data
if ((file.PhysicalFile != "") && (file.OutputData == null))
{
if (!File.Exists(file.PhysicalFile))
{
// File doesn't exist
NotFound();
}
else
{
// Stream the file from the file system
file.OutputData = WriteFile(file.PhysicalFile, cacheOutputData);
}
}
else
{
// Use output data of the file in memory if present
WriteBytes(file.OutputData);
}
}
else
{
NotFound();
}
}
else
{
NotFound();
}
CompleteRequest();
}
protected void Page_Load(object sender, EventArgs e)
{
fileGuid = QueryHelper.GetGuid("fileguid", Guid.Empty);
DebugHelper.SetContext("GetForumAttachment");
int cacheMinutes = this.CacheMinutes;
// Try to get data from cache
using (CachedSection <CMSOutputForumAttachment> cs = new CachedSection <CMSOutputForumAttachment>(ref outputFile, cacheMinutes, true, null, "getforumattachment", CurrentSiteName, CacheHelper.GetBaseCacheKey(true, false), Request.QueryString))
{
if (cs.LoadData)
{
// Disable caching before check permissions
cs.CacheMinutes = 0;
// Process the file
ProcessFile();
// Keep original cache minutes if permissions are ok
cs.CacheMinutes = cacheMinutes;
// Ensure the cache settings
if (cs.Cached)
{
// Prepare the cache dependency
CacheDependency cd = null;
if (outputFile != null)
{
if (outputFile.ForumAttachment != null)
{
cd = CacheHelper.GetCacheDependency(outputFile.ForumAttachment.GetDependencyCacheKeys());
// Do not cache if too big file which would be stored in memory
if (!CacheHelper.CacheImageAllowed(CurrentSiteName, outputFile.ForumAttachment.AttachmentFileSize) && !ForumAttachmentInfoProvider.StoreFilesInFileSystem(CurrentSiteName))
{
cacheMinutes = largeFilesCacheMinutes;
}
}
}
if ((cd == null) && (CurrentSite != null) && (outputFile != null))
{
// Get the current forum id
int forumId = 0;
if (outputFile.ForumAttachment != null)
{
forumId = outputFile.ForumAttachment.AttachmentForumID;
}
// Set default dependency based on GUID
cd = CacheHelper.GetCacheDependency(new string[] { "forumattachment|" + fileGuid.ToString().ToLower() + "|" + CurrentSite.SiteID, "forumattachment|" + forumId });
}
// Cache the data
cs.CacheMinutes = cacheMinutes;
cs.CacheDependency = cd;
cs.Data = outputFile;
}
}
}
// Send the data
SendFile(outputFile);
DebugHelper.ReleaseContext();
}
protected override void ProcessRequestInternal(HttpContextBase context)
{
var hash = QueryHelper.GetString("hash", string.Empty);
var path = QueryHelper.GetString("path", string.Empty);
// Validate hash
var settings = new HashSettings
{
Redirect = false
};
if (!ValidationHelper.ValidateHash("?path=" + URLHelper.EscapeSpecialCharacters(path), hash, settings))
{
RequestHelper.Respond403();
}
if (path.StartsWithCSafe("~"))
{
path = context.Server.MapPath(path);
}
var blobPath = AzurePathHelper.GetBlobPath(path);
var blob = BlobCollection.Instance.GetOrCreate(blobPath);
if (!blob.Exists())
{
RequestHelper.Respond404();
}
CookieHelper.ClearResponseCookies();
Response.Clear();
SetRevalidation();
var eTag = blob.GetAttribute(a => a.Etag);
var lastModified = ValidationHelper.GetDateTime(blob.GetAttribute(a => a.LastModified), DateTimeHelper.ZERO_TIME);
SetResponseContentType(path);
// Client caching - only on the live site
if (AllowCache && AllowClientCache && ETagsMatch(eTag, lastModified))
{
// Set the file time stamps to allow client caching
SetTimeStamps(lastModified);
RespondNotModified(eTag);
return;
}
SetDisposition(Path.GetFileName(path), Path.GetExtension(path));
// Setup Etag property
ETag = eTag;
if (AllowCache)
{
// Set the file time stamps to allow client caching
SetTimeStamps(lastModified);
Response.Cache.SetETag(eTag);
}
else
{
SetCacheability();
}
WriteFile(path, CacheHelper.CacheImageAllowed(CurrentSiteName, Convert.ToInt32(blob.GetAttribute(a => a.Length))));
CompleteRequest();
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputMetaFile file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
// Set the revalidation
SetRevalidation();
// Send the file
if (file != null)
{
// Redirect if the file should be redirected
if (file.RedirectTo != "")
{
URLHelper.Redirect(file.RedirectTo, true, this.CurrentSiteName);
}
// Prepare etag
string etag = null;
if (file.MetaFile != null)
{
etag += file.MetaFile.MetaFileID;
}
// Put etag into ""
etag = "\"" + etag + "\"";
// Client caching - only on the live site
if (useClientCache && AllowCache && AllowClientCache && ETagsMatch(etag, file.LastModified))
{
// Set the file time stamps to allow client caching
SetTimeStamps(file);
RespondNotModified(etag, true);
return;
}
// If physical file not present, try to load
if (file.PhysicalFile == null)
{
EnsurePhysicalFile(outputFile);
}
// If the output data should be cached, return the output data
bool cacheOutputData = false;
if ((this.CacheMinutes > 0) && (file.MetaFile != null))
{
cacheOutputData = CacheHelper.CacheImageAllowed(CurrentSiteName, file.MetaFile.MetaFileSize);
}
// Ensure the file data if physical file not present
if (!file.DataLoaded && (file.PhysicalFile == ""))
{
byte[] cachedData = GetCachedOutputData();
if (file.EnsureData(cachedData))
{
if ((cachedData == null) && cacheOutputData)
{
SaveOutputDataToCache(file.OutputData, GetOutputDataDependency(file.MetaFile));
}
}
}
// Send the file
if ((file.OutputData != null) || (file.PhysicalFile != ""))
{
// Setup the mime type - Fix the special types
string mimetype = file.MimeType;
string extension = file.MetaFile.MetaFileExtension;
switch (extension.ToLower())
{
case ".flv":
mimetype = "video/x-flv";
break;
}
// Prepare response
Response.ContentType = mimetype;
SetDisposition(file.MetaFile.MetaFileName, extension);
// Setup Etag property
ETag = etag;
// Set if resumable downloads should be supported
AcceptRange = !IsExtensionExcludedFromRanges(extension);
if (useClientCache && AllowCache)
{
// Set the file time stamps to allow client caching
SetTimeStamps(file);
Response.Cache.SetETag(etag);
}
// Add the file data
if ((file.PhysicalFile != "") && (file.OutputData == null))
{
// Stream the file from the file system
file.OutputData = WriteFile(file.PhysicalFile, cacheOutputData);
}
else
{
// Use output data of the file in memory if present
WriteBytes(file.OutputData);
}
}
else
{
NotFound();
}
}
else
{
NotFound();
}
CompleteRequest();
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputSharePointFile file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
SetRevalidation();
if ((file != null) && file.IsValid)
{
// Prepare etag in ""
string etag = "\"" + file.SharePointFilePath + "\"";
// Client caching - only on the live site
if (useClientCache && AllowCache && ETagsMatch(etag, file.LastModified))
{
// Set correct response content type
SetResponseContentType(file);
SetTimeStamps(file.LastModified);
RespondNotModified(etag);
return;
}
// If the output data should be cached, return the output data
bool cacheOutputData = false;
if (file.OutputData != null)
{
cacheOutputData = CacheHelper.CacheImageAllowed(CurrentSiteName, file.OutputData.Length);
}
// Ensure the file data
if (!file.DataLoaded)
{
byte[] cachedData = GetCachedOutputData();
// Ensure data are retrieved from SharePoint
if (file.EnsureData(cachedData))
{
if ((cachedData == null) && cacheOutputData)
{
SaveOutputDataToCache(file.OutputData, null);
}
}
}
// Send the file
if (file.OutputData != null)
{
byte[] data;
// Check if the request is for partial data (Range HTTP header)
long[,] rangePosition = GetRange(file.OutputData.Length, HttpContext.Current);
// Send all file contens
if (rangePosition.GetUpperBound(0) == 0)
{
// Set correct response content type
SetResponseContentType(file);
// get file name without the path
string fileName = Path.GetFileName(file.SharePointFilePath);
SetDisposition(fileName, file.FileExtension);
// Setup Etag property
ETag = etag;
// Set if resumable downloads should be supported
AcceptRange = !IsExtensionExcludedFromRanges(file.FileExtension);
if (useClientCache && AllowCache)
{
SetTimeStamps(file.LastModified);
Response.Cache.SetETag(etag);
}
else
{
SetCacheability();
}
data = file.OutputData;
}
// Send partial contens
else
{
data = new byte[file.OutputData.Length - rangePosition[0, ResponseDataSender.RANGE_START]];
// Get part of file
Array.Copy(file.OutputData, rangePosition[0, ResponseDataSender.RANGE_START], data, 0, data.Length);
}
// Use output data of the file in memory if present
WriteBytes(data);
}
else
{
NotFound();
}
}
else
{
NotFound();
}
CompleteRequest();
}
/// <summary>
/// Sends the given file within response.
/// </summary>
/// <param name="file">File to send</param>
protected void SendFile(CMSOutputSharePointFile file)
{
// Clear response.
CookieHelper.ClearResponseCookies();
Response.Clear();
Response.Cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
if ((file != null) && file.IsValid)
{
// Prepare etag in ""
string etag = "\"" + file.SharePointFilePath + "\"";
// Client caching - only on the live site
if (useClientCache && AllowCache && CacheHelper.CacheImageEnabled(CurrentSiteName) && ETagsMatch(etag, file.LastModified))
{
RespondNotModified(etag, true);
return;
}
// If the output data should be cached, return the output data
bool cacheOutputData = false;
if (file.OutputData != null)
{
cacheOutputData = CacheHelper.CacheImageAllowed(CurrentSiteName, file.OutputData.Length);
}
// Ensure the file data
if (!file.DataLoaded)
{
byte[] cachedData = GetCachedOutputData();
// Ensure data are retrieved from SharePoint
if (file.EnsureData(cachedData))
{
if ((cachedData == null) && cacheOutputData)
{
SaveOutputDataToCache(file.OutputData, null);
}
}
}
// Send the file
if (file.OutputData != null)
{
byte[] data = null;
// Check if the request is for partial data (Range HTTP header)
long[,] rangePosition = GetRange(file.OutputData.Length, HttpContext.Current);
// Send all file contens
if (rangePosition.GetUpperBound(0) == 0)
{
// Setup the mime type - Fix the special types
string mimetype = file.MimeType;
switch (file.FileExtension.ToLower())
{
case ".flv":
mimetype = "video/x-flv";
break;
}
// Prepare response
Response.ContentType = mimetype;
// get file name without the path
string fileName = Path.GetFileName(file.SharePointFilePath);
SetDisposition(fileName, file.FileExtension);
// Setup Etag property
ETag = etag;
// Set if resumable downloads should be supported
AcceptRange = !IsExtensionExcludedFromRanges(file.FileExtension);
if (useClientCache && AllowCache && (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(etag);
}
data = file.OutputData;
}
// Send partial contens
else
{
data = new byte[file.OutputData.Length - rangePosition[0, RANGE_START]];
// Get part of file
Array.Copy(file.OutputData, rangePosition[0, RANGE_START], data, 0, data.Length);
}
// Use output data of the file in memory if present
WriteBytes(data);
}
else
{
NotFound();
}
}
else
{
NotFound();
}
CompleteRequest();
}