public static void AssertResetInventoryQuantityReserveAndHold(RealTimeInventory inventory, int toUpdate, int toReserve, int toHold, IInventoryServiceCompletedMessage r)
{
if ((toUpdate - toReserve >= 0) || toReserve <= 0)
{
if (toUpdate - toHold >= 0)
{
Assert.True(r.Successful);
var newReserved = Math.Max(0, toReserve);
Assert.Equal(r.RealTimeInventory.Reserved, newReserved);
Assert.Equal(r.RealTimeInventory.Holds, toHold);
}
else
{
Assert.False(r.Successful);
}
}
else
{
Assert.False(r.Successful);
}
if (r.Successful)
{
return;
}
//else things remain same
Assert.Equal(r.RealTimeInventory.Quantity, inventory.Quantity);
Assert.Equal(r.RealTimeInventory.Reserved, inventory.Reserved);
Assert.Equal(r.RealTimeInventory.Holds, inventory.Holds);
}
public void ETag_Test(RealTimeInventory existingRealTimeInventory, int quantity, int reserve, int hold)
{
var newRealTimeInventory = new RealTimeInventory(existingRealTimeInventory.ProductId, existingRealTimeInventory.Quantity, existingRealTimeInventory.Reserved, existingRealTimeInventory.Holds);
var first = new RealTimeInventory(existingRealTimeInventory.ProductId, 0, 0, 0);
var second = new RealTimeInventory(existingRealTimeInventory.ProductId, 0, 0, 0);
var third = new RealTimeInventory("ticketsections-" + quantity, quantity, reserve, hold);
var forth = new RealTimeInventory("ticketsections-" + quantity, quantity, reserve, hold);
Assert.False(existingRealTimeInventory.IsMostRecentThan(newRealTimeInventory));
Assert.False(existingRealTimeInventory.IsMostRecentThan(new RealTimeInventory(null, 0, 0, 0)));
Assert.False(newRealTimeInventory.IsMostRecentThan(new RealTimeInventory(null, 0, 0, 0)));
var mostRecentEtag = forth.ETag.GetMostRecentEtag(
newRealTimeInventory.ETag,
existingRealTimeInventory.ETag,
first.ETag,
second.ETag,
third.ETag,
forth.ETag
);
Assert.False(newRealTimeInventory.IsMostRecentThan(first));
Assert.False(first.IsMostRecentThan(second));
Assert.False(second.IsMostRecentThan(third));
Assert.False(third.IsMostRecentThan(forth));
Assert.Equal(mostRecentEtag, forth.ETag);
}
public static async Task <OperationResult <IRealTimeInventory> > PurchaseFromHoldsAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int quantity)
{
if (quantity < 0)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.NEGATIVE_PURCHASE_FOR_PURCHASEFROMHOLD, realTimeInventory, quantity).ToFailedOperationResult(realTimeInventory, productId));
}
var newQuantity = realTimeInventory.Quantity - quantity;
var newHolds = realTimeInventory.Holds - quantity;
if (newQuantity < 0 || newHolds < 0)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.PURCHASE_EXCEED_QUANTITY_FOR_PURCHASEFROMHOLD, realTimeInventory, quantity).ToFailedOperationResult(realTimeInventory, productId));
}
var newrealTimeInventory = new RealTimeInventory(productId, newQuantity, realTimeInventory.Reserved,
newHolds);
var result = await inventoryStorage.WriteInventoryAsync(newrealTimeInventory).ConfigureAwait(false);
if (!result.IsSuccessful)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, quantity, result.Errors).ToFailedOperationResult(realTimeInventory, productId));
}
return(newrealTimeInventory.ToOperationResult(isSuccessful: true));
}
public static async Task <OperationResult <IRealTimeInventory> > PurchaseAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int quantity)
{
if (quantity < 0)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.NEGATIVE_PURCHASE_FOR_PURCHASEFROMRESERVATION, realTimeInventory, quantity).ToFailedOperationResult(realTimeInventory, productId));
}
var newQuantity = realTimeInventory.Quantity - quantity;
var newReserved = Math.Max(0, realTimeInventory.Reserved - quantity);
//todo we still want to sell even though there is reservation
//var newReserved = realTimeInventory.Reserved - quantity;
//if(newReserved<0) throw new Exception("provided " + quantity + ", available reservations must be less than or equal to quantity for product " + productId);
if (newQuantity - realTimeInventory.Holds < 0)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.PURCHASE_EXCEED_QUANTITY_FOR_PURCHASEFROMRESERVATION, realTimeInventory, quantity).ToFailedOperationResult(realTimeInventory, productId));
}
var newrealTimeInventory = new RealTimeInventory(productId, newQuantity, newReserved, realTimeInventory.Holds);
var result = await inventoryStorage.WriteInventoryAsync(newrealTimeInventory);
if (!result.IsSuccessful)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, quantity, result.Errors).ToFailedOperationResult(realTimeInventory, productId));
}
return(newrealTimeInventory.ToOperationResult(isSuccessful: true));
}
public void Holds_Test(RealTimeInventory inventory, int toHold)
{
IInventoryServiceCompletedMessage response;
using (var testHelper = CreateInventoryServiceServer(inventory))
response = testHelper.PlaceHoldAsync(inventory, toHold).WaitAndGetOperationResult();
InventoryServiceSpecificationHelper.AssertHolds(inventory, toHold, response);
}
public void UpdateQuantity_Test(RealTimeInventory inventory, int toUpdate)
{
IInventoryServiceCompletedMessage response;
using (var testHelper = CreateInventoryServiceServer(inventory))
response = testHelper.UpdateQuantityAsync(inventory, toUpdate).WaitAndGetOperationResult();
InventoryServiceSpecificationHelper.AssertUpdateQuantity(inventory, toUpdate, response);
}
public void PurchaseFromHolds_Test(RealTimeInventory inventory, uint toPurchase)
{
IInventoryServiceCompletedMessage response;
using (var testHelper = CreateInventoryServiceServer(inventory))
response = testHelper.PurchaseFromHoldsAsync(inventory, (int)toPurchase).WaitAndGetOperationResult();
InventoryServiceSpecificationHelper.AssertPurchaseFromHolds(inventory, toPurchase, response);
}
public void Reservation_Test(RealTimeInventory inventory, int toReserve)
{
IInventoryServiceCompletedMessage response = null;
using (var testHelper = CreateInventoryServiceServer(inventory))
response = testHelper.ReserveAsync(inventory, toReserve).WaitAndGetOperationResult();
InventoryServiceSpecificationHelper.AssertReservations(inventory, toReserve, response);
}
public Task <IInventoryServiceCompletedMessage> PurchaseAsync(RealTimeInventory product, int purchaseQuantity)
{
var request = new PurchaseMessage(product.ProductId, purchaseQuantity);
if (DontUseActorSystem)
{
return(PerformOperation(request, product.PurchaseAsync(TestInventoryStorage, request.ProductId, request.Update), TestInventoryStorage.ReadInventoryAsync(request.ProductId).Result.Result));
}
return(inventoryActor.Ask <IInventoryServiceCompletedMessage>(request, GENERAL_WAIT_TIME));
}
public void ResetInventoryQuantityReserveAndHold_Test(RealTimeInventory inventory, int toUpdate, int toReserve, int toHold)
{
IInventoryServiceCompletedMessage response;
using (var testHelper = CreateInventoryServiceServer(inventory))
{
response = testHelper.ResetInventoryQuantityReserveAndHoldAsync(inventory, toUpdate, toReserve, toHold).WaitAndGetOperationResult();
}
InventoryServiceSpecificationHelper.AssertResetInventoryQuantityReserveAndHold(inventory, toUpdate, toReserve, toHold, response);
}
public void TestMethod1()
{
var initialInventory = new RealTimeInventory("ticketsections-100", 10, 0, 0);
var serverOptions = new InventoryServerOptions()
{
InitialInventory = initialInventory,
InventoryActorAddress = "akka.tcp://InventoryService-Server@localhost:10000/user/InventoryActor",
ServerEndPoint = "http://*:10088/",
StorageType = typeof(InMemory),
ServerActorSystemName = "InventoryService-Server",
ServerActorSystemConfig = @"
akka.actor{provider= ""Akka.Remote.RemoteActorRefProvider, Akka.Remote""}
akka.remote.helios.tcp {
transport-class =""Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote""
port = 10000
transport-protocol = tcp
hostname = ""localhost""
}
"
};
using (var server = new InventoryServiceServer(new TestPerformanceService(), new NullBackUp(), serverOptions))
{
var mySystem = Akka.Actor.ActorSystem.Create("mySystem", ConfigurationFactory.ParseString(@"
akka.actor{provider= ""Akka.Remote.RemoteActorRefProvider, Akka.Remote""}
akka.remote.helios.tcp {
transport-class =""Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote""
port = 0
transport-protocol = tcp
hostname = ""localhost""
}
"));
var inventoryActor = mySystem.ActorSelection(serverOptions.InventoryActorAddress);
var result =
server.inventoryActor.Ask <IInventoryServiceCompletedMessage>(new ReserveMessage(
initialInventory.ProductId, 20));
result.ConfigureAwait(false);
Task.WaitAll(result);
if (result.Result.Successful)
{
Console.WriteLine(result.Result.RealTimeInventory);
}
else
{
Console.WriteLine(result.Result.RealTimeInventory);
}
}
}
public static RealTimeInventory InitializeFromStorage(this RealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string id)
{
var initTask = inventoryStorage.ReadInventoryAsync(id);
Task.WaitAll(initTask);
var inventory = initTask.Result.Result;
if (!initTask.Result.IsSuccessful)
{
throw initTask.Result.Errors.Flatten();
}
return(new RealTimeInventory(id, inventory.Quantity, inventory.Reserved, inventory.Holds));
}
public static async Task <OperationResult <IRealTimeInventory> > UpdateQuantityAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int quantity)
{
var newQuantity = realTimeInventory.Quantity + quantity;
var newRealTimeInventory = new RealTimeInventory(productId, newQuantity, realTimeInventory.Reserved, realTimeInventory.Holds);
var result = await inventoryStorage.WriteInventoryAsync(newRealTimeInventory);
if (!result.IsSuccessful)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, quantity, result.Errors).ToFailedOperationResult(realTimeInventory, productId));
}
return(newRealTimeInventory.ToOperationResult(isSuccessful: true));
}
public InventoryServiceServer CreateInventoryServiceServer(RealTimeInventory inventory)
{
/*
* TODO USE THESE
#if !FULL_INTEGRATION
* return new InventoryServiceServer(new InventoryServerOptions() { InitialInventory = inventory, DontUseActorSystem = true });
#else
* return new InventoryServiceServer(new InventoryServerOptions() { InitialInventory = inventory });
#endif
*/
// return new InventoryServiceServer(new InventoryServerOptions() { InitialInventory = inventory });
return(new InventoryServiceServer(new TestPerformanceService(), new NullBackUp(), new InventoryServerOptions()
{
InitialInventory = inventory, DontUseActorSystem = true
}));
}
public void Holds_Reservation_PurchaseFromHold_And_Purchase_Test(RealTimeInventory inventory, int toUpdate)
{
using (var testHelper = CreateInventoryServiceServer(inventory))
{
const int looplength = 5;
var operations = InventoryServiceSpecificationHelper.GetOperations(testHelper);
var assertions = InventoryServiceSpecificationHelper.GetAssertions();
var updatedInventory = inventory;
for (var i = 0; i < looplength; i++)
{
var selection = new Random().Next(1, operations.Count);
var updatedInventoryMessage = operations[selection](updatedInventory, toUpdate).WaitAndGetOperationResult();
assertions[selection](updatedInventory, toUpdate, updatedInventoryMessage);
updatedInventory = updatedInventoryMessage.RealTimeInventory as RealTimeInventory;
}
}
}
public Task <IInventoryServiceCompletedMessage> ResetInventoryQuantityReserveAndHoldAsync(
RealTimeInventory product,
int quantity,
int reserveQuantity,
int holdsQuantity)
{
var request = new ResetInventoryQuantityReserveAndHoldMessage(product.ProductId, quantity, reserveQuantity, holdsQuantity);
if (DontUseActorSystem)
{
return(PerformOperation(request, product.ResetInventoryQuantityReserveAndHoldAsync(TestInventoryStorage, request.ProductId, request.Update, request.Reservations, request.Holds),
TestInventoryStorage
.ReadInventoryAsync(request.ProductId)
.Result.Result));
}
return(inventoryActor.Ask <IInventoryServiceCompletedMessage>(request, GENERAL_WAIT_TIME));
}
public static async Task <OperationResult <IRealTimeInventory> > PlaceHoldAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int toHold)
{
var newHolds = realTimeInventory.Holds + toHold;
if (newHolds > realTimeInventory.Quantity)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.HOLD_EXCEED_QUANTITY_FOR_HOLD, realTimeInventory, toHold).ToFailedOperationResult(realTimeInventory, productId));
}
var newRealTimeInventory = new RealTimeInventory(productId, realTimeInventory.Quantity, realTimeInventory.Reserved, newHolds);
var result = await inventoryStorage.WriteInventoryAsync(newRealTimeInventory);
if (!result.IsSuccessful)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, toHold, result.Errors).ToFailedOperationResult(realTimeInventory, productId));
}
return(newRealTimeInventory.ToOperationResult(isSuccessful: true));
}
public static async Task <OperationResult <IRealTimeInventory> > ReserveAsync(this IRealTimeInventory realTimeInventory, IInventoryStorage inventoryStorage, string productId, int reservationQuantity)
{
var newReserved = Math.Max(0, realTimeInventory.Reserved + reservationQuantity);
if ((reservationQuantity > 0) && (newReserved > realTimeInventory.Quantity - realTimeInventory.Holds))
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.RESERVATION_EXCEED_QUANTITY, realTimeInventory, reservationQuantity).ToFailedOperationResult(realTimeInventory, productId));
}
var newRealTimeInventory = new RealTimeInventory(productId, realTimeInventory.Quantity, newReserved, realTimeInventory.Holds);
var result = await inventoryStorage.WriteInventoryAsync(newRealTimeInventory);
if (!result.IsSuccessful)
{
return(InventoryServiceErrorMessageGenerator.Generate(ErrorType.UNABLE_TO_UPDATE_INVENTORY_STORAGE, realTimeInventory, reservationQuantity, result.Errors).ToFailedOperationResult(realTimeInventory, productId));
}
return(newRealTimeInventory.ToOperationResult(isSuccessful: true));
}
public static async Task <OperationResult <IRealTimeInventory> > ResetInventoryQuantityReserveAndHoldAsync(this IRealTimeInventory currentInventory, IInventoryStorage inventoryStorage, string productId, int quantity, int reserve, int hold)
{
IRealTimeInventory realTimeInventory = new RealTimeInventory(currentInventory.ProductId, 0, 0, 0);
var result = await realTimeInventory.UpdateQuantityAsync(inventoryStorage, productId, quantity);
if (result.IsSuccessful)
{
result = await result.Data.ReserveAsync(inventoryStorage, productId, reserve);
if (result.IsSuccessful)
{
result = await result.Data.PlaceHoldAsync(inventoryStorage, productId, hold);
if (result.IsSuccessful)
{
return(result.Data.ToOperationResult(isSuccessful: true));
}
}
}
result.Data = currentInventory;
return(result);
}
private void btnExecute_Click(object sender, EventArgs e)
{
try
{
var productName = "productName";
var inventory = new RealTimeInventory(
productName,
Convert.ToInt32(InitialQuantity.Text),
Convert.ToInt32(InitialReservation.Text),
Convert.ToInt32(InitialHold.Text));
InventoryServiceServer helper = new InventoryServiceServer(new TestPerformanceService(), new NullBackUp(), new InventoryServerOptions()
{
StorageType = typeof(Storage.InMemoryLib.InMemory),
InitialInventory = inventory,
ClientActorSystem = ActorSystem
});
var t = helper.ReserveAsync(ActorSystem.ActorSelection(textBox1.Text), 1);
var task = ActorSystem.ActorSelection(textBox1.Text).ResolveOne(TimeSpan.FromSeconds(5));
// task.ConfigureAwait(false);
task.ContinueWith(r =>
{
IInventoryServiceCompletedMessage result = null;
var newUpdate = Convert.ToInt32(NewQuantity.Text);
switch (cmbOoperation.SelectedItem.ToString())
{
case "ReadInventory":
result = helper.GetInventoryAsync(productName).WaitAndGetOperationResult();
break;
case "Reserve":
result = helper.ReserveAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "UpdateQuantity":
result = helper.UpdateQuantityAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "UpdateQuantityAndHold":
result = helper.UpdateQuantityAndHoldAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "PlaceHold":
result = helper.PlaceHoldAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "Purchase":
result = helper.PurchaseAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "PurchaseFromHolds":
result = helper.PurchaseFromHoldsAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
}
if (result != null)
{
ResultQuantity.Text = result.RealTimeInventory.Quantity.ToString();
ResultHold.Text = result.RealTimeInventory.Holds.ToString();
ResultReservation.Text = result.RealTimeInventory.Reserved.ToString();
if (!result.Successful)
{
var errorMessage = result as InventoryOperationErrorMessage;
var list = new List <string>();
var aggregateException = errorMessage?.Error;
if (aggregateException != null)
{
list.Add(aggregateException.ErrorMessage);
}
richTextBox1.Text = errorMessage?.Error?.ErrorMessage + " - " + string.Join(" ", list);
}
else
{
richTextBox1.Text = "";
}
}
});
}
catch (Exception ex)
{
richTextBox1.Text = ex.Message + ex?.InnerException?.Message;
}
}
private List <Tuple <int, RealTimeInventory, int> > CreateInventoryOperationEvents(RealTimeInventory inventory, int toUpdate, int looplength)
{
List <Tuple <int, RealTimeInventory, int> > events = new List <Tuple <int, RealTimeInventory, int> >();
var operations = InventoryServiceSpecificationHelper.GetOperations(null);
var updatedInventory = inventory;
for (var i = 0; i < looplength; i++)
{
var selection = new Random().Next(1, operations.Count);
events.Add(new Tuple <int, RealTimeInventory, int>(selection, new RealTimeInventory(updatedInventory.ProductId, updatedInventory.Quantity, updatedInventory.Reserved, updatedInventory.Holds), toUpdate));
}
return(events);
}
public void Concurrent_Holds_Reservation_PurchaseFromHold_And_Purchase_Async_Test(RealTimeInventory inventory, int toUpdate)
{
const int looplength = 5;
var events = CreateInventoryOperationEvents(inventory, toUpdate, looplength);
RealTimeInventory currentInventoryAfterFirstOperation;
using (var testHelper = CreateInventoryServiceServer(inventory))
currentInventoryAfterFirstOperation = RunSomeInventoryOperationUsingEventsSync(events, testHelper);
RealTimeInventory currentInventoryAfterLastOperation;
using (var testHelper = CreateInventoryServiceServer(inventory))
currentInventoryAfterLastOperation = RunSomeInventoryOperationUsingEventsAsync(events, testHelper);
Assert.Equal(currentInventoryAfterFirstOperation.Quantity, currentInventoryAfterLastOperation.Quantity);
Assert.Equal(currentInventoryAfterFirstOperation.Reserved, currentInventoryAfterLastOperation.Reserved);
Assert.Equal(currentInventoryAfterFirstOperation.Holds, currentInventoryAfterLastOperation.Holds);
}
public RealTimeInventoryFinalResult(RealTimeInventory realTimeInventory, IInventoryServiceCompletedMessage inventoryServiceCompletedMessage, OperationResult <IRealTimeInventory> result)
{
RealTimeInventory = realTimeInventory;
InventoryServiceCompletedMessage = inventoryServiceCompletedMessage;
Result = result;
}
public ProductInventoryActor(IInventoryStorage inventoryStorage, IActorRef InventoryQueryActorRef, string id, bool withCache, IPerformanceService performanceService)
{
PerformanceService = performanceService;
_id = id;
_withCache = withCache;
InventoryStorage = inventoryStorage;
RealTimeInventory = RealTimeInventory.InitializeFromStorage(InventoryStorage, id);
NotificationActorRef = InventoryQueryActorRef;
ReceiveAsync <GetInventoryMessage>(async message =>
{
if (!CanProcessMessage(message.ProductId, message))
{
return;
}
if (_withCache == false)
{
var result = await RealTimeInventory.ReadInventoryFromStorageAsync(InventoryStorage, message.ProductId);
RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory;
}
else
{
RealTimeInventory = RealTimeInventory.ToSuccessOperationResult().ProcessAndSendResult(message, (rti) => new GetInventoryCompletedMessage(rti, true), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory;
}
});
ReceiveAsync <ReserveMessage>(async message =>
{
if (!CanProcessMessage(message.ProductId, message))
{
return;
}
var result = await RealTimeInventory.ReserveAsync(InventoryStorage, message.ProductId, message.Update);
RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory;
});
ReceiveAsync <UpdateQuantityMessage>(async message =>
{
if (!CanProcessMessage(message.ProductId, message))
{
return;
}
var result = await RealTimeInventory.UpdateQuantityAsync(InventoryStorage, message.ProductId, message.Update);
RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory;
});
ReceiveAsync <UpdateAndHoldQuantityMessage>(async message =>
{
if (!CanProcessMessage(message.ProductId, message))
{
return;
}
var updateandHoldResultesult = await RealTimeInventory.UpdateQuantityAndHoldAsync(InventoryStorage, message.ProductId, message.Update);
RealTimeInventory = updateandHoldResultesult.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory;
});
ReceiveAsync <PlaceHoldMessage>(async message =>
{
if (!CanProcessMessage(message.ProductId, message))
{
return;
}
var result = await RealTimeInventory.PlaceHoldAsync(InventoryStorage, message.ProductId, message.Update);
RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory;
});
ReceiveAsync <PurchaseMessage>(async message =>
{
if (!CanProcessMessage(message.ProductId, message))
{
return;
}
var result = await RealTimeInventory.PurchaseAsync(InventoryStorage, message.ProductId, message.Update);
RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory;
});
ReceiveAsync <PurchaseFromHoldsMessage>(async message =>
{
if (!CanProcessMessage(message.ProductId, message))
{
return;
}
var result = await RealTimeInventory.PurchaseFromHoldsAsync(InventoryStorage, message.ProductId, message.Update).ConfigureAwait(false);
RealTimeInventory = result.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory;
});
ReceiveAsync <FlushStreamsMessage>(async message =>
{
var result = await RealTimeInventory.InventoryStorageFlushAsync(InventoryStorage, _id);
Sender.Tell(result.Data);
});
ReceiveAsync <ResetInventoryQuantityReserveAndHoldMessage>(async message =>
{
if (!CanProcessMessage(message.ProductId, message))
{
return;
}
var updateandHoldResultesult = await RealTimeInventory.ResetInventoryQuantityReserveAndHoldAsync(InventoryStorage, message.ProductId, message.Update, message.Reservations, message.Holds);
RealTimeInventory = updateandHoldResultesult.ProcessAndSendResult(message, CompletedMessageFactory.GetResponseCompletedMessage(message), Logger, RealTimeInventory, Sender, NotificationActorRef, PerformanceService).RealTimeInventory;
});
#if DEBUG
// Context.System.Scheduler.ScheduleTellRepeatedly(TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(5), Nobody.Instance, RealTimeInventory, Self);
#endif
}
protected override void PostStop()
{
Logger.Error(" I , the " + _id + " have been stopped. At the moment my inventory is " + RealTimeInventory.GetCurrentQuantitiesReport());
Sender.Tell(new InventoryOperationErrorMessage(new RealTimeInventory(_id, 0, 0, 0), new RealTimeInventoryException()
{
ErrorMessage = "Actor " + _id + " has stopped"
}));
Context.Parent.Tell(new RemoveProductMessage(RealTimeInventory));
base.PostStop();
}
public RemoveProductMessage(RealTimeInventory realTimeInventory, Exception reason = null)
{
RealTimeInventory = realTimeInventory;
Reason = reason;
}