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 async Task <IReadOnlyList <UOrder_Order> > GetOrdersAsync(string userId)
{
using var log = BeginFunction(nameof(OrderUserService), nameof(GetOrdersAsync), userId);
try
{
//await Assert(SecurityPolicy.IsAuthorized, userId).ConfigureAwait(false);
var ordererReference = CreateOrdererReference.FromUserId(userId);
var ordererId = await OrderMicroService.LookupOrdererAsync(ordererReference);
if (ordererId == null)
{
return(null);
}
var mOrderList = await OrderMicroService.GetOrdersAsync(ordererId.Value).ConfigureAwait(false);
var orders = new List <UOrder_Order>();
foreach (var mOrder in mOrderList.Orders)
{
orders.Add(Create.UOrder_Order(mOrder, null));
}
var result = orders;
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 <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 <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;
}
}
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;
}
}