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