public static void Open(Window window, string[] fileExtensions, IRead<string> data)
{
var filter = FileExtensionModule.AddStar(fileExtensions);
var filename = OpenFileModule.WithFilters(window, filter);
if (filename == null) return;
data.Read(filename);
}
public static object Read(IRead read,string filename)
{
if(File.Exists(filename))
{
using (FileStream fs = new FileStream(filename, FileMode.Open))
{
return read.Read(fs);
}
}
return null;
}
private object ExecuteHandler(object command, IRead executor)
{
try
{
return executor.Read(command);
}
finally
{
_container.Release(executor);
}
}
public DefaultDeleteHandler(
Entity entity,
IRead inputReader,
IRead outputReader,
IDelete outputDeleter
) {
_entity = entity;
_inputReader = inputReader;
_outputReader = outputReader;
_outputDeleter = outputDeleter;
}
public static object Read(IRead read, Assembly assembly, string name)
{
foreach (var manifestResourceName in assembly.GetManifestResourceNames())
{
if (manifestResourceName.Contains(name))
{
return read.Read(assembly.GetManifestResourceStream(manifestResourceName));
}
}
return null;
}
public static object Read(IRead read, string value)
{
if (File.Exists(value))
{
using (FileStream stream = new FileStream(value, FileMode.Open))
{
var result = read.Read(stream);
stream.Close();
return result;
}
}
using (MemoryStream memory = new MemoryStream(Encoding.UTF8.GetBytes(value)))
{
return read.Read(memory);
}
}
public void Register(IRead reader) {
Reader = reader;
}
public IndexModel(IRead <Core.Domain.Mission> readAction, IMapper mapper)
: base(readAction, mapper)
{
}
public string ExecuteAsync(IRead fileReader, Document document)
{
Debug.Assert(document != null);
Debug.Assert(document.Statement != null);
var logo64Base = fileReader.GetImagebase64(document.Logo);
var quoteTemplate = fileReader.Read(TEMPLATE);
var serviceTemplate = fileReader.Read(SERVICE_TEMPLATE);
var materialsTemplate = fileReader.Read(MATERIAL_TEMPLATE);
var updatedTemplate1 = ApplyHeaderAsync(quoteTemplate, document.Statement, document.Customer, logo64Base);
var updatedTemplate2 = ApplySummaryAsync(updatedTemplate1, document.Statement);
var statement = document.Statement;
var servicesHtml = ApplyServices(statement.Services, serviceTemplate);
var html = updatedTemplate2;
var htmlWithServices = html.Replace(serviceTemplate, servicesHtml);
var materialsBuilder = new StringBuilder();
var services = statement.Services;
string htmlWithMaterial = null;
bool hasMaterials = false;
foreach (var service in services)
{
string materialsHtml = string.Empty;
if (service.Materials == null)
{
service.Materials = new ObservableCollection<Material>();
}
if (service.Materials.Count > 0)
{
hasMaterials = true;
string materialsTable = ApplyMaterials(service, materialsTemplate);
materialsBuilder.Append(materialsTable);
materialsHtml = materialsBuilder.ToString();
htmlWithMaterial = htmlWithServices.Replace(materialsTemplate, materialsHtml).Replace("~SERVICE_NAME~", string.Empty);
}
}
if (hasMaterials)
{
var destinationFile = string.Format("{0}{1}", Guid.NewGuid(), HtmlFile);
return fileReader.CreateFile(htmlWithMaterial, destinationFile);
}
else
{
var data = fileReader.Read(SERVICE_MATERIAL_TEMPLATE);
bool exists = htmlWithServices.Contains(data);
string noMaterialsHtml = htmlWithServices.Replace(data, string.Empty);
var destinationFile = string.Format("{0}{1}", Guid.NewGuid(), HtmlFile);
return fileReader.CreateFile(noMaterialsHtml, destinationFile);
}
}
public GetAllQuestionnairesHandler(IRead <Questionnaire> questionnaireReader, IMapper mapper)
{
_questionnaireReader = questionnaireReader;
_mapper = mapper;
}
public GenericController(IRead <TEntity> entityReader, ISave <TEntity> entitySaver, IDelete <TEntity> entityDeleter)
{
reader = entityReader;
saver = entitySaver;
deleter = entityDeleter;
}
public UpdateAnswerHandler(IHub hub, ISave <Answer> answerSaver, IRead <Answer> answerReader)
{
_hub = hub;
_answerReader = answerReader;
_answerSaver = answerSaver;
}
/// <summary> /// Reads until the <paramref name="elements"/> is filled. /// </summary> /// <param name="collection">This collection.</param> /// <param name="elements">The <see cref="Array"/> of <typeparamref name="TElement"/> to fill.</param> public static void Read <TElement>(this IRead <TElement?> collection, TElement?[]?elements) => Read(collection, elements.AsSpan());
public Person(IRead newRead)
{
action = newRead;
}
public void Register(IRead reader)
{
_pipeline.Register(reader);
}
public Handler(IMediator mediator, IWrite write, IRead read)
{
_mediator = mediator;
_write = write;
_read = read;
}
public OrderController(IRead <Order> orderReader, ISave <Order> orderSaver, IDelete <Order> orderDeleter)
{
reader = orderReader;
saver = orderSaver;
deleter = orderDeleter;
}
public BaseDetailsModel(IRead <TModel> readAction, IMapper mapper)
{
_readAction = readAction;
_mapper = mapper;
}
public OrderController(IRead <Order> reader, ISave <Order> saver, IDelete <Order> deleter)
{
this.reader = reader;
this.saver = saver;
this.deleter = deleter;
}
public GetAnswersByUserIdHandler(IRead <Answer> answerReader, IMapper mapper)
{
_answerReader = answerReader;
_mapper = mapper;
}
public Serializer(IRead read, IWrite write)
{
_read = read;
_write = write;
}
public UpdateOptionHandler(IHub hub, ISave <Option> optionSaver, IRead <Option> optionReader)
{
_hub = hub;
_optionSaver = optionSaver;
_optionReader = optionReader;
}
public OrderController(IRead<Order> orderReader, ISave<Order> orderSaver, IDelete<Order> orderDeleter)
{
reader = orderReader;
saver = orderSaver;
deleter = orderDeleter;
}
public ReadLogger(IRead <Card> reader, ILogger <ReadLogger <Card> > logger)
{
component = reader;
log = logger;
}
public Engine(IWrite fileWriter, IRead consoleReader, IWrite consoleWriter)
{
this.fileWriter = fileWriter;
this.consoleWriter = consoleWriter;
this.reader = consoleReader;
}
public MonsterController(IRead <Monster> monsterReader, IWrite <Monster> monsterSaver, ILogger <MonsterController> logger)
{
_monsterReader = monsterReader;
_monsterWriter = monsterSaver;
_logger = logger;
}
/// <summary>
/// Reads until the <paramref name="elements"/> is filled.
/// </summary>
/// <param name="collection">This collection.</param>
/// <param name="elements">The <see cref="Memory{T}"/> of <typeparamref name="TElement"/> to fill.</param>
public static void Read <TElement>(this IRead <TElement?> collection, Memory <TElement?> elements) => Read(collection, elements.Span);
public CachedReadRepository(IRead <T, TId> read, ICacheManager cacheManager)
{
_read = read;
_cacheManager = cacheManager;
}
public RecipeUpdateCommandValidator(IRead <Recipe, Guid> read)
{
RuleFor(x => x.Id).MustAsync((id, ct) => read.AnyAsync(id));
RuleFor(x => x.Name).NotEmpty();
}
public GetQuestionnaireByIdHandler(IRead <Questionnaire> questionnaireReader)
{
_questionnaireReader = questionnaireReader;
}
public ReadCache(IRead <Card> reader)
{
component = reader;
oneCache = new Dictionary <string, Card>();
}
public BaseIndexModel(IRead <TModel> readAction, IMapper mapper)
{
_readAction = readAction;
_mapper = mapper;
}
public ItemController(IRead <Item> orderReader, ISave <Item> orderSaver, IDelete <Item> orderDeleter)
{
reader = orderReader;
saver = orderSaver;
deleter = orderDeleter;
}
private void EnsureGetDest(ref IRead<IZone, IPerson> getDest, IPerson reference)
{
if ( getDest == null )
{
lock ( this )
{
Thread.MemoryBarrier();
if ( getDest == null )
{
getDest = UniversalRead<IZone>.CreateReader( reference, this.LookUpString );
Thread.MemoryBarrier();
}
}
}
}
public DeleteModel(
IRead <Core.Domain.Mission> readAction,
IDelete <Core.Domain.Mission> deleteAction,
IMapper mapper) : base(readAction, deleteAction, mapper)
{
}
public ItemController(IRead <Item> itemReader, ISave <Item> itemSaver, IDelete <Item> itemDeleter)
{
reader = itemReader;
saver = itemSaver;
deleter = itemDeleter;
}
void OnRequestFileReaderResponse(object obj) => _fileReader = obj as IRead;
public DetailsModel(IRead <Core.Domain.LogType> readAction, IMapper mapper) : base(readAction, mapper)
{
}
public SqlInputBatchReader(InputContext input, IRead reader) {
_input = input;
_reader = reader;
_fieldsReader = new SqlEntityMatchingFieldsReader(input);
}
public EditModel(
IRead <Core.Domain.LogType> readAction,
IUpdate <Core.Domain.LogType> updateAction,
IMapper mapper) : base(readAction, updateAction, mapper)
{
}
public static object Read(IRead read, Type type, string name) => Read(read, type.Assembly, name);
public ReadCaching(IRead <TEntity> decorated)
{
this.decorated = decorated;
}
public void Register(IRead reader) {
_pipeline.Register(reader);
}
public GenericController(IRead <TEntity> reader, ISave <TEntity> saver, IDelete <TEntity> deleter)
{
this.reader = reader;
this.saver = saver;
this.deleter = deleter;
}
