/// <summary>
/// Download the file from the current directory to a byte array.
/// </summary>
/// <param name="filename">The name of the file to download</param>
/// <returns>The byte array. Any exceptions are thrown.</returns>
public byte[] FileDownload(string filename)
{
byte[] fileContents = new byte[this.FileLength(filename)];
if (!this.FileExists(filename))
{
throw new Exception("Failed to Download File: '" + filename + "' from '" + Directory.Name + ". File was missing.");
}
try
{
using (var stream = new MemoryStream(fileContents, true))
{
ShareFileClient file = Directory.GetFileClient(filename);
ShareFileDownloadInfo download = file.Download();
download.Content.CopyTo(stream);
}
}
catch (Exception ex)
{
throw new Exception("Failed to Download File: '" + filename + "' from '" + Directory.Name + "' Error was: " + ex.Message);
}
return(fileContents);
}
// </snippet_CopyFile>
// <snippet_CopyFileToBlob>
//-------------------------------------------------
// Copy a file from a share to a blob
//-------------------------------------------------
public async Task CopyFileToBlobAsync(string shareName, string sourceFilePath, string containerName, string blobName)
{
Uri fileSasUri = GetFileSasUri(shareName, sourceFilePath, DateTime.UtcNow.AddHours(24), ShareFileSasPermissions.Read);
// Get a reference to the file we created previously
ShareFileClient sourceFile = new ShareFileClient(fileSasUri);
// Ensure that the source file exists
if (await sourceFile.ExistsAsync())
{
// Get the connection string from app settings
string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
// Get a reference to the destination container
BlobContainerClient container = new BlobContainerClient(connectionString, containerName);
// Create the container if it doesn't already exist
await container.CreateIfNotExistsAsync();
BlobClient destBlob = container.GetBlobClient(blobName);
await destBlob.StartCopyFromUriAsync(sourceFile.Uri);
if (await destBlob.ExistsAsync())
{
Console.WriteLine($"File {sourceFile.Name} copied to blob {destBlob.Name}");
}
}
}
public static bool WriteStringToAzureFileShare(string storageConnString, string shareName, string fileName, string content)
{
if (!azureAuthenticated)
{
return(false);
}
try
{
ShareClient share = new ShareClient(storageConnString, shareName);
ShareDirectoryClient directory = share.GetRootDirectoryClient();
directory.DeleteFile(fileName);
ShareFileClient file = directory.GetFileClient(fileName);
byte[] byteArray = Encoding.UTF8.GetBytes(content);
using (MemoryStream stream = new MemoryStream(byteArray))
{
file.Create(stream.Length);
file.UploadRange(
new HttpRange(0, stream.Length),
stream);
}
return(true);
}
catch (Exception _)
{
// Log Ex.Message here
return(false);
}
}
public void VerifyTypeOverrideSupport()
{
var test = new ShareFileClient(BaseUriString);
test.RegisterType <FolderTestClass, Folder>();
var folder = GetFolder();
folder.MetadataUrl =
"https://labs.sf-api.com/sf/v3/$metadata#ShareFile.Api.Models.Folder";
folder.Children.First().MetadataUrl =
"https://labs.sf-api.com/sf/v3/$metadata#ShareFile.Api.Models.File";
var serializer = GetSerializer();
StringWriter writer = new StringWriter();
serializer.Serialize(writer, folder);
var jsonReader = new JsonTextReader(new StringReader(writer.ToString()));
var item = serializer.Deserialize <Item>(jsonReader);
item.GetType().Should().Be(typeof(FolderTestClass));
}
/// <summary>
/// Delete the Sharefile items if Move flag is used
/// </summary>
private void DeleteShareFileItemRecursive(ShareFileClient client, Models.Item source, bool deleteFolder)
{
if (source is Models.Folder)
{
var children = (source as Folder).Children;
var childFiles = children.OfType<Models.File>();
var childFolders = children.OfType<Models.Folder>();
RemoveShareFileItems(client, source, childFiles);
if (Recursive)
{
foreach (var childFolder in childFolders)
{
// KA - Fix. If we pass in 'deleteFolder' I don't know why we don't continue to use that here
// This keeps the behavior of DeleteShareFileItemRecursive consistent with the deleteFolder flag
// DeleteShareFileItemRecursive(client, childFolder, !KeepFolders);
DeleteShareFileItemRecursive(client, childFolder, deleteFolder);
}
}
if (deleteFolder)
{
if(!HasChildren(client, source as Models.Folder))
{
RemoveShareFileItem(client, source);
}
}
}
if (source is Models.File)
{
RemoveShareFileItem(client, source);
}
}
/// <summary>
/// Download all items recursively
/// </summary>
private void DownloadRecursive(ShareFileClient client, int downloadId, Models.Item source, DirectoryInfo target, ActionType actionType)
{
if (source is Models.Folder)
{
var subdir = CreateLocalFolder(target, source as Folder);
var children = client.Items.GetChildren(source.url).Execute();
if (children != null)
{
ActionManager actionManager = new ActionManager();
foreach (var child in children.Feed)
{
if (child is Models.Folder && Recursive)
{
DownloadRecursive(client, downloadId, child, subdir, actionType);
}
else if (child is Models.File)
{
DownloadAction downloadAction = new DownloadAction(FileSupport, client, downloadId, (Models.File)child, subdir, actionType);
actionManager.AddAction(downloadAction);
}
}
actionManager.Execute();
}
}
}
public IActionResult DownloadFile(string userId, string fileName)
{
// Get a reference to a share and then create it
ShareClient share = new ShareClient(Secret.AzureConnectionString, Secret.AzureFileShareName);
if (!share.Exists())
{
share.Create();
}
// Get a reference to a directory and create it
ShareDirectoryClient directory = share.GetDirectoryClient(Auth0Utils.GetUserFolder());
if (!directory.Exists())
{
directory.Create();
}
// Get a reference to a file and upload it
ShareFileClient fileClient = directory.GetFileClient(fileName);
if (fileClient.Exists())
{
//ShareFileDownloadInfo download = file.Download();
return(File(fileClient.OpenRead(), "application/octet-stream"));
}
else
{
return(NotFound());
}
}
public async Task UploadAsync(ConnectorConfig config, string fullFileName, MemoryStream stream)
{
var dirName = Path.GetDirectoryName(fullFileName).ToString();
var fileName = Path.GetFileName(fullFileName).ToString();
ShareClient share = new ShareClient(config.connectionString, config.shareName);
if (!share.Exists())
{
await share.CreateAsync();
}
ShareDirectoryClient directory = share.GetDirectoryClient(dirName);
if (!directory.Exists())
{
await directory.CreateAsync();
}
ShareFileClient file = directory.GetFileClient(fileName);
await file.CreateAsync(stream.Length);
await file.UploadAsync(stream);
/*
* await file.UploadRange(
* ShareFileRangeWriteType.Update,
* new HttpRange(0, stream.Length),
* stream);*/
}
public void UploadFile(string name, Stream file)
{
ShareFileClient shareFile = root.GetRootDirectoryClient().GetFileClient(name);
shareFile.Create(file.Length);
shareFile.Upload(file);
}
public IActionResult DeleteFile(string userId, string fileName)
{
// Get a reference to a share and then create it
ShareClient share = new ShareClient(Secret.AzureConnectionString, Secret.AzureFileShareName);
if (!share.Exists())
{
share.Create();
}
// Get a reference to a directory and create it
ShareDirectoryClient directory = share.GetDirectoryClient(Auth0Utils.GetUserFolder());
if (!directory.Exists())
{
directory.Create();
}
// Get a reference to a file and upload it
ShareFileClient fileClient = directory.GetFileClient(fileName);
fileClient.DeleteIfExists();
return(Ok());
}
private ShareFileClient StorageSetup(IFormFile loadedFile, string fileType)
{
string dirName = fileType;
string fileName = loadedFile.FileName;
ShareClient share = new ShareClient(_storagekey, _storageshare);
try
{
// Try to create the share again
share.Create();
}
catch (RequestFailedException ex)
when(ex.ErrorCode == ShareErrorCode.ShareAlreadyExists)
{
// Ignore any errors if the share already exists
}
ShareDirectoryClient directory = share.GetDirectoryClient(dirName);
try
{
// Try to create the share again
directory.Create();
}
catch (RequestFailedException ex)
{
// Ignore any errors if the share already exists
}
ShareFileClient shareFile = directory.GetFileClient(fileName);
return(shareFile);
}
private async Task DumpJson <T>(T obj, string fileName)
{
// Dump to local temp file (need to do this because need to know file size before copying to Azure File Share).
var tmpFile = Path.GetTempFileName();
using (StreamWriter sw = new StreamWriter(tmpFile))
using (JsonWriter jtw = new JsonTextWriter(sw))
{
var serializer = new JsonSerializer();
serializer.Serialize(jtw, obj);
}
try
{
// Copy the temp file to Azure File Share
ShareClient share = new ShareClient(DataDumpStorageConnectionString, DataDumpStorageShareName);
ShareDirectoryClient directory = share.GetDirectoryClient("/");
ShareFileClient file = directory.GetFileClient(fileName);
using (FileStream stream = File.OpenRead(tmpFile))
{
await file.CreateAsync(stream.Length);
await file.UploadRangeAsync(new HttpRange(0, stream.Length), stream);
}
}
finally
{
// Clean up the temp file
File.Delete(tmpFile);
}
}
public async Task UploadFileAsync(String filename, Stream stream)
{
ShareFileClient file = this.root.GetFileClient(filename);
await file.CreateAsync(stream.Length);
await file.UploadAsync(stream);
}
// <snippet_RestoreFileFromSnapshot>
//-------------------------------------------------
// Restore file from snapshot
//-------------------------------------------------
public async Task RestoreFileFromSnapshot(string shareName, string directoryName, string fileName, string snapshotTime)
{
// Get the connection string from app settings
string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
// Instatiate a ShareServiceClient
ShareServiceClient shareService = new ShareServiceClient(connectionString);
// Get a ShareClient
ShareClient share = shareService.GetShareClient(shareName);
// Get a ShareDirectoryClient, then a ShareFileClient to the live file
ShareDirectoryClient liveDir = share.GetDirectoryClient(directoryName);
ShareFileClient liveFile = liveDir.GetFileClient(fileName);
// Get as ShareClient that points to a snapshot
ShareClient snapshot = share.WithSnapshot(snapshotTime);
// Get a ShareDirectoryClient, then a ShareFileClient to the snapshot file
ShareDirectoryClient snapshotDir = snapshot.GetDirectoryClient(directoryName);
ShareFileClient snapshotFile = snapshotDir.GetFileClient(fileName);
// Restore the file from the snapshot
ShareFileCopyInfo copyInfo = await liveFile.StartCopyAsync(snapshotFile.Uri);
// Display the status of the operation
Console.WriteLine($"Restore status: {copyInfo.CopyStatus}");
}
protected AsyncUploaderBase(ShareFileClient client, UploadSpecificationRequest uploadSpecificationRequest, IPlatformFile file, FileUploaderConfig config = null, int? expirationDays = null)
: base(client, uploadSpecificationRequest, file, expirationDays)
{
Config = config ?? new FileUploaderConfig();
HashProvider = MD5HashProviderFactory.GetHashProvider().CreateHash();
}
/// <summary>
/// Download a file.
/// </summary>
/// <param name="connectionString">
/// A connection string to your Azure Storage account.
/// </param>
/// <param name="shareName">
/// The name of the share to download from.
/// </param>
/// <param name="localFilePath">
/// Path to download the local file.
/// </param>
public static async Task DownloadAsync(string connectionString, string shareName, string localFilePath)
{
#region Snippet:Azure_Storage_Files_Shares_Samples_Sample01b_HelloWorldAsync_DownloadAsync
//@@ string connectionString = "<connection_string>";
// Name of the share, directory, and file we'll download from
//@@ string shareName = "sample-share";
string dirName = "sample-dir";
string fileName = "sample-file";
// Path to the save the downloaded file
//@@ string localFilePath = @"<path_to_local_file>";
// Get a reference to the file
ShareClient share = new ShareClient(connectionString, shareName);
ShareDirectoryClient directory = share.GetDirectoryClient(dirName);
ShareFileClient file = directory.GetFileClient(fileName);
// Download the file
ShareFileDownloadInfo download = await file.DownloadAsync();
using (FileStream stream = File.OpenWrite(localFilePath))
{
await download.Content.CopyToAsync(stream);
}
#endregion Snippet:Azure_Storage_Files_Shares_Samples_Sample01b_HelloWorldAsync_DownloadAsync
}
private async Task <string> DownloadFromShareFileAsync(string shareLink, string itemName)
{
var uri = new Uri(shareLink);
var sfClient = new ShareFileClient($"https://{uri.Authority}/sf/v3");
// Extract shareId from path /d-<shareid>
var shareId = uri.AbsolutePath.Substring(3);
System.Console.WriteLine("ShareId: " + shareId);
var shareEntityUrl = sfClient.Shares.GetEntityUriFromId(shareId);
var response = await sfClient.Shares.Download(shareEntityUrl, redirect : false).ExecuteAsync();
DownloadSpecification sfDownloadSpec = null;
using (var stream = new StreamReader(response))
{
var bodyJson = await stream.ReadToEndAsync();
sfDownloadSpec = JsonConvert.DeserializeObject <DownloadSpecification>(bodyJson);
}
Directory.CreateDirectory("temp");
var fileName = $"temp/{itemName}";
var webClient = new WebClient();
webClient.DownloadFile(sfDownloadSpec.DownloadUrl, fileName);
return(fileName);
}
protected IShareFileClient GetShareFileClient()
{
try
{
using (var fileStream = System.IO.File.OpenRead("TestConfig.json"))
using (var streamReader = new StreamReader(fileStream))
{
var info = streamReader.ReadToEnd();
var userInfo = JsonConvert.DeserializeObject<UserInfo>(info);
var sfClient = new ShareFileClient(userInfo.GetBaseUri().ToString());
lock (oauthTokenLock)
{
if (token == null)
{
var oauthService = new OAuthService(sfClient, userInfo.ClientId, userInfo.ClientSecret);
token = oauthService.GetPasswordGrantRequestQuery(userInfo.Email, userInfo.Password, userInfo.Subdomain, userInfo.Domain).Execute();
}
}
sfClient.BaseUri = token.GetUri();
sfClient.AddOAuthCredentials(token);
return sfClient;
}
}
catch (Exception exception)
{
Assert.Inconclusive(string.Format("No UserInfo found in TestConfig.json. Exception: {0}", exception));
throw;
}
}
public string Download(string connectionString, string shareName, string directory, string fileName)
{
// Get a reference to the file
ShareClient share = new ShareClient(connectionString, shareName);
ShareDirectoryClient directoryClient = share.GetDirectoryClient(directory);
ShareFileClient file = directoryClient.GetFileClient(fileName);
string localFilePath = @"C:\audio\sales\trusted\Sales\" + file.Name;
try
{
// Download the file
ShareFileDownloadInfo download = file.Download();
using (FileStream stream = File.OpenWrite(localFilePath))
{
download.Content.CopyTo(stream);
}
}
catch (Exception e)
{
_errors.Add(fileName + ": " + e.Message);
}
return(localFilePath);
}
public async Task DeleteFileAsync(String filename)
{
ShareDirectoryClient raiz = this.cliente.GetRootDirectoryClient();
ShareFileClient file = raiz.GetFileClient(filename);
await file.DeleteAsync();
}
public async Task PathClient_CanGetParentDirectoryClient()
{
// Arrange
var parentDirName = SharesClientBuilder.GetNewDirectoryName();
await using DisposingShare test = await SharesClientBuilder.GetTestShareAsync();
ShareDirectoryClient parentDirClient = InstrumentClient(test.Container
.GetRootDirectoryClient()
.GetSubdirectoryClient(parentDirName));
await parentDirClient.CreateAsync();
ShareFileClient fileClient = InstrumentClient(parentDirClient
.GetFileClient(SharesClientBuilder.GetNewFileName()));
await fileClient.CreateAsync(Constants.KB);
// Act
parentDirClient = fileClient.GetParentShareDirectoryClient();
// make sure that client is functional
var dirProperties = await parentDirClient.GetPropertiesAsync();
// Assert
Assert.AreEqual(fileClient.Path.GetParentPath(), parentDirClient.Path);
Assert.AreEqual(fileClient.AccountName, parentDirClient.AccountName);
Assert.IsNotNull(dirProperties);
}
protected AsyncUploaderBase(ShareFileClient client, UploadSpecificationRequest uploadSpecificationRequest, IPlatformFile file, FileUploaderConfig config = null, int?expirationDays = null)
: base(client, uploadSpecificationRequest, file, expirationDays)
{
Config = config ?? new FileUploaderConfig();
HashProvider = MD5HashProviderFactory.GetHashProvider().CreateHash();
}
/// <summary>
/// Upload contents recursively
/// </summary>
private void UploadRecursive(ShareFileClient client, int uploadId, FileSystemInfo source, Models.Item target, ActionType actionType)
{
if (source is DirectoryInfo)
{
var newFolder = new Models.Folder()
{
Name = source.Name
};
bool isExist = false;
if (Synchronize)
{
try
{
string path = String.Format("/{0}", source.Name);
Item item = null;
try
{
item = client.Items.ByPath(target.url, path).Execute();
}
catch (ODataException e)
{
if (e.Code != System.Net.HttpStatusCode.NotFound)
{
throw e;
}
}
if (item != null && item is Folder)
{
isExist = true;
newFolder = (Folder)item;
}
}
catch { }
}
if (!isExist)
{
newFolder = client.Items.CreateFolder(target.url, newFolder, OverWrite, false).Execute();
}
ActionManager actionManager = new ActionManager(this, source.Name);
foreach (var fsInfo in ((DirectoryInfo)source).EnumerateFileSystemInfos())
{
if (fsInfo is DirectoryInfo && Recursive)
{
UploadRecursive(client, uploadId, fsInfo, newFolder, actionType);
}
else if (fsInfo is FileInfo)
{
IAction uploadAction = new UploadAction(FileSupport, client, fsInfo, newFolder, Details, actionType);
actionManager.AddAction(uploadAction);
}
}
actionManager.Execute();
}
}
public async Task <string> SaveFileUri(string fileShare, string fileName, string fileContent)
{
ShareClient share = new ShareClient(connectionString, fileShare);
if (!share.Exists())
{
share.Create();
}
ShareDirectoryClient rootDir = share.GetRootDirectoryClient();
ShareFileClient file = rootDir.GetFileClient(fileName);
if (!file.Exists())
{
file.Create(fileContent.Length);
}
byte[] outBuff = Encoding.ASCII.GetBytes(fileContent);
ShareFileOpenWriteOptions options = new ShareFileOpenWriteOptions {
MaxSize = outBuff.Length
};
var stream = await file.OpenWriteAsync(true, 0, options);
stream.Write(outBuff, 0, outBuff.Length);
stream.Flush();
return(file.Uri.ToString());
}
public static void WriteFile(string fullPath, string output, Boolean append)
{
ShareFileClient file = new ShareFileClient(CONNECTIONSTRING, SHARENAME, fullPath);
string original = "";
if (!append && file.Exists())
{
file.Delete();
}
if (append)
{
if (file.Exists())
{
ShareFileDownloadInfo download = file.Download();
original = GetStreamContents(download.Content) + "\n";
}
}
using (Stream outStream = GenerateStreamFromString(original + output)) {
// if (!file.Exists())
file.Create(outStream.Length);
file.UploadRange(new HttpRange(0, outStream.Length), outStream);
}
}
public static void AddDefaultHeaders(this HttpRequestMessage requestMessage, ShareFileClient client)
{
if (client.Configuration.SupportedCultures != null)
{
foreach (var cultureInfo in client.Configuration.SupportedCultures)
{
requestMessage.Headers.AcceptLanguage.Add(new StringWithQualityHeaderValue(cultureInfo.Name));
}
}
if (client.Configuration.ClientCapabilities != null)
{
var provider = ShareFileClient.GetProvider(requestMessage.RequestUri);
IEnumerable<ClientCapability> clientCapabilities;
if (client.Configuration.ClientCapabilities.TryGetValue(provider, out clientCapabilities))
{
requestMessage.Headers.Add(BaseRequestProvider.Headers.ClientCapabilities, clientCapabilities.Select(x => x.ToString()));
}
}
if (client.Configuration.UserAgent != null)
{
requestMessage.Headers.Add("User-Agent", client.Configuration.UserAgent);
}
requestMessage.TryAddCookies(client);
}
public List <Metadata> GetMetadatas()
{
List <Metadata> metadatas = new List <Metadata>();
MetadataParser parser =
new MetadataParser(
new MetadataConverter());
try
{
var remaining = new Queue <ShareDirectoryClient>();
remaining.Enqueue(shareClient.GetDirectoryClient(this.path));
while (remaining.Count > 0)
{
ShareDirectoryClient dir = remaining.Dequeue();
foreach (ShareFileItem item in dir.GetFilesAndDirectories())
{
if (item.IsDirectory)
{
remaining.Enqueue(dir.GetSubdirectoryClient(item.Name));
}
else if (item.Name.Contains(FILE_EXTENSION))
{
Console.WriteLine($" In {dir.Uri.AbsolutePath} found {item.Name}");
ShareFileClient file = dir.GetFileClient(item.Name);
ShareFileDownloadInfo fileContents = file.Download();
string json;
using (MemoryStream ms = new MemoryStream())
{
fileContents.Content.CopyTo(ms);
json = Encoding.UTF8.GetString(ms.ToArray());
}
// Parse json string
Metadata metadata = parser.Parse(json);
// Sets the dataset path relative to the Uri and Path specified in constructor
var filePath =
Path.GetRelativePath(this.path, file.Path)
.Replace(FILE_EXTENSION, "");
metadata.Dataset.DatasetPath = filePath;
metadatas.Add(metadata);
}
}
}
Console.WriteLine($"Found a total of {metadatas.Count} files");
}
catch (Exception e)
{
Console.WriteLine($"An error ocurred: {e}");
}
return(metadatas);
}
// Convert Track1 File object to Track 2 file Client
public static ShareFileClient GetTrack2FileClient(CloudFile cloudFile, AzureStorageContext context)
{
ShareFileClient fileClient;
if (cloudFile.ServiceClient.Credentials.IsSAS) //SAS
{
string sas = Util.GetSASStringWithoutQuestionMark(cloudFile.ServiceClient.Credentials.SASToken);
string fullUri = cloudFile.SnapshotQualifiedUri.ToString();
if (cloudFile.Share.IsSnapshot)
{
// Since snapshot URL already has '?', need remove '?' in the first char of sas
fullUri = fullUri + "&" + sas;
}
else
{
fullUri = fullUri + "?" + sas;
}
fileClient = new ShareFileClient(new Uri(fullUri));
}
else if (cloudFile.ServiceClient.Credentials.IsSharedKey) //Shared Key
{
fileClient = new ShareFileClient(cloudFile.SnapshotQualifiedUri,
new StorageSharedKeyCredential(context.StorageAccountName, cloudFile.ServiceClient.Credentials.ExportBase64EncodedKey()));
}
else //Anonymous
{
fileClient = new ShareFileClient(cloudFile.SnapshotQualifiedUri);
}
return(fileClient);
}
public async Task <string> ReadFile(string fileShare, string fileName)
{
string json = "";
ShareClient share = new ShareClient(connectionString, fileShare);
if (!share.Exists())
{
Exception error = new Exception($"Fileshare {fileName} does not exist ");
throw error;
}
ShareDirectoryClient directory = share.GetRootDirectoryClient();
ShareFileClient file = directory.GetFileClient(fileName);
if (file.Exists())
{
using (Stream fileStream = await file.OpenReadAsync())
{
using (StreamReader reader = new StreamReader(fileStream))
{
json = reader.ReadToEnd();
}
}
}
else
{
Exception error = new Exception($"File {fileName} does not exist in Azure storage ");
throw error;
}
return(json);
}
public static async Task CreateFileAsync(string account, string key, string share, string fileName, Stream fileContent, string folder = null)
{
ShareFileClient file = GetShareFileClient(account, key, share, fileName, folder);
file.Create(fileContent.Length);
await file.UploadRangeAsync(new HttpRange(0, fileContent.Length), fileContent);
}
private static async Task MoveFileAsync(ShareClient share, ShareDirectoryClient directory, ShareFileClient file, string outputFolder)
{
try
{
ShareDirectoryClient outputDirectory = share.GetDirectoryClient(outputFolder);
await outputDirectory.CreateIfNotExistsAsync();
if (outputDirectory.Exists())
{
ShareFileClient outputFile = outputDirectory.GetFileClient(file.Name);
await outputFile.StartCopyAsync(file.Uri);
if (await outputFile.ExistsAsync())
{
Log($"{file.Uri} copied to {outputFile.Uri}");
await DeleteFileAsync(file);
}
}
}
catch (Exception ex)
{
Log(ex);
}
}
protected IShareFileClient GetShareFileClient()
{
try
{
using (var fileStream = System.IO.File.OpenRead("TestConfig.json"))
using (var streamReader = new StreamReader(fileStream))
{
var info = streamReader.ReadToEnd();
var userInfo = JsonConvert.DeserializeObject <UserInfo>(info);
var sfClient = new ShareFileClient(userInfo.GetBaseUri().ToString());
lock (oauthTokenLock)
{
if (token == null)
{
var oauthService = new OAuthService(sfClient, userInfo.ClientId, userInfo.ClientSecret);
token = oauthService.GetPasswordGrantRequestQuery(userInfo.Email, userInfo.Password, userInfo.Subdomain, userInfo.Domain).Execute();
}
}
sfClient.BaseUri = token.GetUri();
sfClient.AddOAuthCredentials(token);
return(sfClient);
}
}
catch (Exception exception)
{
Assert.Inconclusive(string.Format("No UserInfo found in TestConfig.json. Exception: {0}", exception));
throw;
}
}
/// <summary>
/// Delete the Sharefile items if Move flag is used
/// </summary>
private void DeleteShareFileItemRecursive(ShareFileClient client, Models.Item source, bool deleteFolder)
{
if (source is Models.Folder)
{
var children = (source as Folder).Children;
var childFiles = children.OfType <Models.File>();
var childFolders = children.OfType <Models.Folder>();
RemoveShareFileItems(client, source, childFiles);
if (Recursive)
{
foreach (var childFolder in childFolders)
{
DeleteShareFileItemRecursive(client, childFolder, !KeepFolders);
}
}
if (deleteFolder)
{
if (!HasChildren(client, source as Models.Folder))
{
RemoveShareFileItem(client, source);
}
}
}
if (source is Models.File)
{
RemoveShareFileItem(client, source);
}
}
public AsyncScalingFileUploader(ShareFileClient client, UploadSpecificationRequest uploadSpecificationRequest, IPlatformFile file, FileUploaderConfig config = null, int? expirationDays = null)
: base(client, uploadSpecificationRequest, file, config, expirationDays)
{
UploadSpecificationRequest.Raw = true;
var chunkConfig = config != null ? config.PartConfig : new FilePartConfig();
partUploader = new ScalingPartUploader(chunkConfig, Config.NumberOfThreads,
ExecuteChunkUploadMessage,
OnProgress);
}
protected UploaderBase(ShareFileClient client, UploadSpecificationRequest uploadSpecificationRequest, IPlatformFile file, int? expirationDays)
{
Client = client;
UploadSpecificationRequest = uploadSpecificationRequest;
File = file;
ExpirationDays = expirationDays;
Progress = new TransferProgress(uploadSpecificationRequest.FileSize, null, Guid.NewGuid().ToString());
}
public ScalingFileUploader(ShareFileClient client, UploadSpecificationRequest uploadSpecificationRequest, IPlatformFile file, FileUploaderConfig config = null, int? expirationDays = null)
: base(client, uploadSpecificationRequest, file, config, expirationDays)
{
UploadSpecificationRequest.Raw = true;
var partConfig = config != null ? config.PartConfig : new FilePartConfig();
partUploader = new ScalingPartUploader(partConfig, Config.NumberOfThreads,
requestMessage => Task.Factory.StartNew(() => ExecuteChunkUploadMessage(requestMessage)),
OnProgress);
}
public void GetAliasWithMappedAlias(ItemAlias alias, string expectedValue)
{
// Act
var sfClient = new ShareFileClient("https://secure.sf-api.com/sf/v3/");
var uri = sfClient.Items.GetAlias(alias);
// Assert
uri.ToString().Should().Be("https://secure.sf-api.com/sf/v3/Items(" + expectedValue + ")");
}
protected IShareFileClient GetShareFileClient(bool registerFakeExecutors = false)
{
var client = new ShareFileClient(BaseUriString);
if (registerFakeExecutors)
{
RequestExecutorFactory.RegisterAsyncRequestProvider(A.Fake<IAsyncRequestExecutor>());
RequestExecutorFactory.RegisterSyncRequestProvider(A.Fake<ISyncRequestExecutor>());
}
return client;
}
public void GetAliasWithItemId()
{
// Arrange
var alias = "randomId";
// Act
var sfClient = new ShareFileClient("https://secure.sf-api.com/sf/v3/");
var uri = sfClient.Items.GetAlias(alias);
// Assert
uri.ToString().Should().Be("https://secure.sf-api.com/sf/v3/Items(randomId)");
}
public LoggingConverter(ShareFileClient client)
{
this._client = client;
_piiBlacklist = new HashSet<string>();
_piiBlacklist.Add("FullName");
_piiBlacklist.Add("FirstName");
_piiBlacklist.Add("LastName");
_piiBlacklist.Add("Email");
_piiBlacklist.Add("Username");
_piiBlacklist.Add("FullNameShort");
_piiBlacklist.Add("Name");
_piiBlacklist.Add("FileName");
_piiBlacklist.Add("CreatorFirstName");
_piiBlacklist.Add("CreatorLastName");
_piiBlacklist.Add("CreatorNameShort");
_piiBlacklist.Add("Company");
}
public static void TryAddCookies(this HttpRequestMessage requestMessage, ShareFileClient client)
{
if (BaseRequestProvider.RuntimeRequiresCustomCookieHandling)
{
var cookieHeader = client.CookieContainer.GetCookieHeader(
new Uri("https://www." + requestMessage.RequestUri.Host + requestMessage.RequestUri.AbsolutePath));
if (!string.IsNullOrWhiteSpace(cookieHeader))
{
requestMessage.Headers.Add("Cookie", cookieHeader);
}
else
{
cookieHeader = client.CookieContainer.GetCookieHeader(requestMessage.RequestUri);
if (!string.IsNullOrEmpty(cookieHeader))
{
requestMessage.Headers.Add("Cookie", cookieHeader);
}
}
}
}
public void VerifyTypeOverrideSupport()
{
var test = new ShareFileClient(BaseUriString);
test.RegisterType<FolderTestClass, Folder>();
var folder = GetFolder();
folder.MetadataUrl =
"https://labs.sf-api.com/sf/v3/$metadata#ShareFile.Api.Models.Folder";
folder.Children.First().MetadataUrl =
"https://labs.sf-api.com/sf/v3/$metadata#ShareFile.Api.Models.File";
var serializer = GetSerializer();
StringWriter writer = new StringWriter();
serializer.Serialize(writer, folder);
var jsonReader = new JsonTextReader(new StringReader(writer.ToString()));
var item = serializer.Deserialize<Item>(jsonReader);
item.GetType().Should().Be(typeof (FolderTestClass));
}
public AsyncStandardFileUploader(ShareFileClient client, UploadSpecificationRequest uploadSpecificationRequest, IPlatformFile file, FileUploaderConfig config = null, int? expirationDays = null)
: base(client, uploadSpecificationRequest, file, config, expirationDays)
{
UploadSpecificationRequest.Raw = true;
}
