public async Task <long> SubmitCartOrderAsync(string userId)
{
using var log = BeginFunction(nameof(CartUserService), nameof(SubmitCartOrderAsync), userId);
try
{
//AssertIsEndUser(userId);
await Assert(SecurityPolicy.IsAuthorized, userId).ConfigureAwait(false);
var ordererReference = CreateOrdererReference.FromUserId(userId);
var ordererId = await OrderMicroService.AllocateOrdererAsync(ordererReference).ConfigureAwait(false);
var orderId = await OrderMicroService.SubmitCartAsync(ordererId).ConfigureAwait(false);
var result = orderId;
_ = await EventProcessorMicroService.ProcessPendingEvents().ConfigureAwait(false);
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task <bool> AddProjectAsync(string userId, Guid projectId, int quantity)
{
using var log = BeginFunction(nameof(CartUserService), nameof(AddProjectAsync), userId, projectId, quantity);
try
{
await Assert(SecurityPolicy.IsAuthorized, userId).ConfigureAwait(false);
var ordererReference = CreateOrdererReference.FromUserId(userId);
var ordererId = await OrderMicroService.AllocateOrdererAsync(ordererReference).ConfigureAwait(false);
var projectSnapshotId = await ProjectMicroService.GetCurrentSnapshotIdAsync(projectId).ConfigureAwait(false);
var mProjectSnapshotDetail = await ProjectMicroService.GetProjectSnapshotAsync(projectSnapshotId).ConfigureAwait(false);
var mAllocateOrderable = MicroDataFactory.MOrder_AllocateOrderable(mProjectSnapshotDetail);
var mAllocateOrderableResponseData = await OrderMicroService.AllocateOrderableAsync(mAllocateOrderable).ConfigureAwait(false);
var orderableId = mAllocateOrderableResponseData.OrderableId;
var result = await OrderMicroService.AddCartItemAsync(ordererId, orderableId, quantity).ConfigureAwait(false);
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public AggregationMicroServiceFacade()
{
this.orderMicroService = new OrderMicroService();
this.payMicroService = new PayMicroService();
this.productMicroService = new ProductMicroService();
this.stockMicroService = new StockMicroService();
}
public async Task HandleFulfillmentEventAsync(MFulfillment_FulfillableEvent eventData)
{
using var log = BeginFunction(nameof(FulfillmentEventMicroService), nameof(HandleFulfillmentEventAsync), eventData);
try
{
using var ctx = CreateQuiltContext();
foreach (var fulfillmentEventItem in eventData.FulfillableEventItems)
{
if (fulfillmentEventItem.FulfillmentCompleteQuantity != 0)
{
if (TryParseOrderItemId.FromFulfillableItemReference(fulfillmentEventItem.FulfillmentItemReference, out var orderItemId))
{
await OrderMicroService.SetFulfillmentCompleteAsync(orderItemId, fulfillmentEventItem.FulfillmentCompleteQuantity, eventData.UnitOfWork).ConfigureAwait(false);
}
}
if (fulfillmentEventItem.FulfillmentReturnQuantity != 0)
{
if (TryParseOrderItemId.FromFulfillableItemReference(fulfillmentEventItem.FulfillmentItemReference, out var orderItemId))
{
await OrderMicroService.SetFulfillmentReturnAsync(orderItemId, fulfillmentEventItem.FulfillmentReturnQuantity, eventData.UnitOfWork).ConfigureAwait(false);
}
}
}
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task <AEvent_EventLogList> GetEventLogsAsync(string unitOfWork, string source)
{
using var log = BeginFunction(nameof(EventAdminService), nameof(GetEventLogsAsync), unitOfWork);
try
{
await Assert(SecurityPolicy.IsPrivileged).ConfigureAwait(false);
var eventLogs = new AEvent_EventLogList()
{
MFunderEventLogs = await FundingMicroService.GetFunderEventLogSummariesAsync(null, unitOfWork, source).ConfigureAwait(false),
MFundableEventLogs = await FundingMicroService.GetFundableEventLogSummariesAsync(null, unitOfWork, source).ConfigureAwait(false),
MFulfillableEventLogs = await FulfillmentMicroService.GetFulfillableEventLogSummariesAsync(null, unitOfWork, source).ConfigureAwait(false),
MShipmentRequestEventLogs = await FulfillmentMicroService.GetShipmentRequestEventLogSummariesAsync(null, unitOfWork, source).ConfigureAwait(false),
MShipmentEventLogs = await FulfillmentMicroService.GetShipmentEventLogSummariesAsync(null, unitOfWork, source).ConfigureAwait(false),
MReturnRequestTrnsactions = await FulfillmentMicroService.GetReturnRequestEventLogSummariesAsync(null, unitOfWork, source).ConfigureAwait(false),
MReturnEventLogs = await FulfillmentMicroService.GetReturnEventLogSummariesAsync(null, unitOfWork, source).ConfigureAwait(false),
MOrderEventLogs = await OrderMicroService.GetOrderEventLogSummariesAsync(null, unitOfWork, source).ConfigureAwait(false),
MSquarePaymentEventLogs = await SquareMicroService.GetPaymentEventLogSummariesAsync(null, unitOfWork, source).ConfigureAwait(false),
MSquareRefundEventLogs = await SquareMicroService.GetRefundEventLogSummariesAsync(null, null, unitOfWork, source).ConfigureAwait(false)
};
var result = eventLogs;
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task <IReadOnlyList <AOrder_OrderSummary> > GetOrderSummariesAsync(string orderNumber, DateTime?orderDateUtc, MOrder_OrderStatus orderStatus, string userName, int?recordCount)
{
using var log = BeginFunction(nameof(OrderAdminService), nameof(GetOrderSummariesAsync), orderNumber, orderDateUtc, orderStatus, userName, recordCount);
try
{
await Assert(SecurityPolicy.IsPrivileged).ConfigureAwait(false);
long?ordererId;
if (!string.IsNullOrEmpty(userName))
{
var userId = await UserMicroService.LookupUserIdAsync(userName).ConfigureAwait(false);
if (!string.IsNullOrEmpty(userId))
{
var ordererReference = CreateOrdererReference.FromUserId(userId);
ordererId = await OrderMicroService.LookupOrdererAsync(ordererReference);
}
else
{
ordererId = null;
}
}
else
{
ordererId = null;
}
var mOrderSummaryList = await OrderMicroService.GetOrderSummariesAsync(orderNumber, orderDateUtc, orderStatus, ordererId, recordCount).ConfigureAwait(false);
var orderSummaries = new List <AOrder_OrderSummary>();
foreach (var mOrderSummary in mOrderSummaryList.Summaries)
{
orderSummaries.Add(new AOrder_OrderSummary()
{
OrderId = mOrderSummary.OrderId,
OrderNumber = mOrderSummary.OrderNumber,
OrderDateTimeUtc = mOrderSummary.OrderDateTimeUtc,
StatusDateTimeUtc = mOrderSummary.UpdateDateTimeUtc,
OrderStatusType = mOrderSummary.OrderStatus.ToString(),
Total = mOrderSummary.TotalAmount,
UserId = "",
UserName = ""
});
}
var result = orderSummaries;
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task <AUser_User> GetUserAsync(string userId)
{
using var log = BeginFunction(nameof(UserAdminService), nameof(GetUserAsync), userId);
try
{
await Assert(SecurityPolicy.IsPrivileged).ConfigureAwait(false);
using var ctx = QuiltContextFactory.Create();
var dbAspNetUser = await ctx.AspNetUsers
.Include(r => r.AspNetUserRoles)
.ThenInclude(r => r.Role)
.Include(r => r.AspNetUserLogins)
.Where(r => r.Id == userId)
.FirstOrDefaultAsync().ConfigureAwait(false);
if (dbAspNetUser == null)
{
log.Result(null);
return(null);
}
var squareCustomerReference = CreateSquareCustomerReference.FromUserId(userId);
var squareCustomerId = await SquareMicroService.LookupSquareCustomerIdAsync(squareCustomerReference).ConfigureAwait(false);
var mSquareCustomerSummaryList = squareCustomerId != null
? await SquareMicroService.GetSquareCustomerSummariesAsync(squareCustomerId.Value, null).ConfigureAwait(false)
: null;
var mSquarePaymentSummaryList = squareCustomerId != null
? await SquareMicroService.GetSquarePaymentSummariesAsync(squareCustomerId, null, null).ConfigureAwait(false)
: null;
var ordererReference = CreateOrdererReference.FromUserId(userId);
var ordererId = await OrderMicroService.LookupOrdererAsync(ordererReference).ConfigureAwait(false);
var mOrderSummaryList = ordererId != null
? await OrderMicroService.GetOrderSummariesAsync(null, null, MOrder_OrderStatus.MetaAll, ordererId, null).ConfigureAwait(false)
: null;
var result = Create.AUser_User(
dbAspNetUser,
mOrderSummaryList,
mSquareCustomerSummaryList?.Summaries.FirstOrDefault(),
mSquarePaymentSummaryList);
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task HandleShipmentEventAsync(MFulfillment_ShipmentEvent eventData)
{
using var log = BeginFunction(nameof(FulfillmentEventMicroService), nameof(HandleShipmentEventAsync), eventData);
try
{
using var ctx = CreateQuiltContext();
switch (eventData.EventType)
{
case MFulfillment_ShipmentEventTypes.Process:
{
var fulfillableIds = new HashSet <long>();
foreach (var shipmentRequestId in eventData.ShipmentRequestIds)
{
var mShipmentRequest = await FullfillmentMicroService.GetShipmentRequestAsync(shipmentRequestId).ConfigureAwait(false);
foreach (var mShipmentRequestItem in mShipmentRequest.ShipmentRequestItems)
{
var mFulfillable = await FullfillmentMicroService.GetFulfillableByItemAsync(mShipmentRequestItem.FulfillableItemId).ConfigureAwait(false);
var fulfillableId = mFulfillable.FulfillableId;
if (fulfillableIds.Contains(fulfillableId))
{
_ = fulfillableIds.Add(fulfillableId);
if (TryParseOrderId.FromFulfillableReference(mFulfillable.FulfillableReference, out var orderId))
{
var mOrder = await OrderMicroService.GetOrderAsync(orderId).ConfigureAwait(false);
var userId = ParseUserId.FromOrdererReference(mOrder.OrdererReference);
var participantReference = CreateParticipantReference.FromUserId(userId);
var participantId = await CommunicationMicroService.AllocateParticipantAsync(participantReference).ConfigureAwait(false);
var topicReference = CreateTopicReference.FromOrderId(orderId);
var topicId = await CommunicationMicroService.AllocateTopicAsync(topicReference, null).ConfigureAwait(false);
await CommunicationMicroService.SendNotification(participantId, NotificationTypeCodes.OrderShipped, topicId).ConfigureAwait(false);
}
}
}
}
}
break;
}
await Task.CompletedTask.ConfigureAwait(false);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task <int> ProcessPendingEvents()
{
using var log = BeginFunction(nameof(EventProcessorMicroService), nameof(ProcessPendingEvents));
try
{
var totalCount = 0;
int iterationCount;
do
{
iterationCount = 0;
iterationCount += await CommunicationMicroService.ProcessEventsAsync();
iterationCount += await FulfillmentMicroService.ProcessEventsAsync();
iterationCount += await FundingMicroService.ProcessEventsAsync();
iterationCount += await InventoryMicroService.ProcessEventsAsync();
iterationCount += await OrderMicroService.ProcessEventsAsync();
iterationCount += await SquareMicroService.ProcessEventsAsync();
iterationCount += await UserMicroService.ProcessEventsAsync();
//Task<int>[] tasks = {
//CommunicationMicroService.ProcessEventsAsync(),
//FulfillmentMicroService.ProcessEventsAsync(),
//FundingMicroService.ProcessEventsAsync(),
//InventoryMicroService.ProcessEventsAsync(),
//OrderMicroService.ProcessEventsAsync(),
//PayPalMicroService.ProcessEventsAsync(),
//SquareMicroService.ProcessEventsAsync(),
//UserMicroService.ProcessEventsAsync() };
//var counts = await Task.WhenAll(tasks);
//iterationCount = counts.Sum();
totalCount += iterationCount;
} while (iterationCount > 0);
var result = totalCount;
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task CreateProject()
{
var logger = ServiceScope.ServiceProvider.GetService <ILogger <ProjectTest> >();
// Get the user ID.
//
string userId;
{
var identityUser = await UserManager.FindByNameAsync("*****@*****.**");
userId = identityUser.Id;
logger.LogInformation("UserId = {0}", userId);
}
// Create the design.
//
Guid designId;
{
var designData = Factory.CreateDesign();
designId = await DesignAjaxService.SaveDesignAsync(userId, designData);
logger.LogInformation($"Design ID = {designId}");
}
// Create the project.
//
string projectId;
{
projectId = await ProjectUserService.CreateProjectAsync(userId, ProjectUserService.ProjectType_Kit, "Test Project", designId);
logger.LogInformation($"Project ID = {projectId}");
}
// Create the orderable ID.
//
long orderableId;
{
var projectSnapshotId = await ProjectMicroService.GetCurrentSnapshotIdAsync(Guid.Parse(projectId));
var mProjectSnapshotDetail = await ProjectMicroService.GetProjectSnapshotAsync(projectSnapshotId);
var mAllocateOrderable = MicroDataFactory.MOrder_AllocateOrderable(mProjectSnapshotDetail);
var mAllocateOrderableResponseData = await OrderMicroService.AllocateOrderableAsync(mAllocateOrderable);
orderableId = mAllocateOrderableResponseData.OrderableId;
logger.LogInformation($"Orderable ID = {orderableId}");
}
}
public async Task <ActionResult> FulfillableItem(string id, string size)
{
if (!int.TryParse(size, out var sizeValue))
{
sizeValue = Constants.ThumbnailSize;
}
id = WebUtility.UrlDecode(id);
var orderItemId = ParseOrderItemId.FromFulfillableItemReference(id);
var mOrderItem = await OrderMicroService.GetOrderItemAsync(orderItemId);
var projectSnapshotId = (int)ParseProjectSnapshotId.FromOrderableReference(mOrderItem.OrderableReference);
var image = await ProjectUserService.GetProjectSnapshotThumbnailAsync(GetUserId(), projectSnapshotId, sizeValue);
return(new FileContentResult(image, "image/jpg"));
}
public async Task <AOrder_Order> GetOrderAsync(long orderId)
{
using var log = BeginFunction(nameof(OrderAdminService), nameof(GetOrderAsync), orderId);
try
{
await Assert(SecurityPolicy.IsPrivileged).ConfigureAwait(false);
var mOrder = await OrderMicroService.GetOrderAsync(orderId).ConfigureAwait(false);
var mTransactions = await OrderMicroService.GetOrderTransactionSummariesAsync(orderId, null, null);
var mEvents = await OrderMicroService.GetOrderEventLogSummariesAsync(orderId, null, null);
var fulfillableReference = CreateFulfillableReference.FromOrderId(orderId);
var fulfillableId = await FulfillmentMicroService.LookupFulfillableAsync(fulfillableReference);
var mFulfillable = fulfillableId != null
? await FulfillmentMicroService.GetFulfillableAsync(fulfillableId.Value).ConfigureAwait(false)
: null;
var fundableReference = CreateFundableReference.FromOrderId(orderId);
var fundableId = await FundingMicroService.LookupFundableAsync(fundableReference);
var mFundable = fundableId != null
? await FundingMicroService.GetFundableAsync(fundableId.Value).ConfigureAwait(false)
: null;
var mUser = TryParseUserId.FromOrdererReference(mOrder.OrdererReference, out string userId)
? await UserMicroService.GetUserAsync(userId)
: null;
var result = Create.AOrder_Order(mOrder, mTransactions, mEvents, mFulfillable, mFundable, mUser);
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task HandleFundableEventAsync(MFunding_FundableEvent eventData)
{
using var log = BeginFunction(nameof(FundingEventMicroService), nameof(HandleFundableEventAsync), eventData);
try
{
using var ctx = CreateQuiltContext();
if (eventData.FundsReceived != 0)
{
if (TryParseOrderId.FromFundableReference(eventData.FundableReference, out var orderId))
{
_ = await OrderMicroService.SetFundsReceivedAsync(orderId, eventData.FundsReceived, eventData.UnitOfWork).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task <UOrder_Order> GetCartOrderAsync(string userId)
{
using var log = BeginFunction(nameof(CartUserService), nameof(GetCartOrderAsync), userId);
try
{
// HACK: Review logic
//AssertIsEndUser(userId);
//await Assert(SecurityPolicy.IsAuthorized, userId).ConfigureAwait(false);
var ordererReference = CreateOrdererReference.FromUserId(userId);
var ordererId = await OrderMicroService.AllocateOrdererAsync(ordererReference);
var mOrder = await OrderMicroService.GetCartOrderAsync(ordererId).ConfigureAwait(false);
if (mOrder == null)
{
return(null);
}
//var mProjectSnapshots = new List<MProject_ProjectSnapshot>();
//foreach (var mOrderItem in mOrder.OrderItems)
//{
// var projectSnapshotId = ParseProjectSnapshotId.FromOrderableReference(mOrderItem.OrderableReference);
// var mProjectSnapshot = await ProjectMicroService.GetProjectSnapshotAsync(projectSnapshotId).ConfigureAwait(false);
// mProjectSnapshots.Add(mProjectSnapshot);
//}
var result = OrderUserService.Create.UOrder_Order(mOrder, null);
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task <bool> UpdateShippingAddressAsync(string userId, UCart_ShippingAddress shippingAddress)
{
using var log = BeginFunction(nameof(CartUserService), nameof(UpdateShippingAddressAsync), userId, shippingAddress);
try
{
//AssertIsEndUser(userId);
await Assert(SecurityPolicy.IsAuthorized, userId).ConfigureAwait(false);
var ordererReference = CreateOrdererReference.FromUserId(userId);
var ordererId = await OrderMicroService.AllocateOrdererAsync(ordererReference).ConfigureAwait(false);
var result = await OrderMicroService.UpdateShippingAddressAsync(ordererId, shippingAddress).ConfigureAwait(false);
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task CreateOrder()
{
var services = ServiceScope.ServiceProvider;
var logger = services.GetService <ILogger <OrderTest> >();
var unitOfWork = CreateUnitOfWork.Timestamp(GetUniqueNow());
// Get the user ID.
//
string userId;
{
var identityUser = await UserManager.FindByNameAsync("*****@*****.**");
userId = identityUser.Id;
logger.LogInformation("User ID = {0}", userId);
}
// Get the orderer ID.
//
long ordererId;
{
var ordererReference = CreateOrdererReference.FromTimestamp(GetUniqueNow());
ordererId = await OrderMicroService.AllocateOrdererAsync(ordererReference);
logger.LogInformation("Orderer ID = {0}", ordererId);
}
// Get the funder ID.
//
long funderId;
{
var funderReference = CreateFunderReference.FromTimestamp(GetUniqueNow());
funderId = await FundingMicroService.AllocateFunderAsync(funderReference);
logger.LogInformation("Funder ID = {0}", funderId);
}
// Create the design.
//
Guid designId;
{
var designData = Factory.CreateDesign();
designId = await DesignAjaxService.SaveDesignAsync(userId, designData);
logger.LogInformation($"Design ID = {designId}");
}
for (int idx = 0; idx < 3; ++idx)
{
// Create the project.
//
string projectId;
{
projectId = await ProjectUserService.CreateProjectAsync(userId, ProjectUserService.ProjectType_Kit, "Test Project", designId);
logger.LogInformation($"Project ID = {projectId}");
}
// Create the orderable ID.
//
long orderableId;
{
var projectSnapshotId = await ProjectMicroService.GetCurrentSnapshotIdAsync(Guid.Parse(projectId));
var mProjectSnapshotDetail = await ProjectMicroService.GetProjectSnapshotAsync(projectSnapshotId);
var mAllocateOrderable = MicroDataFactory.MOrder_AllocateOrderable(mProjectSnapshotDetail);
var mAllocateOrderableResponseData = await OrderMicroService.AllocateOrderableAsync(mAllocateOrderable);
orderableId = mAllocateOrderableResponseData.OrderableId;
logger.LogInformation($"Orderable ID = {orderableId}");
}
// Add orderable to cart
//
{
// Add item to cart.
//
_ = await OrderMicroService.AddCartItemAsync(ordererId, orderableId, (idx + 1) * 2);
}
}
var shippingAddress = new MCommon_Address()
{
Name = "RICH TODD",
AddressLine1 = "17340 W 156 TER",
City = "OLATHE",
StateCode = "KS",
PostalCode = "66062",
CountryCode = "US"
};
// Create the order.
//
long orderId;
{
// Update shipping address.
//
_ = await OrderMicroService.UpdateShippingAddressAsync(ordererId, shippingAddress);
// Submit order.
//
orderId = await OrderMicroService.SubmitCartAsync(ordererId);
logger.LogInformation($"Order ID = {orderId}");
}
_ = await EventProcessorMicroService.ProcessPendingEvents();
// Create fundable for order.
//
long fundableId;
{
var fundableReference = CreateFundableReference.FromOrderId(orderId);
fundableId = await FundingMicroService.AllocateFundableAsync(fundableReference);
logger.LogInformation($"Fundable ID = {fundableId}");
}
// Retrieve the fundable detail.
//
MFunding_Fundable fundableDetail;
{
fundableDetail = await FundingMicroService.GetFundableAsync(fundableId);
logger.LogInformation($"Fundable Detail = {fundableDetail}");
}
// Post a receipt for the order.
//
{
var fundsRequiredDelta = fundableDetail.FundsRequiredTotal - fundableDetail.FundsReceived;
await FundingMicroService.SetFundsReceivedAsync(funderId, fundableDetail.FundableReference, fundableDetail.FundsRequiredTotal, unitOfWork.Next());
//await fundingService.TransferFundsAsync(funderId, fundableId, fundsRequiredDelta);
logger.LogInformation($"{fundsRequiredDelta} funds applied.");
}
_ = await EventProcessorMicroService.ProcessPendingEvents();
}
public async Task <UCart_Cart> GetCartAsync(string userId)
{
using var log = BeginFunction(nameof(CartUserService), nameof(GetCartAsync), userId);
try
{
// HACK: Review logic
//AssertIsEndUser(userId);
//await Assert(SecurityPolicy.IsAuthorized, userId).ConfigureAwait(false);
var ordererReference = CreateOrdererReference.FromUserId(userId);
var ordererId = await OrderMicroService.AllocateOrdererAsync(ordererReference);
var mOrder = await OrderMicroService.GetCartOrderAsync(ordererId).ConfigureAwait(false);
if (mOrder == null)
{
return(null);
}
var mProjectOrder = OrderUserService.Create.UOrder_Order(mOrder, null);
var squareCustomerReference = CreateSquareCustomerReference.FromUserId(userId);
var squareCustomerId = await SquareMicroService.AllocateSquareCustomerAsync(squareCustomerReference);
var squarePaymentReference = CreateSquarePaymentReference.FromOrderId(mOrder.OrderId);
var squarePaymentId = await SquareMicroService.AllocateSquarePaymentAsync(squarePaymentReference, squareCustomerId);
var mSquarePayment = await SquareMicroService.GetSquarePaymentAsync(squarePaymentId);
var mWebPaymentRequest = mSquarePayment.WebPaymentRequests.Where(r =>
r.WebRequestTypeCode == SquarePaymentWebRequestTypeCodes.Payment &&
r.ProcessingStatusCode != SquareProcessingStatusCodes.Cancelled).SingleOrDefault();
Cart_PaymentStatus paymentStatus;
if (mWebPaymentRequest == null)
{
paymentStatus = Cart_PaymentStatus.Required;
}
else
{
switch (mWebPaymentRequest.ProcessingStatusCode)
{
case SquareProcessingStatusCodes.Rejected:
paymentStatus = Cart_PaymentStatus.Required;
break;
case SquareProcessingStatusCodes.Processed:
paymentStatus = Cart_PaymentStatus.Complete;
break;
case SquareProcessingStatusCodes.Pending:
case SquareProcessingStatusCodes.Processing:
case SquareProcessingStatusCodes.Transmitting:
case SquareProcessingStatusCodes.Transmitted:
case SquareProcessingStatusCodes.Exception:
paymentStatus = Cart_PaymentStatus.InProgress;
break;
default:
// Includes SquarePaymentWebRequestStatusTypes.Cancelled - should have been filtered out above.
//
throw new InvalidOperationException($"Unknown payment transaction status type {mWebPaymentRequest.ProcessingStatusCode}.");
}
}
var result = new UCart_Cart()
{
Order = mProjectOrder,
PaymentStatus = paymentStatus
};
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task CreateOrder()
{
var logger = ServiceScope.ServiceProvider.GetService <ILogger <OrderTest> >();
var ordererReference = CreateOrdererReference.FromTimestamp(GetUniqueNow());
logger.LogInformation($"Orderer reference = {ordererReference}");
var ordererId = await OrderMicroService.AllocateOrdererAsync(ordererReference);
logger.LogInformation($"Orderer ID = {ordererId}");
var orderableReference = CreateOrderableReference.FromTimestamp(GetUniqueNow());
logger.LogInformation($"Orderable reference = {orderableReference}");
var orderableComponentReference = CreateOrderableCompnentReference.FromTimestamp(GetUniqueNow());
logger.LogInformation($"Orderable component reference = {orderableComponentReference}");
var mAllocateOrderable = new MOrder_AllocateOrderable()
{
OrderableReference = orderableReference,
Name = "Orderable Item",
Price = 100,
Components = new List <MOrder_AllocateOrderableComponent>()
{
new MOrder_AllocateOrderableComponent()
{
OrderableComponentReference = orderableComponentReference,
Description = "Orderable Item Component",
Quantity = 2,
ConsumableReference = CreateConsumableReference.FromTimestamp(GetUniqueNow()),
UnitPrice = 25,
TotalPrice = 50
}
}
};
var mAllocateOrderableResponse = await OrderMicroService.AllocateOrderableAsync(mAllocateOrderable);
logger.LogInformation($"Orderable ID = {mAllocateOrderableResponse.OrderableId}");
_ = await OrderMicroService.AddCartItemAsync(ordererId, mAllocateOrderableResponse.OrderableId, 2);
logger.LogInformation("Item added to cart.");
var shippingAddress = new MCommon_Address()
{
Name = "RICHARD TODD",
AddressLine1 = "17340 W 156 TER",
City = "OLATHE",
StateCode = "KS",
PostalCode = "66062",
CountryCode = "US"
};
_ = await OrderMicroService.UpdateShippingAddressAsync(ordererId, shippingAddress);
logger.LogInformation("Shipping address updated.");
var orderId = await OrderMicroService.SubmitCartAsync(ordererId);
logger.LogInformation($"Order {orderId} submitted.");
}
public async Task <ADashboard_Summary> GetDashboardDataAsync()
{
using var log = BeginFunction(nameof(DashboardAdminService), nameof(GetDashboardDataAsync));
try
{
await Assert(SecurityPolicy.IsPrivileged).ConfigureAwait(false);
var result = new ADashboard_Summary()
{
MCommunication_Dashboard = await CommunicationMicroService.GetDashboardAsync(),
MDesign_Dashboard = await DesignMicroService.GetDashboardAsync(),
MFulfillment_Dashboard = await FulfillmentMicroService.GetDashboardAsync(),
MFunding_Dashboard = await FundingMicroService.GetDashboardAsync(),
MLedger_Dashboard = await LedgerMicroService.GetDashboardAsync(),
MOrder_Dashboard = await OrderMicroService.GetDashboardAsync(),
MProject_Dashboard = await ProjectMicroService.GetDashboardAsync(),
MSquare_Dashboard = await SquareMicroService.GetDashboardAsync(),
MUser_Dashboard = await UserMicroService.GetDashboardAsync()
};
//using (var ctx = QuiltContextFactory.Create())
//{
// using var conn = QuiltContextFactory.CreateConnection();
// conn.Open();
// // Order
// //
// {
// var statusCounts = new List<Admin_Dashboard_StatusCountData>();
// foreach (var dbOrder in GetDashboardOrders(conn).ToList())
// {
// var statusCount = new Admin_Dashboard_StatusCountData()
// {
// StatusName = ctx.OrderStatusType(dbOrder.OrderStatusTypeCode).Name,
// Count = dbOrder.RecordCount.GetValueOrDefault()
// };
// statusCounts.Add(statusCount);
// }
// result.OrderStatusCounts = statusCounts;
// }
// // Order Return Request
// //
// {
// var statusCounts = new List<Admin_Dashboard_StatusCountData>();
// foreach (var dbOrderReturnRequest in GetDashboardOrderReturnRequests(conn).ToList())
// {
// var statusCount = new Admin_Dashboard_StatusCountData()
// {
// StatusName = ctx.ReturnRequestStatusType(dbOrderReturnRequest.OrderReturnRequestStatusTypeCode).Name,
// Count = dbOrderReturnRequest.RecordCount.GetValueOrDefault()
// };
// statusCounts.Add(statusCount);
// }
// result.OrderReturnRequestStatusCounts = statusCounts;
// }
// // Order Return
// //
// {
// var statusCounts = new List<Admin_Dashboard_StatusCountData>();
// foreach (var dbOrderReturn in GetDashboardOrderReturns(conn).ToList())
// {
// var statusCount = new Admin_Dashboard_StatusCountData()
// {
// StatusName = ctx.ReturnStatusType(dbOrderReturn.OrderReturnStatusTypeCode).Name,
// Count = dbOrderReturn.RecordCount.GetValueOrDefault()
// };
// statusCounts.Add(statusCount);
// }
// result.OrderReturnStatusCounts = statusCounts;
// }
// // Order Shipment Request
// //
// {
// var statusCounts = new List<Admin_Dashboard_StatusCountData>();
// foreach (var dbOrderShipmentRequest in GetDashboardOrderShipmentRequests(conn).ToList())
// {
// var statusCount = new Admin_Dashboard_StatusCountData()
// {
// StatusName = ctx.ShipmentRequestStatusType(dbOrderShipmentRequest.OrderShipmentRequestStatusTypeCode).Name,
// Count = dbOrderShipmentRequest.RecordCount.GetValueOrDefault()
// };
// statusCounts.Add(statusCount);
// }
// result.OrderShipmentRequestStatusCounts = statusCounts;
// }
// // Order Shipment
// //
// {
// var statusCounts = new List<Admin_Dashboard_StatusCountData>();
// foreach (var dbOrderShipment in GetDashboardOrderShipments(conn).ToList())
// {
// var statusCount = new Admin_Dashboard_StatusCountData()
// {
// StatusName = ctx.ShipmentStatusType(dbOrderShipment.OrderShipmentStatusTypeCode).Name,
// Count = dbOrderShipment.RecordCount.GetValueOrDefault()
// };
// statusCounts.Add(statusCount);
// }
// result.OrderShipmentStatusCounts = statusCounts;
// }
//}
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task CreateAndShipOrder()
{
var services = ServiceScope.ServiceProvider;
var logger = services.GetService <ILogger <OrderTest> >();
var unitOfWork = CreateUnitOfWork.Timestamp(GetUniqueNow());
// Get the user ID.
//
string userId;
{
var identityUser = await UserManager.FindByNameAsync("*****@*****.**");
userId = identityUser.Id;
logger.LogInformation("User ID = {0}", userId);
}
// Get the orderer ID.
//
long ordererId;
{
var ordererReference = CreateOrdererReference.FromTimestamp(GetUniqueNow());
ordererId = await OrderMicroService.AllocateOrdererAsync(ordererReference);
logger.LogInformation("Orderer ID = {0}", ordererId);
}
// Get the funder ID.
//
long funderId;
{
var funderReference = CreateFunderReference.FromTimestamp(GetUniqueNow());
funderId = await FundingMicroService.AllocateFunderAsync(funderReference);
logger.LogInformation("Funder ID = {0}", funderId);
}
// Create the design.
//
Guid designId;
{
var designData = Factory.CreateDesign();
designId = await DesignAjaxService.SaveDesignAsync(userId, designData);
logger.LogInformation($"Design ID = {designId}");
}
// Create the project.
//
string projectId;
{
projectId = await ProjectUserService.CreateProjectAsync(userId, ProjectUserService.ProjectType_Kit, "Test Project", designId);
logger.LogInformation($"Project ID = {projectId}");
}
// Create the orderable ID.
//
long orderableId;
{
var projectSnapshotId = await ProjectMicroService.GetCurrentSnapshotIdAsync(Guid.Parse(projectId));
var mProjectSnapshotDetail = await ProjectMicroService.GetProjectSnapshotAsync(projectSnapshotId);
var mAllocateOrderable = MicroDataFactory.MOrder_AllocateOrderable(mProjectSnapshotDetail);
var mAllocateOrderableResponseData = await OrderMicroService.AllocateOrderableAsync(mAllocateOrderable);
orderableId = mAllocateOrderableResponseData.OrderableId;
logger.LogInformation($"Orderable ID = {orderableId}");
}
var shippingAddress = new MCommon_Address()
{
Name = "RICH TODD",
AddressLine1 = "17340 W 156 TER",
City = "OLATHE",
StateCode = "KS",
PostalCode = "66062",
CountryCode = "US"
};
// Create the order.
//
long orderId;
{
// Add item to cart.
//
_ = await OrderMicroService.AddCartItemAsync(ordererId, orderableId, 2);
// Update shipping address.
//
_ = await OrderMicroService.UpdateShippingAddressAsync(ordererId, shippingAddress);
// Submit order.
//
orderId = await OrderMicroService.SubmitCartAsync(ordererId);
logger.LogInformation($"Order ID = {orderId}");
}
_ = await EventProcessorMicroService.ProcessPendingEvents();
// Create fundable for order.
//
long fundableId;
{
var fundableReference = CreateFundableReference.FromOrderId(orderId);
fundableId = await FundingMicroService.AllocateFundableAsync(fundableReference);
logger.LogInformation($"Fundable ID = {fundableId}");
}
// Retrieve the fundable detail.
//
MFunding_Fundable fundableDetail;
{
fundableDetail = await FundingMicroService.GetFundableAsync(fundableId);
logger.LogInformation($"Fundable Detail = {fundableDetail}");
}
// Post a receipt for the order.
//
{
var fundsRequiredDelta = fundableDetail.FundsRequiredTotal - fundableDetail.FundsReceived;
await FundingMicroService.SetFundsReceivedAsync(funderId, fundableDetail.FundableReference, fundableDetail.FundsRequiredTotal, unitOfWork.Next());
//await fundingService.TransferFundsAsync(funderId, fundableId, fundsRequiredDelta);
logger.LogInformation($"{fundsRequiredDelta} funds applied.");
}
_ = await EventProcessorMicroService.ProcessPendingEvents();
// Lookup fulfillable.
//
long fulfillableId;
{
var fulfillableReference = CreateFulfillableReference.FromOrderId(orderId);
fulfillableId = (await FulfillmentMicroService.LookupFulfillableAsync(fulfillableReference)).Value;
await FulfillmentMicroService.SetFulfillableShippingAddress(fulfillableId, shippingAddress);
logger.LogInformation($"Fulfillable ID = {fulfillableId}");
}
// Lookup pending shipment request.
//
long?shipmentRequestId;
{
shipmentRequestId = await FulfillmentMicroService.GetPendingShipmentRequestAsync(fulfillableId);
logger.LogInformation($"Shipment Request ID = {shipmentRequestId}");
}
// Open it.
//
{
await FulfillmentMicroService.OpenShipmentRequestAsync(shipmentRequestId.Value);
}
// Lookup shipment request.
//
MFulfillment_ShipmentRequest shipmentRequestDetail;
{
shipmentRequestDetail = await FulfillmentMicroService.GetShipmentRequestAsync(shipmentRequestId.Value);
logger.LogInformation($"Shipment Request Detail = {shipmentRequestDetail}");
}
// Create shipment.
//
long shipmentId;
{
var items = new List <MFulfillment_CreateShipmentItem>();
foreach (var shipmentRequestItemDetail in shipmentRequestDetail.ShipmentRequestItems)
{
items.Add(new MFulfillment_CreateShipmentItem()
{
ShipmentRequestItemId = shipmentRequestItemDetail.ShipmentRequestItemId,
Quantity = shipmentRequestItemDetail.Quantity
});
}
var data = new MFulfillment_CreateShipment()
{
ShippingVendorId = ShippingVendorIds.Usps,
ShipmentDateTimeUtc = Locale.GetUtcNow(),
TrackingCode = "123123",
CreateShipmentItems = items
};
shipmentId = await FulfillmentMicroService.CreateShipmentAsync(data);
await FulfillmentMicroService.PostShipmentAsync(shipmentId);
await FulfillmentMicroService.ProcessShipmentAsync(shipmentId);
logger.LogInformation($"Shipment ID = {shipmentId}");
}
_ = await EventProcessorMicroService.ProcessPendingEvents();
}
public async Task <UCart_CreateSquarePaymentResponse> CreateSquarePaymentAsync(string userId, decimal paymentAmount, string nonce)
{
using var log = BeginFunction(nameof(CartUserService), nameof(CreateSquarePaymentAsync), userId, paymentAmount, nonce);
try
{
var ordererReference = CreateOrdererReference.FromUserId(userId);
var ordererId = await OrderMicroService.AllocateOrdererAsync(ordererReference);
var uOrder = await GetCartOrderAsync(userId);
if (uOrder == null)
{
throw new InvalidOperationException("Shopping cart is empty.");
}
var squareCustomerReference = CreateSquareCustomerReference.FromUserId(userId);
var squareCustomerId = await SquareMicroService.AllocateSquareCustomerAsync(squareCustomerReference);
var squarePaymentReference = CreateSquarePaymentReference.FromOrderId(uOrder.MOrder.OrderId);
var squarePaymentId = await SquareMicroService.AllocateSquarePaymentAsync(squarePaymentReference, squareCustomerId);
var squareWebPaymentRequestId = await SquareMicroService.CreateSquareWebPaymentRequestAsync(squarePaymentId, paymentAmount, nonce);
var mProcessWebPaymentTransactionResponse = await SquareMicroService.ProcessWebPaymentRequestAsync(squareWebPaymentRequestId);
IList <Cart_CreateSquarePaymentResponseErrorData> errors;
if (mProcessWebPaymentTransactionResponse.Errors == null)
{
errors = null;
_ = await OrderMicroService.SubmitCartAsync(ordererId);
}
else
{
errors = new List <Cart_CreateSquarePaymentResponseErrorData>();
foreach (var mError in mProcessWebPaymentTransactionResponse.Errors)
{
errors.Add(new Cart_CreateSquarePaymentResponseErrorData()
{
Category = mError.Category,
Code = mError.Code,
Detail = mError.Detail,
Field = mError.Field
});
}
}
var result = new UCart_CreateSquarePaymentResponse()
{
Errors = errors
};
_ = await EventProcessorMicroService.ProcessPendingEvents().ConfigureAwait(false);
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
