private string GetUniqueFileName(string folder, string fileName)
{
var result = fileName;
var copy = T("Admin.Common.Copy");
string name = null;
string extension = null;
for (var i = 1; i < 999999; ++i)
{
var path = _fileSystem.Combine(folder, result);
if (!_fileSystem.FileExists(path))
{
return(result);
}
if (name == null || extension == null)
{
var file = _fileSystem.GetFile(path);
extension = file.FileType;
// this assumes that a storage file name always ends with its file type
name = file.Name.EmptyNull().Substring(0, file.Name.EmptyNull().Length - extension.Length);
}
result = "{0} - {1} {2}{3}".FormatInvariant(name, copy, i, extension);
}
return(result);
}
public void Put(CachedImage cachedImage, Stream stream)
{
if (PreparePut(cachedImage, stream))
{
var path = BuildPath(cachedImage.Path);
_fileSystem.SaveStream(path, stream);
cachedImage.Exists = true;
cachedImage.File = _fileSystem.GetFile(path);
}
}
public void Put(CachedImage cachedImage, IImage image)
{
var path = BuildPath(cachedImage.Path);
using var stream = _fileSystem.GetFile(path).OpenWrite();
if (PreparePut(cachedImage, stream))
{
image.Save(stream);
image.Dispose();
PostPut(cachedImage, path);
}
}
public virtual Stream OpenRead(MediaFile mediaFile)
{
Guard.NotNull(mediaFile, nameof(mediaFile));
var file = _fileSystem.GetFile(GetPath(mediaFile));
return(file.Exists ? file.OpenRead() : null);
}
public long GetSize(MediaFile mediaFile)
{
Guard.NotNull(mediaFile, nameof(mediaFile));
if (mediaFile.Size > 0)
{
return(mediaFile.Size);
}
var file = _fileSystem.GetFile(GetPath(mediaFile));
if (file.Exists)
{
// Hopefully a future commit will save this
mediaFile.Size = (int)file.Size;
}
return(mediaFile.Size);
}
private void DownloadFile(string path)
{
path = GetRelativePath(path);
if (!_fileSystem.FileExists(path))
{
return;
}
var len = 0;
var buffer = new byte[BUFFER_SIZE];
var file = _fileSystem.GetFile(path);
try
{
using (var stream = file.OpenRead())
{
Response.Clear();
Response.Headers.Add("Content-Disposition", "attachment; filename=\"" + file.Name + "\"");
Response.ContentType = MimeTypes.MapNameToMimeType(file.Name);
while (Response.IsClientConnected && (len = stream.Read(buffer, 0, BUFFER_SIZE)) > 0)
{
Response.OutputStream.Write(buffer, 0, len);
Response.Flush();
Array.Clear(buffer, 0, BUFFER_SIZE);
}
Response.End();
}
}
catch (IOException)
{
throw new Exception(T("Admin.Common.FileInUse"));
}
}
public void Put(CachedImageResult cachedImage, byte[] buffer)
{
if (PreparePut(cachedImage, buffer))
{
var path = BuildPath(cachedImage.Path);
_fileSystem.WriteAllBytes(path, buffer);
cachedImage.Exists = true;
cachedImage.File = _fileSystem.GetFile(path);
}
}
public void Put(CachedImageResult cachedImage, byte[] buffer)
{
if (PreparePut(cachedImage, buffer))
{
var path = BuildPath(cachedImage.Path);
if (cachedImage.Extension == "svg")
{
_fileSystem.WriteAllText(path, Encoding.UTF8.GetString(buffer));
}
else
{
_fileSystem.WriteAllBytes(path, buffer);
}
cachedImage.Exists = true;
cachedImage.File = _fileSystem.GetFile(path);
}
}
public virtual Stream OpenCachedImage(CachedImageResult cachedImage)
{
Guard.NotNull(cachedImage, nameof(cachedImage));
return(_fileSystem.GetFile(BuildPath(cachedImage.Path)).OpenRead());
}
public async Task <ActionResult> File(string path)
{
string name = null;
string mime = null;
if (path.IsEmpty())
{
return(NotFound(null));
}
var tenantPrefix = DataSettings.Current.TenantName + "/";
if (path.StartsWith(tenantPrefix))
{
// V3.0.x comapt: in previous versions the file path
// contained the tenant name. Strip it out.
path = path.Substring(tenantPrefix.Length);
}
name = Path.GetFileName(path);
name.SplitToPair(out var nameWithoutExtension, out var extension, ".", true);
mime = MimeTypes.MapNameToMimeType(name);
if (nameWithoutExtension.IsEmpty() || extension.IsEmpty())
{
return(NotFound(mime ?? "text/html"));
}
extension = extension.ToLower();
var file = _mediaFileSystem.GetFile(path);
if (!file.Exists)
{
return(NotFound(mime));
}
var query = CreateImageQuery(mime, extension);
var isProcessableImage = query.NeedsProcessing(true) && _imageProcessor.IsSupportedImage(file.Name);
if (isProcessableImage)
{
var cachedImage = _imageCache.Get(file, query);
return(await HandleImageAsync(
query,
cachedImage,
nameWithoutExtension,
mime,
extension,
getSourceBufferAsync));
}
// It's no image... proceed with standard stuff...
if (Request.HttpMethod == "HEAD")
{
return(new HttpStatusCodeResult(200));
}
if (_mediaFileSystem.IsCloudStorage && !_streamRemoteMedia)
{
// Redirect to existing remote file
Response.ContentType = mime;
return(Redirect(_mediaFileSystem.GetPublicUrl(path, true)));
}
else
{
// Open existing stream
return(new CachedFileResult(file, mime));
}
async Task <byte[]> getSourceBufferAsync(string prevMime)
{
return(await file.OpenRead().ToByteArrayAsync());
}
}
public Stream OpenRead(MediaItem media)
{
return(_fileSystem.GetFile(GetPicturePath(media))?.OpenRead());
}
public Stream OpenRead(MediaItem media)
{
var file = _fileSystem.GetFile(GetPicturePath(media));
return(file.Exists ? file.OpenRead() : null);
}
