public async Task ReceiveReminderAsync(string reminderName, byte[] context, TimeSpan dueTime, TimeSpan period)
{
switch (reminderName)
{
case CustomerOrderReminderNames.FulfillOrderReminder:
await this.FulfillOrderAsync();
CustomerOrderStatus orderStatus = await this.GetOrderStatusAsync();
if (orderStatus == CustomerOrderStatus.Shipped || orderStatus == CustomerOrderStatus.Canceled)
{
//Remove fulfill order reminder so Actor can be gargabe collected.
IActorReminder orderReminder = this.GetReminder(CustomerOrderReminderNames.FulfillOrderReminder);
await this.UnregisterReminderAsync(orderReminder);
}
break;
default:
// We should never arrive here normally. The system won't call reminders that don't exist.
// But for our own sake in case we add a new reminder somewhere and forget to handle it, this will remind us.
throw new InvalidOperationException("Unknown reminder: " + reminderName);
}
}
public IEnumerable <CustomerOrderStatus> StatusOrder()
{
List <CustomerOrderStatus> results = new List <CustomerOrderStatus>();
Hashtable prms = new Hashtable();
DataSet ds = DAL.GetData("sp_get_Customer_order_status", prms, "HomePageController.cs->getItemTable()");
if (ds != null && ds.Tables.Count > 0)
{
foreach (DataRow row in ds.Tables[0].Rows)
{
CustomerOrderStatus itemEntity =
new CustomerOrderStatus(Int32.Parse(row["OrderId"].ToString()), Int32.Parse(row["OrderLine"].ToString()),
Int32.Parse(row["Quantity"].ToString()), decimal.Parse(row["Payment"].ToString()),
row["ProductName"].ToString(),
row["CustomerName"].ToString(),
row["DAY"].ToString(),
row["ShipTo"].ToString(),
row["PhoneContact"].ToString());
results.Add(itemEntity);
itemEntity = null;
GC.Collect();
}
}
return(results);
}
public CustomerOrderViewModel(CustomerOrder co)
{
this.ProductQuoteID = co.ProductQuoteID;
this.CustomerOrderCode = co.CustomerOrderCode;
this.CustomerOrderCodeNew = co.CustomerOrderCodeNew;
this.DateOrder = co.DateOrder;
this.DateOrderView = co.DateOrderView;
this.ApprovedDate = co.ApprovedDate;
this.RejectedDate = co.RejectedDate;
this.CustomerOrderStatus = co.CustomerOrderStatus;
this.ProductQuote = new Models.ProductQuoteViewModel(co.ProductQuote);
}
protected override async Task OnActivateAsync()
{
CustomerOrderStatus orderStatusResult = await this.GetOrderStatusAsync();
if (orderStatusResult == CustomerOrderStatus.Unknown)
{
await this.StateManager.SetStateAsync <List <CustomerOrderItem> >(OrderItemListPropertyName, new List <CustomerOrderItem>());
await this.StateManager.SetStateAsync <long>(RequestIdPropertyName, 0);
await this.SetOrderStatusAsync(CustomerOrderStatus.New);
}
return;
}
/// <summary>
/// Initializes CustomerOrderActor state. Because an order actor will only be activated
/// once in this scenario and never used again, when we initiate the actor's state we
/// change the order's status to "Confirmed," and do not need to check if the actor's
/// state was already set to this.
/// </summary>
///
protected override async Task OnActivateAsync()
{
await InternalActivateAsync(this.ActorService.Context.CodePackageActivationContext, new ServiceProxyFactory());
CustomerOrderStatus orderStatusResult = await this.GetOrderStatusAsync();
if (orderStatusResult == CustomerOrderStatus.Unknown)
{
await this.StateManager.SetStateAsync <List <CustomerOrderItem> >(OrderItemListPropertyName, new List <CustomerOrderItem>());
await this.StateManager.SetStateAsync <long>(RequestIdPropertyName, 0);
await this.SetOrderStatusAsync(CustomerOrderStatus.New);
}
return;
}
protected string GetStatusColor(CustomerOrderStatus status)
{
switch (status)
{
case CustomerOrderStatus.Ruošiama:
case CustomerOrderStatus.Gaminama:
return("#6FA8DC");
case CustomerOrderStatus.Paruošta:
return("#28A745");
case CustomerOrderStatus.Atšaukta:
return("#999999");
case CustomerOrderStatus.Užbaigta:
return("#6C757D");
default:
return("#6C757D");
}
}
public async Task TestFulfillOrderCancelled()
{
// instruct the mock inventory service to return 0 for all items to simulate items that don't exist.
// and have it return false when asked if an item exists to make sure FulfillOrder doesn't get into
// an infinite backorder loop.
MockInventoryService inventoryService = new MockInventoryService()
{
IsItemInInventoryAsyncFunc = itemId => Task.FromResult(false),
RemoveStockAsyncFunc = (itemId, quantity, cmid) => Task.FromResult(0)
};
MockServiceProxy serviceProxy = new MockServiceProxy();
serviceProxy.Supports <IInventoryService>(serviceUri => inventoryService);
MockServiceProxyFactory serviceProxyFactory = new MockServiceProxyFactory();
serviceProxyFactory.AssociateMockServiceAndName(new Uri("fabric:/someapp/" + InventoryServiceName), inventoryService);
CustomerOrderActor target = await CreateCustomerOrderActor(serviceProxyFactory);
await target.StateManager.SetStateAsync <CustomerOrderStatus>(RequestIdPropertyName, CustomerOrderStatus.Submitted);
await target.StateManager.SetStateAsync <long>(RequestIdPropertyName, 0);
await target.StateManager.SetStateAsync <List <CustomerOrderItem> >(OrderItemListPropertyName, new List <CustomerOrderItem>()
{
new CustomerOrderItem(new InventoryItemId(), 5)
});
await target.FulfillOrderAsync();
CustomerOrderStatus status = await target.StateManager.GetStateAsync <CustomerOrderStatus>(OrderStatusPropertyName);
Assert.AreEqual <CustomerOrderStatus>(CustomerOrderStatus.Canceled, status);
}
public async Task TestFulfillOrderCancelled()
{
// instruct the mock inventory service to return 0 for all items to simulate items that don't exist.
// and have it return false when asked if an item exists to make sure FulfillOrder doesn't get into
// an infinite backorder loop.
MockInventoryService inventoryService = new MockInventoryService()
{
IsItemInInventoryAsyncFunc = itemId => Task.FromResult(false),
RemoveStockAsyncFunc = (itemId, quantity, cmid) => Task.FromResult(0)
};
MockServiceProxy serviceProxy = new MockServiceProxy();
serviceProxy.Supports <IInventoryService>(serviceUri => inventoryService);
CustomerOrderActor target = new CustomerOrderActor(serviceProxy, new MockActorStateManager());
PropertyInfo idProperty = typeof(ActorBase).GetProperty("Id");
idProperty.SetValue(target, new ActorId(Guid.NewGuid()));
await target.StateManager.SetStateAsync <CustomerOrderStatus>(RequestIdPropertyName, CustomerOrderStatus.Submitted);
await target.StateManager.SetStateAsync <long>(RequestIdPropertyName, 0);
await target.StateManager.SetStateAsync <List <CustomerOrderItem> >(OrderItemListPropertyName, new List <CustomerOrderItem>()
{
new CustomerOrderItem(new InventoryItemId(), 5)
});
await target.FulfillOrderAsync();
CustomerOrderStatus status = await target.StateManager.GetStateAsync <CustomerOrderStatus>(OrderStatusPropertyName);
Assert.AreEqual <CustomerOrderStatus>(CustomerOrderStatus.Canceled, status);
}
private async Task SetOrderStatusAsync(CustomerOrderStatus orderStatus)
{
await this.StateManager.SetStateAsync<CustomerOrderStatus>(OrderStatusPropertyName, orderStatus);
}
private async Task SetOrderStatusAsync(CustomerOrderStatus orderStatus)
{
await this.StateManager.SetStateAsync <CustomerOrderStatus>(OrderStatusPropertyName, orderStatus);
}
