public async Task Return_Two_WhenSfHasTwoChildren()
{
// Arrange
SourceFormat sf = await CreateSavedSourceFormatEntity().ConfigureAwait(false);
DimensionStructureNode rootDsn = await CreateSavedDimensionStructureNodeEntity().ConfigureAwait(false);
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.AddRootDimensionStructureNodeAsync(sf.Id, rootDsn.Id)
.ConfigureAwait(false);
DimensionStructureNode child = await CreateSavedDimensionStructureNodeEntity().ConfigureAwait(false);
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.AppendDimensionStructureNodeToTreeAsync(child.Id, rootDsn.Id, sf.Id)
.ConfigureAwait(false);
// Act
long amount = await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.GetAmountOfDimensionStructureNodeOfSourceFormatAsync(sf)
.ConfigureAwait(false);
// Assert
amount.Should().Be(2);
}
public virtual void Initialize(FormatStore store, SourceFormat sourceFormat, string comment)
{
this.sourceFormat = sourceFormat;
this.comment = comment;
this.formatStore = store;
this.Restart(this.formatStore.RootNode);
}
public async Task DeleteRootDsn_WhenItDoesNotHaveChildren()
{
// Arrange
SourceFormat sourceFormat = await CreateSavedSourceFormatEntity().ConfigureAwait(false);
DimensionStructureNode rootDsn = await CreateSavedDimensionStructureNodeEntity().ConfigureAwait(false);
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.AddRootDimensionStructureNodeAsync(sourceFormat.Id, rootDsn.Id)
.ConfigureAwait(false);
// Action
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.DeleteRootDimensionStructureNodeAsync(rootDsn.Id, sourceFormat.Id)
.ConfigureAwait(false);
// Assert
SourceFormat result = await _masterDataBusinessLogic.MasterDataSourceFormatBusinessLogic
.GetSourceFormatByIdWithRootDimensionStructureNodeAsync(sourceFormat)
.ConfigureAwait(false);
result.SourceFormatDimensionStructureNode.Should().BeNull();
int dsnAmount = await _masterDataBusinessLogic.MasterDataSourceFormatBusinessLogic
.GetAmountOfDimensionStructureNodeOfSourceFormatAsync(sourceFormat)
.ConfigureAwait(false);
dsnAmount.Should().Be(0);
}
public async Task RootDimensionStructureNodeIsAddedToSourceFormat(Table table)
{
RootDimensionStructureNodeIsAddedToSourceFormatEntity instance = table
.CreateInstance <RootDimensionStructureNodeIsAddedToSourceFormatEntity>();
SourceFormat sf = _scenarioContext.Get <SourceFormat>(instance.SourceFormatResultKey);
Check.IsNotNull(sf);
DimensionStructureNode dsn = _scenarioContext.Get <DimensionStructureNode>(
instance.DimensionStructureNodeResultKey);
Check.IsNotNull(dsn);
AddRootDimensionStructureNodeViewModel vm = new AddRootDimensionStructureNodeViewModel()
{
DimensionStructureNodeId = dsn.Id,
SourceFormatId = sf.Id,
};
DilibHttpClientResponse <SourceFormat> result = await _masterDataHttpClient.SourceFormatHttpClient
.AddRootDimensionStructureNodeAsync(vm)
.ConfigureAwait(false);
_scenarioContext.Add(instance.ResultKey, result);
}
public static ExportHelper GetHelper(SourceFormat srcFormat, ExportFormat format, Dictionary <string, string> customParams = null)
{
ExportHelper helper = null;
switch (srcFormat)
{
case SourceFormat.EPUB:
helper = new ExportHelperEpub(format);
break;
case SourceFormat.MHTML:
helper = new ExportHelperMhtml(format);
break;
case SourceFormat.SVG:
helper = new ExportHelperSvg(format);
break;
case SourceFormat.MD:
helper = new ExportHelperMarkdown(format);
if (customParams != null && customParams.ContainsKey("cssTheme"))
{
((ExportHelperMarkdown)helper).CssTheme = customParams["cssTheme"];
}
break;
case SourceFormat.HTML:
case SourceFormat.XHTML:
default:
helper = new ExportHelperHtml(format);
break;
}
return(helper);
}
public static ExportHelper GetHelper(SourceFormat srcFormat, ExportFormat format)
{
ExportHelper helper = null;
switch (srcFormat)
{
case SourceFormat.EPUB:
helper = new ExportHelperEpub(format);
break;
case SourceFormat.MHTML:
helper = new ExportHelperMhtml(format);
break;
case SourceFormat.SVG:
helper = new ExportHelperSvg(format);
break;
case SourceFormat.HTML:
case SourceFormat.XHTML:
default:
helper = new ExportHelperHtml(format);
break;
}
return(helper);
}
public async Task Throw_WhenBothDsnAndSfHaveConnection_ButToSomewhereElse()
{
// Arrange
SourceFormat sf1 = await CreateSavedSourceFormatEntity().ConfigureAwait(false);
DimensionStructureNode dsn1 = await CreateSavedDimensionStructureNodeEntity().ConfigureAwait(false);
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.AddRootDimensionStructureNodeAsync(sf1.Id, dsn1.Id)
.ConfigureAwait(false);
SourceFormat sf2 = await CreateSavedSourceFormatEntity().ConfigureAwait(false);
DimensionStructureNode dsn2 = await CreateSavedDimensionStructureNodeEntity().ConfigureAwait(false);
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.AddRootDimensionStructureNodeAsync(sf2.Id, dsn2.Id)
.ConfigureAwait(false);
// Action
Func <Task> task = async() =>
{
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.DeleteRootDimensionStructureNodeAsync(dsn1.Id, sf2.Id)
.ConfigureAwait(false);
};
// Assert
task.Should().ThrowExactly <MasterDataBusinessLogicSourceFormatDatabaseOperationException>();
}
/// <inheritdoc/>
public async Task <SourceFormat> GetSourceFormatByIdWithRootDimensionStructureNodeAsync(
SourceFormat querySourceFormat)
{
try
{
Check.IsNotNull(querySourceFormat);
Check.AreNotEqual(querySourceFormat.Id, 0);
using (MasterDataContext ctx = new MasterDataContext(_dbContextOptions))
{
SourceFormat sourceFormat = await ctx.SourceFormats
.Include(i => i.SourceFormatDimensionStructureNode)
.ThenInclude(ii => ii.DimensionStructureNode)
.AsNoTracking()
.FirstAsync(p => p.Id == querySourceFormat.Id)
.ConfigureAwait(false);
return(sourceFormat);
}
}
catch (Exception e)
{
string msg = $"{nameof(MasterDataDimensionBusinessLogic)}." +
$"{nameof(GetSourceFormatByIdWithRootDimensionStructureNodeAsync)} operation failed. " +
$"For further details see inner exception.";
throw new MasterDataBusinessLogicSourceFormatDatabaseOperationException(msg, e);
}
}
/// <inheritdoc/>
public async Task DeleteAsync(
SourceFormat sourceFormat,
CancellationToken cancellationToken = default)
{
try
{
Check.IsNotNull(sourceFormat);
await _masterDataValidators.SourceFormatValidator.ValidateAsync(sourceFormat, o =>
{
o.IncludeRuleSets(SourceFormatValidatorRulesets.Delete);
o.ThrowOnFailures();
}, cancellationToken).ConfigureAwait(false);
using (MasterDataContext ctx = new MasterDataContext(_dbContextOptions))
{
SourceFormat result = await ctx.SourceFormats
.Include(p => p.DimensionStructureNodes)
.Include(pp => pp.SourceFormatDimensionStructureNode)
.FirstOrDefaultAsync(
w => w.Id == sourceFormat.Id,
cancellationToken
)
.ConfigureAwait(false);
if (result is null)
{
string msg = $"There is no {nameof(SourceFormat)} with id: {sourceFormat.Id}";
throw new MasterDataBusinessLogicSourceFormatDatabaseOperationException(msg);
}
if (result.DimensionStructureNodes.Any())
{
foreach (DimensionStructureNode node in result.DimensionStructureNodes)
{
ctx.Entry(node).State = EntityState.Deleted;
}
await ctx.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
}
if (result.SourceFormatDimensionStructureNode is not null)
{
ctx.Entry(result.SourceFormatDimensionStructureNode).State = EntityState.Deleted;
await ctx.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
}
ctx.Entry(result).State = EntityState.Deleted;
await ctx.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
}
catch (Exception e)
{
string msg = $"{nameof(MasterDataSourceFormatBusinessLogic)}." +
$"{nameof(DeleteAsync)} operation failed! " +
"For further information see inner exception!";
throw new MasterDataBusinessLogicSourceFormatDatabaseOperationException(msg, e);
}
}
public void GivenThereIsASourceFormatDimensionStructureNodeDomainObject(Table table)
{
ThereIsASourceFormatDimensionStructureNodeDomainObjectEntity instance = table
.CreateInstance<ThereIsASourceFormatDimensionStructureNodeDomainObjectEntity>();
SourceFormatDimensionStructureNode result = new SourceFormatDimensionStructureNode();
if (instance.SourceFormatKey != null)
{
SourceFormat sourceFormat = _scenarioContext[instance.SourceFormatKey]
as SourceFormat;
Check.IsNotNull(sourceFormat);
result.SourceFormatId = sourceFormat.Id;
result.SourceFormat = sourceFormat;
}
if (instance.DimensionStructureNodeKey != null)
{
DimensionStructureNode dimensionStructureNode = _scenarioContext[instance.DimensionStructureNodeKey]
as DimensionStructureNode;
Check.IsNotNull(dimensionStructureNode);
result.DimensionStructureNodeId = dimensionStructureNode.Id;
result.DimensionStructureNode = dimensionStructureNode;
}
_scenarioContext.Add(instance.ResultKey, result);
}
public async Task Deletes_RootDimensionStructureNodeToo()
{
// Arrange
SourceFormat sourceFormatOrig = await CreateSavedSourceFormatEntity().ConfigureAwait(false);
DimensionStructureNode dimensionStructureNode = await CreateSavedDimensionStructureNodeEntity()
.ConfigureAwait(false);
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.AddRootDimensionStructureNodeAsync(sourceFormatOrig.Id, dimensionStructureNode.Id)
.ConfigureAwait(false);
// Action
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.DeleteAsync(sourceFormatOrig)
.ConfigureAwait(false);
// Assert
List <SourceFormat> sourceFormats = await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.GetAllAsync()
.ConfigureAwait(false);
sourceFormats.Count.Should().Be(0);
List <DimensionStructureNode> dimensionStructureNodes = await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.GetAllDimensionStructureNodesAsync()
.ConfigureAwait(false);
dimensionStructureNodes.Count.Should().Be(0);
}
public async Task Throw_WhenInputIsInvalid(
long id,
string name,
string desc,
int isActive)
{
// Arrange
SourceFormat sourceFormat = new SourceFormat
{
Id = id,
Name = name,
Desc = desc,
IsActive = isActive,
};
// Action
Func <Task> task = async() =>
{
await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.AddAsync(sourceFormat)
.ConfigureAwait(false);
};
// Assert
task.Should().ThrowExactly <MasterDataBusinessLogicSourceFormatDatabaseOperationException>();
}
/// <inheritdoc/>
public async Task <SourceFormat> AddAsync(
SourceFormat sourceFormat,
CancellationToken cancellationToken = default)
{
using (MasterDataContext ctx = new MasterDataContext(_dbContextOptions))
{
try
{
Check.IsNotNull(sourceFormat);
await _masterDataValidators.SourceFormatValidator.ValidateAsync(sourceFormat, o =>
{
o.IncludeRuleSets(SourceFormatValidatorRulesets.Add);
o.ThrowOnFailures();
}, cancellationToken).ConfigureAwait(false);
await ctx.SourceFormats
.AddAsync(sourceFormat, cancellationToken)
.ConfigureAwait(false);
await ctx.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
return(sourceFormat);
}
catch (Exception e)
{
string msg = $"Operation failed: {nameof(AddAsync)}. " +
$"For further details see inner exception.";
throw new MasterDataBusinessLogicSourceFormatDatabaseOperationException(msg, e);
}
}
}
///<Summary>
/// ConvertHtmlToPdf to convert html file to pdf
///</Summary>
public Response ConvertHtmlToPdf(string[] fileNames, string folderName)
{
return(ProcessTask_(fileNames, (inFiles, outPath, zipOutFolder) =>
{
Aspose.Html.Rendering.Pdf.PdfRenderingOptions pdf_options = new Aspose.Html.Rendering.Pdf.PdfRenderingOptions();
if (Opts.HasCustomParameter("ownerPassword") || Opts.HasCustomParameter("userPassword"))
{
var userPw = Opts.GetCustomParameter("userPassword");
var ownerPw = Opts.GetCustomParameter("ownerPassword");
if (!(string.IsNullOrEmpty(userPw) && string.IsNullOrEmpty(ownerPw)))
{
pdf_options.Encryption = new Aspose.Html.Rendering.Pdf.Encryption.PdfEncryptionInfo(
userPw,
ownerPw,
(Aspose.Html.Rendering.Pdf.Encryption.PdfPermissions) 0xF3C,
Aspose.Html.Rendering.Pdf.Encryption.PdfEncryptionAlgorithm.RC4_128
);
}
}
Dictionary <string, string> customParams = null;
if (Opts.HasCustomParameter("mdTheme"))
{
var csstheme = Opts.GetCustomParameter("mdTheme");
customParams = new Dictionary <string, string> {
{ "cssTheme", csstheme }
};
}
SourceFormat srcFormat = ExportHelper.GetSourceFormatByFileName(Opts.FileName);
ExportHelper helper = ExportHelper.GetHelper(srcFormat, ExportFormat.PDF, customParams);
helper.Export(inFiles, outPath, pdf_options);
}));
}
///<Summary>
/// ConvertHtmlToXps to convert html file to xps
///</Summary>
public Response ConvertHtmlToXps(string[] fileNames, string folderName)
{
return(ProcessTask_(fileNames, (inFiles, outPath, zipOutFolder) =>
{
Aspose.Html.Rendering.Xps.XpsRenderingOptions xps_options = new Aspose.Html.Rendering.Xps.XpsRenderingOptions();
if (Opts.HasCustomParameter("pageSize"))
{
var sz = OptionHelper.getPageSizeByName(Opts.GetCustomParameter("pageSize"));
if (sz != null)
{
xps_options.PageSetup.AnyPage.Size = sz;
}
}
Dictionary <string, string> customParams = null;
if (Opts.HasCustomParameter("mdTheme"))
{
var csstheme = Opts.GetCustomParameter("mdTheme");
customParams = new Dictionary <string, string> {
{ "cssTheme", csstheme }
};
}
SourceFormat srcFormat = ExportHelper.GetSourceFormatByFileName(Opts.FileName);
ExportHelper helper = ExportHelper.GetHelper(srcFormat, ExportFormat.XPS, customParams);
helper.Export(inFiles, outPath, xps_options);
}));
}
/// <summary>
/// Construct a reader from a stream
/// </summary>
/// <param name="stream">The stream to read from</param>
/// <param name="format">What is the format of the file, assumes PC and similar architecture</param>
public EndianAwareBinaryReader(Stream stream, SourceFormat format)
: base(stream)
{
if ((format == SourceFormat.BigEndian && BitConverter.IsLittleEndian) ||
(format == SourceFormat.LittleEndian && !BitConverter.IsLittleEndian))
m_shouldReverseOrder = true;
}
/// <inheritdoc/>
public async Task <SourceFormat> GetByIdAsync(
SourceFormat sourceFormat,
CancellationToken cancellationToken = default)
{
Check.IsNotNull(sourceFormat);
try
{
await _masterDataValidators.SourceFormatValidator.ValidateAsync(sourceFormat, o =>
{
o.IncludeRuleSets(SourceFormatValidatorRulesets.GetById);
o.ThrowOnFailures();
}, cancellationToken).ConfigureAwait(false);
using (MasterDataContext ctx = new MasterDataContext(_dbContextOptions))
{
return(await ctx.SourceFormats
.FirstOrDefaultAsync(w => w.Id == sourceFormat.Id, cancellationToken)
.ConfigureAwait(false));
}
}
catch (Exception e)
{
string msg = $"{nameof(MasterDataSourceFormatBusinessLogic)}." +
$"{nameof(GetByIdAsync)} operation failed! " +
$"For further information see inner exception!";
throw new MasterDataBusinessLogicSourceFormatDatabaseOperationException(msg, e);
}
}
public void GivenSourceFormatDimensionStructureNodeIsModified(Table table)
{
SourceFormatDimensionStructureNodeIsModifiedEntity instance = table
.CreateInstance <SourceFormatDimensionStructureNodeIsModifiedEntity>();
SourceFormatDimensionStructureNode node = _scenarioContext[instance.Key] as
SourceFormatDimensionStructureNode;
Check.IsNotNull(node);
if (instance.SourceFormatKey != null)
{
SourceFormat sourceFormat = _scenarioContext[instance.SourceFormatKey] as SourceFormat;
Check.IsNotNull(sourceFormat);
node.SourceFormatId = sourceFormat.Id;
}
if (instance.DimensionStructureNodeKey != null)
{
DimensionStructureNode dimensionStructureNode = _scenarioContext[instance.DimensionStructureNodeKey]
as DimensionStructureNode;
Check.IsNotNull(dimensionStructureNode);
node.DimensionStructureNodeId = dimensionStructureNode.Id;
}
_scenarioContext.Remove(instance.ResultKey);
_scenarioContext.Add(instance.ResultKey, node);
}
/// <inheritdoc/>
public async Task <SourceFormat> GetSourceFormatByIdWithAllDimensionStructuresAndNodesAsync(
SourceFormat sourceFormat)
{
try
{
Check.IsNotNull(sourceFormat);
using (MasterDataContext ctx = new MasterDataContext(_dbContextOptions))
{
SourceFormat result = await ctx.SourceFormats
.AsNoTracking()
.Include(i => i.DimensionStructureNodes)
.ThenInclude <SourceFormat, DimensionStructureNode, DimensionStructure>(ii =>
ii.DimensionStructure)
.FirstOrDefaultAsync(w => w.Id == sourceFormat.Id)
.ConfigureAwait(false);
return(result);
}
}
catch (Exception e)
{
string msg = $"{nameof(MasterDataSourceFormatBusinessLogic)}." +
$"{nameof(GetSourceFormatByIdWithAllDimensionStructuresAndNodesAsync)} " +
$"operation failed. For further info see inner exception.";
throw new MasterDataBusinessLogicSourceFormatDatabaseOperationException(msg, e);
}
}
/// <inheritdoc/>
public async Task <SourceFormat> GetSourceFormatByIdWithActiveOnlyDimensionStructuresInTheTreeAsync(
SourceFormat querySourceFormat)
{
try
{
Check.IsNotNull(querySourceFormat);
SourceFormat result = await GetSourceFormatByIdWithRootDimensionStructureNodeAsync(querySourceFormat)
.ConfigureAwait(false);
if (result == null)
{
return(null);
}
using (MasterDataContext ctx = new MasterDataContext(_dbContextOptions))
{
DimensionStructureNode tree = await GetActiveDimensionStructureNodeTreeAsync(
result.SourceFormatDimensionStructureNode.DimensionStructureNode,
ctx)
.ConfigureAwait(false);
result.SourceFormatDimensionStructureNode.DimensionStructureNode = tree;
}
return(result);
}
catch (Exception e)
{
string msg = $"{nameof(MasterDataSourceFormatBusinessLogic)}." +
$"{nameof(GetSourceFormatByIdWithActiveOnlyDimensionStructuresInTheTreeAsync)} " +
$"operation failed. For further info see inner exception.";
throw new MasterDataBusinessLogicSourceFormatDatabaseOperationException(msg, e);
}
}
public async Task Update_SpecifiedEntity(
string name,
string desc,
int isActive)
{
// Arrange
SourceFormat orig = _sourceFormatFaker.Generate();
SourceFormat origResult = await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.AddAsync(orig)
.ConfigureAwait(false);
SourceFormat update = new SourceFormat
{
Id = origResult.Id,
Name = name,
Desc = desc,
IsActive = isActive,
};
// Action
SourceFormat sourceFormat = await _masterDataBusinessLogic
.MasterDataSourceFormatBusinessLogic
.UpdateAsync(update)
.ConfigureAwait(false);
// Assert
sourceFormat.Id.Should().Be(origResult.Id);
sourceFormat.Name.Should().Be(update.Name);
sourceFormat.Desc.Should().Be(update.Desc);
sourceFormat.IsActive.Should().Be(update.IsActive);
}
/// <inheritdoc/>
public async Task <SourceFormat> GetSourceFormatByNameWithFullDimensionStructureTreeAsync(
SourceFormat sourceFormat)
{
// try
// {
// await _masterDataValidators.SourceFormatValidator.ValidateAndThrowAsync(
// sourceFormat,
// ruleSet: SourceFormatValidatorRulesets.GetByName)
// .ConfigureAwait(false);
//
// using (MasterDataContext ctx = new MasterDataContext(_dbContextOptions))
// {
// SourceFormat result = await ctx.SourceFormats
// .Include(i => i.DimensionStructureTreeRoot)
// .FirstOrDefaultAsync(p => p.Name.Equals(sourceFormat.Name))
// .ConfigureAwait(false);
//
// // result.DimensionStructureTreeRoot.ChildDimensionStructureTreeNodes = await GetDimensionStructureTreeAsync(
// // result.DimensionStructureTreeRoot.Id,
// // ctx)
// // .ConfigureAwait(false);
//
// return result;
// }
// }
// catch (Exception e)
// {
// string message = $"The {nameof(GetSourceFormatByNameWithFullDimensionStructureTreeAsync)} " +
// $"operation failed. See details in the inner exception.";
// throw new MasterDataBusinessLogicException(message, e);
// }
throw new NotImplementedException();
}
/// <summary>
/// Constructor with parameters
/// </summary>
/// <param name="file">name of the archive or file</param>
/// <param name="format">Format of the archive or file</param>
/// <param name="model">ViewModel for data binding</param>
public Extractor(string file, SourceFormat format, ViewModel model)
{
FileName = file;
lastError = "";
DocumentFormat = format;
embeddedFiles = new List <ExtractorItem>();
currentModel = model;
}
/// <summary>
/// Construct a reader from a stream
/// </summary>
/// <param name="stream">The stream to read from</param>
/// <param name="format">What is the format of the file, assumes PC and similar architecture</param>
public EndianAwareBinaryReader(Stream stream, SourceFormat format)
: base(stream)
{
if ((format == SourceFormat.BigEndian && BitConverter.IsLittleEndian) ||
(format == SourceFormat.LittleEndian && !BitConverter.IsLittleEndian))
{
m_shouldReverseOrder = true;
}
}
///<Summary>
/// ConvertHtmlToXps to convert html file to xps
///</Summary>
public Response ConvertHtmlToXps(string fileName, string folderName)
{
return(ProcessTask(fileName, folderName, ".xps", false, false, delegate(string inFilePath, string outPath, string zipOutFolder)
{
Aspose.Html.Rendering.Xps.XpsRenderingOptions xps_options = new Aspose.Html.Rendering.Xps.XpsRenderingOptions();
SourceFormat srcFormat = ExportHelper.GetSourceFormatByFileName(fileName);
ExportHelper helper = ExportHelper.GetHelper(srcFormat, ExportFormat.XPS);
helper.Export(inFilePath, outPath, xps_options);
}));
}
public void ThenSourceFormatIsActivePropertyIs(string key, int expectedResult)
{
Check.IsNotNull(key);
SourceFormat result = _scenarioContext[key] as SourceFormat;
Check.IsNotNull(result);
result.IsActive.Should().Be(expectedResult);
}
public void GivenThereIsASourceFormatDomainObject(Table table)
{
GivenThereIsASourceFormatDomainObjectEntity instance = table
.CreateInstance <GivenThereIsASourceFormatDomainObjectEntity>();
SourceFormat sourceFormat = _masterDataTestHelper.SourceFormatFactory
.Create(instance);
_scenarioContext.Add(instance.Key, sourceFormat);
}
/// <inheritdoc/>
public async Task <DilibHttpClientResponse <SourceFormat> > DeleteAsync(
SourceFormat tobeDeleted,
CancellationToken cancellationToken = default)
{
string url = $"{MasterDataApi.SourceFormat.BasePath}/{MasterDataApi.SourceFormat.V1.Delete}";
DilibHttpClientResponse <SourceFormat> result = await _diLibHttpClient
.DeleteAsync(url, tobeDeleted, cancellationToken)
.ConfigureAwait(false);
return(result);
}
public void ThenSourceFormatNamePropertyIs(string key, string expectedValue)
{
Check.IsNotNull(key);
Check.IsNotNull(expectedValue);
SourceFormat result = _scenarioContext[key] as SourceFormat;
Check.IsNotNull(result);
result.Name.Should().Be(expectedValue);
}
///<Summary>
/// ConvertHtmlToTiff to convert html file to tiff
///</Summary>
public Response ConvertHtmlToTiff(string fileName, string folderName)
{
return(ProcessTask(fileName, folderName, ".tiff", false, false, delegate(string inFilePath, string outPath, string zipOutFolder)
{
ImageRenderingOptions img_options = new ImageRenderingOptions();
img_options.Format = ImageFormat.Tiff;
SourceFormat srcFormat = ExportHelper.GetSourceFormatByFileName(fileName);
ExportHelper helper = ExportHelper.GetHelper(srcFormat, ExportFormat.TIFF);
helper.Export(inFilePath, outPath, img_options);
}));
}
public void GivenStoredSourceFormatDomainObjectIdValueIsSetTo(Table table)
{
GivenStoredSourceFormatDomainObjectIdValueIsSetTo instance = table
.CreateInstance <GivenStoredSourceFormatDomainObjectIdValueIsSetTo>();
SourceFormat sourceFormat = _scenarioContext[instance.Key] as SourceFormat;
sourceFormat.Id = instance.NewValue;
_scenarioContext.Remove(instance.ResultKey);
_scenarioContext.Add(instance.ResultKey, sourceFormat);
}
