public IHttpActionResult ShipOrder([FromBody] GuidModel model)
{
var cmd = new ShipOrder(model.OrderId);
var order = _commandDispatcher.ExecuteCommand <OrderAggregate>(cmd);
return(Ok(OrderModel.FromAggregate(order)));
}
public IAggregate Handle(ShipOrder command)
{
var order = _domainRepository.GetById <Order>(command.Id);
order.ShipOrder();
return(order);
}
public virtual void OrderShip(ShipOrder order, bool append = false)
{
if (append)
{
// Can't append orders after a Patrol/Build!
if (CurrentOrder != null &&
(CurrentOrder is PatrolOrder ||
CurrentOrder is BuildOrder ||
(Orders.Count > 0 && (Orders.Last() is PatrolOrder || Orders.Last() is BuildOrder))))
{
return;
}
// Don't add an order that is already complete (dock replaced)
if (!order.OrderComplete)
{
Orders.Add(order);
}
}
else
{
if (CurrentOrder != null)
{
CurrentOrder.Cancel(this);
}
if (!order.OrderComplete)
{
Orders.Clear();
CurrentOrder = order;
}
}
}
public async Task ShipOrder_Success()
{
//adhere
var initialInventory = ProductStockpileShop.Inventory.DeepCopy();
//arrange
var command = new ShipOrder
{
Id = OrderReadyForShipment.Id,
InitiatorId = GlobalAdmin.Id
};
var handler = new ShipOrderHandler(EntityRepository, OrderService, InventoryService, EventTransmitter);
//act
await handler.HandleAsync(command);
//assert
var orderAmount = OrderReadyForShipment.ItemsProduced.Of(Product1InteriorDoor).Amount;
var inventoryDiff = initialInventory.Of(Product1InteriorDoor).Amount
- ProductStockpileShop.Inventory.Of(Product1InteriorDoor).Amount;
Assert.That(orderAmount, Is.EqualTo(inventoryDiff));
Assert.That(RecordedEventCount <OrderShipped>(), Is.EqualTo(1));
Assert.That(RecordedEventCount <DomainEvent <Order> >(), Is.EqualTo(1));
//annul
ProductStockpileShop.Inventory = initialInventory;
}
public virtual void InsertOrder(ShipOrder order)
{
if (CurrentOrder != null)
{
Orders.Insert(0, CurrentOrder);
}
CurrentOrder = order;
}
internal void Ship(ShipOrder cmd)
{
if (State != OrderState.ReadyForShipping)
{
throw new InvalidOrderStateException(cmd.AggregateId, $"State should be {OrderState.ReadyForShipping} but is {State}");
}
RaiseEvent(new OrderShipped(cmd.AggregateId));
}
public async Task PutOrderShippedAsync(Guid id)
{
var command = new ShipOrder
{
Id = id,
InitiatorId = Guid.NewGuid()
};
await _commandInvoker.Execute(command);
}
public override void OrderShip(ShipOrder order, bool append = false)
{
if (Building)
{
return;
}
base.OrderShip(order, append);
}
public Task Handle(ShipOrder message, IMessageHandlerContext context)
{
log.Info($"Order Shipped. OrderId {message.OrderId}");
Data.OrderId = message.OrderId;
log.Info("Order will complete in 5 seconds");
var timeoutData = new CompleteOrder();
return(RequestTimeout(context, TimeSpan.FromSeconds(5), timeoutData));
}
public void Handle(ShipOrder message)
{
var shippingSvc = new Shipping.ShippingServiceClient();
bool success = shippingSvc.ProcessOrderForShipping(Data.OrderId);
UpdateOrderSuccess(success);
MarkAsComplete();
}
public void Handle_ShipOrderArrived_TimeoutShouldBeSet()
{
Test.Initialize();
var shipOrder = new ShipOrder {
Order = 1
};
Test.Saga <BookShipmentPolicy>()
.ExpectTimeoutToBeSetIn <FedExTimeout>((state, span) => span == TimeSpan.FromSeconds(5))
.When(saga => saga.Handle(shipOrder));
}
public void Handle_ShipOrderArrived_SendToFedEx()
{
Test.Initialize();
var shipOrder = new ShipOrder {
Order = 1
};
Test.Saga <BookShipmentPolicy>()
.ExpectSend <ShipWithFedEx>(m => m.Order == shipOrder.Order)
.When(saga => saga.Handle(shipOrder));
}
public async Task Handle(ShipOrder message, IMessageHandlerContext context)
{
log.Info($"ShipOrderWorkflow for Order #{Data.OrderId} - Trying Maple first.");
// Execute order to ship with Maple
await context.Send(new ShipWithMaple()
{
OrderId = Data.OrderId
});
// Add timeout to escalate if Maple did not ship in time.
await RequestTimeout(context, TimeSpan.FromSeconds(20), new ShippingEscalation());
}
public ActionResult Index()
{
List <Order> OrderLists = new List <Order>();
List <ShipOrder> ShipOrderLists = new List <ShipOrder>();
DataTable tableReader = new DataTable();
using (SqlConnection conn = new SqlConnection(strConnString))
{
conn.Open();
SqlCommand scom = new SqlCommand("SELECT * FROM [dbo].[Table]", conn);
SqlDataReader sread = scom.ExecuteReader();
tableReader.Load(sread);
for (int i = 0; i < tableReader.Rows.Count; i++)
{
Order order = new Order();
order.Id = tableReader.Rows[i]["Id"].ToString();
order.Item = tableReader.Rows[i]["Item"].ToString();
order.Price = Convert.ToInt32(tableReader.Rows[i]["Price"]);
order.Cost = Convert.ToInt32(tableReader.Rows[i]["Cost"]);
order.Status = tableReader.Rows[i]["Status"].ToString();
OrderLists.Add(order);
}
tableReader.Reset();
scom.CommandText = "SELECT * FROM [dbo].[ShippingOrder]";
sread = scom.ExecuteReader();
tableReader.Load(sread);
for (int i = 0; i < tableReader.Rows.Count; i++)
{
ShipOrder shiporder = new ShipOrder();
shiporder.Id = tableReader.Rows[i]["Id"].ToString();
shiporder.OrderId = tableReader.Rows[i]["OrderId"].ToString();
shiporder.Status = tableReader.Rows[i]["Status"].ToString();
shiporder.CreatedDateTime = tableReader.Rows[i]["CreatedDateTime"].ToString();
ShipOrderLists.Add(shiporder);
}
conn.Close();
}
ViewBag.orders = OrderLists;
ViewBag.shiporders = ShipOrderLists;
return(View());
}
public void Handle_FedExTimesOut_SendToUps()
{
Test.Initialize();
var fedExTimeout = new FedExTimeout();
var shipOrder = new ShipOrder {
Order = 1
};
Test.Saga <BookShipmentPolicy>()
.When(policy => policy.Handle(shipOrder))
.ExpectSend <ShipWithUps>(m => m.Order == shipOrder.Order)
.When(saga => saga.Timeout(fedExTimeout));
}
public Task Handle(StartOrder message, IMessageHandlerContext context)
{
Data.OrderId = message.OrderId;
Data.OrderDescription = $"The saga for order {message.OrderId}";
log.Info($"Received StartOrder message {Data.OrderId}. Starting Saga");
var shipOrder = new ShipOrder
{
OrderId = message.OrderId
};
return(context.SendLocal(shipOrder));
}
public ActionResult Dispatch(DispatchRequest tranasctiondetail)
{
var model = this.ImsService.GetPayPalTransaction(tranasctiondetail.ID);
tranasctiondetail.ShiptoName = model.PayerAddressName;
tranasctiondetail.ShipToStreet = model.PayerAddressStreet1;
tranasctiondetail.ShipToStreet2 = model.PayerAddressStreet2;
tranasctiondetail.ShiptoCity = model.PayerCityName;
tranasctiondetail.ShipToState = model.PayerStateOrProvince;
tranasctiondetail.ShipToCountryName = model.PayerCountryName;
tranasctiondetail.ShipToZip = model.PayerPostalCode;
ShipOrder order = this.ImsService.AddDispatchOrder(tranasctiondetail, model);
return(Json(order, JsonRequestBehavior.AllowGet));
}
public Task Handle(ShipOrder message, IMessageHandlerContext context)
{
Log.Info($"Received ShipOrder command for Order with Id {message.OrderId}.");
Log.Info($"Attempting to ship Order with Id {Data.OrderId} with FanCourier.");
Data.OrderId = message.OrderId;
Data.Status = ShippingStatus.ShippingWithFanCourier;
context.Send(new ShipWithFanCourierRequest {
CorrelationId = Data.OrderId
});
RequestTimeout(context, shipmentSla, new DidNotReceiveAResponseFromFanCourierTimeout());
return(Task.CompletedTask);
}
public async Task <IActionResult> OnPostAsync(int shipId, int orderId)
{
if (shipId == 0 || orderId == 0)
{
return(NotFound());
}
ShipOrder = await _context.ShipOrder.FindAsync(shipId, orderId);
if (ShipOrder != null)
{
_context.ShipOrder.Remove(ShipOrder);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
ShipOrder = await _context.ShipOrder
.Include(s => s.Order)
.Include(s => s.Ship).FirstOrDefaultAsync(m => m.ShipId == id);
if (ShipOrder == null)
{
return(NotFound());
}
return(Page());
}
public void When_ShipOrder_OrderShipped()
{
Given(InitialEvents);
var command = new ShipOrder(id);
command.Metadata.CausationId = command.Metadata.CommandId;
command.Metadata.CorrelationId = causationAndCorrelationId;
When(command);
var expectedEvent = new OrderShipped(id);
expectedEvent.Metadata.CausationId = command.Metadata.CommandId;
expectedEvent.Metadata.CorrelationId = causationAndCorrelationId;
expectedEvent.Metadata.ProcessId = command.Metadata.ProcessId;
Then(expectedEvent);
}
public async Task <IActionResult> OnGetAsync(int shipId, int orderId)
{
if (shipId == 0 || orderId == 0)
{
return(NotFound());
}
ShipOrder = await _context.ShipOrder
.Include(s => s.Order)
.Include(s => s.Ship).FirstOrDefaultAsync(m => m.ShipId == shipId);
if (ShipOrder == null)
{
return(NotFound());
}
ViewData["OrderId"] = new SelectList(_context.Order, "Id", "Id");
ViewData["ShipId"] = new SelectList(_context.Ship, "Id", "Class");
ViewData["Count"] = new SelectList(_context.ShipOrder, "Count");
return(Page());
}
public Task Handle(StartOrder message, IMessageHandlerContext context)
{
var orderDescription = $"The saga for order {message.OrderId}";
Data.OrderDescription = orderDescription;
log.Info($"Received StartOrder message {Data.OrderId}. Starting Saga");
var shipOrder = new ShipOrder
{
OrderId = message.OrderId
};
log.Info("Order will complete in 5 seconds");
var timeoutData = new CompleteOrder
{
OrderDescription = orderDescription
};
return(Task.WhenAll(
context.SendLocal(shipOrder),
RequestTimeout(context, TimeSpan.FromSeconds(5), timeoutData)));
}
public Task Handle(PlaceOrder message, IMessageHandlerContext context)
{
log.Info($"Received PlaceOrder, OrderId = {message.OrderId}");
// This is normally where some business logic would occur
// Uncomment to test throwing a systemic exception
//throw new Exception("BOOM");
// Uncomment to test throwing a transient exception
//if (random.Next(0, 5) == 0)
//{
// throw new Exception("Oops");
//}
var shipOrder = new ShipOrder
{
OrderId = message.OrderId
};
return(context.Send(shipOrder));
}
public async Task Handle(StartOrder message, IMessageHandlerContext context)
{
var orderDescription = $"The saga for order {message.OrderId}";
Data.OrderDescription = orderDescription;
log.Info($"Received StartOrder message {Data.OrderId}. Starting Saga");
var shipOrder = new ShipOrder
{
OrderId = message.OrderId
};
await context.SendLocal(shipOrder)
.ConfigureAwait(false);
log.Info("Order will complete in 5 seconds");
var timeoutData = new CompleteOrder
{
OrderDescription = orderDescription
};
await RequestTimeout(context, TimeSpan.FromSeconds(5), timeoutData)
.ConfigureAwait(false);
}
public ActionResult Dispatch(FormCollection collection)
{
//int id =int.Parse(collection["ID"].ToString());
//var model = this.ImsService.GetTransactionDetail(id);
DispatchRequest tranasctiondetail = new DispatchRequest();
this.TryUpdateModel <DispatchRequest>(tranasctiondetail);
var model = this.ImsService.GetTransactionDetail(tranasctiondetail.ID);
tranasctiondetail.ShiptoName = model.ShiptoName;
tranasctiondetail.ShipToStreet = model.ShipToStreet;
tranasctiondetail.ShipToStreet2 = model.ShipToStreet2;
tranasctiondetail.ShiptoCity = model.ShiptoCity;
tranasctiondetail.ShipToState = model.ShipToState;
tranasctiondetail.ShipToCountryName = model.ShipToCountryName;
tranasctiondetail.ShipToZip = model.ShipToZip;
ShipOrder order = this.ImsService.AddDispatchOrder(tranasctiondetail);
return(Json(order, JsonRequestBehavior.AllowGet));
}
public void Handle(StartOrder message)
{
Data.OrderId = message.OrderId;
var orderDescription = $"The saga for order {message.OrderId}";
Data.OrderDescription = orderDescription;
log.Info($"Received StartOrder message {Data.OrderId}. Starting Saga");
var shipOrder = new ShipOrder
{
OrderId = message.OrderId
};
Bus.SendLocal(shipOrder);
log.Info("Order will complete in 5 seconds");
var timeoutData = new CompleteOrder
{
OrderDescription = orderDescription
};
RequestTimeout(TimeSpan.FromSeconds(5), timeoutData);
}
static async Task AsyncMain()
{
Console.Title = "Samples.ServiceControl.ASBAdapter.Sales";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.ServiceControl.ASBAdapter.Sales");
var transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>();
var connectionString = Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString.1");
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new Exception("Could not read 'AzureServiceBus.ConnectionString.1' environment variable. Check sample prerequisites.");
}
var shippingConnectionString = Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString.2");
if (string.IsNullOrWhiteSpace(shippingConnectionString))
{
throw new Exception("Could not read 'AzureServiceBus.ConnectionString.2' environment variable. Check sample prerequisites.");
}
transport.ConnectionString(connectionString);
#region FeaturesUnsuportedBySC
transport.UseNamespaceAliasesInsteadOfConnectionStrings();
transport.DefaultNamespaceAlias("sales");
var routing = transport.NamespaceRouting();
routing.AddNamespace("shipping", shippingConnectionString);
transport.UseForwardingTopology();
transport.BrokeredMessageBodyType(SupportedBrokeredMessageBodyTypes.Stream);
var composition = transport.Composition();
composition.UseStrategy <HierarchyComposition>()
.PathGenerator(path => "scadapter/");
#endregion
var recoverability = endpointConfiguration.Recoverability();
#region NamespaceAlias
recoverability.Failed(
customizations: settings =>
{
settings.HeaderCustomization(
customization: headers =>
{
headers[AdapterSpecificHeaders.OriginalNamespace] = "sales";
});
});
#endregion
endpointConfiguration.UsePersistence <InMemoryPersistence>();
var chaos = new ChaosGenerator();
endpointConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent(() => chaos, DependencyLifecycle.SingleInstance);
});
recoverability.Immediate(
customizations: immediate =>
{
immediate.NumberOfRetries(0);
});
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.DisableLegacyRetriesSatellite();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.AuditProcessedMessagesTo("audit");
endpointConfiguration.EnableInstallers();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press enter to exit");
Console.WriteLine("Press 'o' to generate order");
Console.WriteLine("Press 'f' to toggle simulating of message processing failure");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key == ConsoleKey.Enter)
{
break;
}
var lowerInvariant = char.ToLowerInvariant(key.KeyChar);
if (lowerInvariant == 'o')
{
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var shipOrder = new ShipOrder
{
OrderId = orderId,
Value = random.Next(100)
};
var sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.ServiceControl.ASBAdapter.Shipping@shipping");
await endpointInstance.Send(shipOrder, sendOptions)
.ConfigureAwait(false);
}
if (lowerInvariant == 'f')
{
chaos.IsFailing = !chaos.IsFailing;
Console.WriteLine($"Failure simulation is now turned {(chaos.IsFailing ? "on" : "off")}");
ConsoleHelper.ToggleTitle();
}
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
private IEnumerable <PickDetailDto> PickPermanentItem(ApplicationDbContext context, ShipOrder shipOrderInDb, IEnumerable <PickInfo> objArray)
{
var permanentSKUsInDb = context.PermanentSKUs
.Where(x => x.Status == Status.Active);
var pickDetailList = new List <PickDetail>();
foreach (var o in objArray)
{
var sku = permanentSKUsInDb.SingleOrDefault(x => x.Id == o.LocId);
pickDetailList.Add(new PickDetail
{
CartonRange = "NA",
Container = "NA",
PurchaseOrder = sku.PurchaseOrder,
Style = sku.Style,
Color = sku.Color,
CustomerCode = "NA",
SizeBundle = sku.Size,
PcsBundle = "NA",
PcsPerCarton = 0,
PickCtns = 0,
PickPcs = o.Pcs,
Location = sku.Location,
PickDate = DateTime.Now.ToString("MM/dd/yyyy"),
PermanentSKU = sku,
ShipOrder = shipOrderInDb
});
}
context.PickDetails.AddRange(pickDetailList);
context.SaveChanges();
return(Mapper.Map <IEnumerable <PickDetail>, IEnumerable <PickDetailDto> >(pickDetailList));
}
private void AssignShipToExploreItem(ShipItem ship, IShipExplorable item) {
if (!item.IsExploringAllowedBy(Owner)) {
D.Error("{0} attempting to assign {1} to illegally explore {2}.", DebugName, ship.DebugName, item.DebugName);
}
if (item.IsFullyExploredBy(Owner)) {
D.Error("{0} attempting to assign {1} to explore {2} which is already explored.", DebugName, ship.DebugName, item.DebugName);
}
ShipOrder exploreOrder = new ShipOrder(ShipDirective.Explore, CurrentOrder.Source, toNotifyCmd: true, target: item);
ship.CurrentOrder = exploreOrder;
}
/// <summary>
/// Handles the situation where the provided ship has either successfully explored the
/// provided target in the system, or the exploration of the target failed because the
/// target is dead. Returns <c>true</c> if a new exploration target was assigned to the
/// ship, <c>false</c> otherwise. If the ship received no new assignment, it has been
/// instructed to gather at a nearby assembly station.
/// </summary>
/// <param name="ship">The ship.</param>
/// <param name="exploreTgt">The explore TGT.</param>
/// <returns></returns>
private bool HandleSystemTargetExploredOrDead(ShipItem ship, IShipExplorable exploreTgt) {
_shipSystemExploreTgtAssignments.Remove(exploreTgt);
bool isNowAssigned = AssignShipToExploreSystemTgt(ship);
if (!isNowAssigned) {
if (ship.IsHQ) {
// no point in telling HQ to assume station, but with no more explore assignment, it should
// return to the closest Assembly station so the other ships assume station there
IFleetExplorable fleetExploreTgt = CurrentOrder.Target as IFleetExplorable;
var closestLocalAssyStation = GameUtility.GetClosest(Position, fleetExploreTgt.LocalAssemblyStations);
var speed = Speed.Standard;
float standoffDistance = Constants.ZeroF; // AssyStation can't be owned by anyone
bool isFleetwideMove = false;
ship.CurrentOrder = new ShipMoveOrder(OrderSource.CmdStaff, closestLocalAssyStation, speed, isFleetwideMove, standoffDistance);
}
else {
ShipOrder assumeStationOrder = new ShipOrder(ShipDirective.AssumeStation, OrderSource.CmdStaff);
ship.CurrentOrder = assumeStationOrder;
}
}
return isNowAssigned;
}
void AssumingFormation_EnterState() {
LogEvent();
D.Log(ShowDebugLog, "{0} issuing {1} order to all ships.", DebugName, ShipDirective.AssumeStation.GetValueName());
var shipAssumeFormationOrder = new ShipOrder(ShipDirective.AssumeStation, CurrentOrder.Source, toNotifyCmd: true);
Elements.ForAll(e => {
var ship = e as ShipItem;
ship.CurrentOrder = shipAssumeFormationOrder;
});
}
void Attacking_EnterState() {
LogEvent();
_attackTarget = CurrentOrder.Target as IMortalTarget;
_attackTarget.onTargetDeathOneShot += OnTargetDeath;
var shipAttackOrder = new ShipOrder(ShipDirective.Attack, OrderSource.UnitCommand, _attackTarget);
Elements.ForAll(e => (e as ShipModel).CurrentOrder = shipAttackOrder);
}
private void InitiateRepair(bool retainSuperiorsOrderOnRepairCompletion) {
D.AssertNotEqual(ShipState.Repairing, CurrentState);
D.Assert(!_debugSettings.DisableRepair);
D.Assert(Data.Health < Constants.OneHundredPercent);
//D.Log(ShowDebugLog, "{0} is investigating whether to Disengage or AssumeStation before Repairing.", DebugName);
ShipOrder goToStationAndRepairOrder;
if (IsThereNeedForAFormationStationChangeTo(WithdrawPurpose.Repair)) {
// there is a need for a station change to repair
D.AssertDefault((int)_fsmDisengagePurpose);
_fsmDisengagePurpose = WithdrawPurpose.Repair;
goToStationAndRepairOrder = new ShipOrder(ShipDirective.Disengage, OrderSource.Captain) {
FollowonOrder = new ShipOrder(ShipDirective.Repair, OrderSource.Captain)
};
}
else {
// there is no need to change FormationStation because either ship is HQ or it is already assigned a reserve station
goToStationAndRepairOrder = new ShipOrder(ShipDirective.AssumeStation, OrderSource.Captain) {
FollowonOrder = new ShipOrder(ShipDirective.Repair, OrderSource.Captain)
};
}
OverrideCurrentOrder(goToStationAndRepairOrder, retainSuperiorsOrderOnRepairCompletion);
}
/// <summary>
/// The Captain uses this method to issue orders.
/// </summary>
/// <param name="captainsOverrideOrder">The captains override order.</param>
/// <param name="retainSuperiorsOrder">if set to <c>true</c> [retain superiors order].</param>
private void OverrideCurrentOrder(ShipOrder captainsOverrideOrder, bool retainSuperiorsOrder) {
D.AssertEqual(OrderSource.Captain, captainsOverrideOrder.Source, captainsOverrideOrder.ToString());
D.AssertNull(captainsOverrideOrder.StandingOrder, captainsOverrideOrder.ToString());
D.Assert(!captainsOverrideOrder.ToNotifyCmd, captainsOverrideOrder.ToString());
ShipOrder standingOrder = null;
if (retainSuperiorsOrder && CurrentOrder != null) {
if (CurrentOrder.Source != OrderSource.Captain) {
D.AssertNull(CurrentOrder.FollowonOrder, CurrentOrder.ToString());
// the current order is from the Captain's superior so retain it
standingOrder = CurrentOrder;
}
else {
// the current order is from the Captain, so it or its FollowonOrder's standing order, if any, should be retained
standingOrder = CurrentOrder.FollowonOrder != null ? CurrentOrder.FollowonOrder.StandingOrder : CurrentOrder.StandingOrder;
}
}
// assign the standingOrder, if any, to the last order to be executed in the overrideOrder
if (captainsOverrideOrder.FollowonOrder != null) {
captainsOverrideOrder.FollowonOrder.StandingOrder = standingOrder;
}
else {
captainsOverrideOrder.StandingOrder = standingOrder;
}
CurrentOrder = captainsOverrideOrder;
}
IEnumerator ExecuteAttackOrder_EnterState() {
LogEvent();
IUnitAttackable unitAttackableTgt = _fsmTgt as IUnitAttackable;
_apMoveSpeed = Speed.Full;
_apMoveTgtStandoffDistance = CalcApMoveTgtStandoffDistance(unitAttackableTgt);
Call(FleetState.Moving);
yield return null; // required so Return()s here
if (_orderFailureCause != UnitItemOrderFailureCause.None) {
switch (_orderFailureCause) {
case UnitItemOrderFailureCause.UnitItemNeedsRepair:
// TODO Initiate Fleet Repair and communicate failure to boss?
break;
case UnitItemOrderFailureCause.UnitItemDeath:
// TODO Communicate failure to boss?
break;
case UnitItemOrderFailureCause.TgtRelationship:
// TODO Communicate failure to boss?
// No longer allowed to attack _fsmTgt
IssueAssumeFormationOrderFromCmdStaff();
break;
case UnitItemOrderFailureCause.TgtUncatchable:
// TODO Communicate failure to boss?
IssueAssumeFormationOrderFromCmdStaff();
break;
case UnitItemOrderFailureCause.TgtDeath:
// order was to Move to _fsmTgt (unitAttackableTgt) so tgtDeath is an order failure
IssueAssumeFormationOrderFromCmdStaff();
break;
case UnitItemOrderFailureCause.None:
default:
throw new NotImplementedException(ErrorMessages.UnanticipatedSwitchValue.Inject(_orderFailureCause));
}
yield return null;
}
// If there was a failure generated by Moving, resulting new Orders or Dead state should keep this point from being reached
D.AssertDefault((int)_orderFailureCause, _orderFailureCause.GetValueName());
// issue ship attack orders
var shipAttackOrder = new ShipOrder(ShipDirective.Attack, CurrentOrder.Source, toNotifyCmd: true, target: unitAttackableTgt as IShipNavigable);
Elements.ForAll(e => (e as ShipItem).CurrentOrder = shipAttackOrder);
}
/// <summary>
/// Kills all remaining elements of the Unit along with this Command. All Elements are ordered
/// to Scuttle (assume Dead state) which results in the Command assuming its own Dead state.
/// </summary>
private void ScuttleUnit() {
var elementScuttleOrder = new ShipOrder(ShipDirective.Scuttle, OrderSource.CmdStaff);
Elements.ForAll(e => (e as ShipItem).CurrentOrder = elementScuttleOrder);
}
private IEnumerable <PickDetailDto> PickRegularItem(ApplicationDbContext context, ShipOrder shipOrderInDb, IEnumerable <PickInfo> objArray)
{
var regularItemsInDb = context.FCRegularLocationDetails
.Where(x => x.AvailableCtns != 0 || x.AvailablePcs != 0);
var pickDetailList = new List <PickDetail>();
foreach (var o in objArray)
{
var pickDetailInList = pickDetailList.SingleOrDefault(x => x.Id == o.Id);
var item = regularItemsInDb.SingleOrDefault(x => x.Id == o.Id);
item.AvailableCtns -= o.Ctns;
item.PickingCtns += o.Ctns;
item.AvailablePcs -= o.Pcs;
item.PickingPcs += o.Pcs;
if (pickDetailInList == null)
{
pickDetailList.Add(new PickDetail
{
Id = o.Id,
CartonRange = item.CartonRange,
Container = item.Container,
PurchaseOrder = item.PurchaseOrder,
Style = item.Style,
Color = item.Color,
CustomerCode = item.CustomerCode,
SizeBundle = item.SizeBundle,
PcsBundle = item.PcsBundle,
PcsPerCarton = item.PcsPerCaron,
PickCtns = o.Ctns,
PickPcs = o.Pcs,
Location = item.Location,
PickDate = DateTime.Now.ToString("MM/dd/yyyy"),
FCRegularLocationDetail = item,
ShipOrder = shipOrderInDb
});
}
else
{
pickDetailInList.PickPcs += o.Pcs;
pickDetailInList.PickCtns += o.Ctns;
}
}
context.PickDetails.AddRange(pickDetailList);
context.SaveChanges();
return(Mapper.Map <IEnumerable <PickDetail>, IEnumerable <PickDetailDto> >(pickDetailList));
}
public void __IssueShipMovementOrders(INavigableTarget target, Speed speed) {
var shipMoveToOrder = new ShipOrder(ShipDirective.Move, OrderSource.UnitCommand, target, speed);
Elements.ForAll(e => (e as ShipModel).CurrentOrder = shipMoveToOrder);
}
private void OnContextMenuSelection() {
int subMenuItemId = _ctxObject.selectedItem; // IMPROVE assumes all menu items have submenus
ValueRange<int> orderKey = _subMenuOrderLookup.Keys.Single<ValueRange<int>>(subMenuItemIdRange => subMenuItemIdRange.ContainsValue(subMenuItemId));
ShipDirective orderSelected = _subMenuOrderLookup[orderKey];
IMortalTarget targetSelected = GetTargetSelected(orderSelected, subMenuItemId);
D.Log("{0} selected order {1} and submenu item {2} from context menu.", Presenter.FullName, orderSelected.GetValueName(), targetSelected.FullName);
ShipOrder order = new ShipOrder(orderSelected, OrderSource.User, targetSelected);
Presenter.Model.CurrentOrder = order;
}
IEnumerator ExecuteAttackOrder_EnterState() {
LogEvent();
TryBreakOrbit();
IUnitAttackable unitAttackTgt = CurrentOrder.Target as IUnitAttackable;
string unitAttackTgtName = unitAttackTgt.DebugName;
if (!unitAttackTgt.IsOperational) {
// if this occurs, it happened in the yield return null delay before EnterState execution
D.Warn("{0} was killed before {1} could begin attack. Canceling Attack Order.", unitAttackTgtName, DebugName);
CurrentState = ShipState.Idling;
yield return null;
}
// Other unitAttackTgt condition changes (owner, relationship, infoAccess) handled by FleetCmd
ShipCombatStance stance = Data.CombatStance;
if (stance == ShipCombatStance.Disengage) {
if (IsHQ) {
D.Warn("{0} as HQ cannot have {1} of {2}. Changing to {3}.", DebugName, typeof(ShipCombatStance).Name,
ShipCombatStance.Disengage.GetValueName(), ShipCombatStance.Defensive.GetValueName());
Data.CombatStance = ShipCombatStance.Defensive;
}
else {
if (IsThereNeedForAFormationStationChangeTo(WithdrawPurpose.Disengage)) {
D.AssertDefault((int)_fsmDisengagePurpose);
_fsmDisengagePurpose = WithdrawPurpose.Disengage;
ShipOrder disengageOrder = new ShipOrder(ShipDirective.Disengage, OrderSource.Captain);
OverrideCurrentOrder(disengageOrder, retainSuperiorsOrder: false);
}
else {
D.Log(ShowDebugLog, "{0} is already {1}d as the current FormationStation meets that need. Canceling Attack Order.",
DebugName, ShipDirective.Disengage.GetValueName());
CurrentState = ShipState.Idling;
}
yield return null;
}
}
if (stance == ShipCombatStance.Defensive) {
D.Log(ShowDebugLog, "{0}'s {1} is {2}. Changing Attack order to AssumeStationAndEntrench.",
DebugName, typeof(ShipCombatStance).Name, ShipCombatStance.Defensive.GetValueName());
ShipOrder assumeStationAndEntrenchOrder = new ShipOrder(ShipDirective.AssumeStation, OrderSource.Captain) {
FollowonOrder = new ShipOrder(ShipDirective.Entrench, OrderSource.Captain)
};
OverrideCurrentOrder(assumeStationAndEntrenchOrder, retainSuperiorsOrder: false);
yield return null;
}
if (unitAttackTgt.IsColdWarAttackByAllowed(Owner)) {
// we are not at war with the owner of this Unit as Owner must be accessible
WeaponRangeMonitors.ForAll(wrm => wrm.ToEngageColdWarEnemies = true);
// IMPROVE weapons will shoot at ANY ColdWar or War enemy in range, even innocent ColdWar bystanders
}
bool allowLogging = true;
IShipAttackable primaryAttackTgt;
while (unitAttackTgt.IsOperational) {
if (TryPickPrimaryAttackTgt(unitAttackTgt, allowLogging, out primaryAttackTgt)) {
D.Log(ShowDebugLog, "{0} picked {1} as primary attack target.", DebugName, primaryAttackTgt.DebugName);
// target found within sensor range that it can and wants to attack
_fsmTgt = primaryAttackTgt as IShipNavigable;
Call(ShipState.Attacking);
yield return null; // reqd so Return()s here
if (_orderFailureCause != UnitItemOrderFailureCause.None) {
Command.HandleOrderOutcome(CurrentOrder.Directive, this, isSuccess: false, target: primaryAttackTgt, failCause: _orderFailureCause);
switch (_orderFailureCause) {
case UnitItemOrderFailureCause.TgtUncatchable:
continue; // pick another primary attack target
case UnitItemOrderFailureCause.UnitItemNeedsRepair:
InitiateRepair(retainSuperiorsOrderOnRepairCompletion: false);
break;
case UnitItemOrderFailureCause.UnitItemDeath:
// No Cmd notification reqd in this state. Dead state will follow
break;
case UnitItemOrderFailureCause.TgtDeath:
// Should not happen as Attacking does not generate a failure cause when target dies
case UnitItemOrderFailureCause.TgtRelationship:
case UnitItemOrderFailureCause.TgtUnreachable:
default:
throw new NotImplementedException(ErrorMessages.UnanticipatedSwitchValue.Inject(_orderFailureCause));
}
yield return null;
}
else {
D.Assert(!primaryAttackTgt.IsOperational);
Command.HandleOrderOutcome(CurrentOrder.Directive, this, isSuccess: true, target: primaryAttackTgt);
}
_fsmTgt = null;
allowLogging = true;
}
else {
// declined to pick first or subsequent primary target
if (allowLogging) {
D.LogBold(ShowDebugLog, "{0} is staying put as it found no target it chooses to attack associated with UnitTarget {1}.",
DebugName, unitAttackTgt.DebugName); // either no operational weapons or no targets in sensor range
allowLogging = false;
}
}
yield return null;
}
if (IsInOrbit) {
D.Error("{0} is in orbit around {1} after killing {2}.", DebugName, _itemBeingOrbited.DebugName, unitAttackTgtName);
}
CurrentState = ShipState.Idling;
}
/// <summary>
/// The Captain uses this method to issue orders.
/// </summary>
/// <param name="order">The order.</param>
/// <param name="retainSuperiorsOrder">if set to <c>true</c> [retain superiors order].</param>
/// <param name="target">The target.</param>
/// <param name="speed">The speed.</param>
private void OverrideCurrentOrder(ShipDirective order, bool retainSuperiorsOrder, INavigableTarget target = null, Speed speed = Speed.None) {
// if the captain says to, and the current existing order is from his superior, then record it as a standing order
ShipOrder standingOrder = null;
if (retainSuperiorsOrder && CurrentOrder != null) {
if (CurrentOrder.Source != OrderSource.ElementCaptain) {
// the current order is from the Captain's superior so retain it
standingOrder = CurrentOrder;
if (IsHQElement) {
// the captain is overriding his superior on the flagship so declare an emergency // HACK
Command.__OnHQElementEmergency();
}
}
else if (CurrentOrder.StandingOrder != null) {
// the current order is from the Captain, but there is a standing order in it so retain it
standingOrder = CurrentOrder.StandingOrder;
}
}
ShipOrder newOrder = new ShipOrder(order, OrderSource.ElementCaptain, target, speed) {
StandingOrder = standingOrder
};
CurrentOrder = newOrder;
}
