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); } }
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(); }