public void GetSubFolders_Returns_Valid_SubFolders_When_Folder_Is_Not_Empty()
{
var expectedResult = new List <string>
{
Constants.FOLDER_ValidSubFolderRelativePath,
Constants.FOLDER_OtherValidSubFolderRelativePath,
};
var folderMapping = new FolderMappingInfo();
folderMapping.PortalID = Constants.CONTENT_ValidPortalId;
var subFolders = new List <IFolderInfo>
{
new FolderInfo {
FolderPath = Constants.FOLDER_ValidSubFolderRelativePath
},
new FolderInfo {
FolderPath = Constants.FOLDER_OtherValidSubFolderRelativePath
},
};
this._folderManager.Setup(fm => fm.GetFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(this._folderInfo.Object);
this._folderManager.Setup(fm => fm.GetFolders(this._folderInfo.Object)).Returns(subFolders);
var result = this._dfp.GetSubFolders(Constants.FOLDER_ValidFolderRelativePath, folderMapping).ToList();
CollectionAssert.AreEqual(expectedResult, result);
}
/// <remarks>
/// Azure Storage doesn't support folders, so we create a file in order for the folder to not be deleted during future synchronizations.
/// The file has an extension not allowed by host. This way the file won't be added during synchronizations.
/// </remarks>
public override void AddFolder(string folderPath, FolderMappingInfo folderMapping, string mappedPath)
{
Requires.NotNull("folderPath", folderPath);
Requires.NotNull("folderMapping", folderMapping);
this.UpdateFileInternal(new MemoryStream(), folderMapping, mappedPath + Constants.PlaceHolderFileName);
}
public void DeleteFile_Calls_FolderProviderDeleteFile()
{
// Arrange
var fileInfo = new FileInfoBuilder().Build();
this._fileVersionController.Setup(fv => fv.DeleteAllUnpublishedVersions(fileInfo, false));
var folderMapping = new FolderMappingInfo {
FolderProviderType = Constants.FOLDER_ValidFolderProviderType
};
this._folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping);
this._mockData.Setup(md => md.DeleteFile(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <int>()));
this._mockFolderProvider.Setup(mf => mf.DeleteFile(fileInfo)).Verifiable();
string someString;
this._mockFileLockingController.Setup(mflc => mflc.IsFileLocked(fileInfo, out someString)).Returns(false);
// Act
FileDeletionController.Instance.DeleteFile(fileInfo);
// Assert
this._mockFolderProvider.Verify();
}
protected override IList <IRemoteStorageItem> GetObjectList(FolderMappingInfo folderMapping)
{
var cacheKey = string.Format(ListObjectsCacheKey, folderMapping.FolderMappingID);
return(CBO.GetCachedObject <IList <IRemoteStorageItem> >(new CacheItemArgs(cacheKey,
ListObjectsCacheTimeout,
CacheItemPriority.Default,
folderMapping.FolderMappingID),
c =>
{
var container = GetContainer(folderMapping);
BlobContinuationToken continuationToken = null;
BlobResultSegment resultSegment = null;
var list = new List <IRemoteStorageItem>();
do
{
//This overload allows control of the page size. You can return all remaining results by passing null for the maxResults parameter,
//or by calling a different overload.
resultSegment = container.ListBlobsSegmented("", true, BlobListingDetails.All, 10, continuationToken, null, null);
foreach (var blobItem in resultSegment.Results)
{
list.Add(new AzureRemoteStorageItem {
Blob = new AzureBlob(blobItem as CloudBlob)
});
}
//Get the continuation token.
continuationToken = resultSegment.ContinuationToken;
}while (continuationToken != null);
return list;
}));
}
protected static string GetSetting(FolderMappingInfo folderMapping, string settingName)
{
Requires.NotNull(nameof(folderMapping), folderMapping);
Requires.NotNullOrEmpty(nameof(settingName), settingName);
return(folderMapping.FolderMappingSettings[settingName]?.ToString());
}
public void GetSubFolders_Returns_Valid_SubFolders_When_Folder_Is_Not_Empty()
{
var expectedSubFolders = new[] {
Constants.FOLDER_ValidSubFolderRelativePath,
Constants.FOLDER_OtherValidSubFolderRelativePath
};
var folderMapping = new FolderMappingInfo {
PortalID = Constants.CONTENT_ValidPortalId
};
_pathUtils.Setup(pu => pu.GetPhysicalPath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderPath);
_pathUtils.Setup(pu => pu.GetRelativePath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidSubFolderPath)).Returns(Constants.FOLDER_ValidSubFolderRelativePath);
_pathUtils.Setup(pu => pu.GetRelativePath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_OtherValidSubFolderPath)).Returns(Constants.FOLDER_OtherValidSubFolderRelativePath);
var subFolders = new[] {
Constants.FOLDER_ValidSubFolderPath,
Constants.FOLDER_OtherValidSubFolderPath
};
_directoryWrapper.Setup(dw => dw.GetDirectories(Constants.FOLDER_ValidFolderPath)).Returns(subFolders);
var result = _sfp.GetSubFolders(Constants.FOLDER_ValidFolderRelativePath, folderMapping).ToList();
CollectionAssert.AreEqual(expectedSubFolders, result);
}
/// <summary>
/// Gets the list of subfolders for the specified folder.
/// </summary>
public override IEnumerable <string> GetSubFolders(string folderPath, FolderMappingInfo folderMapping)
{
Requires.NotNull("folderPath", folderPath);
Requires.NotNull("folderMapping", folderMapping);
var list = GetObjectList(folderMapping, folderPath);
var pattern = "^" + Regex.Escape(folderPath);
return((from o in list
let f = o.Key
let r =
(!string.IsNullOrEmpty(folderPath)
? Regex.Replace(f, pattern, "", RegexOptions.IgnoreCase, TimeSpan.FromSeconds(2))
: f)
where f.StartsWith(folderPath, StringComparison.InvariantCultureIgnoreCase) &&
f.Length > folderPath.Length &&
r.IndexOf("/", StringComparison.Ordinal) > -1
select folderPath + r.Substring(0, r.IndexOf("/", StringComparison.Ordinal)) + "/").Distinct().ToList());
//var mylist = (from o in list
// let f = o.Key
// let r = (!string.IsNullOrEmpty(folderPath) ? RegexUtils.GetCachedRegex(Regex.Escape(folderPath)).Replace(f, string.Empty, 1) : f)
// where f.StartsWith(folderPath)
// && f.Length > folderPath.Length
// && r.IndexOf("/", StringComparison.Ordinal) > -1
// select folderPath + r.Substring(0, r.IndexOf("/", StringComparison.Ordinal)) + "/").Distinct().ToList();
//return mylist;
}
/// <summary>
/// Moves the folder and files at the specified folder path to the new folder path.
/// </summary>
public override void MoveFolder(string folderPath, string newFolderPath, FolderMappingInfo folderMapping)
{
Requires.NotNullOrEmpty("folderPath", folderPath);
Requires.NotNullOrEmpty("newFolderPath", newFolderPath);
Requires.NotNull("folderMapping", folderMapping);
MoveFolderInternal(folderMapping, folderPath, newFolderPath);
}
protected override void DeleteFileInternal(FolderMappingInfo folderMapping, string uri)
{
var container = this.GetContainer(folderMapping);
var blob = container.GetBlobReference(uri);
blob.DeleteIfExists();
this.ClearCache(folderMapping.FolderMappingID);
}
private FolderMappingViewModel GetFolderMappingViewModel(FolderMappingInfo folderMapping)
{
return(new FolderMappingViewModel
{
Id = folderMapping.FolderMappingID,
FolderTypeName = folderMapping.FolderProviderType,
Name = folderMapping.MappingName
});
}
protected static int GetIntegerSetting(FolderMappingInfo folderMapping, string settingName, int defaultValue)
{
int value;
if (int.TryParse(GetSetting(folderMapping, settingName), out value))
{
return(value);
}
return(defaultValue);
}
private static bool AreThereFolderMappingsWithSameSettings(FolderMappingInfo folderMapping, string accountName, string container)
{
var folderMappingController = FolderMappingController.Instance;
var folderMappings = folderMappingController.GetFolderMappings(folderMapping.PortalID);
return(folderMappings
.Where(fm => fm.FolderMappingID != folderMapping.FolderMappingID && fm.FolderProviderType == folderMapping.FolderProviderType)
.Any(fm => fm.FolderMappingSettings[AccountName].ToString().Equals(accountName, StringComparison.InvariantCulture) &&
fm.FolderMappingSettings[Container].ToString().Equals(container, StringComparison.InvariantCultureIgnoreCase)));
}
/// <summary>
/// GetImageFileUrl - this method returns the valid URL for any file, regardless to folder or folder provider in use
/// </summary>
/// <param name="oFile">Fully loaded IFileInfo object</param>
/// <returns></returns>
/// <remarks>
/// WARNING!!! This method can return exceptions. They should be caught and processed in the UI though.
/// </remarks>
public string GetFileUrl(IFileInfo oFile)
{
/*******************************************************
* ' WARNING!!!
* ' This method can return exceptions. They should be
* ' caught and processed in the UI though.
* '*******************************************************/
FolderMappingInfo mapFolder = FolderMappingController.Instance.GetFolderMapping(oFile.FolderMappingID);
return(FolderProvider.Instance(mapFolder.FolderProviderType).GetFileUrl(oFile));
}
private string GetFileUrl(string fileUrl)
{
if (Regex.IsMatch(fileUrl, "^\\d+$"))
{
IFileInfo file = FileManager.Instance.GetFile(int.Parse(fileUrl, NumberStyles.Integer));
FolderMappingInfo mapFolder = FolderMappingController.Instance.GetFolderMapping(file.FolderMappingID);
return(FolderProvider.Instance(mapFolder.FolderProviderType).GetFileUrl(file));
}
return(fileUrl);
}
protected override void CopyFileInternal(FolderMappingInfo folderMapping, string sourceUri, string newUri)
{
var container = this.GetContainer(folderMapping);
var sourceBlob = container.GetBlobReference(sourceUri);
var newBlob = container.GetBlobReference(newUri);
newBlob.StartCopy(sourceBlob.Uri);
this.ClearCache(folderMapping.FolderMappingID);
}
private static void CheckSettings(FolderMappingInfo folderMapping)
{
var settings = folderMapping.FolderMappingSettings;
if (string.IsNullOrEmpty((string)settings[Constants.AccountName]) ||
string.IsNullOrEmpty((string)settings[Constants.AccountKey]) ||
string.IsNullOrEmpty((string)settings[Constants.Container]) ||
string.IsNullOrEmpty((string)settings[Constants.UseHttps]))
{
throw new Exception("Settings cannot be found.");
}
}
public void ExistsFolder_Returns_False_When_Folder_Does_Not_Exist()
{
var folderMapping = new FolderMappingInfo();
folderMapping.PortalID = Constants.CONTENT_ValidPortalId;
_mockData.Setup(md => md.GetFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath).Read()).Returns(false);
var result = _dfp.FolderExists(Constants.FOLDER_ValidFolderRelativePath, folderMapping);
Assert.IsFalse(result);
}
protected override Stream GetFileStreamInternal(FolderMappingInfo folderMapping, string uri)
{
var container = this.GetContainer(folderMapping);
var blob = container.GetBlockBlobReference(uri);
var memoryStream = new MemoryStream();
blob.DownloadToStream(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
return(memoryStream);
}
public void ExistsFolder_Calls_DirectoryWrapper_Exists()
{
var folderMapping = new FolderMappingInfo {
PortalID = Constants.CONTENT_ValidPortalId
};
this._pathUtils.Setup(pu => pu.GetPhysicalPath(folderMapping.PortalID, Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderPath);
this._sfp.FolderExists(Constants.FOLDER_ValidFolderRelativePath, folderMapping);
this._directoryWrapper.Verify(dw => dw.Exists(Constants.FOLDER_ValidFolderPath), Times.Once());
}
public void ExistsFolder_Returns_True_When_Folder_Exists()
{
var folderMapping = new FolderMappingInfo();
folderMapping.PortalID = Constants.CONTENT_ValidPortalId;
this._folderManager.Setup(fm => fm.GetFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(new FolderInfo());
var result = this._dfp.FolderExists(Constants.FOLDER_ValidFolderRelativePath, folderMapping);
Assert.IsTrue(result);
}
/// <summary>
/// Updates a file in Azure folder provider.
/// </summary>
/// <remarks>
/// Azure is case sensitive. If you update dnninternals.pdf with DNNINTERNALS.pdf, to DNN it's the same
/// so it just re-uploads it, causing both files to exist in Azure. This azure specific method deletes the
/// old existing duplicate that only differs in case as part of the update.
/// </remarks>
public override void UpdateFile(IFolderInfo folder, string fileName, Stream content)
{
IFileInfo originalFile = FileManager.Instance.GetFile(folder, fileName);
base.UpdateFile(folder, fileName, content);
if (originalFile != null && originalFile.FileName != fileName)
{
FolderMappingInfo folderMapping = FolderMappingController.Instance.GetFolderMapping(folder.FolderMappingID);
this.DeleteFileInternal(folderMapping, folder.MappedPath + originalFile.FileName);
}
}
public void GetSubFolders_Calls_DirectoryWrapper_GetFiles()
{
var folderMapping = new FolderMappingInfo {
PortalID = Constants.CONTENT_ValidPortalId
};
_pathUtils.Setup(pu => pu.GetPhysicalPath(folderMapping.PortalID, Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderPath);
_sfp.GetSubFolders(Constants.FOLDER_ValidFolderRelativePath, folderMapping).ToList();
_directoryWrapper.Verify(dw => dw.GetDirectories(Constants.FOLDER_ValidFolderPath), Times.Once());
}
public void ExistsFolder_Calls_DataProvider_GetFolder()
{
var folderMapping = new FolderMappingInfo();
folderMapping.PortalID = Constants.CONTENT_ValidPortalId;
_mockData.Setup(md => md.GetFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath).Read()).Returns(true);
_dfp.FolderExists(Constants.FOLDER_ValidFolderRelativePath, folderMapping);
_mockData.Verify(md => md.GetFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath), Times.Once());
}
public void GetSubFolders_Calls_FolderManager_GetFoldersByParentFolder()
{
var folderMapping = new FolderMappingInfo();
folderMapping.PortalID = Constants.CONTENT_ValidPortalId;
this._folderManager.Setup(fm => fm.GetFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(this._folderInfo.Object);
this._folderManager.Setup(fm => fm.GetFolders(this._folderInfo.Object)).Returns(new List <IFolderInfo>());
this._dfp.GetSubFolders(Constants.FOLDER_ValidFolderRelativePath, folderMapping).ToList();
this._folderManager.Verify(fm => fm.GetFolders(this._folderInfo.Object), Times.Once());
}
public void ExistsFolder_Returns_False_When_Folder_Does_Not_Exist()
{
var folderMapping = new FolderMappingInfo {
PortalID = Constants.CONTENT_ValidPortalId
};
_pathUtils.Setup(pu => pu.GetPhysicalPath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderPath);
_directoryWrapper.Setup(dw => dw.Exists(Constants.FOLDER_ValidFolderPath)).Returns(false);
var result = _sfp.FolderExists(Constants.FOLDER_ValidFolderRelativePath, folderMapping);
Assert.IsFalse(result);
}
public void ExistsFolder_Returns_False_When_Folder_Does_Not_Exist()
{
var folderMapping = new FolderMappingInfo();
folderMapping.PortalID = Constants.CONTENT_ValidPortalId;
FolderInfo folder = null;
_folderManager.Setup(fm => fm.GetFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(folder);
var result = _dfp.FolderExists(Constants.FOLDER_ValidFolderRelativePath, folderMapping);
Assert.IsFalse(result);
}
public List <string> GetAllContainers(FolderMappingInfo folderMapping)
{
List <string> containers = new List <string>();
var accountName = this.GetEncryptedSetting(folderMapping.FolderMappingSettings, Constants.AccountName);
var accountKey = this.GetEncryptedSetting(folderMapping.FolderMappingSettings, Constants.AccountKey);
var useHttps = GetBooleanSetting(folderMapping, Constants.UseHttps);
var sc = new StorageCredentials(accountName, accountKey);
var csa = new CloudStorageAccount(sc, useHttps);
var blobClient = csa.CreateCloudBlobClient();
blobClient.ListContainers().ToList().ForEach(x => containers.Add(x.Name));
return(containers);
}
protected override void UpdateFileInternal(Stream stream, FolderMappingInfo folderMapping, string uri)
{
var container = this.GetContainer(folderMapping);
var blob = container.GetBlockBlobReference(uri);
stream.Seek(0, SeekOrigin.Begin);
blob.UploadFromStream(stream);
// Set the content type
blob.Properties.ContentType = FileContentTypeManager.Instance.GetContentType(Path.GetExtension(uri));
blob.SetProperties();
this.ClearCache(folderMapping.FolderMappingID);
}
/// <summary>
/// Checks the existence of the specified folder.
/// </summary>
public override bool FolderExists(string folderPath, FolderMappingInfo folderMapping)
{
Requires.NotNull("folderPath", folderPath);
Requires.NotNull("folderMapping", folderMapping);
//the root folder should always exist.
if (folderPath == "")
{
return(true);
}
var list = GetObjectList(folderMapping, folderPath);
return(list.Any(o => o.Key.StartsWith(folderPath, StringComparison.InvariantCultureIgnoreCase)));
}
private CloudBlobContainer GetContainer(FolderMappingInfo folderMapping)
{
CheckSettings(folderMapping);
var accountName = this.GetEncryptedSetting(folderMapping.FolderMappingSettings, Constants.AccountName);
var accountKey = this.GetEncryptedSetting(folderMapping.FolderMappingSettings, Constants.AccountKey);
var container = GetSetting(folderMapping, Constants.Container);
var useHttps = GetBooleanSetting(folderMapping, Constants.UseHttps);
var sc = new StorageCredentials(accountName, accountKey);
var csa = new CloudStorageAccount(sc, useHttps);
var blobClient = csa.CreateCloudBlobClient();
return(blobClient.GetContainerReference(container));
}
