public async Task <ResourceOrder> CreateOrder(ResourceOrder order)
{
var savedOrder = await _resourceOrdersRepository.SaveOrder(order);
_eventAggregator.SendMessage <ResourceOrderAddedEvent>(new ResourceOrderAddedEvent()
{
Order = savedOrder
});
return(savedOrder);
}
public async Task <ResourceOrder> CreateOrderAsync(ResourceOrder order, CancellationToken cancellationToken = default(CancellationToken))
{
var savedOrder = await _resourceOrdersRepository.SaveOrderAsync(order, cancellationToken);
_eventAggregator.SendMessage <ResourceOrderAddedEvent>(new ResourceOrderAddedEvent()
{
Order = savedOrder
});
return(savedOrder);
}
public ResourceShipment DeliverKeptAside(ResourceCarrier carrier)
{
ResourceOrder order = null;
if (_keptAsideOrders.TryGetValue(carrier, out order))
{
_keptAsideOrders.Remove(carrier);
return(order.shipment);
}
return(null);
}
public virtual int MakeKeepAsideOrder(string resourceName, int orderedAmount, ResourceCarrier recipient)
{
int availableStock = stock.StockFor(resourceName) - OrderedAmountFor(resourceName);
int ordered = Math.Min(availableStock, orderedAmount);
if (ordered > 0)
{
_keptAsideOrders[recipient] = new ResourceOrder(new ResourceShipment(resourceName, ordered), recipient.origin);
}
return(ordered);
}
public async Task <ResourceOrder> CreateOrderAsync(ResourceOrder order, CancellationToken cancellationToken = default(CancellationToken))
{
order.Summary = StringHelpers.SanitizeHtmlInString(order.Summary);
order.SpecialInstructions = StringHelpers.SanitizeHtmlInString(order.SpecialInstructions);
var savedOrder = await _resourceOrdersRepository.SaveOrderAsync(order, cancellationToken);
_eventAggregator.SendMessage <ResourceOrderAddedEvent>(new ResourceOrderAddedEvent()
{
Order = savedOrder
});
return(savedOrder);
}
/**
* Coroutine se chargeant d'envoyer tout ce qui a été produit par le bâtiment
* et se trouve contenu dans son stock à l'entrepôt le plus proche capable
* de l'accueillir ou à un bâtiment l'ayant commandé. Tout cela se voit bien
* entendu diviser entre les transporteurs
* disponibles pour le bâtiment.
**/
private IEnumerator ManageProductionStorage()
{
FreightAreaData freightData = orderManager.freightAreaData;
while (true)
{
if (!orderManager.SendOrderIfPossible() && !orderManager.OrdersToTreat() && _warehouseOrders.Count > 0)//L'appel à la méthode envoie une commande si elle retourne true, d'où l'aspect un peu étrange de la condition
{
ResourceOrder warehouseOrder = _warehouseOrders.Dequeue();
ResourceShipment orderShipment = warehouseOrder.shipment;
FreightAreaIn destinationIn = warehouseOrder.deliveryPlace.freightAreaData.freightAreaIn;
if (orderManager.stock.StockFor(orderShipment.resourceName) >= orderShipment.amount && RoadsPathfinding.RouteStar(destinationIn.road, freightData.freightAreaOut.road, 10, Orientation.SOUTH) != null)//TODO orientation
{
_currentStock.RemoveFromStock(orderShipment.resourceName, orderShipment.amount);
freightData.SendCarrier(warehouseOrder.deliveryPlace, Orientation.SOUTH, orderShipment);//TODO orientation
}
}
yield return(new WaitForSeconds(0.5f));
}
}
public bool SendOrderIfPossible()
{
FreightAreaOut freightOut = freightAreaData.freightAreaOut;
if (freightAreaData.availableCarriers > 0 && OrdersToTreat() && freightOut.road.roadLock.IsFree(Orientation.SOUTH))//TODO orientation (opposée à celle du bâtiment)
{
ResourceOrder toTreat = NextOrder();
FreightAreaIn destinationIn = toTreat.deliveryPlace.freightAreaData.freightAreaIn;
if (RoadsPathfinding.RouteStar(destinationIn.road, freightOut.road, 10, Orientation.SOUTH) != null)//TODO orientation
{
MarkAsTreated(toTreat);
freightAreaData.SendCarrier(toTreat.deliveryPlace, Orientation.SOUTH, toTreat.shipment);//TODO orientation (opposée à celle du bâtiment)
return(true);
}
else //Si la destination n'est pas raccordée au réseau routier, on annule sa commande et on l'en notifie
{
toTreat.deliveryPlace.freightAreaData.parentStock.GetComponent <ResourceConsumer>().CancelResourceOrder(toTreat.shipment);
}
}
return(false);
}
public async Task <ResourceOrder> SaveOrder(ResourceOrder order)
{
using (IDbConnection db = new SqlConnection(connectionString))
{
if (order.ResourceOrderId == 0)
{
var id = await db.InsertAsync <ResourceOrder>(order);
if (id != null)
{
order.ResourceOrderId = id.Value;
foreach (var item in order.Items)
{
item.ResourceOrderId = id.Value;
var itemId = await db.InsertAsync <ResourceOrderItem>(item);
if (itemId != null)
{
item.ResourceOrderItemId = itemId.Value;
}
}
}
}
else
{
await db.UpdateAsync(order);
foreach (var item in order.Items)
{
await db.UpdateAsync(item);
}
}
}
return(order);
}
private void MarkAsTreated(ResourceOrder order)
{
stock.RemoveFromStock(order.shipment);
_totalOrderedAmount -= order.shipment.amount;
}
