public void ImplementationsCanBeDeterminedByNewType()
{
var needs = new Needs();
needs.Add(new PearVariant(new SomeImplementation()));
needs.Add(new PlumVariant(new SomeImplementation()));
Assert.AreNotEqual(needs.Get <PearVariant>().Value, needs.Get <PlumVariant>().Value);
}
public void SimpleMultiUseDecoration()
{
var needs = new Needs();
needs.Add <IFacility, BasicFacility>();
Assert.AreEqual(1, needs.Get <IFacility>().Facilitate());
needs.Decorate <IFacility, AdvancedFacility>();
Assert.AreEqual(2, needs.Get <IFacility>().Facilitate());
// Decorator can be re-applied/re-wrapped multiple times
needs.Decorate <IFacility, AdvancedFacility>();
Assert.AreEqual(3, needs.Get <IFacility>().Facilitate());
}
/// <summary>
/// Add pressure to a need, can also be negative, wont go below zero
/// </summary>
/// <param name="need">the need to apply pressure to</param>
/// <param name="amount">how much pressure</param>
/// <returns>the highest current need after application</returns>
public Motivator ApplyPressure(Motivator need, int amount)
{
Tuple <Motivator, int> currentNeed = Needs.FirstOrDefault(nd => nd.Item1 == need);
if (currentNeed != null)
{
amount += currentNeed.Item2;
Needs.Remove(currentNeed);
}
Needs.Add(new Tuple <Motivator, int>(need, Math.Max(0, amount)));
return(Needs.OrderByDescending(nd => nd.Item2).FirstOrDefault().Item1);
}
public void AddNeed(string need)
{
Needs.Add(need);
}
/// <summary>
/// 安排生产， 增加产能指数
/// </summary>
/// <param name="schedule"></param>
/// <param name="arrangeInfos"></param>
public SmartTaskOrderScheduleDetail AddTaskOrderSchedule(SmartTaskOrderScheduleDetail schedule, List <ArrangeInfo> arrangeInfos)
{
if (schedule.ProcessTime == ProcessTime)
{
if (!Needs.ContainsKey(schedule.PId))
{
Needs.Add(schedule.PId, new List <SmartTaskOrderScheduleDetail>());
}
if (arrangeInfos.Any())
{
var productType = schedule.ProductType;
int item;
Dictionary <int, List <ArrangeInfo> > use;
//是否设备
if (productType == 0)
{
item = schedule.CategoryId;
use = DeviceUse;
}
else if (productType == 1)
{
item = schedule.PId;
use = OperatorUse;
}
else
{
return(null);
}
foreach (var arrangeInfo in arrangeInfos)
{
if (!use.ContainsKey(item))
{
use.Add(item, new List <ArrangeInfo>());
use[item].Add(new ArrangeInfo(arrangeInfo.Item, arrangeInfo.Id));
}
var first = use[item].FirstOrDefault(x => x.Id == arrangeInfo.Id);
if (first == null)
{
use[item].Add(new ArrangeInfo(arrangeInfo.Item, arrangeInfo.Id));
first = use[item].FirstOrDefault(x => x.Id == arrangeInfo.Id);
}
foreach (var arrange in arrangeInfo.Arranges)
{
if (arrange.Count > 0)
{
var productArrange = first.Arranges.FirstOrDefault(x => x.ProductId == arrange.ProductId && x.PId == arrange.PId);
if (productArrange != null)
{
productArrange.Count += arrange.Count;
}
else
{
first.Arranges.Add(arrange);
}
}
}
}
var arranges = arrangeInfos.ToDictionary(x => x.Id, info => info.Arranges.Sum(y => y.Count));
if (productType == 0)
{
schedule.DeviceList = arranges;
}
else if (productType == 1)
{
schedule.OperatorsList = arranges;
}
}
var oldSchedule = Needs[schedule.PId]
.FirstOrDefault(x => x.TaskOrderId == schedule.TaskOrderId && x.PId == schedule.PId);
if (oldSchedule == null)
{
schedule.ArrangeOrder = Needs[schedule.PId].Count + 1;
Needs[schedule.PId].Add(schedule);
}
else
{
schedule.ArrangeOrder = oldSchedule.ArrangeOrder;
if (schedule.Target < oldSchedule.Target)
{
return(oldSchedule);
}
oldSchedule.Stock = schedule.Stock;
oldSchedule.Target = schedule.Target;
oldSchedule.Put = schedule.Put;
if (schedule.ProductType == 0)
{
foreach (var(deviceId, count) in schedule.DeviceList)
{
if (oldSchedule.DeviceList.Any(x => x.Key == deviceId))
{
var cnt = oldSchedule.DeviceList[deviceId];
if (cnt < count)
{
oldSchedule.DeviceList[deviceId] = count;
}
}
else
{
oldSchedule.DeviceList.Add(deviceId, count);
}
}
}
else if (schedule.ProductType == 1)
{
foreach (var(opId, count) in schedule.OperatorsList)
{
if (oldSchedule.OperatorsList.Any(x => x.Key == opId))
{
var cnt = oldSchedule.OperatorsList[opId];
if (cnt < count)
{
oldSchedule.OperatorsList[opId] = count;
}
}
else
{
oldSchedule.OperatorsList.Add(opId, count);
}
}
}
}
}
return(null);
}
// ReSharper restore UnusedAutoPropertyAccessor.Global
public void AddNeed(Need need)
{
Needs.Add(need);
}
