private static ProcessingResult ProcessSendMail(Services services, ProcessingArgs args)
{
var email = args.CommandData as string;
if (string.IsNullOrEmpty(email))
{
email = services.Storage.ReadUserMail(args.UserId);
if (string.IsNullOrEmpty(email))
{
return(ProcessingResultType.RequestedMail);
}
}
else
{
services.Storage.SetUserMail(args.UserId, email);
}
var entries = services.Storage.ReadAllEntries(args.UserId).ToLogic();
if (entries.Length < 1)
{
return(new EmptyEntryListError());
}
services.EmailService.SendListAsync(email, entries);
return(new ProcessingResult(ProcessingResultType.MailSent, email));
}
private void OnProcessingFile(ProcessingArgs e)
{
if (ProcessingFile != null)
{
ProcessingFile(this, e);
}
}
private void OnProcessingFile(ProcessingArgs e)
{
if (ProcessingFile != null)
{
ProcessingFile(this, e);
}
}
public override Dictionary <string, IArgument> ToWorkItemArgs(ProcessingArgs data)
{
var args = base.ToWorkItemArgs(data); // includes only first output arg
args.Add(MessagesParamName, new XrefTreeArgument {
Verb = Verb.Put, Url = data.AdoptMessagesUrl, Optional = false
});
return(args);
}
private static ProcessingResult ProcessAddMail(Services services, ProcessingArgs args)
{
if (!(args.CommandData is string email))
{
return(new UnexpectedNullOrEmptyStringException(nameof(email)));
}
services.Storage.SetUserMail(args.UserId, email);
return(new ProcessingResult(ProcessingResultType.MailAdded, email));
}
internal async Task <ProcessingResult> GenerateDrawing(ProcessingArgs data)
{
ProcessingResult result = await _updateDrawingsWork.ProcessAsync(data);
if (!result.Success)
{
result.ErrorMessage = "Failed to update drawing file(s)";
}
return(result);
}
private static ProcessingResult ProcessDelete(Services services, ProcessingArgs args)
{
if (!(args.CommandData is ParsedEntry parsedEntry))
{
return(new UnexpectedTypeException(args.CommandData, typeof(ParsedEntry)));
}
var entry = ConvertToEntry(parsedEntry);
return(SubtractMaterial(services.Storage, args.UserId, entry));
}
internal async Task <ProcessingResult> GenerateRfa(ProcessingArgs rfaData)
{
ProcessingResult rfaResult = await _rfaWork.ProcessAsync(rfaData);
if (!rfaResult.Success)
{
rfaResult.ErrorMessage = "Failed to generate RFA file";
}
return(rfaResult);
}
private static ProcessingResult ProcessDeleteMail(Services services, ProcessingArgs args)
{
var email = services.Storage.ReadUserMail(args.UserId);
if (string.IsNullOrEmpty(email))
{
return(new MailIsEmptyError());
}
services.Storage.DeleteUserMail(args.UserId);
return(new ProcessingResult(ProcessingResultType.MailDeleted, email));
}
public override Dictionary <string, IArgument> ToWorkItemArgs(ProcessingArgs data)
{
var workItemArgs = base.ToWorkItemArgs(data);
DrawingPdfData projectData = data as DrawingPdfData;
workItemArgs.Add(DrawingParameter, new StringArgument {
Value = projectData.DrawingToGenerate
});
return(workItemArgs);
}
public override Dictionary <string, IArgument> ToWorkItemArgs(ProcessingArgs data)
{
var args = base.ToWorkItemArgs(data);
args.Add(OutputModelIAMParameterName, new XrefTreeArgument {
Verb = Verb.Put, Url = data.OutputIAMModelUrl, Optional = true
});
args.Add(OutputModelIPTParameterName, new XrefTreeArgument {
Verb = Verb.Put, Url = data.OutputIPTModelUrl, Optional = true
});
return(args);
}
private static ProcessingResult ProcessMore(Services services, ProcessingArgs args)
{
if (!(args.CommandData is ParsedEntry commandEntry))
{
return(new ProcessingResult(ProcessingResultType.Error));
}
ProcessingResultType effectiveStateType;
if (args.State.Type == ProcessingResultType.Added ||
args.State.Type == ProcessingResultType.Deleted)
{
effectiveStateType = args.State.Type;
if (!(args.State.Data is Entry stateEntry))
{
return(new ProcessingResult(ProcessingResultType.Error));
}
if (commandEntry.Name is null)
{
commandEntry.Name = stateEntry.Name;
}
if (commandEntry.Unit is null)
{
commandEntry.Unit = stateEntry.UnitOfMeasure;
}
}
else
{
effectiveStateType = ProcessingResultType.Added;
}
var entry = ConvertToEntry(commandEntry);
if (entry.Name == null)
{
return(new ProcessingResult(ProcessingResultType.Error));
}
switch (effectiveStateType)
{
case ProcessingResultType.Added:
return(AddMaterial(services.Storage, args.UserId, entry));
case ProcessingResultType.Deleted:
return(SubtractMaterial(services.Storage, args.UserId, entry));
default:
return(ProcessingResultType.Error);
}
}
public virtual Dictionary <string, IArgument> ToWorkItemArgs(ProcessingArgs data)
{
var args = new Dictionary <string, IArgument>();
AddInputArgs(args, data);
if (HasOutput)
{
AddOutputArgs(args, data);
}
return(args);
}
/// <summary>
/// Generate RFA (or take it from cache).
/// </summary>
public async Task GenerateRfaAsync(string projectName, string hash)
{
_logger.LogInformation($"Generating RFA for hash {hash}");
ProjectStorage storage = await _userResolver.GetProjectStorageAsync(projectName);
Project project = storage.Project;
//// *********************************************
//// temporary fail *********************************************
//_logger.LogError($"Failed to generate SAT file");
//throw new FdaProcessingException($"Failed to generate SAT file", "https://localhost:5000/#");
//// *********************************************
var ossNameProvider = project.OssNameProvider(hash);
var bucket = await _userResolver.GetBucketAsync();
// check if RFA file is already generated
try
{
// TODO: this might be ineffective as some "get details" API call
await bucket.CreateSignedUrlAsync(ossNameProvider.Rfa);
return;
}
catch (ApiException e) when(e.ErrorCode == StatusCodes.Status404NotFound)
{
// the file does not exist, so just swallow
}
// OK, nothing in cache - generate it now
var inputDocUrl = await bucket.CreateSignedUrlAsync(ossNameProvider.GetCurrentModel(storage.IsAssembly));
ProcessingArgs satData = await _arranger.ForSatAsync(inputDocUrl, storage.Metadata.TLA);
ProcessingArgs rfaData = await _arranger.ForRfaAsync(satData.SatUrl);
ProcessingResult result = await _fdaClient.GenerateRfa(satData, rfaData);
if (!result.Success)
{
_logger.LogError($"{result.ErrorMessage} for project {project.Name} and hash {hash}");
throw new FdaProcessingException($"{result.ErrorMessage} for project {project.Name} and hash {hash}", result.ReportUrl);
}
await _arranger.MoveRfaAsync(project, hash);
}
/// <summary>
/// Add input and output arguments for the work item.
/// </summary>
public virtual Dictionary <string, IArgument> ToWorkItemArgs(ProcessingArgs data)
{
var args = new Dictionary <string, IArgument>();
AddInputArgs(args, data);
if (HasOutput)
{
args.Add(OutputParameterName, new XrefTreeArgument {
Verb = Verb.Put, Url = OutputUrl(data), Optional = IsOutputOptional
});
}
return(args);
}
private static ProcessingResult ProcessAccept(Services services, ProcessingArgs args)
{
switch (args.State.Type)
{
case ProcessingResultType.ClearRequested:
services.Storage.DeleteAllEntries(args.UserId);
return(new ProcessingResult(ProcessingResultType.Cleared));
case ProcessingResultType.MailAdded:
return(ProcessSendMail(services, args));
default:
return(new ProcessingResult(ProcessingResultType.Error));
}
}
public async Task Should_Process_Steps_In_Sequence()
{
//Arrange
var expected = 11;
var builder = new ProcessBuilder <ProcessingArgs>()
.Add(context => { context.Result = 10; return(Task.CompletedTask); })
.Add(context => { context.Result += 1; return(Task.CompletedTask); });
var process = builder.Build();
var args = new ProcessingArgs();
//Act
await process.Invoke(args);
//Assert
args.Result.Should().Be(expected);
}
protected virtual void AddInputArgs(IDictionary <string, IArgument> args, ProcessingArgs data)
{
if (data.IsAssembly)
{
args.Add(InputDocParameterName, new XrefTreeArgument {
PathInZip = data.TLA, LocalName = FolderToBeZippedName, Url = data.InputDocUrl
});
}
else
{
args.Add(InputDocParameterName, new XrefTreeArgument {
Url = data.InputDocUrl, LocalName = IptName
});
}
}
/// <summary>
/// Generate RFA (or take it from cache).
/// </summary>
public async Task <FdaStatsDTO> GenerateRfaAsync(string projectName, string hash)
{
_logger.LogInformation($"Generating RFA for hash {hash}");
ProjectStorage storage = await _userResolver.GetProjectStorageAsync(projectName);
Project project = storage.Project;
//// *********************************************
//// temporary fail *********************************************
//_logger.LogError($"Failed to generate SAT file");
//throw new FdaProcessingException($"Failed to generate SAT file", "https://localhost:5000/#");
//// *********************************************
var ossNames = project.OssNameProvider(hash);
var bucket = await _userResolver.GetBucketAsync();
// check if RFA file is already generated
if (await bucket.ObjectExistsAsync(ossNames.Rfa))
{
var stats = await bucket.DeserializeAsync <Statistics[]>(ossNames.StatsRFA);
return(FdaStatsDTO.CreditsOnly(stats));
}
// OK, nothing in cache - generate it now
var inputDocUrl = await bucket.CreateSignedUrlAsync(ossNames.GetCurrentModel(storage.IsAssembly));
ProcessingArgs satData = await _arranger.ForSatAsync(inputDocUrl, storage.Metadata.TLA);
ProcessingArgs rfaData = await _arranger.ForRfaAsync(satData.SatUrl);
ProcessingResult result = await _fdaClient.GenerateRfa(satData, rfaData);
if (!result.Success)
{
_logger.LogError($"{result.ErrorMessage} for project {project.Name} and hash {hash}");
throw new FdaProcessingException($"{result.ErrorMessage} for project {project.Name} and hash {hash}", result.ReportUrl);
}
await _arranger.MoveRfaAsync(project, hash);
await bucket.UploadAsJsonAsync(ossNames.StatsRFA, result.Stats);
return(FdaStatsDTO.All(result.Stats));
}
public async Task <int?> ProcessAsync()
{
if (Processing?.GetInvocationList() is Delegate[] processors)
{
var args = new ProcessingArgs();
foreach (Func <ProcessingArgs, Task> processor in processors)
{
await processor(args);
}
return(args.Result);
}
else
{
return(null);
}
}
private static ProcessingResult ProcessCancel(Services services, ProcessingArgs args)
{
var state = args.State;
switch (state.Type)
{
case ProcessingResultType.Added:
{
if (!(state.Data is Entry stateEntry))
{
return(new UnexpectedTypeException(state.Data, typeof(Entry)));
}
var result = SubtractMaterial(services.Storage, args.UserId, stateEntry);
if (result.Type != ProcessingResultType.Deleted)
{
return(result);
}
return(new ProcessingResult(ProcessingResultType.AddCanceled, stateEntry));
}
case ProcessingResultType.Deleted:
{
if (!(state.Data is Entry stateEntry))
{
return(new UnexpectedTypeException(state.Data, typeof(Entry)));
}
var result = AddMaterial(services.Storage, args.UserId, stateEntry);
if (result.Type != ProcessingResultType.Added)
{
return(result);
}
return(new ProcessingResult(ProcessingResultType.DeleteCanceled, stateEntry));
}
default:
return(ProcessingResultType.Error);
}
}
internal async Task <ProcessingResult> GenerateRfa(ProcessingArgs satData, ProcessingArgs rfaData)
{
ProcessingResult satResult = await _satWork.ProcessAsync(satData);
if (!satResult.Success)
{
satResult.ErrorMessage = "Failed to generate SAT file";
return(satResult);
}
ProcessingResult rfaResult = await _rfaWork.ProcessAsync(rfaData);
if (!rfaResult.Success)
{
rfaResult.ErrorMessage = "Failed to generate RFA file";
}
rfaResult.Stats.AddRange(satResult.Stats);
return(rfaResult);
}
public override Dictionary <string, IArgument> ToWorkItemArgs(ProcessingArgs data)
{
var workItemArgs = base.ToWorkItemArgs(data);
UpdateData projectData = data as UpdateData;
if (projectData.InputParamsUrl != null) // TODO: use generics
{
workItemArgs.Add(InventorParameters, new XrefTreeArgument {
Url = projectData.InputParamsUrl
});
workItemArgs.Add(OutputModelIAMParameterName, new XrefTreeArgument {
Verb = Verb.Put, Url = data.OutputIAMModelUrl, Optional = true
});
workItemArgs.Add(OutputModelIPTParameterName, new XrefTreeArgument {
Verb = Verb.Put, Url = data.OutputIPTModelUrl, Optional = true
});
}
return(workItemArgs);
}
public async Task Should_Process_Steps_In_Sequence()
{
//Arrange
var expected = 11;
var builder = new ProcessBuilder()
.AddStep(context => context.Result = 10)
.AddStep(async(context, next) => {
//do something before
//pass context down stream
await next(context);
//do something after;
})
.AddStep(context => { context.Result += 1; return(Task.CompletedTask); });
var process = builder.Build();
var args = new ProcessingArgs();
//Act
await process.Invoke(args);
//Assert
args.Result.Should().Be(expected);
}
/// <summary>
/// Generate Drawing zip with folder structure (or take it from cache).
/// </summary>
public async Task <(FdaStatsDTO stats, string reportUrl)> GenerateDrawingAsync(string projectName, string hash)
{
_logger.LogInformation($"Generating Drawing for hash {hash}");
ProjectStorage storage = await _userResolver.GetProjectStorageAsync(projectName);
Project project = storage.Project;
var ossNames = project.OssNameProvider(hash);
var bucket = await _userResolver.GetBucketAsync();
// check if Drawing file is already generated
if (await bucket.ObjectExistsAsync(ossNames.Drawing))
{
var stats = await bucket.DeserializeAsync <Statistics[]>(ossNames.StatsDrawings);
return(FdaStatsDTO.CreditsOnly(stats), null);
}
// OK, nothing in cache - generate it now
var inputDocUrl = await bucket.CreateSignedUrlAsync(ossNames.GetCurrentModel(storage.IsAssembly));
ProcessingArgs drawingData = await _arranger.ForDrawingAsync(inputDocUrl, storage.Metadata.TLA);
ProcessingResult result = await _fdaClient.GenerateDrawing(drawingData);
if (!result.Success)
{
_logger.LogError($"{result.ErrorMessage} for project {project.Name} and hash {hash}");
throw new FdaProcessingException($"{result.ErrorMessage} for project {project.Name} and hash {hash}", result.ReportUrl);
}
await _arranger.MoveDrawingAsync(project, hash);
await bucket.UploadAsJsonAsync(ossNames.StatsDrawings, result.Stats);
return(FdaStatsDTO.All(result.Stats), result.ReportUrl);
}
public ProcessingResult ProcessInput(string userId, UserInput input)
{
ParsedCommand command = _services.Parser.ParseInput(input);
if (!_commandProcessingMethods.ContainsKey(command.Type))
{
return(new ProcessingResult(new KeyNotFoundException()));
}
var args = new ProcessingArgs
{
UserId = userId,
CommandData = command.Data,
State = _services.ResultCache.Get(userId)
};
var result = _commandProcessingMethods[command.Type](_services, args);
result.CultureInfo = input.CultureInfo;
_services.ResultCache.Set(userId, result);
return(result);
}
protected override string OutputUrl(ProcessingArgs projectData) => projectData.RfaUrl;
public async Task <bool> ExportDrawingViewablesAsync(string projectName, string hash)
{
_logger.LogInformation($"Generating drawing viewables for hash {hash}");
ProjectStorage storage = await _userResolver.GetProjectStorageAsync(projectName);
Project project = storage.Project;
var ossNameProvider = project.OssNameProvider(hash);
bool generated = false;
ApiResponse <dynamic> ossObjectResponse = null;
var bucket = await _userResolver.GetBucketAsync();
// check if Drawing viewables file is already generated
try
{
ossObjectResponse = await bucket.GetObjectAsync(ossNameProvider.DrawingViewables);
if (ossObjectResponse != null)
{
using (Stream objectStream = ossObjectResponse.Data)
{
// zero length means that there is nothing to generate, but processed and do not continue
generated = objectStream.Length > 0;
}
}
return(generated);
}
catch (ApiException e) when(e.ErrorCode == StatusCodes.Status404NotFound)
{
// the file does not exist, so just swallow
}
// OK, nothing in cache - generate it now
var inputDocUrl = await bucket.CreateSignedUrlAsync(ossNameProvider.GetCurrentModel(storage.IsAssembly));
ProcessingArgs drawingData = await _arranger.ForDrawingViewablesAsync(inputDocUrl, storage.Metadata.TLA);
ProcessingResult result = await _fdaClient.ExportDrawingAsync(drawingData);
if (!result.Success)
{
_logger.LogError($"{result.ErrorMessage} for project {project.Name} and hash {hash}");
throw new FdaProcessingException($"{result.ErrorMessage} for project {project.Name} and hash {hash}", result.ReportUrl);
}
// check if Drawing viewables file is generated
try
{
await bucket.CreateSignedUrlAsync(ossNameProvider.DrawingViewables);
generated = true;
}
catch (ApiException e) when(e.ErrorCode == StatusCodes.Status404NotFound)
{
// the file does not exist after generating drawing, so just mark with zero length that we already processed it
await bucket.UploadObjectAsync(ossNameProvider.DrawingViewables, new MemoryStream(0));
}
await _arranger.MoveDrawingViewablesAsync(project, hash);
return(generated);
}
/// <summary>
/// Handler for event in FileSplitWorker, Process in execution
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
static void fs_splitProcess(object sender, ProcessingArgs args)
{
if (lastFile != args.FileName) {
lastFile = args.FileName;
Console.WriteLine("Writing " + lastFile);
}
}
public async Task <(FdaStatsDTO stats, int drawingIdx, string reportUrl)> ExportDrawingPdfAsync(string projectName, string hash, string drawingKey)
{
_logger.LogInformation($"Getting drawing pdf for hash {hash}");
ProjectStorage storage = await _userResolver.GetProjectStorageAsync(projectName);
Project project = storage.Project;
var ossNames = project.OssNameProvider(hash);
var ossAttributes = project.OssAttributes;
// get drawing index from drawing specified
var bucket = await _userResolver.GetBucketAsync();
var localAttributes = project.LocalAttributes;
// read cached drawingsList
var drawings = Json.DeserializeFile <List <string> >(localAttributes.DrawingsList);
int index = drawings.IndexOf(drawingKey);
var drawingIdx = index >= 0 ? index : 0;
// check if Drawing viewables file is already generated
try
{
bool generated = false;
ApiResponse <dynamic> ossObjectResponse = await bucket.GetObjectAsync(ossNames.DrawingPdf(drawingIdx));
if (ossObjectResponse != null)
{
await using Stream objectStream = ossObjectResponse.Data;
// zero length means that there is nothing to generate, but processed and do not continue
generated = objectStream.Length > 0;
}
if (generated)
{
var nativeStats = await bucket.DeserializeAsync <List <Statistics> >(ossNames.StatsDrawingPDF(drawingIdx));
return(FdaStatsDTO.CreditsOnly(nativeStats), drawingIdx, null);
}
else
{
return(null, drawingIdx, null);
}
}
catch (ApiException e) when(e.ErrorCode == StatusCodes.Status404NotFound)
{
// the file does not exist, so just swallow
}
_logger.LogInformation($"Drawing PDF for hash {hash}: generating");
// OK, nothing in cache - generate it now
var inputDocUrl = await bucket.CreateSignedUrlAsync(ossNames.GetCurrentModel(storage.IsAssembly));
ProcessingArgs drawingData = await _arranger.ForDrawingPdfAsync(inputDocUrl, drawingKey, storage.Metadata.TLA);
ProcessingResult result = await _fdaClient.ExportDrawingAsync(drawingData);
if (!result.Success)
{
_logger.LogError($"{result.ErrorMessage} for project {project.Name} and hash {hash}");
throw new FdaProcessingException($"{result.ErrorMessage} for project {project.Name} and hash {hash}", result.ReportUrl);
}
// move to the right place
await _arranger.MoveDrawingPdfAsync(project, drawingIdx, hash);
// check if Drawing PDF file is generated
try
{
await bucket.CreateSignedUrlAsync(ossNames.DrawingPdf(drawingIdx));
// handle statistics
await bucket.UploadAsJsonAsync(ossNames.StatsDrawingPDF(drawingIdx), result.Stats);
_logger.LogInformation($"Drawing PDF for hash {hash} is generated");
return(FdaStatsDTO.All(result.Stats), drawingIdx, result.ReportUrl);
}
catch (ApiException e) when(e.ErrorCode == StatusCodes.Status404NotFound)
{
// the file does not exist after generating drawing, so just mark with zero length that we already processed it
await bucket.UploadObjectAsync(ossNames.DrawingPdf(drawingIdx), new MemoryStream(0));
_logger.LogError($"Drawing PDF for hash {hash} is NOT generated");
return(null, drawingIdx, result.ReportUrl);
}
}
protected override string OutputUrl(ProcessingArgs projectData) => projectData.DrawingPdfUrl;
protected override void AddInputArgs(IDictionary <string, IArgument> args, ProcessingArgs data)
{
args.Add(InputDocParameterName, new XrefTreeArgument {
Url = data.InputDocUrl, LocalName = "Input.sat"
});
}
/// <summary>
/// Event launched when Split is in process
/// </summary>
/// <param name="sender">spliter object</param>
/// <param name="args">Paramaters of actual split</param>
void fileSplitter_splitProcess(object sender, ProcessingArgs args)
{
lbSplitInfo.Text = String.Format(Properties.Resources.SPLITTING_FILE, args.FileName);
if (fileSplitter.OperationMode != SplitUnit.Lines) {
progressBarFiles.Style = ProgressBarStyle.Continuous;
int percPart = Convert.ToInt32((args.Part * 100) / args.Parts);
if (percPart < progressBarFiles.Maximum) {
progressBarFiles.Value = percPart;
} else {
progressBarFiles.Value = progressBarFiles.Maximum;
}
} else {
progressBarFiles.Style = ProgressBarStyle.Marquee;
}
int percSize = Convert.ToInt32((args.PartSizeWritten * 100) / args.PartSize);
if (percSize < progressBarFileSize.Maximum) {
progressBarFileSize.Value = percSize;
}else{
progressBarFileSize.Value = progressBarFileSize.Maximum;
}
Application.DoEvents();
}
