private static ProcessingResult ValidateFinPeriods(GLBudgetEntry graph, IEnumerable <GLBudgetLineDetail> records) { ProcessingResult generalResult = new ProcessingResult(); var recordsByPeriod = records.GroupBy(record => record.FinPeriodID); foreach (var recordsByPeriodGroup in recordsByPeriod) { string finPeriodID = recordsByPeriodGroup.Key; int?[] orgnizationIDs = recordsByPeriodGroup.GroupBy(t => PXAccess.GetParentOrganizationID(t.BranchID)) .Select(g => g.Key) .ToArray(); ICollection <OrganizationFinPeriod> finPeriods = PXSelect <OrganizationFinPeriod, Where <OrganizationFinPeriod.organizationID, In <Required <OrganizationFinPeriod.organizationID> >, And <OrganizationFinPeriod.finPeriodID, Equal <Required <OrganizationFinPeriod.finPeriodID> > > > > .Select(graph, orgnizationIDs, finPeriodID) .RowCast <OrganizationFinPeriod>() .ToArray(); if (finPeriods.Count != orgnizationIDs.Length) { string[] organizationCDs = orgnizationIDs.Except(finPeriods.Select(period => period.OrganizationID)) .Select(PXAccess.GetOrganizationCD) .ToArray(); generalResult.AddErrorMessage(Messages.FinPeriodDoesNotExistForCompanies, FinPeriodIDFormattingAttribute.FormatForError(finPeriodID), organizationCDs.JoinIntoStringForMessageNoQuotes(20)); } foreach (OrganizationFinPeriod finPeriod in finPeriods) { ProcessingResult result = new ProcessingResult(); if (finPeriod.Status == FinPeriod.status.Locked) { result.AddErrorMessage(Messages.FinPeriodIsLockedInCompany, FinPeriodIDFormattingAttribute.FormatForError(finPeriod.FinPeriodID), PXAccess.GetOrganizationCD(finPeriod.OrganizationID)); } generalResult.Aggregate(result); if (generalResult.Messages.Count > 20) { return(generalResult); } } } return(generalResult); }
public void GetEmptyResultFromCache() { ResultCache sut = new ResultCache(); ProcessingResult cachedResultUser1 = sut.Get("testUser1"); sut.Set("testUser3", new ProcessingResult()); ProcessingResult cachedResultUser2 = sut.Get("testUser2"); Assert.Null(cachedResultUser1); Assert.Null(cachedResultUser2); }
private static ProcessingResult GetMemberInstances(MemberInfo member, ProcessingResult instanceResult) { if (instanceResult.IsSingleItem) { return(new ProcessingResult(true, GetValue(instanceResult.Result, member), true)); } var instances = from object item in instanceResult.GetItems() select GetValue(item, member); return(new ProcessingResult(true, instances.ToList())); }
private static void CheckForErrors(ProcessingResult result) { if (!result.Success) { // TODO: Remove this method after simplifying ProcessingEngine error handling to always throw exceptions on error. if (result.UserMessage != null) { throw new UserException(result.UserMessage, result.SystemMessage); // JsonErrorHandler will return HttpStatusCode.BadRequest. } throw new FrameworkException(result.SystemMessage); // JsonErrorHandler will return HttpStatusCode.InternalServerError. } }
public void SubjectMustHasValidContentLength() { // Arrange var note = new HmmNote { Author = _user, Description = "testing note", Subject = "", Content = "<root><time>2017-08-01</time></root>", Catalog = new NoteCatalog() }; // Act var processResult = new ProcessingResult(); var result = _validator.IsValidEntity(note, processResult); // Assert Assert.False(result); // Arrange note = new HmmNote { Author = _user, Description = "testing note", Subject = GetRandomString(1001), Content = "<root><time>2017-08-01</time></root>", Catalog = new NoteCatalog() }; // Act processResult = new ProcessingResult(); result = _validator.IsValidEntity(note, processResult); // Assert Assert.False(result); // Arrange note = new HmmNote { Author = _user, Description = "testing note", Subject = GetRandomString(15), Content = "<root><time>2017-08-01</time></root>", Catalog = new NoteCatalog() }; // Act processResult = new ProcessingResult(); result = _validator.IsValidEntity(note, processResult); // Assert Assert.True(result); }
public ProcessingResult <ICollection <ICroppedArea> > CropUserInput(Bitmap bitmapToCropIntoParts, Guid documentId, ITemplatePageDefinition definitionForCropping) { if (definitionForCropping == null) { return(ProcessingResult <ICollection <ICroppedArea> > .Failure(new PageDefinitionNotProvided())); } if (documentId == Guid.Empty) { return(ProcessingResult <ICollection <ICroppedArea> > .Failure(new MissingDocumentId())); } //Can this be more granular without downloading bitmap all over again? //Maybe parent holding bitmap and just passing it over to all children? using (bitmapToCropIntoParts) { var results = new List <ICroppedArea>(); foreach (var templateArea in definitionForCropping.DefinedAreas) { try { var croppedAreaParts = new List <OrderedBitmap>(); if (templateArea.InterestPoints == null || templateArea.InterestPoints.Count == 0) { croppedAreaParts.Add( new OrderedBitmap(0, new Crop(templateArea.AreaDimension).Apply(bitmapToCropIntoParts))); } else { foreach (var areaPart in templateArea.InterestPoints) { croppedAreaParts.Add( new OrderedBitmap(areaPart.OrderInArea, new Crop(areaPart.Dimension).Apply(bitmapToCropIntoParts))); } } results.Add(new CroppedArea(templateArea, croppedAreaParts, documentId)); } catch (UnsupportedImageFormatException) { return(ProcessingResult <ICollection <ICroppedArea> > .Failure(new UnsupportedImageFormat())); } catch (Exception ex) { ProcessingResult <ICollection <ICroppedArea> > .Failure(new UncaughtException(ex)); } } return(ProcessingResult <ICollection <ICroppedArea> > .Success(results)); } }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { var itemType = parentResult.IsDeferred() ? typeof(NodeReference) : QueryProcessingHelper.GetSourceParameterType(query); var result = RuntimeMethodInvoker.InvokeFuncCached <IEnumerable <RuntimeType1>, IEnumerable <RuntimeType1> >( Reverse, new RuntimeTypeBinding { new RuntimeType1(itemType) }, parentResult.Result); return(new ProcessingResult(true, result)); }
private static ProcessingResult LoadData(ProcessingResult result, Type dataType) { if (!result.IsSuccess) { return(ProcessingResult.Unsuccessful); } var loadedResult = result.IsSingleItem ? result.GetLoadedItem(dataType) : result.GetLoadedItems(dataType); return(new ProcessingResult(true, loadedResult, result.IsSingleItem)); }
private void ResizeBeetleSuccess(MediaDimension resizeBy, int size, ImageSaveFormat format) { ImageResizeProcessor processor = GetProcessor(resizeBy, size, format, false); processor.Init(RunInfo); ProcessingResult result = processor.Process(GetTestFile("beetle.jpg"), MatchResultType.Yes, new string[0], new FileInfo[0], ProcessInput.OriginalFile, CancellationToken.None); processor.Cleanup(); Assert.AreEqual(ProcessingResultType.Success, result.Type); Assert.AreEqual(1, result.OutputFiles.Length); }
protected virtual ProcessingResult HandleErrorThatPeriodIsClosed(IFinPeriod finPeriod) { ProcessingResult result = new ProcessingResult(); if (!CanPostToClosedPeriod()) { result.AddErrorMessage(Messages.FinPeriodIsClosedInCompany, FinPeriodIDFormattingAttribute.FormatForError(finPeriod.FinPeriodID), PXAccess.GetOrganizationCD(finPeriod.OrganizationID)); } return(result); }
public void Publish(ProcessingResult result) { try { var filePath = ResolveFilePath(result.Payload); SaveFile(filePath, result.Print()); } catch (Exception e) { _logger.LogError("Error writing result {0}:{1}", e.Message, e.StackTrace); } }
protected virtual ProcessingResult Processing(bool processActions) { using (var entry = ConcurrencyLimiter.TryEnter()) { ProcessingResult result = entry.HasEntry ? ProcessingResult.Processed : ProcessingResult.ExclusiveSkip; NullSafeSequencer.PointArg(SeqPointTypeUC.Notify, TimerProcessorSequencer.Processing, result); if (result == ProcessingResult.Processed) { ExclusiveProcessing(processActions); } return(result); } }
/// <summary> /// Generate project data for the given parameters and cache results locally. /// </summary> /// <returns>Resulting parameters hash</returns> private async Task <(string hash, FdaStatsDTO stats)> UpdateAsync(ProjectStorage storage, InventorParameters parameters, string hash, bool bForceUpdate = false) { _logger.LogInformation("Update the project"); var bucket = await _userResolver.GetBucketAsync(); var isUpdateExists = bForceUpdate ? false : await IsGenerated(bucket, storage.GetOssNames(hash)); FdaStatsDTO stats; if (isUpdateExists) { _logger.LogInformation("Detected existing outputs at OSS"); var statsNative = await bucket.DeserializeAsync <List <Statistics> >(storage.GetOssNames(hash).StatsUpdate); stats = FdaStatsDTO.CreditsOnly(statsNative); } else { Project project = storage.Project; var inputDocUrl = await bucket.CreateSignedUrlAsync(project.OSSSourceModel); UpdateData updateData = await _arranger.ForUpdateAsync(inputDocUrl, storage.Metadata.TLA, parameters); ProcessingResult result = await _fdaClient.UpdateAsync(updateData); if (!result.Success) { _logger.LogError($"Failed to update '{project.Name}' project."); throw new FdaProcessingException($"Failed to update '{project.Name}' project.", result.ReportUrl); } _logger.LogInformation("Moving files around"); // rearrange generated data according to the parameters hash // NOTE: hash might be changed if Inventor adjust them! hash = await _arranger.MoveViewablesAsync(project, storage.IsAssembly); // process statistics await bucket.UploadAsJsonAsync(storage.GetOssNames(hash).StatsUpdate, result.Stats); stats = FdaStatsDTO.All(result.Stats); } _logger.LogInformation($"Cache the project locally ({hash})"); // and now cache the generated stuff locally await storage.EnsureViewablesAsync(bucket, hash); return(hash, stats); }
public virtual ProcessingResult CanPostToPeriod(IFinPeriod finPeriod, Type fieldModuleClosed = null) { ProcessingResult result = new ProcessingResult(); if (finPeriod.Status == FinPeriod.status.Locked) { result.AddErrorMessage(Messages.FinPeriodIsLockedInCompany, FinPeriodIDFormattingAttribute.FormatForError(finPeriod.FinPeriodID), PXAccess.GetOrganizationCD(finPeriod.OrganizationID)); return(result); } if (AllowPostToUnlockedPeriodAnyway) { return(result); } if (finPeriod.Status == FinPeriod.status.Inactive) { result.AddErrorMessage(Messages.FinPeriodIsInactiveInCompany, FinPeriodIDFormattingAttribute.FormatForError(finPeriod.FinPeriodID), PXAccess.GetOrganizationCD(finPeriod.OrganizationID)); return(result); } if (finPeriod.Status == FinPeriod.status.Closed) { result = HandleErrorThatPeriodIsClosed(finPeriod); if (result.HasWarningOrError) { return(result); } } if (fieldModuleClosed != null) { PXCache cache = Graph.Caches[BqlCommand.GetItemType(fieldModuleClosed)]; bool?isClosedInModule = (bool)cache.GetValue(finPeriod, fieldModuleClosed.Name); if (isClosedInModule == true) { result = HandleErrorThatPeriodIsClosed(finPeriod); } } return(result); }
public void SingleFailure() { Mock <IProcessor> mockProcessor1 = new Mock <IProcessor>(); Mock <IProcessor> mockProcessor2 = new Mock <IProcessor>(); FileInfo file1 = GetTestFile("BasicTextFile.txt"); FileInfo file2 = GetTestFile("Lipsum.txt"); FileInfo file3 = GetTestFile("TextFileWithNewlines.txt"); FileInfo[] generatedFiles = new FileInfo[] { file2, file2, file2 }; FileInfo[] outputFiles = new FileInfo[] { file3, file3, file3 }; string[] values = new string[] { "foo", "bar", "baz" }; mockProcessor1.Setup(p => p.Init(It.IsAny <IRunInfo>())); mockProcessor1.Setup(p => p.InputFileSource).Returns(InputFileSource.ParentInput); mockProcessor1.Setup(p => p.Process(file1, It.IsAny <MatchResultType>(), values, generatedFiles, ProcessInput.GeneratedFiles, It.IsAny <CancellationToken>())) .Returns(new ProcessingResult(ProcessingResultType.Success, "Processor 1 Success", outputFiles)); mockProcessor1.Setup(p => p.ProcessAggregated(It.IsAny <CancellationToken>())); mockProcessor1.Setup(p => p.Cleanup()); mockProcessor2.Setup(p => p.Init(It.IsAny <IRunInfo>())); mockProcessor2.Setup(p => p.InputFileSource).Returns(InputFileSource.ParentInput); mockProcessor2.Setup(p => p.Process(file1, It.IsAny <MatchResultType>(), values, generatedFiles, ProcessInput.GeneratedFiles, It.IsAny <CancellationToken>())) .Returns(new ProcessingResult(ProcessingResultType.Failure, "Processor 2 Failure", new FileInfo[] { })); mockProcessor2.Setup(p => p.ProcessAggregated(It.IsAny <CancellationToken>())); mockProcessor2.Setup(p => p.Cleanup()); MultiProcessor multiProcessor = new MultiProcessor(); multiProcessor.Processors.Add(mockProcessor1.Object); multiProcessor.Processors.Add(mockProcessor2.Object); multiProcessor.Init(RunInfo); ProcessingResult result = multiProcessor.Process(file1, MatchResultType.Yes, values, generatedFiles, ProcessInput.GeneratedFiles, CancellationToken.None); multiProcessor.ProcessAggregated(CancellationToken.None); multiProcessor.Cleanup(); mockProcessor1.VerifyAll(); mockProcessor2.VerifyAll(); Assert.IsNotNull(result); Assert.AreEqual(ProcessingResultType.Failure, result.Type); Assert.AreEqual("Processor 1 Success | Processor 2 Failure", result.Message); Assert.AreEqual(3, result.OutputFiles.Length); Assert.IsTrue(result.OutputFiles.All(file => file == file3)); }
/// <summary> /// Go through all modules and check if any of them can handle the current request. /// </summary> /// <param name="context"></param> /// <returns></returns> private ProcessingResult ProcessModules(RequestContext context) { foreach (IModule module in _modules) { ProcessingResult result = module.Process(context); if (result != ProcessingResult.Continue) { _logger.Debug(module.GetType().Name + ": " + result); return(result); } } return(ProcessingResult.Continue); }
public static ProcessingResult ProcessRules(ShippingContext shippingContext, List <Rule> rules) { ProcessingResult ruleProcessingResult = new ProcessingResult(); rules.ForEach(rule => { ruleProcessingResult = rule.Func(shippingContext); shippingContext.processingResult.discount = ruleProcessingResult.discount; }); shippingContext.totalDiscount += ruleProcessingResult.discount; return(ruleProcessingResult); }
public async Task <TResult> ExecuteTransaction <TResult>(string requestId, TPartition partitionKey, Func <IHumanInterfaceConnectorMessageSession, Task <TResult> > transaction) { var transactionRecordContainer = applicationStateStore.Create(partitionKey); var outcome = await processor.Process(requestId, transactionRecordContainer, null, async (ctx, transactionContext) => { var session = new HumanInterfaceConnectorMessageSession(requestId, transactionContext, rootMessageSession, messageStore); var result = await transaction(session).ConfigureAwait(false); await transactionInProgressStore.BeginTransaction(requestId, transactionRecordContainer.UniqueIdentifier).ConfigureAwait(false); return(ProcessingResult <TResult> .Successful(result)); }); return(outcome.Value); //Duplicate check is ignored in the human interface }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { var elementType = QueryProcessingHelper.GetSourceParameterType(query); var items = parentResult.GetLoadedItems(elementType); var comparer = query.Arguments.Count > 1 ? ((ConstantExpression)query.Arguments[1]).Value : null; var result = RuntimeMethodInvoker.InvokeFuncCached <IEnumerable <RuntimeType1>, IEqualityComparer <RuntimeType1>, List <RuntimeType1> >( Distinct, new RuntimeTypeBinding { new RuntimeType1(elementType) }, items, comparer); return(new ProcessingResult(true, result)); }
public void AuthorAccountNameMustHasValidContentLength() { // Arrange var author = new Author { AccountName = "", IsActivated = true, }; // Act var processResult = new ProcessingResult(); var result = _validator.IsValidEntity(author, processResult); // Assert Assert.False(result); Assert.NotEmpty(processResult.MessageList[0].Message); // Arrange author = new Author { AccountName = GetRandomString(154), IsActivated = true, }; // Act processResult = new ProcessingResult(); result = _validator.IsValidEntity(author, processResult); // Assert Assert.True(result); Assert.Empty(processResult.MessageList); // Arrange author = new Author { AccountName = GetRandomString(500), IsActivated = true, }; // Act processResult = new ProcessingResult(); result = _validator.IsValidEntity(author, processResult); // Assert Assert.False(result); Assert.NotEmpty(processResult.MessageList[0].Message); }
public static AliceResponse CreateAliceResponse(ProcessingResult result, Session session, Func <int, int> variantSelector) { var responseArgs = GetResponseArgs(result); var response = CreateResponse(responseArgs, result.CultureInfo, variantSelector); var aliceResponse = new AliceResponse() { Response = response, Session = session, Version = "1.0" }; return(aliceResponse); }
public ProcessingResult ValidateTaxYearStructure(TaxPeriod taxPeriod) { var finPeriodWithSameStartDate = _gafRepository.FindFinPeriodWithStartDate(taxPeriod.StartDate); var finPeriodWithSameEndDate = _gafRepository.FindFinPeriodWithEndDate(taxPeriod.EndDate); if (finPeriodWithSameStartDate == null || finPeriodWithSameEndDate == null) { var result = new ProcessingResult(); result.AddErrorMessage(Messages.TheGAFFileCannotBePrepared); return(result); } return(ProcessingResult.Success); }
private static void ProcessFiles(string folderPath) { IEnumerable <string> files = Directory.EnumerateFiles(folderPath); Console.WriteLine("Processing {0} files...", files.Count()); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); ProcessingResult result = FileProcessor.ProcessFiles(files); stopwatch.Stop(); FormattedOutput(stopwatch, result); }
private void ThrowExceptionOnError(ProcessingResult processingResult) { if (!processingResult.Success) { if (processingResult.UserMessage != null) { throw new UserException(processingResult.UserMessage, processingResult.SystemMessage); } else { throw new FrameworkException(processingResult.SystemMessage); } } }
public void RunsCommandLine() { CommandLineProcessor p = new CommandLineProcessor(); p.SetParameter("CommandLine", $"copy \"{{FullName}}\" \"{CurrentTestResultsDirectoryPath}\""); p.SetParameter("WaitForTaskToFinish", true); p.Init(RunInfo); FileInfo file = GetTestFile("BasicTextFile.txt"); ProcessingResult result = p.Process(file, MatchResultType.Yes, new string[0], new FileInfo[0], ProcessInput.OriginalFile, CancellationToken.None); Assert.AreEqual(ProcessingResultType.Success, result.Type); p.Cleanup(); }
public void GetResultFromCacheAfterInitialAdd() { ResultCache sut = new ResultCache(); ProcessingResult resultUser1 = new ProcessingResult(); ProcessingResult resultUser2 = new ProcessingResult(); sut.Set("testUser1", resultUser1); sut.Set("testUser2", resultUser2); ProcessingResult cachedResultUser1 = sut.Get("testUser1"); ProcessingResult cachedResultUser2 = sut.Get("testUser2"); Assert.Equal(resultUser1, cachedResultUser1); Assert.Equal(resultUser2, cachedResultUser2); }
internal void AddResult(ProcessingResult result) { if (!result.IsSuccess) { IsSuccess = false; } if (!result.IsSingleItem) { IsSingle = false; } Result = result; }
public void GetProcessingResultFromCopyAndDeleteTempFile_Successs() { Mock <ProcessorBase> mockProcessor = new Mock <ProcessorBase>(); ProcessorBase processor = mockProcessor.Object; string tmpFile = Path.GetTempFileName(); File.WriteAllText(tmpFile, "This is the final text."); string outputPath = GetCurrentTestResultsFilePath("out.txt"); ProcessingResult result = processor.GetProcessingResultFromCopyAndDeleteTempFile( null, outputPath, tmpFile, true, true); Assert.IsFalse(File.Exists(tmpFile)); Assert.AreEqual(ProcessingResultType.Success, result.Type); }
public ProcessingResult ProcessFiles(IEnumerable <string> files) { Regex pattern = new Regex(PatternString, RegexOptions.Compiled | RegexOptions.Multiline); List <Task <ProcessingResult> > tasks = new List <Task <ProcessingResult> >(); foreach (string fileName in files) { Task <ProcessingResult> task = Task.Factory.StartNew <ProcessingResult>((arg) => { string localFileName = (string)arg; ProcessingResult localResult = new ProcessingResult(); byte[] bytes = File.ReadAllBytes(localFileName); string body = Encoding.UTF8.GetString(bytes); Match match = pattern.Match(body); while (match.Success) { localResult.Total++; if (match.Groups[2].Value == Tele2Brand) { Guid id = Guid.Parse(match.Groups[1].Value); localResult.Tele2OrderIds.Add(id); } match = match.NextMatch(); } return(localResult); }, fileName); tasks.Add(task); } Task.WaitAll(tasks.ToArray()); // Aggregate the results ProcessingResult aggregatedResult = new ProcessingResult(); foreach (var task in tasks) { aggregatedResult.Total += task.Result.Total; aggregatedResult.Tele2OrderIds.AddRange(task.Result.Tele2OrderIds); } return(aggregatedResult); }
/// <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); }
public void ProcessingCompleted(ProcessingResult result) { this.logger.Log( LogLevel.Information, "Processing completed: {0}", result.StatusMessage); }
private void ProcessTree(Item item) { Assert.ArgumentNotNull(item, "item"); var pr = new ProcessingResult() {Path = item.Paths.ContentPath, Updated = false}; if (!_processingResults.ContainsKey(item.ID)) { _processingResults.Add(item.ID, pr); } ProcessItem(item); if (RenderingModifierSettings.ProcessDescendants) { ProcessChildren(item); } }
/// <summary> /// Process result (check if it should be sent back or not) /// </summary> /// <param name="result"></param> /// <param name="e"></param> /// <returns><c>true</c> if request was processed properly.; otherwise <c>false</c>.</returns> protected virtual bool ProcessResult(ProcessingResult result, RequestEventArgs e) { if (result == ProcessingResult.Abort) { e.IsHandled = true; return true; } if (result == ProcessingResult.SendResponse) { SendResponse(e.Context, e.Request, e.Response); e.IsHandled = true; return true; } return false; }
public void AddResult(ProcessingResult result) { _results.Add(result); }