private void ScheduleBackwardSecond(IDirectedGraph <INode> orderOperationGraph)
{
INodes childRootNodes = new Nodes();
foreach (var rootNode in orderOperationGraph.GetRootNodes())
{
if (rootNode.GetEntity().GetType() != typeof(CustomerOrderPart))
{
continue;
}
Providers childProviders = ZppConfiguration.CacheManager.GetAggregator()
.GetAllChildProvidersOf((Demand)rootNode.GetEntity());
if (childProviders == null || childProviders.Count() > 1)
{
throw new MrpRunException(
"After Mrp1 a CustomerOrderPart MUST have exact one child.");
}
childRootNodes.AddAll(childProviders.ToNodes());
}
IBackwardsScheduler backwardsScheduler =
new BackwardScheduler(childRootNodes.ToStack(), orderOperationGraph, false);
backwardsScheduler.ScheduleBackward();
}
private void changeProviderPlace(string move)
{
ObservableCollection <Provider> tempProviders = new ObservableCollection <Provider>();
if (Providers.Contains(SelectedProvider))
{
int actualIndex = Providers.IndexOf(SelectedProvider);
if (move == "before")
{
Provider previousProvider = new Provider();
if (actualIndex != 0)
{
foreach (Provider p in Providers)
{
if (Providers.IndexOf(p) == actualIndex - 1)
{
previousProvider = p;
}
else if (Providers.IndexOf(p) == actualIndex)
{
tempProviders.Add(p);
tempProviders.Add(previousProvider);
}
else
{
tempProviders.Add(p);
}
}
Providers = tempProviders;
refreshSettings();
}
}
if (move == "after")
{
Provider nextProvider = new Provider();
if (actualIndex != Providers.Count() - 1)
{
foreach (Provider p in Providers)
{
if (Providers.IndexOf(p) == actualIndex + 1)
{
nextProvider = p;
}
else if (Providers.IndexOf(p) == actualIndex)
{
nextProvider = Providers[Providers.IndexOf(p) + 1];
tempProviders.Add(nextProvider);
tempProviders.Add(p);
}
else
{
tempProviders.Add(p);
}
}
Providers = tempProviders;
refreshSettings();
}
}
}
}
public override byte[] Serialize()
{
byte[] serializedData = null;
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
writer.Write(CircularBufferSizeInMB);
writer.Write((uint)Format);
writer.Write(RequestRundown);
writer.Write(Providers.Count());
foreach (var provider in Providers)
{
writer.Write(provider.Keywords);
writer.Write((uint)provider.EventLevel);
writer.WriteString(provider.Name);
writer.WriteString(provider.FilterData);
}
writer.Flush();
serializedData = stream.ToArray();
}
return(serializedData);
}
//public DateTime LastVerifiedValue { get; set; }
//TimeSpan VerificationExpirationInterval { get; set; }
public DateTime GetUtc()
{
//await Task.Delay(500).ConfigureAwait(false);
Log?.Notice($"Get UTC time using {RandomizedProvidersPerTry} randomized servers with a maximum of {MaxFailsPerTry} fails.");
var res = TaskManager.StartNew(async() =>
{
if (Providers.Count(p => p.IsRandomized) < RandomizedProvidersPerTry)
{
throw new Exception($"At least {RandomizedProvidersPerTry} providers must be added");
}
//var ents = Providers.ToList();
var ents = Providers.TakeRandomly(RandomizedProvidersPerTry, ran).ToList();
Log?.Debug($@"Selected servers: {ents.Aggregate("", (a, c) => a + "\r\n - " + c.Provider)}");
foreach (var en in ents)
{
en.Task = TaskManager.StartNew(p => p.Provider.UtcNow(), en);
}
DateTime[] results = null;
try
{
//Task.WaitAll(ents.Select(en => en.Task).ToArray());
results = await Task.WhenAll(ents.Select(en => en.Task).ToArray()).ConfigureAwait(false);
}
catch (Exception ex)
{
Debug.WriteLine("");
}
foreach (var en in ents)
{
if (en.Task.Exception == null)
{
Log?.Info($"Provider '{en.Provider}' was a result: " + en.Task.Result);
}
else
{
Log?.Warn($"Provider '{en.Provider}' failed with error '{en.Task.Exception.GetType().Name}': " + en.Task.Exception.Message, en.Task.Exception);
}
}
var fails = ents.Where(p => p.Task.Exception != null).ToList();
if (fails.Count > MaxFailsPerTry)
{
throw new Exception($"Failed {fails.Count} providers when the maximun to fail is {MaxFailsPerTry}");
}
var r = ents
.Where(en => en.Task.Exception == null)
.Select(en => en.Task.Result)
.RemoveOutliers()
.AverageDateTime();
Log?.Notice("Result: " + r);
return(r);
});
return(res.Result);
}
/// <summary>
/// Updates the preparation details.
/// </summary>
public void UpdatePreparationDetails()
{
SelectedProvidersCount = Providers.Count(x => x.IsSelectedForProcessing);
ShowFilter = Providers.Count > ListFilterTrigger;
SelectedProviderIDs = SelectedProvidersCount > ListFilterTrigger
? Resources.TooManyToDisplayText
: string.Join(", ", Providers.Where(x => x.IsSelectedForProcessing).Select(x => $"{x.Source.ID}"));
BindingReadSelectAll();
}
public DueTime GetEarliestPossibleStartTimeOf(ProductionOrderBom productionOrderBom)
{
DueTime earliestStartTime = productionOrderBom.GetStartTimeBackward();
Providers providers = ZppConfiguration.CacheManager.GetAggregator()
.GetAllChildProvidersOf(productionOrderBom);
if (providers.Count() > 1)
{
throw new MrpRunException("A productionOrderBom can only have one provider !");
}
Provider stockExchangeProvider = providers.GetAny();
if (earliestStartTime.IsGreaterThanOrEqualTo(
stockExchangeProvider.GetStartTimeBackward()))
{
earliestStartTime = stockExchangeProvider.GetStartTimeBackward();
}
else
{
throw new MrpRunException("A provider of a demand cannot have a later dueTime.");
}
Demands stockExchangeDemands = ZppConfiguration.CacheManager.GetAggregator()
.GetAllChildDemandsOf(stockExchangeProvider);
if (stockExchangeDemands.Any() == false)
// StockExchangeProvider has no childs (stockExchangeDemands),
// take that from stockExchangeProvider
{
DueTime childDueTime = stockExchangeProvider.GetStartTimeBackward();
if (childDueTime.IsGreaterThan(earliestStartTime))
{
earliestStartTime = childDueTime;
}
}
else
// StockExchangeProvider has childs (stockExchangeDemands)
{
foreach (var stockExchangeDemand in stockExchangeDemands)
{
DueTime stockExchangeDemandDueTime = stockExchangeDemand.GetStartTimeBackward();
if (stockExchangeDemandDueTime.IsGreaterThan(earliestStartTime))
{
earliestStartTime = stockExchangeDemandDueTime;
}
}
}
return(earliestStartTime);
}
/**
* covers parent StockExchangeProvider(and its parent CustomerOrderPart if exist), child PurchaseOrderPart if exist
* --> 3 types of subgraphs: Production, Purchase, Customer
*/
private static List <IDemandOrProvider> GetItemsOfStockExchangeDemandSubGraph(
StockExchangeDemand stockExchangeDemand, IDbTransactionData dbTransactionData,
IAggregator aggregator, bool includeStockExchangeProviderHavingMultipleChilds)
{
List <IDemandOrProvider> items = new List <IDemandOrProvider>();
items.Add(stockExchangeDemand);
Providers stockExchangeProviders =
aggregator.GetAllParentProvidersOf(stockExchangeDemand);
foreach (var stockExchangeProvider in stockExchangeProviders)
{
Demands childsOfStockExchangeProvider =
aggregator.GetAllChildDemandsOf(stockExchangeProvider);
if (includeStockExchangeProviderHavingMultipleChilds ||
childsOfStockExchangeProvider.Count() == 1)
{
items.Add(stockExchangeProvider);
Demands customerOrderParts =
aggregator.GetAllParentDemandsOf(stockExchangeProvider);
if (customerOrderParts.Count() > 1)
{
throw new MrpRunException(
"A stockExchangeProvider can only have one parent.");
}
foreach (var customerOrderPart in customerOrderParts)
{
items.Add(customerOrderPart);
}
}
}
Providers purchaseOrderParts = aggregator.GetAllChildProvidersOf(stockExchangeDemand);
if (purchaseOrderParts.Count() > 1)
{
throw new MrpRunException("A stockExchangeDemand can only have one child.");
}
foreach (var purchaseOrderPart in purchaseOrderParts)
{
items.Add(purchaseOrderPart);
}
return(items);
}
/**
* Subgraph of a productionOrder includes:
* - parent (StockExchangeDemand) if includeStockExchanges true
* - childs (ProductionOrderBoms)
* - childs of childs (StockExchangeProvider) if includeStockExchanges true
*/
private static List <IDemandOrProvider> CreateProductionOrderSubGraph(
bool includeStockExchanges, ProductionOrder productionOrder, IAggregator aggregator)
{
List <IDemandOrProvider> demandOrProvidersOfProductionOrderSubGraph =
new List <IDemandOrProvider>();
demandOrProvidersOfProductionOrderSubGraph.Add(productionOrder);
if (includeStockExchanges)
{
Demands stockExchangeDemands = aggregator.GetAllParentDemandsOf(productionOrder);
if (stockExchangeDemands.Count() > 1)
{
throw new MrpRunException(
"A productionOrder can only have one parentDemand (stockExchangeDemand).");
}
demandOrProvidersOfProductionOrderSubGraph.AddRange(stockExchangeDemands);
foreach (var stockExchangeDemand in stockExchangeDemands)
{
Providers parentStockExchangeProviders =
aggregator.GetAllParentProvidersOf(stockExchangeDemand);
foreach (var parentStockExchangeProvider in parentStockExchangeProviders)
{
if (aggregator.GetAllChildDemandsOf(parentStockExchangeProvider).Count() ==
1)
{
demandOrProvidersOfProductionOrderSubGraph.Add(
parentStockExchangeProvider);
}
else
{
// stockExchangeProvider must stay
}
}
}
}
Demands productionOrderBoms = aggregator.GetAllChildDemandsOf(productionOrder);
demandOrProvidersOfProductionOrderSubGraph.AddRange(productionOrderBoms);
if (includeStockExchanges)
{
foreach (var productionOrderBom in productionOrderBoms)
{
Providers stockExchangeProvider =
aggregator.GetAllChildProvidersOf(productionOrderBom);
if (stockExchangeProvider.Count() > 1)
{
throw new MrpRunException(
"A ProductionOrderBom can only have one childProvider (stockExchangeProvider).");
}
demandOrProvidersOfProductionOrderSubGraph.AddRange(stockExchangeProvider);
}
}
return(demandOrProvidersOfProductionOrderSubGraph);
}
