private async void RenameCurrentCloudFile()
{
if (!HasGottenFolder())
{
return;
}
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
if (currentRow.name == tsTxtObjectName.Text)
{
StatusMsg("Name not changed, ignored");
}
string oldName = currentRow.name;
Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType ceType = Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType.File;
if (currentRow.directory)
{
ceType = Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType.Folder;
}
currentRow.path = txtFolderPath.Text + tsTxtObjectName.Text;
Cloud_Elements_API.CloudFile Result = await APIConnector.PatchDocEntryMetaData(ceType, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.ID, currentRow.id, currentRow);
StatusMsg(string.Format("Renamed [{0}] to {1}", oldName, Result.name));
Task refresh = RefreshCurrentFolder();
}
async private Task uploadFile(System.IO.FileInfo sourceFile, string targetPath, List <String> tagList, string description)
{
var MIMEType = Cloud_Elements_API.Tools.FileTypeToMimeContentType(System.IO.Path.GetExtension(sourceFile.Name));
DateTime StartedAt = DateTime.Now;
StatusMsg("Uploading " + sourceFile.Name);
string SourceFileName = System.IO.Path.GetFileName(sourceFile.Name);
if (!targetPath.EndsWith("/"))
{
targetPath += "/";
}
targetPath += SourceFileName;
//System.IO.FileInfo fInfo = new System.IO.FileInfo(sourceFileName);
var sizeInBytes = sourceFile.Length;
Cloud_Elements_API.CloudFile Result = await APIConnector.PostFile(sourceFile.OpenRead(), MIMEType,
targetPath, description,
tagList.ToArray(), false, sizeInBytes);
sourceFile = null;
double uploadSeconds = DateTime.Now.Subtract(StartedAt).TotalSeconds;
StatusMsg(string.Format("Uploaded {0} in {1:F1}s, {2:F1} mb/s ", SourceFileName, uploadSeconds, (sizeInBytes / 1024.0) / uploadSeconds));
}
private async void tsRemoveEmptyFolders_Click(object sender, EventArgs e)
{
if (!HasGottenFolder())
{
return;
}
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
frmEmptyFolderScanOptions emptyOptions = new frmEmptyFolderScanOptions();
if (emptyOptions.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
{
return;
}
ScanOptions = emptyOptions.ScanOptions;
APIConnector.EndpointMaxRequestsPerSecond = 2;
CountOfFoldersRemoved = 0;
StatusMsg("Starting folder scan...");
await scanForEmptyFolders(ScanOptions, currentRow);
StatusMsg("Folder scan ended, see test log for results.");
TestStatusMsg(string.Format("Folders Removed: {0}", CountOfFoldersRemoved));
}
/// <summary>
/// Asynchronously download a files, with progress messages to status bar
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>You can have multiple simultaneous downloads</remarks>
private async void tsGetFileMenuItem_Click(object sender, EventArgs e)
{
cmdGetFolderContents.Enabled = false;
try
{
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
StatusMsg("Requesting...");
DateTime startAt = DateTime.Now;
Cloud_Elements_API.FileContent Result = await APIConnector.GetFile(currentRow);
StatusMsg(string.Format(">> Get File Result: {2:F1}s for content-length: {0}; disposition: [{1}]", Result.ContentLength, Result.Disposition, DateTime.Now.Subtract(startAt).TotalSeconds));
string fn = System.IO.Path.Combine(WorkPath, Result.Disposition);
if (Result.Disposition.Length == 0)
{
fn += currentRow.name;
}
if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(fn)))
{
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(fn));
}
if (System.IO.File.Exists(fn))
{
// HINT: would be better to check this before downloading...but we are using the response disposition to illustrate its existence....
if (System.Windows.Forms.MessageBox.Show(string.Format("Download will replace existing file {0}\n\nOkay?", fn), "Confirmation", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.No)
{
Result.ContentStream.Close();
return;
}
System.IO.File.Delete(fn);
}
System.IO.Stream Target = new System.IO.FileStream(fn, System.IO.FileMode.Create, System.Security.AccessControl.FileSystemRights.FullControl, System.IO.FileShare.None, 16384, System.IO.FileOptions.Asynchronous, null);
StatusMsg("Receiving...");
//error handling here would be nice...
Cloud_Elements_API.Tools.Progress += Tools_Progress;
await Cloud_Elements_API.Tools.StreamCopyWithProgress(Result.ContentStream, Target, Result.ContentLength);
Result.ContentStream.Close();
Target.Seek(0, System.IO.SeekOrigin.Begin);
StatusMsg(string.Format("Downloaded content for {1}: MD5={0}", Cloud_Elements_API.Tools.HashForBuffer(Target, "MD5"), System.IO.Path.GetFileName(fn)));
Target.Seek(0, System.IO.SeekOrigin.Begin);
StatusMsg(string.Format("Downloaded content for {1}: SHA1={0}", Cloud_Elements_API.Tools.HashForBuffer(Target, "SHA1"), System.IO.Path.GetFileName(fn)));
Target.Close();
Cloud_Elements_API.Tools.Progress -= Tools_Progress;
StatusMsg(string.Format("Stored {1}: {0}", Cloud_Elements_API.Tools.SizeInBytesToString(Result.ContentLength), System.IO.Path.GetFileName(fn)));
}
finally
{
cmdGetFolderContents.Enabled = true;
}
}
private async void cmdGetID_Click(object sender, EventArgs e)
{
frmGetCloudFileID frmGet = new frmGetCloudFileID();
cmdGetID.Enabled = false;
if (frmGet.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
Cloud_Elements_API.CloudElementsConnector.TraceLevel diagTraceWas = Cloud_Elements_API.CloudElementsConnector.DiagOutputLevel;
try
{
TestStatusMsg("Checking: " + frmGet.FileID);
Cloud_Elements_API.CloudFile CloudFileInfoByID;
Cloud_Elements_API.CloudElementsConnector.DiagOutputLevel = Cloud_Elements_API.CloudElementsConnector.TraceLevel.All;
CloudFileInfoByID = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.ID, frmGet.FileID);
if (CloudFileInfoByID == null)
{
StatusMsg("Nothing Returned! (not expecting not found)");
}
else
{
if (CloudFileInfoByID.directory)
{
txtFolderPath.Text = CloudFileInfoByID.path;
}
else
{
txtFolderPath.Text = CloudFileInfoByID.path.Substring(0, CloudFileInfoByID.path.LastIndexOf("/"));
}
TestStatusMsg("Getting: " + CloudFileInfoByID.path);
Task refresh = RefreshCurrentFolder();
await refresh;
//dgFolderContents.SelectedRows.Clear();
foreach (DataGridViewRow gridRow in dgFolderContents.Rows)
{
Cloud_Elements_API.CloudFile itemrow = (Cloud_Elements_API.CloudFile)gridRow.DataBoundItem;
if (itemrow.id == frmGet.FileID)
{
gridRow.Selected = true;
dgFolderContents.CurrentCell = dgFolderContents.Rows[gridRow.Index].Cells[0];
break;
}
}
}
}
catch (Exception ex)
{
StatusMsg(string.Format("FAILED: {0}", ex.Message));
}
finally
{
Cloud_Elements_API.CloudElementsConnector.DiagOutputLevel = diagTraceWas;
}
}
cmdGetID.Enabled = true;
}
private void tsGetPriorFolder_Click(object sender, EventArgs e)
{
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
GetPriorFolder_Click(sender, e);
}
private bool HasCurrentCloudFile(ref Cloud_Elements_API.CloudFile currentRow)
{
currentRow = GetCurrentFolderContentRow();
bool result = !(currentRow == null);
if (!result)
{
StatusMsg("No current row");
}
return(result);
}
private async void tsGetThisFolder_Click(object sender, EventArgs e)
{
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
txtFolderPath.Text = currentRow.path;
await RefreshCurrentFolder();
}
private async void deleteThisFolderToolStripMenuItem_Click(object sender, EventArgs e)
{
if (!HasGottenFolder())
{
return;
}
try
{
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
if (currentRow.directory)
{
if (currentRow.size > 0)
{
if (System.Windows.Forms.MessageBox.Show(string.Format("Folder is not empty! Delete [{0}] anyway?", currentRow.path), "Confirmation", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.No)
{
return;
}
}
StatusMsg(string.Format("Deleting {0}, size={1}", currentRow.path, Cloud_Elements_API.Tools.SizeInBytesToString(currentRow.size)));
bool Result = await APIConnector.DeleteFolder(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, currentRow.path, false);
}
else
{
if (currentRow.size > 0)
{
if (System.Windows.Forms.MessageBox.Show(string.Format("File is not empty! Delete [{0}] anyway?", currentRow.path), "Confirmation", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.No)
{
return;
}
}
StatusMsg(string.Format("Deleting {0}, size={1}", currentRow.path, Cloud_Elements_API.Tools.SizeInBytesToString(currentRow.size)));
bool Result = await APIConnector.DeleteFile(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.ID, currentRow.id, false);
}
StatusMsg("Done.");
await this.RefreshCurrentFolder();
}
finally
{
cmdGetFolderContents.Enabled = true;
}
}
private Cloud_Elements_API.CloudFile GetCurrentFolderContentRow()
{
//BindingManagerBase grdBinding = this.BindingContext(dgFolderContents.DataSource, dgFolderContents.DataMember);
Cloud_Elements_API.CloudFile currentRow = null;
if (dgFolderContents.CurrentRow != null)
{
if (dgFolderContents.CurrentRow.DataBoundItem is Cloud_Elements_API.CloudFile)
{
currentRow = (Cloud_Elements_API.CloudFile)dgFolderContents.CurrentRow.DataBoundItem;
}
}
return(currentRow);
}
private void FolderRowContextMenu_Opening(object sender, CancelEventArgs e)
{
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
tsGetThisFolder.Enabled = currentRow.directory;
tsGetPriorFolder.Enabled = (FolderPathHistory.Count > 1);
tsDeleteFolderMenuItem.Enabled = true;
tsGetFileMenuItem.Enabled = !currentRow.directory;
if (currentRow.directory)
{
tsDeleteFolderMenuItem.Text = "Delete this folder...";
}
else
{
tsDeleteFolderMenuItem.Text = "Delete this file...";
}
tsTxtObjectName.Text = currentRow.name;
tsFileTagInfoMenuItem.Text = "Tags (not requested)";
tsFileTagInfoMenuItem.Enabled = chkWithTags.Checked;
if (tsFileTagInfoMenuItem.Enabled)
{
tsFileTagInfoMenuItem.DropDownItems.Clear();
if (currentRow.tags != null)
{
tsFileTagInfoMenuItem.Text = string.Format("{0} Tags ", currentRow.tags.Length);
foreach (string tag in currentRow.tags)
{
tsFileTagInfoMenuItem.DropDownItems.Add(tag);
}
}
else
{
tsFileTagInfoMenuItem.Text = string.Format("No Tags ", 0);
tsFileTagInfoMenuItem.Enabled = false;
}
}
}
private void dgFolderContents_DoubleClick(object sender, EventArgs e)
{
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
if (currentRow.directory)
{
tsGetThisFolder_Click(sender, e);
}
else
{
if (System.Windows.Forms.MessageBox.Show(string.Format("Download {0}", currentRow.path), "Confirmation", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
{
tsGetFileMenuItem_Click(sender, e);
}
}
}
private async void toolStripButton1_Click_1(object sender, EventArgs e)
{
if (!HasGottenFolder())
{
return;
}
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
string TagToSet = tstxtTagData.Text;
//Type the tag to add. If includes an = is treated as a KV pair; Try: *TestTag for a random tag or sfKey=* for a guid tag
if (TagToSet == "*TestTag")
{
TagToSet = "Day-" + DateTime.Today.DayOfWeek.ToString();
}
if (TagToSet.StartsWith("sfKey="))
{
TagToSet = string.Format("sfKey={0}", Guid.NewGuid());
}
if (!chkWithTags.Checked || !currentRow.HasTags)
{
StatusMsg("Getting current Tag(s).... ");
currentRow = await APIConnector.GetDocEntryMetaData(currentRow.EntryType, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.ID, currentRow.id, false);
}
StatusMsg("Storing Tag: " + TagToSet);
await Cloud_Elements_API.TagOperations.SetTag(APIConnector, currentRow, TagToSet);
if (!chkWithTags.Checked)
{
chkWithTags.Checked = true;
}
await RefreshCurrentFolder();
}
private async void tsBtnNewFolder_Click(object sender, EventArgs e)
{
if (!HasGottenFolder())
{
return;
}
if (tsTxtFolderName.Text.Length > 0)
{
Cloud_Elements_API.CloudFile newFolder = new Cloud_Elements_API.CloudFile();
newFolder.path = CurrentFolderPath;
if (!tsTxtFolderName.Text.StartsWith("/"))
{
newFolder.path += "/";
}
newFolder.path += tsTxtFolderName.Text;
newFolder.tags = new string[] { "sfCE.NET" };
Cloud_Elements_API.CloudFile Result = await APIConnector.CreateFolder(newFolder);
StatusMsg(string.Format("Created {0}, id={1}", Result.path, Result.id));
Task ignoredRefreshFolderTask = RefreshCurrentFolder(); // very naughty, ignore exceptions; ref http://stackoverflow.com/questions/14903887/warning-this-call-is-not-awaited-execution-of-the-current-method-continues
}
}
async private Task uploadFolder(string sourcePath, string targetPath)
{
List <String> TagList = new List <String>(); // unchanged in this method
TagList.Add("sfCETest.NET");
var HTMLMIMEType = Cloud_Elements_API.Tools.FileTypeToMimeContentType(".htm");
System.Text.StringBuilder FileList = new System.Text.StringBuilder();
foreach (var fn in System.IO.Directory.GetFiles(sourcePath))
{
System.IO.FileInfo fInfo = new System.IO.FileInfo(fn);
FileList.AppendFormat("<tr><td>{0}</td><td>{1:d} {1:t}</td><td>{2:d} {2:t}</td></tr>", fInfo.Name, fInfo.CreationTime, fInfo.LastWriteTime);
await uploadFile(fInfo, targetPath, TagList, "");
}
if (FileList.Length > 0)
{
System.Text.StringBuilder FolderMarker = new System.Text.StringBuilder();
FolderMarker.AppendFormat("<!DOCTYPE html><html><head><title>{0}</title></head><body>\n", targetPath);
FolderMarker.Append("<h2>Original Creation and Modification dates for this folder</h2><hr /><table style='width:88%;'>");
FolderMarker.AppendFormat("<tr style='font-weight:bold;'><td>{0}</td><td>{1}</td><td>{2}</td></tr>", "File Name", "Created", "Last Write");
FolderMarker.Append(FileList);
FolderMarker.AppendFormat("</table><span style='font-size: 0.6em'>Uploaded {0:d} at {0:t}</span>", DateTime.Now);
FolderMarker.AppendLine("</body></html>");
byte[] ByteBuffer = System.Text.Encoding.ASCII.GetBytes(FolderMarker.ToString());
System.IO.MemoryStream logFileStream = new System.IO.MemoryStream(ByteBuffer);
Cloud_Elements_API.CloudFile Result = await APIConnector.PostFile(logFileStream, HTMLMIMEType,
targetPath + "/Uploaded File Date Information.html", "",
TagList.ToArray(), false, ByteBuffer.Length);
}
string nestedPath;
foreach (var folderName in System.IO.Directory.GetDirectories(sourcePath))
{
nestedPath = string.Format("{0}/{1}", targetPath, new System.IO.DirectoryInfo(folderName).Name);
await uploadFolder(folderName, nestedPath);
}
}
private async void getMetadataByIDToolStripMenuItem_Click(object sender, EventArgs e)
{
if (!HasGottenFolder())
{
return;
}
Cloud_Elements_API.CloudFile currentRow = null;
Cloud_Elements_API.CloudFile CloudFileInfoByID = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
Cloud_Elements_API.CloudElementsConnector.TraceLevel diagTraceWas = Cloud_Elements_API.CloudElementsConnector.DiagOutputLevel;
try
{
Cloud_Elements_API.CloudElementsConnector.DiagOutputLevel = Cloud_Elements_API.CloudElementsConnector.TraceLevel.All;
CloudFileInfoByID = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.ID, currentRow.id);
if (CloudFileInfoByID == null)
{
StatusMsg("Nothing Returned! (not expecting not found)");
}
else
{
StatusMsg(string.Format("OK: ID is {0}, by [{2}], hash {1}", CloudFileInfoByID.id, Cloud_Elements_API.FileOperations.ContentHash(APIConnector, CloudFileInfoByID),
Cloud_Elements_API.FileOperations.LastWrittenBy(APIConnector, CloudFileInfoByID)));
}
}
catch (Exception ex)
{
StatusMsg(string.Format("FAILED: {0}", ex.Message));
}
finally
{
Cloud_Elements_API.CloudElementsConnector.DiagOutputLevel = diagTraceWas;
}
}
private async void tsGetFileLink_Click(object sender, EventArgs e)
{
if (!HasGottenFolder())
{
return;
}
Cloud_Elements_API.CloudFile currentRow = null;
if (!HasCurrentCloudFile(ref currentRow))
{
return;
}
if (currentRow.directory)
{
StatusMsg("API does not support a link to a folder");
}
Cloud_Elements_API.CloudLink Result = await APIConnector.FileLinks(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.ID, currentRow.id);
StatusMsg(string.Format("ceLink: {0}", Result.cloudElementsLink));
StatusMsg(string.Format("Provider View Link: {0}", Result.providerViewLink));
StatusMsg(string.Format("Provider Link: {0}", Result.providerLink));
StatusMsg("See log for links...");
}
private async Task RunUnitTest()
{
TestStatusMsg("Beginning test suite...");
TestStatusMsg("Testing with " + toolStripTxtConnectionNow.Text);
string basepath = txtFolderPath.Text;
SerializeGetFileMetadataRequests = chkSerializeGetFileInfoReq.Checked;
APIConnector.EndpointMaxRequestsPerSecond = (int)spnRequestsPerSecond.Value;
if (basepath.EndsWith("/"))
{
basepath.TrimEnd(new char[] { '/' });
}
string tfoldername = basepath + "/Cloud Elements API Test Folder";
AsyncBasePath = tfoldername;
Boolean remnant = false;
Boolean fremnant = false;
DateTime StartTime = DateTime.Now;
Cloud_Elements_API.CloudFile TestFileStore;
//FIRST TEST: Check for folder. If no folder, create test folder.
try
{
// List<Cloud_Elements_API.CloudFile> fe = await APIConnector.ListFolderContents(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, tfoldername, chkWithTags.Checked);
Cloud_Elements_API.CloudFile Result = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, tfoldername);
if (Result != null)
{
remnant = true;
TestStatusMsg("Using existing test folder");
}
else
{
remnant = false;
}
}
//catch (System.Net.Http.HttpRequestException e)
//{
// //NOTE: handle different http exceptions!
// remnant = false;
//}
catch (Exception ex)
{
TestStatusMsg("Problem checking if test folder exists: " + ex.Message);
throw ex;
}
if (!remnant)
{
TestStatusMsg("Test: Creating folder...");
try
{
Cloud_Elements_API.CloudFile newFolder = new Cloud_Elements_API.CloudFile();
newFolder.path = tfoldername;
//newFolder.tags = new string[] { "sfCE.NET" };
Cloud_Elements_API.CloudFile Result = await APIConnector.CreateFolder(newFolder);
TestStatusMsg(string.Format("Created {0}, id={1}", Result.path, Result.id));
Task ignoredRefreshFolderTask = RefreshCurrentFolder(); // very naughty, ignore exceptions; ref http://stackoverflow.com/questions/14903887/warning-this-call-is-not-awaited-execution-of-the-current-method-continues
}
catch (Exception ec)
{
TestStatusMsg("Create Folder failed: " + ec.Message);
throw ec;
}
}
TestStatusMsg("Checking for test file...");
try
{
string TargetPath = tfoldername + "/SFCE_test_file_prime.txt";
Cloud_Elements_API.CloudFile Result = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, TargetPath);
if (Result != null)
{
TestStatusMsg(string.Format("Test file exists: {0}, id={1}", Result.path, Result.id));
fremnant = true;
TestFileStore = Result;
}
else
{
TestStatusMsg("Test file not found"); TestFileStore = null;
}
}
catch (Exception ec)
{
TestStatusMsg("Check for file failed: " + ec.Message);
TestFileStore = null;
// throw ec;
}
double UploadRequiredMS = 0d;
if (!fremnant)
{
//SECOND TEST: Create file.
TestStatusMsg("Test: Uploading file...");
try
{
using (System.IO.Stream teststream = GenerateStreamFromString("This is a dummy test file; its diminutive size is quite reasonable."))
{
string MIMEType = Cloud_Elements_API.Tools.FileTypeToMimeContentType("txt");
List <String> TagList = new List <String>();
var sizeInBytes = teststream.Length;
string TargetPath = tfoldername + "/SFCE_test_file_prime.txt";
DateTime Started = DateTime.Now;
Cloud_Elements_API.CloudFile Result = await APIConnector.PostFile(teststream, MIMEType,
TargetPath, "Temporary test file",
TagList.ToArray(), false, sizeInBytes);
UploadRequiredMS = DateTime.Now.Subtract(Started).TotalMilliseconds;
TestStatusMsg(string.Format("Uploaded {0}, id={1}", Result.path, Result.id));
TestFileStore = Result;
}
}
catch (Exception eu)
{
TestStatusMsg("Upload file failed: " + eu.Message);
TestFileStore = null;
}
}
else
{
TestStatusMsg("Skipping file upload");
}
//THIRD TEST: Copy File.
TestStatusMsg("Test: Copying file...");
double CopyRequiredMS = 0d;
try
{
if (TestFileStore == null)
{
TestFileStore = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, tfoldername + "/SFCE_test_file_prime.txt");
}
string CopyFileName = tfoldername + "/SFCE_test_file_copy.txt";
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
DateTime Started = DateTime.Now;
Cloud_Elements_API.CloudFile Result = await Cloud_Elements_API.FileOperations.Copy(APIConnector, currentRow, CopyFileName);
if (Result == null)
{
TestStatusMsg(string.Format("?? Copy did not return CloudFile object ", 0));
}
else
{
CopyRequiredMS = DateTime.Now.Subtract(Started).TotalMilliseconds;
TestStatusMsg(string.Format("Copied [{0}] to {1}", currentRow.name, Result.path));
if (UploadRequiredMS > 0)
{
TestStatusMsg(string.Format("Comparison: Upload {0:F1}ms; Copy {1:F1}ms; Pct {2:P2} ", UploadRequiredMS, CopyRequiredMS, CopyRequiredMS / UploadRequiredMS));
}
}
}
catch (Exception ecopy)
{
TestStatusMsg("Copy File failed: " + ecopy.Message);
}
//FOURTH TEST: Rename File.
TestStatusMsg("Test: Renaming file (by path)...");
try
{
string oldName = "SFCE_test_file_prime.txt";
string oldPath = tfoldername + "/" + oldName;
Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType ceType = Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType.File;
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
currentRow.path = tfoldername + "/SFCE_test_file_rename_path.txt";
Cloud_Elements_API.CloudFile Result = await APIConnector.PatchDocEntryMetaData(ceType, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, oldPath, currentRow);
TestStatusMsg(string.Format("Renamed [{0}] to {1}", oldName, Result.name));
TestFileStore = Result;
}
catch (Exception er)
{
TestStatusMsg("Rename file by path failed: " + er.Message);
}
TestStatusMsg("Test: Renaming file (by ID)...");
try
{
Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType ceType = Cloud_Elements_API.CloudElementsConnector.DirectoryEntryType.File;
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
string oldName = TestFileStore.name;
currentRow.path = tfoldername + "/SFCE_test_file_rename_id.txt";
Cloud_Elements_API.CloudFile PatchData = new Cloud_Elements_API.CloudFile();
PatchData.id = currentRow.id;
PatchData.path = currentRow.path;
Cloud_Elements_API.CloudFile Result = await APIConnector.PatchDocEntryMetaData(ceType, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.ID, TestFileStore.id, PatchData);
TestStatusMsg(string.Format("Renamed [{0}] to {1}", oldName, Result.name));
TestFileStore = Result;
}
catch (Exception er)
{
TestStatusMsg("Rename file failed: " + er.Message);
}
//FIFTH TEST: Add two Tags
TestStatusMsg("Test: Adding Tags...");
try
{
for (int i = 1; i <= 2; i++)
{
string TagToSet = "API Test Tag #" + i.ToString();
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
TestFileStore = await Cloud_Elements_API.TagOperations.SetTag(APIConnector, currentRow, TagToSet);
TestStatusMsg(string.Format("Tag <{0}> added to [{1}] ", TagToSet, currentRow.name));
}
}
catch (Exception etag)
{
TestStatusMsg("Add Tag failed: " + etag.Message);
}
//SIXTH TEST: Remove a Tag
TestStatusMsg("Test: Deleting Tags...");
try
{
for (int i = 1; i <= 2; i++)
{
string TagToDel = "API Test Tag #" + i.ToString();
Cloud_Elements_API.CloudFile currentRow = TestFileStore;
TestFileStore = await Cloud_Elements_API.TagOperations.DeleteTag(APIConnector, currentRow, TagToDel);
TestStatusMsg(string.Format("Tag <{0}> removed from [{1}] ", TagToDel, currentRow.name));
}
}
catch (Exception edt)
{
TestStatusMsg("Delete Tag failed: " + edt.Message);
}
//SEVENTH TEST: Async Uploads
TestStatusMsg("Test: Multiple ASYNC uploads...");
NumberOfFilesAlreadyUploaded = 0;
bool AsyncUploadPassed = false;
System.Func <Task <string> > UploadTestAction;
Task <Task <string> > AsyncUploadTest = null;
Task <string> FinalAwaitableTestTask = null;
System.Runtime.CompilerServices.ConfiguredTaskAwaitable <Task <string> > AwaitableTestTask;
try
{
string info;
// we need to run away from the UI
UploadTestAction = new System.Func <Task <string> >(TestMultiFileAsyncUploads);
AsyncUploadTest = new Task <Task <string> >(UploadTestAction);
AsyncUploadTest.Start();
AwaitableTestTask = AsyncUploadTest.ConfigureAwait(false);
FinalAwaitableTestTask = await AwaitableTestTask;
info = await FinalAwaitableTestTask;
TestStatusMsg(info);
AsyncUploadPassed = true;
NumberOfFilesAlreadyUploaded = 8;
}
catch (Exception eu)
{
TestStatusMsg("Async Uploads failed: " + eu.Message);
}
if (AsyncUploadPassed)
{
//SEVENTH TEST: repeat Async Uploads
UploadTestAction = new System.Func <Task <string> >(TestMultiFileAsyncUploads);
AsyncUploadTest = new Task <Task <string> >(UploadTestAction);
TestStatusMsg("Test: Repeat Multiple ASYNC uploads, without waiting...");
AsyncUploadTest.Start();
AwaitableTestTask = AsyncUploadTest.ConfigureAwait(false);
}
//EIGHTH TEST: Download File
TestStatusMsg("Test: Downloading file...");
System.IO.Stream Target = null;
try
{
string TargetPath = tfoldername + string.Format("/SFCE_test_file_{0}.txt", "1");
Cloud_Elements_API.CloudFile FileRow = await Cloud_Elements_API.FileOperations.GetCloudFileInfo(APIConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, TargetPath);
if (FileRow != null)
{
Cloud_Elements_API.FileContent Result = await APIConnector.GetFile(FileRow);
string fn = System.IO.Path.Combine(WorkPath, Result.Disposition);
if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(fn)))
{
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(fn));
}
if (System.IO.File.Exists(fn))
{
System.IO.File.Delete(fn);
}
Target = new System.IO.FileStream(fn, System.IO.FileMode.Create, System.Security.AccessControl.FileSystemRights.FullControl, System.IO.FileShare.None, 16384, System.IO.FileOptions.Asynchronous, null);
await Cloud_Elements_API.Tools.StreamCopyWithProgress(Result.ContentStream, Target, Result.ContentLength);
Result.ContentStream.Close();
Result.Dispose();
Target.Close();
Target = null;
System.IO.FileInfo finfo = new System.IO.FileInfo(fn);
TestStatusMsg(string.Format("Stored {1}: {0}", Cloud_Elements_API.Tools.SizeInBytesToString(finfo.Length), Result.Disposition));
int DownloadedHash = Cloud_Elements_API.Tools.FileToString(fn).GetHashCode();
if (DownloadedHash != DownloadTestExpectedHash)
{
TestStatusMsg(string.Format("Warning: Hash of {0} does not match", fn));
}
}
else
{
TestStatusMsg(string.Format("Could not find file to download ({0})", TargetPath));
}
}
catch (Exception ed)
{
TestStatusMsg("*** >>>> File download failed: " + ed.Message);
}
finally
{
if (Target != null)
{
Target.Close();
}
}
if (AsyncUploadPassed)
{
//NINETH TEST: Async Meta Info
TestStatusMsg("Test: Multiple ASYNC File Meta Info reads ...");
NumberOfFilesAlreadyUploaded = 0;
System.Func <Task <string> > TestMetaInfoAction;
Task <Task <string> > AsyncMetaInfoTest = null;
Task <string> FinalAwaitableMetaInfoTask = null;
System.Runtime.CompilerServices.ConfiguredTaskAwaitable <Task <string> > AwaitableMetaInfoTask;
try
{
// we need to run away from the UI
TestMetaInfoAction = new System.Func <Task <string> >(TestAsyncGetFileMeta);
AsyncMetaInfoTest = new Task <Task <string> >(TestMetaInfoAction);
AsyncMetaInfoTest.Start();
AwaitableMetaInfoTask = AsyncMetaInfoTest.ConfigureAwait(false);
FinalAwaitableMetaInfoTask = await AwaitableMetaInfoTask;
}
catch (Exception eu)
{
TestStatusMsg("Async Meta Info failed: " + eu.Message);
}
AwaitableTestTask = AsyncUploadTest.ConfigureAwait(false);
FinalAwaitableTestTask = await AwaitableTestTask;
string FinalInfo = await FinalAwaitableTestTask;
TestStatusMsg(FinalInfo);
FinalInfo = await FinalAwaitableMetaInfoTask;
TestStatusMsg(FinalInfo);
}
TestStatusMsg(string.Format("Test suite complete: Elapsed time: {0:F1}s", DateTime.Now.Subtract(StartTime).TotalSeconds));
}
async Task <string> TestMultiFileAsyncUploads()
{
string tfoldername = AsyncBasePath; // set at start of tests
System.Collections.Generic.Queue <Task <Cloud_Elements_API.CloudFile> > UploadTasks = new System.Collections.Generic.Queue <Task <Cloud_Elements_API.CloudFile> >();
System.Collections.Generic.List <Cloud_Elements_API.CloudElementsConnector> ConnectorsUsed = new System.Collections.Generic.List <Cloud_Elements_API.CloudElementsConnector>();
DateTime Started = DateTime.Now;
int uploadCount = 0;
System.IO.Stream teststream;
string RandomContent = GenerateRandomContent(256 * 1024 * 8);
if (NumberOfFilesAlreadyUploaded == 0)
{
DownloadTestExpectedHash = RandomContent.GetHashCode();
}
long TotalBytes = 0;
for (int i = 1; i <= 8; i++)
{
teststream = GenerateStreamFromString(RandomContent);
RandomContent = RandomContent.Substring(RandomContent.Length / 2);
string MIMEType = Cloud_Elements_API.Tools.FileTypeToMimeContentType("txt");
List <String> TagList = new List <String>();
long sizeInBytes = teststream.Length;
TotalBytes += sizeInBytes;
string TargetPath = tfoldername + string.Format("/SFCE_test_file_{0}.txt", i + NumberOfFilesAlreadyUploaded);
Cloud_Elements_API.CloudElementsConnector ViaConnector = APIConnector.Clone();
ConnectorsUsed.Add(ViaConnector);
Task <Cloud_Elements_API.CloudFile> AnUpload = ViaConnector.PostFile(teststream, MIMEType,
TargetPath, "Temporary test file",
TagList.ToArray(), false, sizeInBytes);
//System.Runtime.CompilerServices.ConfiguredTaskAwaitable<Cloud_Elements_API.CloudFile> AwaitableUpload;
//AwaitableUpload = AnUpload.ConfigureAwait(false);
UploadTasks.Enqueue(AnUpload);
uploadCount += 1;
}
int rewaitCnt = 0;
System.Text.StringBuilder Summary = new System.Text.StringBuilder();
while (UploadTasks.Count > 0)
{
Task <Cloud_Elements_API.CloudFile> AnUpload = UploadTasks.Dequeue();
if (AnUpload.GetAwaiter().IsCompleted)
{
try
{
Cloud_Elements_API.CloudFile Result = await AnUpload;
Summary.AppendFormat("\t{5}: Task {2} Uploaded {4:F1}KB to {0}, id={1}, ok={3} \r\n", Result.name, Result.id, AnUpload.Id, !AnUpload.IsFaulted,
Result.size / 1024d, Cloud_Elements_API.Tools.TraceTimeNow());
}
catch (Exception ex)
{
Summary.AppendFormat("\t{5}: Task {2} Upload Exception {0}, ok={3} \r\n", ex.Message, 0, AnUpload.Id, !AnUpload.IsFaulted,
0, Cloud_Elements_API.Tools.TraceTimeNow());
}
}
else
{
// if (AnUpload.Status == TaskStatus.WaitingForActivation) AnUpload.ci
UploadTasks.Enqueue(AnUpload);
rewaitCnt += 1;
System.Threading.Thread.Sleep(128);
}
}
foreach (Cloud_Elements_API.CloudElementsConnector ViaConnector in ConnectorsUsed)
{
ViaConnector.Close();
}
ConnectorsUsed.Clear();
Summary.AppendFormat("\t{0}: Finished \r\n", Cloud_Elements_API.Tools.TraceTimeNow());
double RequiredMS = DateTime.Now.Subtract(Started).TotalMilliseconds;
Summary.Insert(0, string.Format("Uploaded {0} files in {1:F2}s, average {2:F2}s / file, {4:F2}ms/KB; Async Waits: {3} \r\n", uploadCount, RequiredMS / 1000d, RequiredMS / (1000d * uploadCount),
rewaitCnt, (RequiredMS) / (TotalBytes / 1024d)));
return(Summary.ToString());
}
async Task <string> TestAsyncGetFileMeta()
{
string tfoldername = AsyncBasePath; // as set at start of tests
System.Collections.Generic.Queue <Task <Cloud_Elements_API.CloudFile> > MetaTasks = new System.Collections.Generic.Queue <Task <Cloud_Elements_API.CloudFile> >();
System.Collections.Generic.List <Cloud_Elements_API.CloudElementsConnector> ConnectorsUsed = new System.Collections.Generic.List <Cloud_Elements_API.CloudElementsConnector>();
DateTime Started = DateTime.Now;
int MetaCount = 0;
for (int rr = 1; rr <= 4; rr++)
{
for (int i = 1; i <= 16; i++)
{
string TargetPath = tfoldername + string.Format("/SFCE_test_file_{0}.txt", i);
Cloud_Elements_API.CloudElementsConnector ViaConnector = null;
ViaConnector = APIConnector.Clone();
Task <Cloud_Elements_API.CloudFile> OneMeta = Cloud_Elements_API.FileOperations.GetCloudFileInfo(ViaConnector, Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, TargetPath);
ConnectorsUsed.Add(ViaConnector);
MetaTasks.Enqueue(OneMeta);
if (SerializeGetFileMetadataRequests)
{
OneMeta.Wait();
}
MetaCount += 1;
}
}
int rewaitCnt = 0;
System.Text.StringBuilder Summary = new System.Text.StringBuilder();
while (MetaTasks.Count > 0)
{
Task <Cloud_Elements_API.CloudFile> AnUpload = MetaTasks.Dequeue();
if (AnUpload.GetAwaiter().IsCompleted)
{
try
{
Cloud_Elements_API.CloudFile Result = await AnUpload;
if (Result != null)
{
Summary.AppendFormat("\t{5}: Task {2} File Info for {0}, id={1}, ok={3} \r\n", Result.name, Result.id, AnUpload.Id, !AnUpload.IsFaulted,
0, Cloud_Elements_API.Tools.TraceTimeNow());
}
else
{
Summary.AppendFormat("\t{5}: Task {2} did not obtain file Info for {0}, id={1}, ok={3} \r\n", "", "", AnUpload.Id, !AnUpload.IsFaulted,
0, Cloud_Elements_API.Tools.TraceTimeNow());
}
}
catch (Exception ex)
{
Summary.AppendFormat("\t{5}: Task {2} File Info Exception {0}, ok={3} \r\n", ex.Message, 0, AnUpload.Id, !AnUpload.IsFaulted,
0, Cloud_Elements_API.Tools.TraceTimeNow());
}
}
else
{
// if (AnUpload.Status == TaskStatus.WaitingForActivation) AnUpload.ci
MetaTasks.Enqueue(AnUpload);
rewaitCnt += 1;
System.Threading.Thread.Sleep(128);
}
}
foreach (Cloud_Elements_API.CloudElementsConnector ViaConnector in ConnectorsUsed)
{
ViaConnector.Close();
}
ConnectorsUsed.Clear();
Summary.AppendFormat("\t{0}: Finished \r\n", Cloud_Elements_API.Tools.TraceTimeNow());
double RequiredMS = DateTime.Now.Subtract(Started).TotalMilliseconds;
Summary.Insert(0, string.Format("Got {0} file infos in {1:F2}s, average {2:F2}s / file; Async Waits: {3} \r\n", MetaCount, RequiredMS / 1000d, RequiredMS / (1000d * MetaCount),
rewaitCnt, 0));
return(Summary.ToString());
}
private async Task <bool> scanForEmptyFolders(EmptyFolderOptions scanOptions, Cloud_Elements_API.CloudFile currentRow)
{
//StatusMsg(string.Format("Scanning folder {0}", currentRow.name));
Cloud_Elements_API.CloudElementsConnector ViaConnector = APIConnector.Clone();
bool deletedAnything = false;
try
{
if (currentRow.directory)
{
List <Cloud_Elements_API.CloudFile> ResultList = null;
if (currentRow.size > 0)
{
ResultList = await ViaConnector.ListFolderContents(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, currentRow.path, chkWithTags.Checked);
TestStatusMsg(string.Format("FYI: Folder {1} contains {0} bytes in file(s)", currentRow.size, currentRow.path));
for (int i = 0; i < ResultList.Count; i++)
{
if (ResultList[i].directory)
{
deletedAnything = await scanForEmptyFolders(scanOptions, ResultList[i]);
}
}
}
// if anything was deleted by our recursive calls, we need to re-get the result list!
if (deletedAnything)
{
ResultList = await ViaConnector.ListFolderContents(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, currentRow.path, chkWithTags.Checked);
//TestStatusMsg(string.Format("FYI: Folder {1} now contains {0} bytes", currentRow.size, currentRow.path));
if (ResultList.Count > 1)
{
return(deletedAnything);
}
}
if ((currentRow.size > 0) && (scanOptions.SingleFileOK) && (ResultList.Count == 1) && !ResultList[0].directory)
{
double fileAge = -1;
if (ResultList[0].IsCreatedValid)
{
fileAge = DateTime.Now.Subtract(ResultList[0].WhenCreated()).TotalHours;
}
if ((ResultList[0].size <= scanOptions.SingleFileSizeUnder) &&
(!scanOptions.SingleFileTagRequired || ResultList[0].HasTags) &&
(ResultList[0].IsCreatedValid && (fileAge >= scanOptions.SingleFileAgeInHours)) &&
(ResultList[0].path.EndsWith(scanOptions.SingleFileType, StringComparison.CurrentCultureIgnoreCase)))
{
// single file is ok to ignored (removed message from here)
}
else
{
TestStatusMsg(string.Format("Kept {0} - folder contains {1}, {2} bytes; {3:F1} hours old", currentRow.path, ResultList[0].name, ResultList[0].size, fileAge));
return(deletedAnything);
}
}
if ((scanOptions.PathCheck) && (currentRow.path.IndexOf(scanOptions.PathMustContain, StringComparison.CurrentCultureIgnoreCase) < 0))
{
TestStatusMsg(string.Format("Kept {0} - folder path does not contain {1}", currentRow.path, scanOptions.PathMustContain));
return(deletedAnything);
}
TestStatusMsg(string.Format("Deleting {0}; (empty)", currentRow.path));
StatusMsg(string.Format("Deleting {0}, size={1}", currentRow.path, Cloud_Elements_API.Tools.SizeInBytesToString(currentRow.size)));
deletedAnything = await ViaConnector.DeleteFolder(Cloud_Elements_API.CloudElementsConnector.FileSpecificationType.Path, currentRow.path, false);
CountOfFoldersRemoved++;
}
}
catch (Exception exep)
{
StatusMsg(string.Format("Problem! {0}", exep));
}
ViaConnector.Close();
return(deletedAnything);
}