public Builder Result(ResultContext resultContext = ResultContext.Class, string name = null) { ComparerResult comparerResult = new ComparerResult(resultContext, name); _comparerResult.AddComparerResult(comparerResult); return(new Builder(this, comparerResult)); }
public override Tree VisitFuncDeclaration(FuncDeclarationContext context) { String name = context.name.Text; ResultContext resultContext = context.result(); IList <FormalParameterContext> parameterContexts = context._params; bool isPrivate = context.isPrivate; TypeContext resType = resultContext.type(); TypeTree type; if (resType != null) { type = (TypeTree)VisitType(resType); } else { //void IToken voidToken = resultContext.Start; int len = voidToken.StopIndex - voidToken.StartIndex; type = new PrimitiveTypeNode(voidToken.Line, voidToken.Column, voidToken.Line, voidToken.Column + len, TypeTag.VOID); } VariableDeclaration[] parameters = new VariableDeclaration[parameterContexts.Count]; for (int i = 0; i < parameterContexts.Count; i++) { parameters[i] = (VariableDeclaration)VisitFormalParameter(parameterContexts[i]); } Block block = (Block)VisitBlock(context.funcBody().block()); return(new FuncDef(type.beginLine, type.beginCol, block.endLine, block.endCol, name, type, parameters, block, isPrivate)); }
public AgentLiveController(AgentCore agentSimulator, ProductionDomainContext context, ResultContext resultCtx, IMessageHub messageHub) { _agentSimulator = agentSimulator; _resultCtx = resultCtx; _context = context; _messageHub = messageHub; }
public static async Task <TResult> Result <TResult>(this Task <ResultContext <TResult> > result) where TResult : class { ResultContext <TResult> resultContext = await result.ConfigureAwait(false); return(resultContext.Result); }
public DataTable GetResultData() { using (var db = new ResultContext()) { DataTable dt = new DataTable("Calculations"); var query = from b in db.Calculations orderby b.CalculationId select b; List <CalculationResult> list = query.ToList(); var props = typeof(CalculationResult).GetProperties(); dt.Columns.AddRange(props.Select(p => new DataColumn(p.Name, p.PropertyType)).ToArray()); if (list.Count() > 0) { for (int i = 0; i < list.Count(); i++) { ArrayList tempList = new ArrayList(); foreach (PropertyInfo pi in props) { object obj = pi.GetValue(list.ElementAt(i), null); tempList.Add(obj); } object[] array = tempList.ToArray(); dt.LoadDataRow(array, true); } } return(dt); } }
public SimulationTimelineViewComponent(ProductionDomainContext context, ResultContext resultContext) { _context = context; _resultContext = resultContext; _today = DateTime.Now.GetEpochMilliseconds(); _ganttContext = new GanttContext(); }
public async Task GetLastResultForDiffAsync_includes_differences() { // Arrange var expectedResult = new DiffResult { Id = Guid.NewGuid(), Differences = new InputDifference[] { new InputDifference(1, 2), new InputDifference(5, 6), new InputDifference(12, 4) } }; var options = new DbContextOptionsBuilder <ResultContext>() .UseInMemoryDatabase("resultsDb_notEmpty") .Options; var context = new ResultContext(options); var repository = new DiffResultsRepository(context); context.DiffResults.Add(expectedResult); context.SaveChanges(); // Act var result = await repository.GetLastResultForDiffAsync(expectedResult.DiffId); // Assert Assert.NotEmpty(result.Differences); Assert.All(result.Differences, diff => expectedResult.Differences.Contains(diff)); }
public CollectionMaterializationContext(object parent, object collection, object[] parentIdentifier, object[] outerIdentifier) { Parent = parent; Collection = collection; ParentIdentifier = parentIdentifier; OuterIdentifier = outerIdentifier; ResultContext = new ResultContext(); }
public Task Send(ResultContext <CheckInventory, CheckInventoryResult> context, IPipe <ResultContext <CheckInventory, CheckInventoryResult> > next) { _cache.Set(context.Result); Console.WriteLine("Cached Result: {0}", context.Request.ItemNumber); return(next.Send(context)); }
public void AggreteResults() { var _resultContext = ResultContext.GetContext(remoteResultCtxString); var aggregator = new ResultAggregator(_resultContext); aggregator.BuildResults(1); }
public ComparerResult(ResultContext resultContext, string name) { _resultContext = resultContext; _name = name; _changedProperties = new List <Changed <string> >(); _changedFlags = new List <Changed <bool> >(); _addedItems = new List <AddedOrRemoved>(); _removedItems = new List <AddedOrRemoved>(); _comparerResults = new List <IComparerResult>(); }
public ComparerResult(ResultContext resultContext, string name) { _resultContext = resultContext; _name = name; _changedProperties = new List<Changed<string>>(); _changedFlags = new List<Changed<bool>>(); _addedItems = new List<AddedOrRemoved>(); _removedItems = new List<AddedOrRemoved>(); _comparerResults = new List<IComparerResult>(); }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public SplitQueryCollectionContext( object?parent, object?collection, object[] parentIdentifier) { Parent = parent; Collection = collection; ParentIdentifier = parentIdentifier; ResultContext = new ResultContext(); }
public AddedOrRemoved(ResultContext resultContext, string itemName, Severity severity) : base(severity) { if (string.IsNullOrEmpty(itemName)) { throw new ArgumentException("Value is null or empty", "itemName"); } _itemName = itemName; _resultContext = resultContext; }
private void LogToDB(Collector agent, bool writeToDatabase) { if (agent.saveToDB.Value && writeToDatabase) { using (var ctx = ResultContext.GetContext(resultCon: agent.Config.GetOption <DBConnectionString>().Value)) { ctx.Kpis.AddRange(entities: StockValuesOverTime); ctx.SaveChanges(); ctx.Dispose(); } } }
public void CalculationResultDbInsertion(double firstOperand, string operatorSymbol, double secondOperand, double result) { using (var dbContext = new ResultContext()) { var calculation = new CalculationResult() { FirstOperand = firstOperand, OperatorSymble = operatorSymbol, SecondOperand = secondOperand, Result = result }; dbContext.Calculations.Add(calculation); dbContext.SaveChanges(); } }
private void WriteToDB(Collector agent, bool writeResultsToDB) { if (agent.saveToDB.Value && writeResultsToDB) { using (var ctx = ResultContext.GetContext(resultCon: agent.Config.GetOption <DBConnectionString>().Value)) { ctx.SimulationOrders.AddRange(entities: simulationOrders); ctx.SaveChanges(); ctx.Dispose(); } } }
public void CheckOrganizationDegreeFromResults() { var simNumber = 9; var dbContext = MasterDBContext.GetContext(testCtxString); var dbResultCtx = ResultContext.GetContext(testResultCtxString); var dbGeneratorCtx = DataGeneratorContext.GetContext(testGeneratorCtxString); var transitionMatrixGeneratorVerifier = new TransitionMatrixGeneratorVerifier(); transitionMatrixGeneratorVerifier.VerifySimulatedData(dbContext, dbGeneratorCtx, dbResultCtx, simNumber); Assert.True(true); }
protected override void DoParse() { try { tokens = Lexer.GetEnumerator(); fetchPrimary(); var root = doAny(); ResultContext.setData(root); } catch (abortException) { } }
private void LogToDB(bool writeResultsToDB) { if (Collector.saveToDB.Value && writeResultsToDB) { using (var ctx = ResultContext.GetContext(resultCon: Collector.Config.GetOption <DBConnectionString>().Value)) { ctx.SimulationOperations.AddRange(entities: simulationWorkschedules); ctx.Kpis.AddRange(entities: Kpis); ctx.SaveChanges(); ctx.Dispose(); } } }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public SingleQueryCollectionContext( object?parent, object?collection, object[] parentIdentifier, object[] outerIdentifier) { Parent = parent; Collection = collection; ParentIdentifier = parentIdentifier; OuterIdentifier = outerIdentifier; ResultContext = new ResultContext(); SelfIdentifier = null !; }
public JsonResult GetTable() { using (ResultContext db = new ResultContext()) { var resultats = db.Results.ToList(); var jsonData = new { rows = resultats }; return(Json(jsonData, JsonRequestBehavior.AllowGet)); } }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app , IWebHostEnvironment env , HangfireDBContext hangfireContext , MasterDBContext context , ResultContext contextResults , ProductionDomainContext productionDomainContext) { MasterDbInitializerTable.DbInitialize(context: context); ResultDBInitializerBasic.DbInitialize(context: contextResults); #region Hangfire HangfireDBInitializer.DbInitialize(context: hangfireContext); GlobalConfiguration.Configuration .UseFilter(filter: new AutomaticRetryAttribute { Attempts = 0 }) .UseSqlServerStorage(nameOrConnectionString: Configuration.GetConnectionString(name: "Hangfire")) .UseConsole(); app.UseHangfireDashboard(); #endregion var options = app.ApplicationServices.GetService <IOptions <RequestLocalizationOptions> >(); app.UseRequestLocalization(options: options.Value); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseBrowserLink(); } else { app.UseExceptionHandler(errorHandlingPath: "/Home/Error"); } app.UseCors("CorsPolicy"); app.UseFileServer(); app.UseStaticFiles(); app.UseRouting(); app.UseEndpoints(router => { router.MapHub <MessageHub>("/MessageHub"); }); app.UseMvc(configureRoutes: routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); }
public void ResetResultsDB(string connectionString, string resultConnectionString) { MasterDBContext masterCtx = MasterDBContext.GetContext(connectionString); masterCtx.Database.EnsureDeleted(); masterCtx.Database.EnsureCreated(); MasterDBInitializerTruck.DbInitialize(masterCtx, ModelSize.Medium, ModelSize.Small, ModelSize.Small, 3, true); ResultContext results = ResultContext.GetContext(resultCon: resultConnectionString); results.Database.EnsureDeleted(); results.Database.EnsureCreated(); ResultDBInitializerBasic.DbInitialize(results); }
private void HandleLiveResultPacket(Packet packet) { var liveResultEventModel = (LiveResultPacket)packet; var liveResultUpdate = _resultConverter.FromLiveResult(liveResultEventModel.Results); _result.Add(liveResultUpdate); var context = new ResultContext { Name = Name, Result = _result }; _syncContext.Send(o => _sessionHandler.HandleResult(context), null); }
private void LogToDB(bool writeResultsToDB) { if (Collector.saveToDB.Value && writeResultsToDB) { using (var ctx = ResultContext.GetContext(resultCon: Collector.Config.GetOption <DBConnectionString>().Value)) { ctx.TaskItems.AddRange(entities: _taskArchive.Select(x => x.Value).ToArray()[0].ToList().Cast <TaskItem>()); ctx.TaskItems.AddRange(entities: _taskArchive.Select(x => x.Value).ToArray()[1].ToList().Cast <TaskItem>()); ctx.SaveChanges(); ctx.Kpis.AddRange(entities: Collector.Kpis); ctx.SaveChanges(); ctx.Dispose(); } } }
private void LogToDB(bool writeResultsToDB) { if (Collector.saveToDB.Value && writeResultsToDB) { using (var ctx = ResultContext.GetContext(resultCon: Collector.Config.GetOption <DBConnectionString>().Value)) { ctx.SimulationJobs.AddRange(entities: simulationJobsForDb); ctx.SaveChanges(); ctx.SimulationResourceSetups.AddRange(entities: simulationResourceSetupsForDb); ctx.SaveChanges(); ctx.Kpis.AddRange(entities: Collector.Kpis); ctx.SaveChanges(); ctx.Dispose(); } } }
public static void ConvertBackAndSave(ResultContext resultCtx, Configuration config, int simulationNumber) { var configs = new List <SimulationConfig>(); foreach (var item in config) { configs.Add(new SimulationConfig() { Property = item.Key.Name, PropertyValue = ((dynamic)item.Value).Value.ToString(), SimulationNumber = simulationNumber }); } resultCtx.SimulationConfigs.AddRange(configs); resultCtx.SaveChanges(); }
private static void CreateSimulation(ResultContext context, List <ConfigurationItem> items, string description) { _simulationId++; var configurationItems = new List <ConfigurationItem> { new ConfigurationItem { Property = "SimulationId", PropertyValue = _simulationId.ToString(), Description = description }, }; items.ForEach(x => configurationItems.Add(x)); context.ConfigurationItems.AddRange(configurationItems); context.SaveChanges(); AssertConfigurations(context, configurationItems, _simulationId); }
private static void AssertConfigurations(ResultContext context, List <ConfigurationItem> configurationItems, int simulationId) { var configurationRelations = new List <ConfigurationRelation>(); var simId = int.Parse(configurationItems.Single(x => x.Property == "SimulationId").PropertyValue); foreach (var item in configurationItems) { if (item.Id != 1) { configurationRelations.Add(new ConfigurationRelation { ParentItemId = simId, ChildItemId = item.Id, Id = simulationId }); } } context.ConfigurationRelations.AddRange(entities: configurationRelations); context.SaveChanges(); }
private static List <ConfigurationItem> AddDefaultItems(ResultContext resultCtx, List <ConfigurationItem> configurationSpecificItems) { var configurationItems = resultCtx.ConfigurationRelations .Include(x => x.ChildItem) .Where(x => x.Id == 1).Select(x => x.ChildItem).ToList(); foreach (var specificItem in configurationSpecificItems) { var itemToRemove = configurationItems.SingleOrDefault(x => x.Property == specificItem.Property); if (itemToRemove != null) { configurationItems.Remove(itemToRemove); } } configurationItems.AddRange(configurationSpecificItems); return(configurationItems); }
void Start() { Result = new ResultContext(); }
public Builder(ResultContext resultContext = ResultContext.Assembly, string name = null) : this(null, new ComparerResult(resultContext, name)) { }
public void AddRemovedItem(ResultContext resultContext, string itemName, Severity severity) { _removedItems.Add(new AddedOrRemoved(resultContext, itemName, severity)); }
public Builder Removed(Severity severity = Severity.Error, ResultContext resultContext = ResultContext.Class, string itemName = "Item") { _comparerResult.AddRemovedItem(resultContext, itemName, severity); return this; }
public Builder Result(ResultContext resultContext = ResultContext.Class, string name = null) { ComparerResult comparerResult = new ComparerResult(resultContext, name); _comparerResult.AddComparerResult(comparerResult); return new Builder(this, comparerResult); }
public IComparerResult CreateComparerResult(ResultContext resultContext, string name) { return new ComparerResult(resultContext, name); }