public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
{
return new ChunkedUploadSession(RestoreIds(file), contentLength)
{
UseChunks = false
}
}
;
var uploadSession = new ChunkedUploadSession(file, contentLength);
uploadSession.Items["TempPath"] = Path.GetTempFileName();
uploadSession.File = RestoreIds(uploadSession.File);
return(uploadSession);
}
public void AbortUploadSession(ChunkedUploadSession uploadSession)
{
if (uploadSession.Items.ContainsKey("OneDriveSession"))
{
var oneDriveSession = uploadSession.GetItemOrDefault <ResumableUploadSession>("OneDriveSession");
if (oneDriveSession.Status != ResumableUploadSessionStatus.Completed)
{
OneDriveProviderInfo.Storage.CancelTransfer(oneDriveSession);
oneDriveSession.Status = ResumableUploadSessionStatus.Aborted;
}
}
else if (uploadSession.Items.ContainsKey("TempPath"))
{
System.IO.File.Delete(uploadSession.GetItemOrDefault <string>("TempPath"));
}
}
public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
{
return new ChunkedUploadSession(RestoreIds(file), contentLength)
{
UseChunks = false
}
}
;
var uploadSession = new ChunkedUploadSession(file, contentLength);
Item onedriveFile;
if (file.ID != null)
{
onedriveFile = GetOneDriveItem(file.ID);
}
else
{
var folder = GetOneDriveItem(file.FolderID);
onedriveFile = new Item {
Name = file.Title, ParentReference = new ItemReference {
Id = folder.Id
}
};
}
var onedriveSession = OneDriveProviderInfo.Storage.CreateResumableSession(onedriveFile, contentLength);
if (onedriveSession != null)
{
uploadSession.Items["OneDriveSession"] = onedriveSession;
}
else
{
uploadSession.Items["TempPath"] = TempPath.GetTempFileName();
}
uploadSession.File = RestoreIds(uploadSession.File);
return(uploadSession);
}
public ChunkedUploadSession <string> CreateUploadSession(File <string> file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
{
return new ChunkedUploadSession <string>(MakeId(file), contentLength)
{
UseChunks = false
}
}
;
var uploadSession = new ChunkedUploadSession <string>(file, contentLength);
var isNewFile = false;
ICloudFileSystemEntry sharpboxFile;
if (file.ID != null)
{
sharpboxFile = GetFileById(file.ID);
}
else
{
var folder = GetFolderById(file.FolderID);
sharpboxFile = ProviderInfo.Storage.CreateFile(folder, GetAvailableTitle(file.Title, folder, IsExist));
isNewFile = true;
}
var sharpboxSession = sharpboxFile.GetDataTransferAccessor().CreateResumableSession(contentLength);
if (sharpboxSession != null)
{
uploadSession.Items["SharpboxSession"] = sharpboxSession;
uploadSession.Items["IsNewFile"] = isNewFile;
}
else
{
uploadSession.Items["TempPath"] = Path.GetTempFileName();
}
uploadSession.File = MakeId(uploadSession.File);
return(uploadSession);
}
private File <string> FinalizeUploadSession(ChunkedUploadSession <string> uploadSession)
{
if (uploadSession.Items.ContainsKey("OneDriveSession"))
{
var oneDriveSession = uploadSession.GetItemOrDefault <ResumableUploadSession>("OneDriveSession");
ProviderInfo.CacheReset(oneDriveSession.FileId);
var parentDriveId = oneDriveSession.FolderId;
if (parentDriveId != null)
{
ProviderInfo.CacheReset(parentDriveId);
}
return(ToFile(GetOneDriveItem(oneDriveSession.FileId)));
}
using var fs = new FileStream(uploadSession.GetItemOrDefault <string>("TempPath"), FileMode.Open, FileAccess.Read, System.IO.FileShare.None, 4096, FileOptions.DeleteOnClose);
return(SaveFile(uploadSession.File, fs));
}
public void AbortUploadSession(ChunkedUploadSession <string> uploadSession)
{
if (uploadSession.Items.ContainsKey("SharpboxSession"))
{
var sharpboxSession =
uploadSession.GetItemOrDefault <AppLimit.CloudComputing.SharpBox.StorageProvider.BaseObjects.ResumableUploadSession>("SharpboxSession");
var isNewFile = uploadSession.Items.ContainsKey("IsNewFile") && uploadSession.GetItemOrDefault <bool>("IsNewFile");
var sharpboxFile =
isNewFile
? ProviderInfo.Storage.CreateFile(GetFolderById(sharpboxSession.ParentId), sharpboxSession.FileName)
: GetFileById(sharpboxSession.FileId);
sharpboxFile.GetDataTransferAccessor().AbortResumableSession(sharpboxSession);
}
else if (uploadSession.Items.ContainsKey("TempPath"))
{
File.Delete(uploadSession.GetItemOrDefault <string>("TempPath"));
}
}
private File GetFileForCommit(ChunkedUploadSession uploadSession)
{
if (uploadSession.File.ID != null)
{
var file = GetFile(uploadSession.File.ID);
file.Version++;
file.ContentLength = uploadSession.BytesTotal;
file.ConvertedType = null;
file.Comment = FilesCommonResource.CommentUpload;
return(file);
}
return(new File
{
FolderID = uploadSession.File.FolderID,
Title = uploadSession.File.Title,
ContentLength = uploadSession.BytesTotal,
Comment = FilesCommonResource.CommentUpload,
});
}
public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
{
return new ChunkedUploadSession(file, contentLength)
{
UseChunks = false
}
}
;
var tempPath = Guid.NewGuid().ToString();
var uploadId = Global.GetStore().InitiateChunkedUpload(FileConstant.StorageDomainTmp, tempPath);
var uploadSession = new ChunkedUploadSession(file, contentLength);
uploadSession.Items["TempPath"] = tempPath;
uploadSession.Items["UploadId"] = uploadId;
return(uploadSession);
}
public File FinalizeUploadSession(ChunkedUploadSession uploadSession)
{
if (uploadSession.Items.ContainsKey("GoogleDriveSession"))
{
var googleDriveSession = uploadSession.GetItemOrDefault <ResumableUploadSession>("GoogleDriveSession");
CacheReset(googleDriveSession.FileId);
var parentDriveId = googleDriveSession.FolderId;
if (parentDriveId != null)
{
CacheReset(parentDriveId, false);
}
return(ToFile(GetDriveEntry(googleDriveSession.FileId)));
}
using (var fs = new FileStream(uploadSession.GetItemOrDefault <string>("TempPath"), FileMode.Open, FileAccess.Read, FileShare.None, 4096, FileOptions.DeleteOnClose))
{
return(SaveFile(uploadSession.File, fs));
}
}
public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
{
return new ChunkedUploadSession(file, contentLength)
{
UseChunks = false
}
}
;
var tempPath = Path.GetRandomFileName();
var uploadId = Global.GetStore().InitiateChunkedUpload(string.Empty, tempPath);
var uploadSession = new ChunkedUploadSession(file, contentLength);
uploadSession.Items["TempPath"] = tempPath;
uploadSession.Items["UploadId"] = uploadId;
return(uploadSession);
}
public File UploadChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
{
if (!uploadSession.UseChunks)
{
if (uploadSession.BytesTotal == 0)
{
uploadSession.BytesTotal = chunkLength;
}
uploadSession.File = SaveFile(uploadSession.File, stream);
uploadSession.BytesUploaded = chunkLength;
return(uploadSession.File);
}
if (uploadSession.Items.ContainsKey("OneDriveSession"))
{
var oneDriveSession = uploadSession.GetItemOrDefault <ResumableUploadSession>("OneDriveSession");
OneDriveProviderInfo.Storage.Transfer(oneDriveSession, stream, chunkLength);
}
else
{
var tempPath = uploadSession.GetItemOrDefault <string>("TempPath");
using (var fs = new FileStream(tempPath, FileMode.Append))
{
stream.CopyTo(fs);
}
}
uploadSession.BytesUploaded += chunkLength;
if (uploadSession.BytesUploaded == uploadSession.BytesTotal)
{
uploadSession.File = FinalizeUploadSession(uploadSession);
}
else
{
uploadSession.File = RestoreIds(uploadSession.File);
}
return(uploadSession.File);
}
public void UploadChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
{
if (!uploadSession.UseChunks)
{
if (uploadSession.BytesTotal == 0)
{
uploadSession.BytesTotal = chunkLength;
}
uploadSession.File = SaveFile(uploadSession.File, stream);
uploadSession.BytesUploaded = chunkLength;
return;
}
if (uploadSession.Items.ContainsKey("SharpboxSession"))
{
var sharpboxSession = uploadSession.GetItemOrDefault <IResumableUploadSession>("SharpboxSession");
sharpboxSession.File.GetDataTransferAccessor().Transfer(sharpboxSession, stream, chunkLength);
}
else
{
var tempPath = uploadSession.GetItemOrDefault <string>("TempPath");
using (var fs = new FileStream(tempPath, FileMode.Append))
{
stream.CopyTo(fs);
}
}
uploadSession.BytesUploaded += chunkLength;
if (uploadSession.BytesUploaded == uploadSession.BytesTotal)
{
uploadSession.File = FinalizeUploadSession(uploadSession);
}
else
{
uploadSession.File = MakeId(uploadSession.File);
}
}
public void UploadChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
{
if (!uploadSession.UseChunks)
{
using (var streamToSave = ChunkedUploadSessionHolder.UploadSingleChunk(uploadSession, stream, chunkLength))
{
if (streamToSave != Stream.Null)
{
uploadSession.File = SaveFile(GetFileForCommit(uploadSession), streamToSave);
}
}
return;
}
ChunkedUploadSessionHolder.UploadChunk(uploadSession, stream, chunkLength);
if (uploadSession.BytesUploaded == uploadSession.BytesTotal)
{
uploadSession.File = FinalizeUploadSession(uploadSession);
}
}
public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
{
return new ChunkedUploadSession(RestoreIds(file), contentLength)
{
UseChunks = false
}
}
;
var uploadSession = new ChunkedUploadSession(file, contentLength);
DriveFile driveFile;
if (file.ID != null)
{
driveFile = GetDriveEntry(file.ID);
}
else
{
var folder = GetDriveEntry(file.FolderID);
driveFile = GoogleDriveProviderInfo.Storage.FileConstructor(file.Title, null, folder.Id);
}
var googleDriveSession = GoogleDriveProviderInfo.Storage.CreateResumableSession(driveFile, contentLength);
if (googleDriveSession != null)
{
uploadSession.Items["GoogleDriveSession"] = googleDriveSession;
}
else
{
uploadSession.Items["TempPath"] = Path.GetTempFileName();
}
uploadSession.File = RestoreIds(uploadSession.File);
return(uploadSession);
}
public ChunkedUploadSession CreateUploadSession(Core.File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
{
return new ChunkedUploadSession(MakeId(file), contentLength)
{
UseChunks = false
}
}
;
var uploadSession = new ChunkedUploadSession(file, contentLength);
ICloudFileSystemEntry googleDriveFile;
if (file.ID != null)
{
googleDriveFile = GetFileById(file.ID);
}
else
{
var folder = GetFolderById(file.FolderID);
googleDriveFile = GoogleDriveProviderInfo.Storage.CreateFile(folder, GetAvailableTitle(file.Title, folder, IsExist));
}
var googleDriveSession = googleDriveFile.GetDataTransferAccessor().CreateResumableSession(contentLength);
if (googleDriveSession != null)
{
uploadSession.Items["GoogleDriveSession"] = googleDriveSession;
}
else
{
uploadSession.Items["TempPath"] = Path.GetTempFileName();
}
uploadSession.File = MakeId(uploadSession.File);
return(uploadSession);
}
public File UploadChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
{
if (!uploadSession.UseChunks)
{
if (uploadSession.BytesTotal == 0)
{
uploadSession.BytesTotal = chunkLength;
}
uploadSession.File = SaveFile(uploadSession.File, stream);
uploadSession.BytesUploaded = chunkLength;
return(uploadSession.File);
}
var tempPath = uploadSession.GetItemOrDefault <string>("TempPath");
using (var fs = new FileStream(tempPath, FileMode.Append))
{
stream.CopyTo(fs);
}
uploadSession.BytesUploaded += chunkLength;
if (uploadSession.BytesUploaded == uploadSession.BytesTotal)
{
using (var fs = new FileStream(uploadSession.GetItemOrDefault <string>("TempPath"),
FileMode.Open, FileAccess.Read, FileShare.None, 4096, FileOptions.DeleteOnClose))
{
uploadSession.File = SaveFile(uploadSession.File, fs);
}
}
else
{
uploadSession.File = RestoreIds(uploadSession.File);
}
return(uploadSession.File);
}
public void UploadChunk(ChunkedUploadSession <string> uploadSession, Stream stream, long chunkLength)
{
if (!uploadSession.UseChunks)
{
if (uploadSession.BytesTotal == 0)
{
uploadSession.BytesTotal = chunkLength;
}
uploadSession.File = SaveFile(uploadSession.File, stream);
uploadSession.BytesUploaded = chunkLength;
return;
}
if (uploadSession.Items.ContainsKey("DropboxSession"))
{
var dropboxSession = uploadSession.GetItemOrDefault <string>("DropboxSession");
ProviderInfo.Storage.Transfer(dropboxSession, uploadSession.BytesUploaded, stream);
}
else
{
var tempPath = uploadSession.GetItemOrDefault <string>("TempPath");
using var fs = new FileStream(tempPath, FileMode.Append);
stream.CopyTo(fs);
}
uploadSession.BytesUploaded += chunkLength;
if (uploadSession.BytesUploaded == uploadSession.BytesTotal)
{
uploadSession.File = FinalizeUploadSession(uploadSession);
}
else
{
uploadSession.File = RestoreIds(uploadSession.File);
}
}
private void UploadSingleChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
{
if (uploadSession.BytesTotal == 0)
{
uploadSession.BytesTotal = chunkLength;
}
if (uploadSession.BytesTotal == chunkLength)
{
uploadSession.File = SaveFile(GetFileForCommit(uploadSession), stream);
uploadSession.BytesUploaded = chunkLength;
}
else if (uploadSession.BytesTotal > chunkLength)
{
//This is hack fixing strange behaviour of plupload in flash mode.
if (!uploadSession.Items.ContainsKey("ChunksBuffer"))
{
uploadSession.Items["ChunksBuffer"] = Path.GetTempFileName();
}
using (var bufferStream = new FileStream(uploadSession.GetItemOrDefault <string>("ChunksBuffer"), FileMode.Append))
{
stream.StreamCopyTo(bufferStream);
}
uploadSession.BytesUploaded += chunkLength;
if (uploadSession.BytesTotal == uploadSession.BytesUploaded)
{
using (var bufferStream = new FileStream(uploadSession.GetItemOrDefault <string>("ChunksBuffer"), FileMode.Open, FileAccess.Read, FileShare.None, 4096, FileOptions.DeleteOnClose))
{
uploadSession.File = SaveFile(GetFileForCommit(uploadSession), bufferStream);
}
}
}
}
public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
return new ChunkedUploadSession(file, contentLength) { UseChunks = false };
var tempPath = Guid.NewGuid().ToString();
var uploadId = Global.GetStore().InitiateChunkedUpload(FileConstant.StorageDomainTmp, tempPath);
var uploadSession = new ChunkedUploadSession(file, contentLength);
uploadSession.Items["TempPath"] = tempPath;
uploadSession.Items["UploadId"] = uploadId;
return uploadSession;
}
public static void AbortUploadSession(ChunkedUploadSession uploadSession)
{
CommonSessionHolder().Abort(uploadSession);
}
private static long GetMaxFileSize(ChunkedUploadSession uploadSession)
{
return(GetMaxFileSize(uploadSession.BytesTotal > 0));
}
public static void RemoveSession(ChunkedUploadSession uploadSession)
{
HttpRuntime.Cache.Remove(uploadSession.Id);
}
private File FinalizeUploadSession(ChunkedUploadSession uploadSession)
{
var tempPath = uploadSession.GetItemOrDefault<string>("TempPath");
var uploadId = uploadSession.GetItemOrDefault<string>("UploadId");
var eTags = uploadSession.GetItemOrDefault<List<string>>("ETag")
.Select((x, i) => new KeyValuePair<int, string>(i + 1, x))
.ToDictionary(x => x.Key, x => x.Value);
Global.GetStore().FinalizeChunkedUpload(FileConstant.StorageDomainTmp, tempPath, uploadId, eTags);
var file = GetFileForCommit(uploadSession);
SaveFile(file, null);
Global.GetStore().Move(FileConstant.StorageDomainTmp, tempPath, string.Empty, GetUniqFilePath(file));
return file;
}
private File GetFileForCommit(ChunkedUploadSession uploadSession)
{
if (uploadSession.File.ID != null)
{
var file = GetFile(uploadSession.File.ID);
file.Version++;
file.ContentLength = uploadSession.BytesTotal;
file.Comment = string.Empty;
return file;
}
return new File { FolderID = uploadSession.File.FolderID, Title = uploadSession.File.Title, ContentLength = uploadSession.BytesTotal };
}
public void AbortUploadSession <T>(ChunkedUploadSession <T> uploadSession)
{
CommonSessionHolder().Abort(uploadSession);
}
public Stream UploadSingleChunk <T>(ChunkedUploadSession <T> uploadSession, Stream stream, long chunkLength)
{
return(CommonSessionHolder().UploadSingleChunk(uploadSession, stream, chunkLength));
}
public void FinalizeUploadSession <T>(ChunkedUploadSession <T> uploadSession)
{
CommonSessionHolder().Finalize(uploadSession);
}
public void Move <T>(ChunkedUploadSession <T> chunkedUploadSession, string newPath)
{
CommonSessionHolder().Move(chunkedUploadSession, newPath);
}
public static void RemoveSession(ChunkedUploadSession s)
{
Global.GetStore(false).Delete(FileConstant.StorageDomainTmp, Path.Combine("sessions", s.Id + ".session"));
}
private static object ToResponseObject(ChunkedUploadSession session)
{
return new
{
id = session.Id,
created = session.Created,
expired = session.Expired,
location = session.Location,
bytes_uploaded = session.BytesUploaded,
bytes_total = session.BytesTotal
};
}
public void UploadChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
{
if (!uploadSession.UseChunks)
{
if (uploadSession.BytesTotal == 0)
uploadSession.BytesTotal = chunkLength;
uploadSession.File = SaveFile(uploadSession.File, stream);
uploadSession.BytesUploaded = chunkLength;
return;
}
if (uploadSession.Items.ContainsKey("SharpboxSession"))
{
var sharpboxSession = uploadSession.GetItemOrDefault<IResumableUploadSession>("SharpboxSession");
sharpboxSession.File.GetDataTransferAccessor().Transfer(sharpboxSession, stream, chunkLength);
}
else
{
var tempPath = uploadSession.GetItemOrDefault<string>("TempPath");
using (var fs = new FileStream(tempPath, FileMode.Append))
{
stream.CopyTo(fs);
}
}
uploadSession.BytesUploaded += chunkLength;
if (uploadSession.BytesUploaded == uploadSession.BytesTotal)
{
uploadSession.File = FinalizeUploadSession(uploadSession);
}
else
{
uploadSession.File = MakeId(uploadSession.File);
}
}
public void UploadChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
{
if (!uploadSession.UseChunks)
{
UploadSingleChunk(uploadSession, stream, chunkLength);
return;
}
var tempPath = uploadSession.GetItemOrDefault<string>("TempPath");
var uploadId = uploadSession.GetItemOrDefault<string>("UploadId");
var chunkNumber = uploadSession.GetItemOrDefault<int>("ChunksUploaded") + 1;
var eTag = Global.GetStore().UploadChunk(FileConstant.StorageDomainTmp, tempPath, uploadId, stream, chunkNumber, chunkLength);
var eTags = uploadSession.GetItemOrDefault<List<string>>("ETag") ?? new List<string>();
eTags.Add(eTag);
uploadSession.Items["ChunksUploaded"] = chunkNumber;
uploadSession.Items["ETag"] = eTags;
uploadSession.BytesUploaded += chunkLength;
if (uploadSession.BytesUploaded == uploadSession.BytesTotal)
{
uploadSession.File = FinalizeUploadSession(uploadSession);
}
}
public ChunkedUploadSession CreateUploadSession(Files.Core.File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
return new ChunkedUploadSession(MakeId(file), contentLength) { UseChunks = false };
var uploadSession = new ChunkedUploadSession(file, contentLength);
ICloudFileSystemEntry sharpboxFile;
if (file.ID != null)
{
sharpboxFile = GetFileById(file.ID);
}
else
{
var folder = GetFolderById(file.FolderID);
sharpboxFile = SharpBoxProviderInfo.Storage.CreateFile(folder, GetAvailableTitle(file.Title, folder, IsExist));
}
var sharpboxSession = sharpboxFile.GetDataTransferAccessor().CreateResumableSession(contentLength);
if (sharpboxSession != null)
{
uploadSession.Items["SharpboxSession"] = sharpboxSession;
}
else
{
uploadSession.Items["TempPath"] = Path.GetTempFileName();
}
uploadSession.File = MakeId(uploadSession.File);
return uploadSession;
}
private void UploadSingleChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
{
if (uploadSession.BytesTotal == 0)
uploadSession.BytesTotal = chunkLength;
if (uploadSession.BytesTotal == chunkLength)
{
uploadSession.File = SaveFile(GetFileForCommit(uploadSession), stream);
uploadSession.BytesUploaded = chunkLength;
}
else if (uploadSession.BytesTotal > chunkLength)
{
//This is hack fixing strange behaviour of plupload in flash mode.
if (!uploadSession.Items.ContainsKey("ChunksBuffer"))
uploadSession.Items["ChunksBuffer"] = Path.GetTempFileName();
using (var bufferStream = new FileStream(uploadSession.GetItemOrDefault<string>("ChunksBuffer"), FileMode.Append))
{
stream.StreamCopyTo(bufferStream);
}
uploadSession.BytesUploaded += chunkLength;
if (uploadSession.BytesTotal == uploadSession.BytesUploaded)
{
using (var bufferStream = new FileStream(uploadSession.GetItemOrDefault<string>("ChunksBuffer"), FileMode.Open, FileAccess.Read, FileShare.None, 4096, FileOptions.DeleteOnClose))
{
uploadSession.File = SaveFile(GetFileForCommit(uploadSession), bufferStream);
}
}
}
}
private static long GetMaxFileSize(ChunkedUploadSession uploadSession)
{
return GetMaxFileSize(uploadSession.BytesTotal > 0);
}
public void AbortUploadSession(ChunkedUploadSession uploadSession)
{
if (uploadSession.UseChunks)
{
var tempPath = uploadSession.GetItemOrDefault<string>("TempPath");
var uploadId = uploadSession.GetItemOrDefault<string>("UploadId");
Global.GetStore().AbortChunkedUpload(FileConstant.StorageDomainTmp, tempPath, uploadId);
}
else if (uploadSession.Items.ContainsKey("ChunksBuffer"))
{
System.IO.File.Delete(uploadSession.GetItemOrDefault<string>("ChunksBuffer"));
}
}
public File FinalizeUploadSession(ChunkedUploadSession uploadSession)
{
if (uploadSession.Items.ContainsKey("GoogleDriveSession"))
{
var googleDriveSession = uploadSession.GetItemOrDefault<ResumableUploadSession>("GoogleDriveSession");
CacheInsert(googleDriveSession.File);
var parentDriveId = GetParentDriveId(googleDriveSession.File);
if (parentDriveId != null) CacheReset(parentDriveId, false);
return ToFile(googleDriveSession.File);
}
using (var fs = new FileStream(uploadSession.GetItemOrDefault<string>("TempPath"), FileMode.Open, FileAccess.Read, FileShare.None, 4096, FileOptions.DeleteOnClose))
{
return SaveFile(uploadSession.File, fs);
}
}
private static void AbortUpload(ChunkedUploadSession uploadSession)
{
using (var dao = Global.DaoFactory.GetFileDao())
{
dao.AbortUploadSession(uploadSession);
}
ChunkedUploadSessionHolder.RemoveSession(uploadSession);
}
public static object ToResponseObject(ChunkedUploadSession session, bool initiate = false)
{
var pathFolder = initiate ? EntryManager.GetBreadCrumbs(session.FolderId).Select(f => f.ID) : new List<object> {session.FolderId};
return new
{
id = session.Id,
path = pathFolder,
created = session.Created,
expired = session.Expired,
location = session.Location,
bytes_uploaded = session.BytesUploaded,
bytes_total = session.BytesTotal
};
}
public static void StoreSession(ChunkedUploadSession uploadSession)
{
HttpRuntime.Cache.Insert(uploadSession.Id, uploadSession, null, AbsoluteExpiration, SlidingExpiration, OnCacheItemRemoved);
}
public void UploadChunk(ChunkedUploadSession uploadSession, Stream chunkStream, long chunkLength)
{
if (!uploadSession.UseChunks)
{
if (uploadSession.BytesTotal == 0)
uploadSession.BytesTotal = chunkLength;
uploadSession.File = SaveFile(uploadSession.File, chunkStream);
uploadSession.BytesUploaded = chunkLength;
return;
}
throw new NotImplementedException();
}
public void AbortUploadSession(ChunkedUploadSession uploadSession)
{
//throw new NotImplementedException();
}
public void AbortUploadSession(ChunkedUploadSession uploadSession)
{
//throw new NotImplementedException();
}
public void AbortUploadSession(ChunkedUploadSession uploadSession)
{
if (uploadSession.Items.ContainsKey("GoogleDriveSession"))
{
var googleDriveSession = uploadSession.GetItemOrDefault<ResumableUploadSession>("GoogleDriveSession");
if (googleDriveSession.Status != ResumableUploadSessionStatus.Completed)
{
googleDriveSession.Status = ResumableUploadSessionStatus.Aborted;
}
}
else if (uploadSession.Items.ContainsKey("TempPath"))
{
System.IO.File.Delete(uploadSession.GetItemOrDefault<string>("TempPath"));
}
}
public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
return new ChunkedUploadSession(file, contentLength) { UseChunks = false };
var tempPath = Path.GetRandomFileName();
var uploadId = Global.GetStore().InitiateChunkedUpload(string.Empty, tempPath);
var uploadSession = new ChunkedUploadSession(file, contentLength);
uploadSession.Items["TempPath"] = tempPath;
uploadSession.Items["UploadId"] = uploadId;
return uploadSession;
}
public void UploadChunk(ChunkedUploadSession uploadSession, Stream chunkStream, long chunkLength)
{
var dao = GetFileDao(uploadSession.File);
uploadSession.File = ConvertId(uploadSession.File);
dao.UploadChunk(uploadSession, chunkStream, chunkLength);
}
public void AbortUploadSession(ChunkedUploadSession uploadSession)
{
if (uploadSession.Items.ContainsKey("SharpboxSession"))
{
var sharpboxSession = uploadSession.GetItemOrDefault<IResumableUploadSession>("SharpboxSession");
sharpboxSession.File.GetDataTransferAccessor().AbortResumableSession(sharpboxSession);
}
else if (uploadSession.Items.ContainsKey("TempPath"))
{
System.IO.File.Delete(uploadSession.GetItemOrDefault<string>("TempPath"));
}
}
public void AbortUploadSession(ChunkedUploadSession uploadSession)
{
var dao = GetFileDao(uploadSession.File);
uploadSession.File = ConvertId(uploadSession.File);
dao.AbortUploadSession(uploadSession);
}
public Files.Core.File FinalizeUploadSession(ChunkedUploadSession uploadSession)
{
if (uploadSession.Items.ContainsKey("SharpboxSession"))
{
var sharpboxSession = uploadSession.GetItemOrDefault<IResumableUploadSession>("SharpboxSession");
return ToFile(sharpboxSession.File);
}
using (var fs = new FileStream(uploadSession.GetItemOrDefault<string>("TempPath"), FileMode.Open, FileAccess.Read, FileShare.None, 4096, FileOptions.DeleteOnClose))
{
return SaveFile(uploadSession.File, fs);
}
}
public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
return new ChunkedUploadSession(RestoreIds(file), contentLength) { UseChunks = false };
var uploadSession = new ChunkedUploadSession(file, contentLength);
Google.Apis.Drive.v2.Data.File driveFile;
if (file.ID != null)
{
driveFile = GetDriveEntry(file.ID);
}
else
{
var folder = GetDriveEntry(file.FolderID);
driveFile = GoogleDriveProviderInfo.Storage.FileConstructor(file.Title, null, folder.Id);
}
var googleDriveSession = GoogleDriveProviderInfo.Storage.CreateResumableSession(driveFile, contentLength);
if (googleDriveSession != null)
{
uploadSession.Items["GoogleDriveSession"] = googleDriveSession;
}
else
{
uploadSession.Items["TempPath"] = Path.GetTempFileName();
}
uploadSession.File = RestoreIds(uploadSession.File);
return uploadSession;
}
public void UploadChunk <T>(ChunkedUploadSession <T> uploadSession, Stream stream, long length)
{
CommonSessionHolder().UploadChunk(uploadSession, stream, length);
}
public void StoreSession <T>(ChunkedUploadSession <T> s)
{
CommonSessionHolder(false).Store(s);
}
public void UploadChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
{
if (!uploadSession.UseChunks)
{
if (uploadSession.BytesTotal == 0)
uploadSession.BytesTotal = chunkLength;
uploadSession.File = SaveFile(uploadSession.File, stream);
uploadSession.BytesUploaded = chunkLength;
return;
}
if (uploadSession.Items.ContainsKey("GoogleDriveSession"))
{
var googleDriveSession = uploadSession.GetItemOrDefault<ResumableUploadSession>("GoogleDriveSession");
GoogleDriveProviderInfo.Storage.Transfer(googleDriveSession, stream, chunkLength);
}
else
{
var tempPath = uploadSession.GetItemOrDefault<string>("TempPath");
using (var fs = new FileStream(tempPath, FileMode.Append))
{
stream.CopyTo(fs);
}
}
uploadSession.BytesUploaded += chunkLength;
if (uploadSession.BytesUploaded == uploadSession.BytesTotal)
{
uploadSession.File = FinalizeUploadSession(uploadSession);
}
else
{
uploadSession.File = RestoreIds(uploadSession.File);
}
}
public void AbortUploadSession(ChunkedUploadSession uploadSession)
{
ChunkedUploadSessionHolder.AbortUploadSession(uploadSession);
}
public void RemoveSession <T>(ChunkedUploadSession <T> s)
{
CommonSessionHolder(false).Remove(s);
}
