public void SetUp()
{
var builder = new ComDependencyBuilder();
var dependencies = builder.ComDependencies;
LoggingHelper.InitConsoleLogger("PDFCreatorTest", LoggingLevel.Off);
var installationPathProvider = new InstallationPathProvider(@"Software\pdfforge\PDFCreator\Settings", @"Software\pdfforge\PDFCreator", "{00000000-0000-0000-0000-000000000000}");
var settingsProvider = new DefaultSettingsProvider();
var translationHelper = new TranslationHelper(new TranslationProxy(), settingsProvider, new AssemblyHelper());
translationHelper.InitTranslator("None");
var settingsLoader = new SettingsLoader(translationHelper, Substitute.For <ISettingsMover>(), installationPathProvider, Substitute.For <ILanguageDetector>(), Substitute.For <IPrinterHelper>(), Substitute.For <ITranslator>());
var settingsManager = new SettingsManager(settingsProvider, settingsLoader);
settingsManager.LoadAllSettings();
var folderProvider = new FolderProvider(new PrinterPortReader(new RegistryWrap(), new PathWrapSafe()), new PathWrap());
_queue = new Queue();
_queue.Initialize();
_testPageHelper = new TestPageHelper(new AssemblyHelper(), new OsHelper(), folderProvider, dependencies.QueueAdapter.JobInfoQueue, new JobInfoManager(new LocalTitleReplacerProvider(new List <TitleReplacement>())));
}
public void SetUp()
{
var dependencies = ComTestHelper.ModifyAndBuildComDependencies();
LoggingHelper.InitConsoleLogger("PDFCreatorTest", LoggingLevel.Off);
var installationPathProvider = new InstallationPathProvider(@"Software\pdfforge\PDFCreator\Settings", @"Software\pdfforge\PDFCreator", "{00000000-0000-0000-0000-000000000000}");
var settingsProvider = new DefaultSettingsProvider();
var translationHelper = new TranslationHelper(settingsProvider, new AssemblyHelper(GetType().Assembly), new TranslationFactory(), null);
translationHelper.InitTranslator("None");
var settingsLoader = new SettingsLoader(translationHelper, Substitute.For <ISettingsMover>(), installationPathProvider, Substitute.For <IPrinterHelper>());
var settingsManager = new SettingsManager(settingsProvider, settingsLoader, installationPathProvider, new VersionHelper(Assembly.GetExecutingAssembly()), new List <IFirstTimeCommand>());
settingsManager.LoadAllSettings();
var folderProvider = new FolderProvider(new PrinterPortReader(new RegistryWrap(), new PathWrapSafe()), new PathWrap());
_queue = new Queue();
_queue.Initialize();
_testPageHelper = new TestPageHelper(new VersionHelper(GetType().Assembly), new OsHelper(), folderProvider,
dependencies.QueueAdapter.JobInfoQueue, new JobInfoManager(new LocalTitleReplacerProvider(new List <TitleReplacement>())), new ApplicationNameProvider("FREE"));
}
public async Task <IResult <Folder> > GetFolderPageAsync(string name, string path, int pageNumber)
{
var relativePathResult = PathManager.Combine(path, name);
if (!relativePathResult.IsSuccess)
{
return(new FailureResult <Folder>(relativePathResult.Exception));
}
var folderResult = FolderProvider.GetFolder(relativePathResult.Data);
if (!folderResult.IsSuccess)
{
return(new FailureResult <Folder>(folderResult.Exception));
}
var loadPageResult = await folderResult.Data.LoadFolderPageAsync(pageNumber);
if (!loadPageResult.IsSuccess)
{
return(new FailureResult <Folder>(loadPageResult.Exception));
}
return(new SuccessResult <Folder>(folderResult.Data));
}
public void SetUp()
{
var dependencies = ComTestHelper.ModifyAndBuildComDependencies();
LoggingHelper.InitConsoleLogger("PDFCreatorTest", LoggingLevel.Off);
_queue = new Queue();
_queue.Initialize();
var assembly = GetType().Assembly;
var assemblyHelper = new AssemblyHelper(assembly);
var translationHelper = new TranslationHelper(new DefaultSettingsProvider(), assemblyHelper, new TranslationFactory(), null);
translationHelper.InitTranslator("None");
var folderProvider = new FolderProvider(new PrinterPortReader(new RegistryWrap(), new PathWrapSafe()), new PathWrap());
_testPageHelper = new TestPageHelper(new VersionHelper(assembly), new OsHelper(), folderProvider,
dependencies.QueueAdapter.JobInfoQueue, new JobInfoManager(new LocalTitleReplacerProvider(new List <TitleReplacement>())), new ApplicationNameProvider("FREE"));
CreateTestPages(1);
_printJob = _queue.NextJob;
_printJobInfo = _printJob.PrintJobInfo;
}
public async Task <IResult <Void> > FinishUploadAsync(string name, string path)
{
var fileResult = await _uploadFolder.GetChildFileAsync(GetFileName(name, path));
if (!fileResult.IsSuccess)
{
return(new FailureResult(fileResult.Exception));
}
var streamResult = await fileResult.Data.GetStreamAsync();
if (!streamResult.IsSuccess)
{
return(new FailureResult(streamResult.Exception));
}
var destinationFolderResult = FolderProvider.GetFolder(path);
if (!destinationFolderResult.IsSuccess)
{
return(new FailureResult(destinationFolderResult.Exception));
}
var addFileResult = await destinationFolderResult.Data.AddFileAsync(streamResult.Data, name);
if (!addFileResult.IsSuccess)
{
return(new FailureResult(addFileResult.Exception));
}
return(await fileResult.Data.DeleteAsync());
}
public async Task <IResult <Void> > DeleteFileAsync(string name, string path)
{
var parentFolderResult = FolderProvider.GetFolder(path);
if (!parentFolderResult.IsSuccess)
{
return(new FailureResult(parentFolderResult.Exception));
}
var fileToDeleteResult = await parentFolderResult.Data.GetChildFileAsync(name);
if (!fileToDeleteResult.IsSuccess)
{
return(new FailureResult(fileToDeleteResult.Exception));
}
var deleteFolderResult = await fileToDeleteResult.Data.DeleteAsync();
if (!deleteFolderResult.IsSuccess)
{
return(new FailureResult(deleteFolderResult.Exception));
}
return(new SuccessResult());
}
public void DeleteFile(IFileInfo file)
{
string lockReason;
if (FileLockingController.Instance.IsFileLocked(file, out lockReason))
{
throw new FileLockedException(Localization.GetExceptionMessage(lockReason, "File locked. The file cannot be updated. Reason: " + lockReason));
}
FileVersionController.Instance.DeleteAllUnpublishedVersions(file, false);
try
{
var folderMapping = FolderMappingController.Instance.GetFolderMapping(file.PortalId, file.FolderMappingID);
FolderProvider.Instance(folderMapping.FolderProviderType).DeleteFile(file);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new FolderProviderException(Localization.GetExceptionMessage("DeleteFileUnderlyingSystemError", "The underlying system threw an exception. The file has not been deleted."), ex);
}
this.DeleteFileData(file);
DataCache.RemoveCache("GetFileById" + file.FileId);
}
private void BindFolderProviders()
{
var defaultProviders = DefaultFolderProviders.GetDefaultProviders();
foreach (var provider in FolderProvider.GetProviderList().Keys.Where(provider => !defaultProviders.Contains(provider)).OrderBy(provider => provider))
{
FolderProvidersComboBox.AddItem(provider, provider);
}
FolderProvidersComboBox.InsertItem(0, "", "");
}
public void AppDataFolderReturnsPath()
{
FolderProvider folderProvider = new FolderProvider();
string folder = folderProvider.AppDataFolder;
Assert.That(folder, Is.Not.Empty);
Assert.That(folder, Contains.Substring("PasswordManagement"));
Assert.That(folder, Contains.Substring("REFame"));
}
/// <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));
}
public void IfPrinterPortCantBeRead_UsesPDFCreatorAsTempFolderName()
{
_printerPortReader.ReadPrinterPort("pdfcmon").ReturnsNull();
var folderProvider = new FolderProvider(_printerPortReader, _path);
var expectedTempFolder = Path.Combine(TempPath, "PDFCreator");
expectedTempFolder = Path.Combine(expectedTempFolder, "Temp");
Assert.AreEqual(expectedTempFolder, folderProvider.TempFolder);
}
/// <summary>
/// Loads concrete settings.
/// </summary>
/// <param name="folderMappingSettings">The Hashtable containing the folder mapping settings.</param>
public override void LoadSettings(Hashtable folderMappingSettings)
{
var folderProvider = FolderProvider.Instance(Constants.FolderProviderType);
if (folderMappingSettings.ContainsKey(Constants.AccountName))
{
this.tbAccountName.Text = folderProvider.GetEncryptedSetting(folderMappingSettings, Constants.AccountName);
}
if (folderMappingSettings.ContainsKey(Constants.AccountKey))
{
this.tbAccountKey.Text = folderProvider.GetEncryptedSetting(folderMappingSettings, Constants.AccountKey);
}
if (this.tbAccountName.Text.Length > 0 && this.tbAccountKey.Text.Length > 0)
{
var bucketName = string.Empty;
if (folderMappingSettings.ContainsKey(Constants.Container))
{
bucketName = folderMappingSettings[Constants.Container].ToString();
}
this.LoadContainers();
var bucket = this.ddlContainers.Items.FindByText(bucketName);
if (bucket != null)
{
this.ddlContainers.SelectedIndex = this.ddlContainers.Items.IndexOf(bucket);
}
}
if (folderMappingSettings.ContainsKey(Constants.UseHttps))
{
this.chkUseHttps.Checked = bool.Parse(folderMappingSettings[Constants.UseHttps].ToString());
}
this.chkDirectLink.Checked = !folderMappingSettings.ContainsKey(Constants.DirectLink) || folderMappingSettings[Constants.DirectLink].ToString().ToLowerInvariant() == "true";
if (folderMappingSettings.ContainsKey(Constants.CustomDomain))
{
this.tbCustomDomain.Text = folderProvider.GetEncryptedSetting(folderMappingSettings, Constants.CustomDomain);
}
if (folderMappingSettings.ContainsKey(Constants.SyncBatchSize) && folderMappingSettings[Constants.SyncBatchSize] != null)
{
this.tbSyncBatchSize.Text = folderMappingSettings[Constants.SyncBatchSize].ToString();
}
else
{
this.tbSyncBatchSize.Text = Constants.DefaultSyncBatchSize.ToString();
}
}
private void BindFolderProviders()
{
var defaultProviders = DefaultFolderProviders.GetDefaultProviders();
foreach (var provider in FolderProvider.GetProviderList().Keys.Where(provider => !defaultProviders.Contains(provider)).OrderBy(provider => provider))
{
cboFolderProviders.Items.Add(provider);
}
cboFolderProviders.Items.Insert(0, new ListItem(Localization.GetString("SelectFolderProvider", LocalResourceFile), ""));
}
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);
}
private bool AreMappedPathsSupported(int folderMappingId)
{
if (MappedPathsSupported.ContainsKey(folderMappingId))
{
return((bool)MappedPathsSupported[folderMappingId]);
}
var result = FolderProvider.Instance(FolderMappingController.Instance.GetFolderMapping(folderMappingId).FolderProviderType).SupportsMappedPaths;
MappedPathsSupported.Add(folderMappingId, result);
return(result);
}
private void BindFolderProviders()
{
var defaultProviders = DefaultFolderProviders.GetDefaultProviders();
foreach (var provider in FolderProvider.GetProviderList().Keys.Where(provider => !defaultProviders.Contains(provider)).OrderBy(provider => provider))
{
this.FolderProvidersComboBox.Items.Add(new ListItem(provider, provider));
}
this.FolderProvidersComboBox.Items.Insert(0, new ListItem(string.Empty, string.Empty));
}
public override int AddOrUpdateFile(FileInfo objFile, byte[] content, bool contentOnly)
{
var objFolder = FolderManager.Instance.GetFolder(objFile.FolderId);
if (objFolder != null)
{
if (content != null && content.Length > 0)
{
using (var objStream = new MemoryStream(content))
{
if (objFile.FileId > 0)
{
var toReturn = objFile.FileId;
if (!contentOnly)
{
toReturn = FileManager.Instance.UpdateFile(objFile, objStream).FileId;
}
//Todo: seems the updatefile does not have the proper call to that function. Should be registered as a bug.
FolderProvider folderProvider =
FolderProvider.Instance(
ComponentBase <IFolderMappingController, FolderMappingController> .Instance
.GetFolderMapping(objFolder.PortalID, objFolder.FolderMappingID)
.FolderProviderType);
folderProvider.UpdateFile(objFolder, objFile.FileName, objStream);
return(toReturn);
}
else
{
return(FileManager.Instance.AddFile(objFolder, objFile.FileName, objStream).FileId);
}
}
}
else
{
if (objFile.FileId > 0)
{
var toReturn = objFile.FileId;
if (!contentOnly)
{
toReturn = FileManager.Instance.UpdateFile(objFile).FileId;
}
return(toReturn);
}
else
{
return(FileManager.Instance.AddFile(objFolder, objFile.FileName, null).FileId);
}
}
}
return(-1);
}
public async void OpenFolderAsync(string workspacePath)
{
try
{
var provider = new FolderProvider(workspacePath);
await this.LoadDevelopmentAsync(provider, workspacePath);
}
catch
{
var message = LocalizationManager.Instance.LocalizeString("ERROR_FOLDER_READ");
this.viewService.ShowMessageBox(message, icon: MessageBoxImage.Error);
}
SaveLastOpenedFolder(workspacePath);
}
public async Task <IResult <Void> > CopyFileAsync(
string sourcePath,
string sourceFileName,
string destPath,
string destName)
{
var parentFolderResult = FolderProvider.GetFolder(sourcePath);
if (!parentFolderResult.IsSuccess)
{
return(new FailureResult(parentFolderResult.Exception));
}
var sourceFileResult = await parentFolderResult.Data.GetChildFileAsync(sourceFileName);
if (!sourceFileResult.IsSuccess)
{
return(new FailureResult(sourceFileResult.Exception));
}
var destParentFolderResult = FolderProvider.GetFolder(destPath);
if (!destParentFolderResult.IsSuccess)
{
return(new FailureResult(destParentFolderResult.Exception));
}
var destFolderResult = await destParentFolderResult.Data.GetChildFolderAsync(destName);
if (!destFolderResult.IsSuccess)
{
return(new FailureResult(destFolderResult.Exception));
}
var sourceStreamResult = await sourceFileResult.Data.GetStreamAsync();
if (!sourceStreamResult.IsSuccess)
{
return(new FailureResult(sourceStreamResult.Exception));
}
var createResult = await destFolderResult.Data.AddFileAsync(sourceStreamResult.Data, sourceFileName);
if (!createResult.IsSuccess)
{
return(new FailureResult(createResult.Exception));
}
return(new SuccessResult());
}
public void AfterContruction_TempFolderIsSetCorrectly()
{
var port = new PrinterPort();
port.TempFolderName = "MyTempFolderName";
_printerPortReader.ReadPrinterPort("pdfcmon").Returns(port);
var folderProvider = new FolderProvider(_printerPortReader, _path);
var expectedTempFolder = Path.Combine(TempPath, "MyTempFolderName");
expectedTempFolder = Path.Combine(expectedTempFolder, "Temp");
Assert.AreEqual(expectedTempFolder, folderProvider.TempFolder);
}
private string GetSetting(Hashtable settings, string name, bool encrypt = false)
{
if (!settings.ContainsKey(name))
{
return(string.Empty);
}
if (encrypt)
{
var folderProvider = FolderProvider.Instance(Constants.FolderProviderType);
return(folderProvider.GetEncryptedSetting(settings, name));
}
return(settings[name].ToString());
}
/// <summary>
/// Loads concrete settings.
/// </summary>
/// <param name="folderMappingSettings">The Hashtable containing the folder mapping settings.</param>
public override void LoadSettings(Hashtable folderMappingSettings)
{
var folderProvider = FolderProvider.Instance(FolderProviderType);
if (folderMappingSettings.ContainsKey(AccountName))
{
tbAccountName.Text = folderProvider.GetEncryptedSetting(folderMappingSettings, AccountName);
}
if (folderMappingSettings.ContainsKey(AccountKey))
{
tbAccountKey.Text = folderProvider.GetEncryptedSetting(folderMappingSettings, AccountKey);
}
if (tbAccountName.Text.Length > 0 && tbAccountKey.Text.Length > 0)
{
var bucketName = "";
if (folderMappingSettings.ContainsKey(Container))
{
bucketName = folderMappingSettings[Container].ToString();
}
LoadContainers();
var bucket = ddlContainers.Items.FindByText(bucketName);
if (bucket != null)
{
ddlContainers.SelectedIndex = ddlContainers.Items.IndexOf(bucket);
}
}
if (folderMappingSettings.ContainsKey(UseHttps))
{
chkUseHttps.Checked = bool.Parse(folderMappingSettings[UseHttps].ToString());
}
chkDirectLink.Checked = !folderMappingSettings.ContainsKey(DirectLink) || folderMappingSettings[DirectLink].ToString().ToLowerInvariant() == "true";
if (folderMappingSettings.ContainsKey(CustomDomain))
{
tbCustomDomain.Text = folderProvider.GetEncryptedSetting(folderMappingSettings, CustomDomain);
}
}
public async Task <IResult <Void> > RenameFolderAsync(string name, string path, string newName)
{
var parentFolderResult = FolderProvider.GetFolder(path);
if (!parentFolderResult.IsSuccess)
{
return(new FailureResult(parentFolderResult.Exception));
}
var folderResult = await parentFolderResult.Data.GetChildFolderAsync(name);
if (!folderResult.IsSuccess)
{
return(new FailureResult(folderResult.Exception));
}
return(await folderResult.Data.RenameAsync(newName));
}
public void SetUp()
{
var builder = new ComDependencyBuilder();
var dependencies = builder.ComDependencies;
LoggingHelper.InitConsoleLogger("PDFCreatorTest", LoggingLevel.Off);
_queue = new Queue();
_queue.Initialize();
var translationHelper = new TranslationHelper(new TranslationProxy(), new DefaultSettingsProvider(), new AssemblyHelper());
translationHelper.InitTranslator("None");
var folderProvider = new FolderProvider(new PrinterPortReader(new RegistryWrap(), new PathWrapSafe()), new PathWrap());
_testPageHelper = new TestPageHelper(new AssemblyHelper(), new OsHelper(), folderProvider, dependencies.QueueAdapter.JobInfoQueue, new JobInfoManager(new LocalTitleReplacerProvider(new List <TitleReplacement>())));
}
public virtual async Task <IResult <long> > GetNumOfFolderPagesAsync(string name, string path)
{
var relativePathResult = PathManager.Combine(path, name);
if (!relativePathResult.IsSuccess)
{
return(new FailureResult <long>(relativePathResult.Exception));
}
var folderResult = FolderProvider.GetFolder(relativePathResult.Data);
if (!folderResult.IsSuccess)
{
return(new FailureResult <long>(folderResult.Exception));
}
return(await folderResult.Data.GetNumOfFolderPagesAsync());
}
public async Task <IResult <Stream> > GetFileStreamAsync(string name, string path)
{
var folderResult = FolderProvider.GetFolder(path);
if (!folderResult.IsSuccess)
{
return(new FailureResult <Stream>(folderResult.Exception));
}
var fileResult = await folderResult.Data.GetChildFileAsync(name);
if (!fileResult.IsSuccess)
{
return(new FailureResult <Stream>(fileResult.Exception));
}
return(await fileResult.Data.GetStreamAsync());
}
public IResult <SortType> GetSortType(string name, string path)
{
var relativePathResult = PathManager.Combine(path, name);
if (!relativePathResult.IsSuccess)
{
return(new FailureResult <SortType>(relativePathResult.Exception));
}
var folderResult = FolderProvider.GetFolder(relativePathResult.Data);
if (!folderResult.IsSuccess)
{
return(new FailureResult <SortType>(folderResult.Exception));
}
return(new SuccessResult <SortType>(folderResult.Data.SortType));
}
public IResult <int> GetNumberOfElementToShowOnPage(string name, string path)
{
var relativePathResult = PathManager.Combine(path, name);
if (!relativePathResult.IsSuccess)
{
return(new FailureResult <int>(relativePathResult.Exception));
}
var folderResult = FolderProvider.GetFolder(relativePathResult.Data);
if (!folderResult.IsSuccess)
{
return(new FailureResult <int>(folderResult.Exception));
}
return(new SuccessResult <int>(folderResult.Data.NumberOfElementToShowOnPage));
}
public async Task <IResult <Void> > CreateFileAsync(string name, string path, Stream content)
{
var folderResult = FolderProvider.GetFolder(path);
if (!folderResult.IsSuccess)
{
return(new FailureResult(folderResult.Exception));
}
var fileResult = await folderResult.Data.AddFileAsync(content, name);
if (!fileResult.IsSuccess)
{
return(new FailureResult(fileResult.Exception));
}
return(new SuccessResult());
}
private void BindFolderMappingSettings()
{
string folderProviderType;
if (FolderMappingID != Null.NullInteger)
{
var folderMapping = _folderMappingController.GetFolderMapping(FolderMappingID);
folderProviderType = folderMapping.FolderProviderType;
}
else
{
folderProviderType = FolderProvidersComboBox.SelectedValue;
}
if (string.IsNullOrEmpty(folderProviderType))
{
return;
}
var settingsControlVirtualPath = FolderProvider.Instance(folderProviderType).GetSettingsControlVirtualPath();
if (String.IsNullOrEmpty(settingsControlVirtualPath))
{
return;
}
var settingsControl = LoadControl(settingsControlVirtualPath);
if (settingsControl == null || !(settingsControl is FolderMappingSettingsControlBase))
{
return;
}
// This is important to allow settings control to be localizable
var baseType = settingsControl.GetType().BaseType;
if (baseType != null)
{
settingsControl.ID = baseType.Name;
}
ProviderSettingsPlaceHolder.Controls.Clear();
ProviderSettingsPlaceHolder.Controls.Add(settingsControl);
}
