public ViewModel(Window parentWindow, FileEntityAggregator fileEntityAggregator)
{
_parentWindow = parentWindow;
_fileEntityAggregator = fileEntityAggregator;
_saveSelectedVersionCommand = new SaveSelectedVersionCommandImplementation(this);
_cancelCommand = new CancelCommandImplementation(this);
_diffStampsList = new List<DiffStampAdapter>();
ResolveDiffstampsDescriptorsGet();
}
public GetSpecificFileVersionWindow(FileEntityAggregator fileEntityAggregator)
{
InitializeComponent();
_viewModel = new ViewModel(this, fileEntityAggregator);
}
public async Task<FileEntityAggregator> TryFormSourceFileEntityAggregator(File fileDescriptor)
{
FileEntityAggregator result = default(FileEntityAggregator);
if (fileDescriptor == default(File))
{
//Descriptor empty
}
else
{
FileTrackingInfo fileTrackingInfo =
await TryGetFileTrackingInfo(fileDescriptor.Parents.First().Id);
if (fileTrackingInfo == default(FileTrackingInfo))
{
//Failed to get tracking data
}
else
{
result = new FileEntityAggregator(
fileTrackingInfo.UserPCLocation,
fileDescriptor.Id,
fileDescriptor.Parents.First().Id,
fileDescriptor.DownloadUrl,
fileDescriptor.MimeType);
result = await UpdateFileEntityAggregator(result);
}
}
return result;
}
public async Task<FileEntityAggregator> UpdateFileEntityAggregator(FileEntityAggregator source)
{
DriveService driveService = await TryGetAuthorizer();
FilesResource.ListRequest filesListRequest = driveService.Files.List();
filesListRequest.Q = String.Format("'{0}' in parents and trashed=false", source.GoogleDriveParentId);
FileList filelist = await filesListRequest.ExecuteAsync();
Int64 bytesTaken = filelist.Items.Sum((File file) => Convert.ToInt64(file.FileSize));
IEnumerable<File> fileListDiffStamps = filelist.Items.Where(
fileRecord => fileRecord.FileExtension == BsdiffStampExtension);
DateTime latestDiffStampDate =
fileListDiffStamps.Count() > 0 ?
fileListDiffStamps.Max(item => DateTime.Parse(item.CreatedDate)) :
default(DateTime);
source.DiffStampsAmount = fileListDiffStamps.Count();
source.CloudMemory = FormatBytes(bytesTaken);
source.LatestDiffStampTakenDateTime = latestDiffStampDate;
return source;
}
public async Task<FileTrackingInfo> TryGetFileTrackingInfo(String fileRecordDirectoryId)
{
File fileTrackingInfoDescriptor = await TryGetFileTrackingInfoDescriptor(fileRecordDirectoryId);
FileEntityAggregator fileTrackingInfoWrapper = new FileEntityAggregator(
String.Empty,
fileTrackingInfoDescriptor.Id,
fileRecordDirectoryId,
fileTrackingInfoDescriptor.DownloadUrl,
FileLocationInfoExtension);
IO.MemoryStream memoryStream = await TryDownloadFileToStream(fileTrackingInfoWrapper);
if (memoryStream == default(IO.MemoryStream))
{
//Fail
return default(FileTrackingInfo);
}
else
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(FileTrackingInfo));
memoryStream.Position = 0;
FileTrackingInfo fileTrackingInfo = xmlSerializer.Deserialize(memoryStream) as FileTrackingInfo;
memoryStream.Dispose();
return fileTrackingInfo;
}
}
//Refactoring ++OK
public async Task<List<DiffStampAdapter>> TryDownloadAllDiffstampsForFile(FileEntityAggregator targetFile)
{
DriveService driveService = await TryGetAuthorizer();
//Get all files from folder
FilesResource.ListRequest filesListRequest = driveService.Files.List();
filesListRequest.Q = String.Format("'{0}' in parents and trashed=false", targetFile.GoogleDriveParentId);
FileList filelist = await filesListRequest.ExecuteAsync();
//Get diff stamps descriptors
IEnumerable<File> foundDiffStamps =
from items in filelist.Items
where items.FileExtension == BsdiffStampExtension
orderby DateTime.Parse(items.CreatedDate, CultureInfo.InvariantCulture) ascending
select items;
//Download diff stamps
MediaDownloader mediaDownloader = new MediaDownloader(driveService);
List<DiffStampAdapter> resultDiffStampAdapters = new List<DiffStampAdapter>();
foreach (File diffStampDescriptor in foundDiffStamps)
{
using (IO.MemoryStream memoryStream = new IO.MemoryStream())
{
mediaDownloader.Download(diffStampDescriptor.DownloadUrl, memoryStream);
BinaryFormatter binaryFormatter = new BinaryFormatter();
memoryStream.Position = 0;
DiffStampAdapter diffStampAdapter =
binaryFormatter.Deserialize(memoryStream) as DiffStampAdapter;
resultDiffStampAdapters.Add(diffStampAdapter);
}
}
return resultDiffStampAdapters;
}
//Refactoring OK++
public async Task<DiffStampAdapter> TryMakeDiffStamp(
FileEntityAggregator targetFile,
String diffStampDescription)
{
//Download source file
IO.MemoryStream fileMemoryStream = await TryDownloadFileToStream(targetFile);
if (fileMemoryStream == default(IO.MemoryStream))
{
//Failed to download
return default(DiffStampAdapter);
}
else
{
//Download present diff stamps
List<DiffStampAdapter> diffStamps = await TryDownloadAllDiffstampsForFile(targetFile); //OK
//Apply all of them (memory hungry section)
Byte[] latestData = fileMemoryStream.ToArray();
fileMemoryStream.Dispose(); //As there is a temp stream to apply patches
foreach (DiffStampAdapter diffStamp in diffStamps)
{
using (IO.MemoryStream outputStream = new IO.MemoryStream())
{
using (IO.MemoryStream currentPatchedMemoryStream = new IO.MemoryStream(latestData))
{
//Apply a patch
BinaryPatchUtility.Apply(
currentPatchedMemoryStream,
diffStamp.OpenMemoryStreamForPatching,
outputStream);
//Prepare applied data for next iteration patching
outputStream.Position = 0;
latestData = outputStream.ToArray();
}
}
}
//When all patches are applied, make new one with the difference between last on cloud and on PC
IO.FileStream fileStream = default(IO.FileStream);
IO.MemoryStream latestPatchMemoryStream = new IO.MemoryStream();
DiffStampAdapter resultPatch = default(DiffStampAdapter);
try
{
//Read a file to byte array
fileStream = new IO.FileStream(targetFile.LocalFilePath, IO.FileMode.Open);
Byte[] lastFromUserPC = new Byte[fileStream.Length];
fileStream.Read(lastFromUserPC, 0, Convert.ToInt32(fileStream.Length));
//Get bytes from latest patched from cloud
BinaryPatchUtility.Create(latestData, lastFromUserPC, latestPatchMemoryStream);
//Create new binary patch instance
resultPatch = new DiffStampAdapter(
latestPatchMemoryStream.ToArray(),
diffStampDescription,
DateTime.Now);
}
catch (Exception)
{
//Patching failed
}
finally
{
fileStream.Dispose();
latestPatchMemoryStream.Dispose();
}
return resultPatch;
}
}
public async Task<Byte[]> TryGetFilePatchedUntilDateTime(
FileEntityAggregator targetFile,
DateTime dateTimeUntil)
{
//Download source file
IO.MemoryStream fileMemoryStream = await TryDownloadFileToStream(targetFile);
if (fileMemoryStream == default(IO.MemoryStream))
{
//Failed to download
return default(Byte[]);
}
else
{
//Download present diff stamps
List<DiffStampAdapter> diffStamps = await TryDownloadAllDiffstampsForFileUntilDateTime(
targetFile, dateTimeUntil); //OK
//Apply all of them (memory hungry section)
Byte[] latestData = fileMemoryStream.ToArray();
fileMemoryStream.Dispose(); //As there is a temp stream to apply patches
foreach (DiffStampAdapter diffStamp in diffStamps)
{
using (IO.MemoryStream outputStream = new IO.MemoryStream())
{
using (IO.MemoryStream currentPatchedMemoryStream = new IO.MemoryStream(latestData))
{
//Apply a patch
BinaryPatchUtility.Apply(
currentPatchedMemoryStream,
diffStamp.OpenMemoryStreamForPatching,
outputStream);
//Prepare applied data for next iteration patching
outputStream.Position = 0;
latestData = outputStream.ToArray();
}
}
}
return latestData;
}
}
public async Task<String> TryRemoveRecordFromGoogleDrive(FileEntityAggregator targetFile)
{
DriveService driveService = await TryGetAuthorizer();
FilesResource.DeleteRequest deleteRequest = new FilesResource.DeleteRequest(
driveService,
targetFile.GoogleDriveParentId);
return await deleteRequest.ExecuteAsync();
}
//Refactoring OK++
public async Task<FileEntityAggregator> TryMakeAndUploadDiffStamp(
FileEntityAggregator targetFile,
String diffStampDescription)
{
DiffStampAdapter diffStampAdapter =
await CloudFileTrackingAggregatorSingleton.Instance.TryMakeDiffStamp(
targetFile, diffStampDescription);
if (diffStampAdapter == default(DiffStampAdapter))
{
//Fail
return default(FileEntityAggregator);
}
else
{
return await TryUploadDiffStampForFileAsync(targetFile, diffStampAdapter);
}
}
//Refactoring OK++
public async Task<FileEntityAggregator> TryUploadDiffStampForFileAsync(
FileEntityAggregator targetFile,
DiffStampAdapter diffStamp)
{
DriveService driveService = await TryGetAuthorizer();
//Instantiate file entity
File fileToUpload = new File
{
Title = String.Format("{0}.{1}", diffStamp.Description, BsdiffStampExtension),
Parents = new ParentReference[] { new ParentReference { Id = targetFile.GoogleDriveParentId } }
};
//Instantiate request
IUploadProgress uploadProgress = default(IUploadProgress);
FileEntityAggregator result = default(FileEntityAggregator);
using (IO.MemoryStream uploadFileStream = new IO.MemoryStream())
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(uploadFileStream, diffStamp);
uploadFileStream.Position = 0;
var insertUploadRequest = driveService.Files.Insert(
fileToUpload, uploadFileStream, BsdiffStampMIMEType);
insertUploadRequest.ChunkSize = FilesResource.InsertMediaUpload.MinimumChunkSize * 2;
//Start uploading task
uploadProgress = await insertUploadRequest.UploadAsync();
//Return data according to upload completion state
if (uploadProgress.Status == UploadStatus.Completed)
{
result = new FileEntityAggregator
{
LocalFilePath = String.Empty,
GoogleDriveId = insertUploadRequest.ResponseBody.Id,
GoogleDrivePath = insertUploadRequest.ResponseBody.DownloadUrl,
GoogleDriveParentId = targetFile.GoogleDriveParentId,
MIMEType = BsdiffStampMIMEType
};
}
else
{
result = default(FileEntityAggregator);
}
}
return result;
}
public async Task<IO.MemoryStream> TryDownloadFileToStream(FileEntityAggregator targetFile)
{
DriveService driveService = await TryGetAuthorizer();
MediaDownloader mediaDownloader = new MediaDownloader(driveService);
IO.MemoryStream memoryStream = new IO.MemoryStream();
try
{
mediaDownloader.Download(targetFile.GoogleDrivePath, memoryStream);
return memoryStream;
}
catch (Exception)
{
memoryStream.Dispose();
return default(IO.MemoryStream);
}
}
