public async Task Reload()
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService);
handler.Start(LOG_TAG, "Reload", GetActorProperties());
try
{
// Given the actor id (which is the event id), re-load the event stats
TicketEventStats stats = await DataStoreService.GetEventStats(this.Id.GetStringId());
var state = new EventActorState(stats);
// Make sure the state is saved
await SetEntityStateAsync(state);
}
catch (Exception ex)
{
error = ex.Message;
}
finally
{
handler.Stop(error);
if (!string.IsNullOrEmpty(error))
{
this.HealthReporterService.SendReportForService(HealthState.Error, GetHealthErrorMessage("GetStats", error));
}
}
}
public async Task <TicketOrder> GetOrder()
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService);
handler.Start(LOG_TAG, "GetOrder", GetActorProperties());
try
{
var state = await this.StateManager.GetStateAsync <TicketOrder>(ActorStatePropertyName);
return(state);
}
catch (Exception ex)
{
error = ex.Message;
return(null);
}
finally
{
handler.Stop(error);
if (!string.IsNullOrEmpty(error))
{
this.HealthReporterService.SendReportForService(HealthState.Error, GetHealthErrorMessage("GetOrder", error));
}
}
}
public async Task <IHttpActionResult> PostEvent([FromBody] TicketEvent tEvent)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "PostEvent", GetServiceProperties());
try
{
TicketEvent.Validate(tEvent);
IDataStoreService dataService = ServiceFactory.GetInstance().GetDataStoreService(TheSettingService, TheLoggerService);
var id = await dataService.CreateEvent(tEvent);
return(Ok(await dataService.GetEventById(id)));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
// Enqueuer Interface Implementation
public async Task <bool> EnqueueProcess(EntityTransaction transaction)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(SettingService);
handler.Start(LOG_TAG, "EnqueueProcess", GetServiceProperties());
bool blReturn = false;
try
{
handler.Info("Processing business key: " + transaction.BusinessKey + " - entity type: " + transaction.EntityType);
// Gets (or creates) a replicated dictionary called "ProcessQueue" in this partition.
var requests = await this.StateManager.GetOrAddAsync <IReliableQueue <EntityTransaction> >(ProcessQueueName);
using (var tx = this.StateManager.CreateTransaction())
{
await requests.EnqueueAsync(tx, transaction);
await tx.CommitAsync();
}
blReturn = true;
}
catch (Exception ex)
{
error = ex.Message;
}
finally
{
handler.Stop(error);
}
return(blReturn);
}
public async Task <string> Authorize(TicketOrder order)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(_settingService, _loggerService);
handler.Start(LOG_TAG, "Authorize", null);
var confirmation = "";
try
{
if (order == null)
{
throw new Exception("No Order");
}
// Charge against a payment processor
confirmation = GenerateRandomNumber(12);
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
return(confirmation);
}
public async Task <IHttpActionResult> PostTicketOrdersSimulation([FromBody] TicketOrderSimulationRequest request)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "PostOrder", GetServiceProperties());
try
{
TicketOrderSimulationRequest.Validate(request);
IExternalizationService extService = ServiceFactory.GetInstance().GetExternalizationService(TheSettingService, TheLoggerService);
await extService.Simulate(request);
return(Ok("Running"));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
public async Task <IHttpActionResult> PostOrder([FromBody] TicketOrder order)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "PostOrder", GetServiceProperties());
try
{
TicketOrder.Validate(order);
ServiceLocationService locator = new ServiceLocationService();
UriBuilderService builder = new UriBuilderService(Constants.ContosoEventsApplicationInstance, Constants.ContosoEventsTicketOrderServiceName);
ITicketOrderService dispenderService = locator.Create <ITicketOrderService>(builder.ToUri());
return(Ok(await dispenderService.EnqueueOrder(order)));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
public async Task Process(EntityTransaction transaction)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(SettingService);
handler.Start(LOG_TAG, "Process", GetActorProperties());
try
{
if (transaction == null)
{
handler.Info("Process transactions is null");
return;
}
// Scheduler a reminder to reprocess myself and my parent
// TODO: I think the actor does not evict from memory
// as long as there are reminders. To garbage collect, reminders
// have to be removed
await this.RegisterReminderAsync(
ReprocessReminder,
ObjectToByteArray(transaction),
TimeSpan.FromSeconds(0), // Remind immediately
TimeSpan.FromDays(1)); // Remind again in 1 day - useless of course!!
}
catch (Exception ex)
{
error = ex.Message;
}
finally
{
handler.Stop(error);
}
}
public async Task <TicketEvent> GetEventById(string eventId)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(_settingService, _loggerService);
handler.Start(LOG_TAG, "GetEventById", null);
try
{
if (this._docDbClient == null)
{
return(null);
}
FeedOptions queryOptions = new FeedOptions {
MaxItemCount = -1
};
return(this._docDbClient.CreateDocumentQuery <TicketEvent>(
UriFactory.CreateDocumentCollectionUri(_databaseName, _eventsCollectionName), queryOptions)
.Where(e => e.Id == eventId).AsEnumerable().FirstOrDefault());
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
}
public async Task Backup(EventActorState eventState)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(_settingService, _loggerService);
handler.Start(LOG_TAG, "Backup", null);
try
{
// Enqueue the event to a queue so it can be processed by an Azure function or whatever
if (_backupQueue != null)
{
var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(eventState));
await _backupQueue.AddMessageAsync(queueMessage);
}
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
}
public async Task <string> CreateEvent(TicketEvent tEvent)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(_settingService, _loggerService);
handler.Start(LOG_TAG, "CreateEvent", null);
var id = tEvent.Id;
try
{
if (this._docDbClient == null)
{
return("");
}
await this._docDbClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(_databaseName, _eventsCollectionName), tEvent);
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
return(id);
}
public async Task <List <TicketEvent> > GetEvents()
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(_settingService, _loggerService);
handler.Start(LOG_TAG, "GetEvents", null);
try
{
if (this._docDbClient == null)
{
return(new List <TicketEvent>());
}
FeedOptions queryOptions = new FeedOptions {
MaxItemCount = -1
};
IQueryable <TicketEvent> eventsQuery = this._docDbClient.CreateDocumentQuery <TicketEvent>(
UriFactory.CreateDocumentCollectionUri(_databaseName, _eventsCollectionName), queryOptions);
return(eventsQuery.ToList());
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
}
public async Task <List <TicketOrder> > GetOrdersByUserName(string userName)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(_settingService, _loggerService);
handler.Start(LOG_TAG, "GetOrdersByUserName", null);
try
{
if (this._docDbClient == null)
{
return(new List <TicketOrder>());
}
FeedOptions queryOptions = new FeedOptions {
MaxItemCount = -1
};
IQueryable <TicketOrder> ordersQuery = this._docDbClient.CreateDocumentQuery <TicketOrder>(
UriFactory.CreateDocumentCollectionUri(_databaseName, _ordersCollectionName), queryOptions)
.Where(o => o.UserName.ToLower() == userName)
.OrderByDescending(o => o.OrderDate);
return(ordersQuery.ToList());
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
}
public async Task <string> CreateEvent(TicketEvent tEvent)
{
var error = string.Empty;
var handler = HandlersFactory.GetProfilerHandler(settingService, logger);
handler.Start(LOG_TAG, "CreateEvent", null);
var id = tEvent.Id;
try
{
using (CosmosClient cosmosClient = new CosmosClient(endpointUri, primaryKey))
{
var databaseResponse = await cosmosClient.Databases.CreateDatabaseIfNotExistsAsync(databaseName);
var containerResponse = await databaseResponse.Database.Containers.CreateContainerIfNotExistsAsync(eventsContainerName, "/id");
await containerResponse.Container.Items.CreateItemAsync(tEvent.Id, tEvent);
}
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
return(id);
}
private async Task Initialize()
{
var error = string.Empty;
var handler = HandlersFactory.GetProfilerHandler(settingService, logger);
handler.Start(LOG_TAG, "Initialize", null);
try
{
using (CosmosClient cosmosClient = new CosmosClient(endpointUri, primaryKey))
{
var databaseResponse = await cosmosClient.Databases.CreateDatabaseIfNotExistsAsync(databaseName);
var containerResponse = await databaseResponse.Database.Containers.CreateContainerIfNotExistsAsync(eventsContainerName, "/id");
var event1 = CreateTicketEvent();
var itemResponse = await containerResponse.Container.Items.ReadItemAsync <TicketEvent>(event1.Id, event1.Id);
if (itemResponse.StatusCode == System.Net.HttpStatusCode.NotFound)
{
var ticketEventCreationResponse = await containerResponse.Container.Items.CreateItemAsync(event1.Id, event1);
}
}
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
}
public async Task <bool> ReserveTickets(TicketOrder order)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService);
handler.Start(LOG_TAG, "ReserveTickets", GetActorProperties());
bool isAvailable = false;
try
{
var state = await this.StateManager.GetStateAsync <EventActorState>(ActorStatePropertyName);
if ((state.Tickets - state.RequestedTickets + state.FailedTickets + state.CancelledTickets) >= order.Tickets)
{
isAvailable = true;
state.RequestedTickets += order.Tickets;
state.Orders.Add(order);
await SetEntityStateAsync(state);
}
}
catch (Exception ex)
{
error = ex.Message;
}
finally
{
handler.Stop(error);
if (!string.IsNullOrEmpty(error))
{
this.HealthReporterService.SendReportForService(HealthState.Error, GetHealthErrorMessage("ReserveTickets", error));
}
}
return(isAvailable);
}
/// <summary>
/// Adds a SapherStep to Sapher configuration
/// </summary>
/// <typeparam name="T">InputHandler type</typeparam>
/// <param name="name">Step name</param>
/// <param name="configure">Configuration action for the Step creation</param>
/// <returns>Updated ISapherConfigurator for fluent configuration</returns>
public ISapherConfigurator AddStep <T>(
string name,
Action <ISapherStepConfigurator> configure = null)
where T : class, IHandlesInput
{
var inputHandlerType = typeof(T);
if (!HandlersFactory.TryToRegisterInputHandler(
inputHandlerType,
this.serviceCollection,
out var inputMessageType,
out var outputMessage))
{
throw new SapherConfigurationException(
outputMessage,
Pair.Of("StepName", name),
Pair.Of("InputHandler", inputHandlerType.Name));
}
var stepConfigurator = new SapherStepConfigurator(
name,
inputMessageType,
inputHandlerType,
this.serviceCollection);
configure?.Invoke(stepConfigurator);
var stepConfiguration = stepConfigurator.Configure();
this.sapherSteps.Add(new SapherStep(stepConfiguration));
return(this);
}
public async Task CancelTickets(TicketOrder order)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService);
handler.Start(LOG_TAG, "CancelTickets", GetActorProperties());
try
{
var state = await this.StateManager.GetStateAsync <EventActorState>(ActorStatePropertyName);
state.CancelledTickets += order.Tickets;
state.Orders.Add(order);
await SetEntityStateAsync(state);
}
catch (Exception ex)
{
error = ex.Message;
}
finally
{
handler.Stop(error);
if (!string.IsNullOrEmpty(error))
{
this.HealthReporterService.SendReportForService(HealthState.Error, GetHealthErrorMessage("CancelTickets", error));
}
}
}
public async Task <IHttpActionResult> CancelOrder(string id)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "CancelOrder", GetServiceProperties());
try
{
//TODO: Task 3.1 - Get the actor location service
//IActorLocationService locator = ServiceFactory.GetInstance()./*...complete this...*/;
//TODO: Task 3.2 - Acquire the Order Actor instance
//ITicketOrderActor orderActor = locator./*...complete this...*/(new ActorId(id), Constants.ContosoEventsApplicationName);
//TODO: Task 3.3 - Cancel the order
//await orderActor./*...complete this...*/;
return(Ok("Ok"));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
public async Task <string> GetNodeName()
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService);
handler.Start(LOG_TAG, "GetNodeName", GetServiceProperties());
string nodeName = "Unknown";
try
{
nodeName = Context.NodeContext.NodeName;
}
catch (Exception ex)
{
error = ex.Message;
throw ex;
}
finally
{
handler.Stop(error);
if (!string.IsNullOrEmpty(error))
{
this.HealthReporterService.SendReportForService(HealthState.Error, GetHealthErrorMessage("GetNodeName", error));
}
}
return(nodeName);
}
public async Task Simulate(TicketOrderSimulationRequest request)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(_settingService, _loggerService);
handler.Start(LOG_TAG, "Simulate", null);
try
{
//TODO: Task 7 BEGIN - Enqueue the simulation request
//// Enqueue the event to a queue so it can be processed by an Azure function or whatever
//if (_simulationQueue != null)
//{
// var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(request));
// await _simulationQueue.AddMessageAsync(queueMessage);
//}
//TODO: Task 7 END
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
}
public async Task <IHttpActionResult> CancelOrder(string id)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService, TheLoggerService);
handler.Start(LOG_TAG, "CancelOrder", GetServiceProperties());
try
{
IActorLocationService locator = ServiceFactory.GetInstance().GetActorLocationService();
ITicketOrderActor orderActor = locator.Create <ITicketOrderActor>(new ActorId(id), Constants.ContosoEventsApplicationName);
await orderActor.CancelOrder();
return(Ok("Ok"));
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
public void SendReportForPartition(HealthState healthState, string message)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(_settingService, _loggerService);
handler.Start(LOG_TAG, "SendReportForPartition", null);
try
{
HealthReport healthReport = new PartitionHealthReport(_partitionId,
new HealthInformation(_serviceName, message, healthState));
healthReport.HealthInformation.TimeToLive = TimeSpan.FromMinutes(_settingService.GetHealthIssuesTimeToLive());
healthReport.HealthInformation.RemoveWhenExpired = false;
ReportHealth(healthReport);
}
catch (Exception ex)
{
error = ex.Message;
/* Ignore */
}
finally
{
handler.Stop(error);
}
}
public async Task <EntityView> GetView()
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(SettingService);
handler.Start(LOG_TAG, "GetView", GetActorProperties());
try
{
var state = await this.StateManager.GetStateAsync <EntityActorState>(ActorStatePropertyName);
return(new EntityView()
{
Type = state.Entity.Type,
BusinessKey = state.Entity.BusinessKey,
Name = state.Entity.Name,
Purchases = state.Purchases,
Cancellations = state.Cancellations,
SoldItems = state.SoldItems,
Revenue = state.Revenue,
Tax = state.Tax,
Shipping = state.Shipping
});
}
catch (Exception ex)
{
error = ex.Message;
return(null);
}
finally
{
handler.Stop(error);
}
}
public Mediator(HandlersFactory factory, IMediatorConfiguration options)
{
this.options = options;
this.factory = factory;
HandlersAssembly = options.HandlersAssembly;
}
public async Task <bool> Refund(TicketOrder order)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(_settingService, _loggerService);
handler.Start(LOG_TAG, "Refund", null);
var isSuccess = false;
try
{
if (order == null)
{
throw new Exception("No Order");
}
// Refund against a payment processor
isSuccess = true;
}
catch (Exception ex)
{
error = ex.Message;
throw new Exception(error);
}
finally
{
handler.Stop(error);
}
return(isSuccess);
}
public async Task <List <TicketOrder> > GetHistoricalOrders()
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService);
handler.Start(LOG_TAG, "GetHistoricalOrders", GetActorProperties());
List <TicketOrder> orders = new List <TicketOrder>();
try
{
var state = await this.StateManager.GetStateAsync <EventActorState>(ActorStatePropertyName);
orders = state.Orders.OrderBy(o => o.OrderDate).ToList();
}
catch (Exception ex)
{
error = ex.Message;
}
finally
{
handler.Stop(error);
if (!string.IsNullOrEmpty(error))
{
this.HealthReporterService.SendReportForService(HealthState.Error, GetHealthErrorMessage("GetHistoricalOrders", error));
}
}
return(orders);
}
public async Task <IHttpActionResult> PostReprocess([FromBody] EntityTransaction transaction)
{
var error = "";
var handler = HandlersFactory.GetProfilerHandler(TheSettingService);
handler.Start(LOG_TAG, "PostReprocess", GetServiceProperties());
try
{
ServiceLocationService locator = new ServiceLocationService();
UriBuilderService builder = new UriBuilderService(Constants.ApplicationInstance, Constants.EnqueuerServiceName);
var partitionKey = (long)transaction.EntityType;
IEnqueuerService enqueuerService = locator.Create <IEnqueuerService>(partitionKey, builder.ToUri());
bool isEnqueued = await enqueuerService.EnqueueProcess(transaction);
if (isEnqueued)
{
return(Ok());
}
else
{
throw new Exception("Enqueuing failed!!!");
}
}
catch (Exception ex)
{
error = ex.Message;
return(BadRequest(ex.Message));
}
finally
{
handler.Stop(error);
}
}
protected override void OnAbort()
{
var handler = HandlersFactory.GetProfilerHandler(SettingService);
handler.Start(LOG_TAG, "OnAbort", GetServiceProperties());
handler.Stop();
base.OnAbort();
}
protected override Task OnDeactivateAsync()
{
var handler = HandlersFactory.GetProfilerHandler(SettingService, LoggerService);
handler.Start(LOG_TAG, "OnDeactivateAsync", GetActorProperties());
handler.Stop();
return(base.OnDeactivateAsync());
}
