public void RemoveRequirement_ForExistingRequriement_Should_Work()
{
//Arrange
Demands demands = new Demands();
demands.Add(new Requirements(eResourceType.Hardware, 5));
demands.Add(new Requirements(eResourceType.Firmware, 15));
demands.Add(new Requirements(eResourceType.Other, 25));
demands.Add(new Requirements(eResourceType.Software, 15));
demands.Remove(new Requirements(eResourceType.Other, 25));
Assert.Equal(3, demands.Requirements.Count);
}
public void Should_Add_Requirements_To_Demands()
{
//Arrange
Demands demands = new Demands();
demands.Add(new Requirements(eResourceType.Hardware, 5));
demands.Add(new Requirements(eResourceType.Firmware, 5));
demands.Add(new Requirements(eResourceType.Software, 5));
demands.Add(new Requirements(eResourceType.Other, 5));
//Act,Assert
Assert.Equal(4, demands.Requirements.Count);
}
public void AddRequirement_Should_ThowException_For_Existing_Requirement_Types()
{
//Arrange
Demands demands = new Demands();
demands.Add(new Requirements(eResourceType.Hardware, 5));
demands.Add(new Requirements(eResourceType.Firmware, 5));
Action addDuplicateRequirement = () => demands.Add(new Requirements(eResourceType.Hardware, 10));
//Act,Assert
var exception = Assert.Throws <Exception>(addDuplicateRequirement);
Assert.Equal("Can add only one instance of a particualr Requirements type", exception.Message);
}
//Todo: check logic
public void CreatePurchaseDemand(IDemandToProvider demand, decimal amount, int time)
{
if (NeedToRefill(demand, amount))
{
var providerPurchasePart = new DemandProviderPurchasePart()
{
Quantity = amount,
ArticleId = demand.ArticleId,
DemandRequesterId = demand.Id,
State = State.Created,
};
Demands.Add(providerPurchasePart);
CreatePurchase(demand, amount, providerPurchasePart, time);
Demands.Update(providerPurchasePart);
}
else
{
var providerStock = new DemandProviderStock()
{
Quantity = amount,
ArticleId = demand.ArticleId,
DemandRequesterId = demand.Id,
State = State.Created,
StockId = Stocks.Single(a => a.ArticleForeignKey == demand.ArticleId).Id
};
Demands.Add(providerStock);
}
SaveChanges();
}
/// <summary>
/// copies am Article and his Childs to ProductionOrder
/// Creates Demand Provider for Production oder and DemandRequests for childs
/// </summary>
/// <returns></returns>
public ProductionOrder CopyArticleToProductionOrder(int articleId, decimal quantity, int demandRequesterId)
{
var article = Articles.Include(a => a.ArticleBoms).ThenInclude(c => c.ArticleChild).Single(a => a.Id == articleId);
var mainProductionOrder = new ProductionOrder
{
ArticleId = article.Id,
Name = "Prod. Auftrag: " + article.Name,
Quantity = quantity,
};
ProductionOrders.Add(mainProductionOrder);
CreateProductionOrderWorkSchedules(mainProductionOrder);
var demandProvider = new DemandProviderProductionOrder()
{
ProductionOrderId = mainProductionOrder.Id,
Quantity = quantity,
ArticleId = article.Id,
DemandRequesterId = demandRequesterId,
};
Demands.Add(demandProvider);
SaveChanges();
return(mainProductionOrder);
}
public void CountIntersect()
{
Provider provider = new Provider();
provider.Add(new Resource(ResourceType.Firmware, 10));
provider.Add(new Resource(ResourceType.Hardware, 20));
Demands demands = new Demands();
demands.Add(new Resource(ResourceType.Firmware, 10));
demands.Add(new Resource(ResourceType.Other, 30));
int c = Create(provider, demands);
Assert.IsTrue(c == 1);
}
public void RemoveRequirement_ForNonExistingRequirement_Should_ThrowException()
{
//Arrange
Demands demands = new Demands();
demands.Add(new Requirements(eResourceType.Hardware, 5));
demands.Add(new Requirements(eResourceType.Firmware, 15));
//Remove nonexisting resource.
Action removeRequirement = () => demands.Remove(new Requirements(eResourceType.Other, 10));
//Act,Assert
var exception = Assert.Throws <Exception>(removeRequirement);
Assert.Equal("Requirements doesn't exist", exception.Message);
}
public void AddRequirements_Should_Allow_Max_Four_Requriemnt_Types()
{
//Arrange
Demands demands = new Demands();
demands.Add(new Requirements(eResourceType.Hardware, 5));
demands.Add(new Requirements(eResourceType.Firmware, 15));
demands.Add(new Requirements(eResourceType.Other, 25));
demands.Add(new Requirements(eResourceType.Software, 15));
//Adding 5th one.
Action addDuplicateRequirement = () => demands.Add(new Requirements(eResourceType.Hardware, 10));
//Act,Assert
var exception = Assert.Throws <Exception>(addDuplicateRequirement);
Assert.Equal("Allowed zero to four instances only", exception.Message);
}
private void HandleLine(string sLine, int number)
{
if (sLine == "EOF")
{
return;
}
var collection = sLine.Trim().Split();
var rest = sLine.Substring(collection[0].Length).Trim();
if (SetFlags(sLine))
{
return;
}
;
if (SetSingleValues(collection[0], rest))
{
return;
}
if (depots_flag)
{
Depots.Add(int.Parse(collection[0]));
}
else if (demands_flag)
{
Demands.Add(int.Parse(collection[1]));
}
else if (locationCordSection_flag)
{
LocationCordSection.Add(new Tuple <int, int>(int.Parse(collection[1]), int.Parse(collection[2])));
}
else if (depotLocationSection_flag)
{
DepotLocationSection.Add(new Tuple <int, int>(int.Parse(collection[0]), int.Parse(collection[1])));
}
else if (durationSection_flag)
{
DurationSection.Add(int.Parse(collection[1]));
}
else if (visitLocationSection_flag)
{
VisitLocationSection.Add(new Tuple <int, int>(int.Parse(collection[0]), int.Parse(collection[1])));
}
else if (depotTimeWindowSection_flag)
{
DepotTimeWindowSection.Add(new Tuple <int, int>(int.Parse(collection[1]), int.Parse(collection[2])));
}
else if (timeAvailSection_flag)
{
TimeAvailSection.Add(int.Parse(collection[1]));
}
}
public Demands CustomerOrderPartGetAll()
{
Demands demands = new Demands();
foreach (var demand in _customerOrderParts)
{
demands.Add(new CustomerOrderPart(demand.ToIDemand()));
}
return(demands);
}
public void Should_Return_Demand_To_Resource_Ratio()
{
Demands demands = new Demands();
demands.Add(new Requirements(eResourceType.Hardware, 5));
demands.Add(new Requirements(eResourceType.Firmware, 5));
demands.Add(new Requirements(eResourceType.Software, 5));
demands.Add(new Requirements(eResourceType.Other, 5));
Provider provider = new Provider();
provider.Add(new Resource(eResourceType.Hardware, 10));
provider.Add(new Resource(eResourceType.Firmware, 10));
provider.Add(new Resource(eResourceType.Software, 10));
provider.Add(new Resource(eResourceType.Other, 10));
int count = TestDriver.GetCount(provider, demands);
Assert.Equal(8, count);
}
public void Should_Return_RightNumber_When_Some_Resources_DoesntExists()
{
Demands demands = new Demands();
demands.Add(new Requirements(eResourceType.Hardware, 5));
demands.Add(new Requirements(eResourceType.Firmware, 5));
demands.Add(new Requirements(eResourceType.Software, 5));
demands.Add(new Requirements(eResourceType.Other, 5));
Provider provider = new Provider();
provider.Add(new Resource(eResourceType.Hardware, 10));
// provider.Add(new Resource(eResourceType.Firmware,4)); //
// provider.Add(new Resource(eResourceType.Software,4)); //
provider.Add(new Resource(eResourceType.Other, 10));
int count = TestDriver.GetCount(provider, demands);
Assert.Equal(4, count);
}
public void Should_Return_ZERO_When_Insufficient_Resources()
{
Demands demands = new Demands();
demands.Add(new Requirements(eResourceType.Hardware, 5));
demands.Add(new Requirements(eResourceType.Firmware, 5));
demands.Add(new Requirements(eResourceType.Software, 5));
demands.Add(new Requirements(eResourceType.Other, 5));
Provider provider = new Provider();
provider.Add(new Resource(eResourceType.Hardware, 4));
provider.Add(new Resource(eResourceType.Firmware, 4));
provider.Add(new Resource(eResourceType.Software, 4));
provider.Add(new Resource(eResourceType.Other, 4));
int count = TestDriver.GetCount(provider, demands);
Assert.Equal(0, count);
}
public void ConsumerClient()
{
Provider provider = new Provider();
provider.Add(new Resource(ResourceType.Firmware, 10));
Demands demands = new Demands();
demands.Add(new Requirements(ResourceType.Firmware, 5));
int c = Create(provider, demands);
}
public void ValueEquals()
{
Provider provider = new Provider();
provider.Add(new Resource(ResourceType.Firmware, 10));
Demands demands = new Demands();
demands.Add(new Resource(ResourceType.Firmware, 10));
int c = Create(provider, demands);
Assert.IsTrue(c == 1);
}
protected override void OnParse(byte[] table)
{
if (ActualRegisterTable == null)
{
throw new InvalidOperationException("La propiedad ActualRegisterTable no puede ser nula.");
}
/*if (BitConverter.IsLittleEndian)
* Array.Reverse(cant_arr);
* short cant = BitConverter.(cant_arr, 0);*/
int offset = 0;
for (int i = 0; i < ActualRegisterTable.NumberOfPresentDemands; i++)
{
int hours = (int)table[offset];
offset++;
int minutes = (int)table[offset];
offset++;
int seconds = (int)table[offset];
offset++;
byte[] demandArray = new byte[5];
Array.Copy(table, offset, demandArray, 0, 5);
Array.Reverse(demandArray);
PresentDemand demand = new PresentDemand
{
TimeRemaining = new TimeSpan(hours, minutes, seconds),
Value = new BillingRegister()
{
Value = Helper.GetLong(demandArray)
}
};
Demands.Add(demand);
offset = offset + 5;
}
for (int i = 0; i < ActualRegisterTable.NumberOfPresentValues; i++)
{
byte[] valueArray = new byte[6];
Array.Copy(table, offset, valueArray, 0, 6);
Array.Reverse(valueArray);
long value = Helper.GetLong(valueArray);
Values.Add(new BillingRegister()
{
Value = value
});
offset = offset + 6;
}
}
/**
* ProviderToDemand
*/
public Demands GetAllChildDemandsOf(Provider provider)
{
Demands demands = new Demands();
Ids ids = _dbTransactionData.ProviderToDemandGetAll().GetByProviderId(provider.GetId());
foreach (var id in ids)
{
T_ProviderToDemand providerToDemand =
_dbTransactionData.ProviderToDemandGetById(id);
demands.Add(_dbTransactionData.DemandsGetById(providerToDemand.GetDemandId()));
}
return(demands);
}
public Demands CreateProductionOrderBomsForArticleBom(
M_ArticleBom articleBom, Quantity quantity,
ProductionOrder parentProductionOrder)
{
Demands newProductionOrderBoms = new Demands();
ProductionOrderOperation productionOrderOperation = null;
if (articleBom.OperationId == null)
{
throw new MrpRunException(
"Every PrOBom must have an operation. Add an operation to the articleBom.");
}
// load articleBom.Operation
if (articleBom.Operation == null)
{
articleBom.Operation =
_dbMasterDataCache.M_OperationGetById(
new Id(articleBom.OperationId.GetValueOrDefault()));
}
// don't create an productionOrderOperation twice, take existing
if (_alreadyCreatedProductionOrderOperations.ContainsKey(articleBom.Operation))
{
productionOrderOperation =
_alreadyCreatedProductionOrderOperations[articleBom.Operation];
}
ProductionOrderBom newProductionOrderBom =
ProductionOrderBom.CreateTProductionOrderBom(articleBom, parentProductionOrder,
productionOrderOperation, quantity);
if (newProductionOrderBom.HasOperation() == false)
{
throw new MrpRunException(
"Every PrOBom must have an operation. Add an operation to the articleBom.");
}
if (_alreadyCreatedProductionOrderOperations.ContainsKey(articleBom.Operation) == false)
{
_alreadyCreatedProductionOrderOperations.Add(articleBom.Operation,
newProductionOrderBom.GetProductionOrderOperation());
}
newProductionOrderBoms.Add(newProductionOrderBom);
return(newProductionOrderBoms);
}
public void TestEqualReference()
{
Resource r = new Resource(ResourceType.Firmware, 10);
Provider provider = new Provider();
provider.Add(r);
Demands demands = new Demands();
demands.Add(r);
int c = Create(provider, demands);
Assert.IsTrue(c == 1);
}
public Demands GetProductionOrderBomsBy(ProductionOrderOperation operation)
{
Ids productionOrderBomIds = _dbTransactionData.ProductionOrderBomGetAll()
.GetProductionOrderBomsBy(operation);
Demands productionOrderBoms = new Demands();
foreach (var productionOrderBomId in productionOrderBomIds)
{
Demand productionOrderBom =
_dbTransactionData.ProductionOrderBomGetById(productionOrderBomId);
productionOrderBoms.Add(productionOrderBom);
}
return(productionOrderBoms);
}
public DemandStock CreateStockDemand(IDemandToProvider demand, Stock stock, decimal amount)
{
var demandStock = new DemandStock()
{
Quantity = amount,
Article = demand.Article,
ArticleId = demand.ArticleId,
State = State.Created,
DemandProvider = new List <DemandToProvider>(),
StockId = stock.Id,
};
Demands.Add(demandStock);
SaveChanges();
return(demandStock);
}
public IDemandToProvider CreateDemandOrderPart(OrderPart orderPart)
{
var demand = new DemandOrderPart()
{
OrderPartId = orderPart.Id,
Quantity = orderPart.Quantity,
Article = orderPart.Article,
ArticleId = orderPart.ArticleId,
OrderPart = orderPart,
DemandProvider = new List <DemandToProvider>(),
State = State.Created
};
Demands.Add(demand);
SaveChanges();
return(demand);
}
/**
* DemandToProvider
* D --> P
*/
public Demands GetAllParentDemandsOf(Provider provider)
{
Demands demands = new Demands();
Ids ids = _dbTransactionData.DemandToProviderGetAll().GetByProviderId(provider.GetId());
if (ids == null)
{
return(null);
}
foreach (var id in ids)
{
T_DemandToProvider demandToProvider =
_dbTransactionData.DemandToProviderGetById(id);
demands.Add(_dbTransactionData.DemandsGetById(demandToProvider.GetDemandId()));
}
return(demands);
}
private async Task GetDemandsAsync()
{
IsBusy = true;
var demands = await _testAccessService.GetDemands();
demands.ForEach(d =>
{
var demand = new DemandListItem
{
Id = d.Id,
Description = $"{d.Description} - {d.Owner.Username} ({d.Status})"
};
Demands.Add(demand);
});
IsBusy = false;
}
public void AddDemand(Demand oneDemand, Quantity reservedQuantity)
{
if (_demands.GetDemandById(oneDemand.GetId()) != null)
{
throw new MrpRunException("You cannot add an already added demand.");
}
// if it has quantity that is not reserved, remember it for later reserving
if (oneDemand.GetType() == typeof(StockExchangeDemand) &&
reservedQuantity.IsSmallerThan(oneDemand.GetQuantity()))
{
_openDemands.Add(oneDemand.GetArticle(),
new OpenNode <Demand>(oneDemand, oneDemand.GetQuantity().Minus(reservedQuantity),
oneDemand.GetArticle()));
}
// save demand
_demands.Add(oneDemand);
}
public Demands CalculateUnsatisfiedDemands(Demands demands)
{
Demands unSatisfiedDemands = new Demands();
Dictionary <Provider, Quantity> reservableQuantityToProvider =
new Dictionary <Provider, Quantity>();
foreach (var provider in StackSet)
{
reservableQuantityToProvider.Add(provider, provider.GetQuantity());
}
foreach (var demand in demands.GetAll())
{
Quantity neededQuantity = demand.GetQuantity();
foreach (var provider in StackSet)
{
Quantity reservableQuantity = reservableQuantityToProvider[provider];
if (provider.GetArticleId().Equals(demand.GetArticleId()) &&
reservableQuantity.IsGreaterThan(Quantity.Null()))
{
reservableQuantityToProvider[provider] = reservableQuantity
.Minus(neededQuantity);
neededQuantity = neededQuantity.Minus(reservableQuantity);
// neededQuantity < 0
if (neededQuantity.IsSmallerThan(Quantity.Null()))
{
break;
}
// neededQuantity > 0: continue to provide it
}
}
if (neededQuantity.IsGreaterThan(Quantity.Null()))
{
unSatisfiedDemands.Add(demand);
}
}
return(unSatisfiedDemands);
}
public DemandProviderProductionOrder CreateDemandProviderProductionOrder(IDemandToProvider demand, ProductionOrder productionOrder, decimal amount)
{
var demandProviderProductionOrder = new DemandProviderProductionOrder()
{
Quantity = amount,
Article = demand.Article,
ArticleId = demand.ArticleId,
ProductionOrderId = productionOrder.Id,
DemandRequesterId = demand.Id
};
Demands.Add(demandProviderProductionOrder);
if (productionOrder.DemandProviderProductionOrders == null)
{
productionOrder.DemandProviderProductionOrders = new List <DemandProviderProductionOrder>();
}
productionOrder.DemandProviderProductionOrders.Add(demandProviderProductionOrder);
SaveChanges();
return(demandProviderProductionOrder);
}
public Demands GetUnsatisfiedCustomerOrderParts()
{
Demands unsatisfiedCustomerOrderParts = new Demands();
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.GetDbTransactionData();
IAggregator aggregator = ZppConfiguration.CacheManager.GetAggregator();
Demands customerOrderParts = dbTransactionData.CustomerOrderPartGetAll();
foreach (var customerOrderPart in customerOrderParts)
{
Providers customerOrderPartChilds =
aggregator.GetAllChildProvidersOf(customerOrderPart);
if (customerOrderPartChilds == null || customerOrderPartChilds.Any() == false)
{
unsatisfiedCustomerOrderParts.Add(customerOrderPart);
}
}
return(unsatisfiedCustomerOrderParts);
}
public void Add(Demand demand)
{
_demands.Add(demand);
}
