public async Task CreatePayment()
{
var logger = ServiceScope.ServiceProvider.GetService <ILogger <SquareTest> >();
var squareCustomerReference = CreateSquareCustomerReference.FromTimestamp(GetUniqueNow());
var squareCustomerId = await SquareMicroService.AllocateSquareCustomerAsync(squareCustomerReference);
logger.LogInformation($"Square customer ID = {squareCustomerId}");
var squarePaymentReference = CreateSquarePaymentReference.FromTimestamp(GetUniqueNow());
var squarePaymentId = await SquareMicroService.AllocateSquarePaymentAsync(squarePaymentReference, squareCustomerId);
logger.LogInformation($"Square payment ID = {squarePaymentId}");
var squareWebPaymentTransactionId = await SquareMicroService.CreateSquareWebPaymentRequestAsync(squarePaymentId, 100m, "cnon:card-nonce-ok");
var paymentResponse = await SquareMicroService.ProcessWebPaymentRequestAsync(squareWebPaymentTransactionId);
logger.LogInformation($"Square payment response = {paymentResponse}");
//var squareRefundTransactionId = await SquareMicroService.CreateSquareRefundTransactionAsync(squarePaymentId, 25m);
//var refundResponse = await SquareMicroService.ProcessSquarePaymentTransactionAsync(squareRefundTransactionId);
//logger.LogInformation($"Square refund response = {refundResponse}");
_ = await SquareMicroService.ProcessEventsAsync();
}
private async Task <ASquare_Payment> GetPaymentDetails(MSquare_Payment mPayment)
{
var mPaymentTransactions = await SquareMicroService.GetPaymentTransactionSummariesAsync(mPayment.SquarePaymentId, null, null);
var mPaymentEvents = await SquareMicroService.GetPaymentEventLogSummariesAsync(mPayment.SquarePaymentId, null, null);
var mRefundTransactions = await SquareMicroService.GetRefundTransactionSummariesAsync(null, mPayment.SquarePaymentId, null, null);
var mRefundEvents = await SquareMicroService.GetRefundEventLogSummariesAsync(null, mPayment.SquarePaymentId, null, null);
var mUser = TryParseUserId.FromSquareCustomerReference(mPayment.SquareCustomerReference, out string userId)
? await UserMicroService.GetUserAsync(userId).ConfigureAwait(false)
: null;
var funderReference = CreateFunderReference.FromSquarePaymentId(mPayment.SquarePaymentId);
var funderId = await FundingMicroService.LookupFunderAsync(funderReference);
var result = new ASquare_Payment()
{
MPayment = mPayment,
MPaymentTransactions = mPaymentTransactions,
MPaymentEvents = mPaymentEvents,
MRefundTransactions = mRefundTransactions,
MRefundEvents = mRefundEvents,
MUser = mUser,
FunderId = funderId
};
return(result);
}
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 <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 CreateCustomer()
{
var originalSquareCustomerReference = CreateSquareCustomerReference.FromTimestamp(GetUniqueNow());
var originalSquareCustomerId = await SquareMicroService.AllocateSquareCustomerAsync(originalSquareCustomerReference);
var squareCustomerId = await SquareMicroService.LookupSquareCustomerIdAsync(originalSquareCustomerReference);
Assert.AreEqual(originalSquareCustomerId, squareCustomerId);
var squareCustomer = await SquareMicroService.GetSquareCustomerAsync(originalSquareCustomerId);
Assert.IsNotNull(squareCustomer);
Assert.AreEqual(originalSquareCustomerReference, squareCustomer.SquareCustomerReference);
}
public async Task <ASquare_Payment> GetPaymentAsync(long squarePaymentId)
{
using var log = BeginFunction(nameof(SquareAdminService), nameof(GetPaymentAsync), squarePaymentId);
try
{
await Assert(SecurityPolicy.IsPrivileged).ConfigureAwait(false);
var mPayment = await SquareMicroService.GetSquarePaymentAsync(squarePaymentId);
var result = await GetPaymentDetails(mPayment);
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task <ASquare_CustomerSummaryList> GetCustomerSummariesAsync(long?squareCustomerId, int?recordCount)
{
using var log = BeginFunction(nameof(SquareAdminService), nameof(GetCustomerSummariesAsync), squareCustomerId, recordCount);
try
{
await Assert(SecurityPolicy.IsPrivileged).ConfigureAwait(false);
var mCustomerSummaryList = await SquareMicroService.GetSquareCustomerSummariesAsync(squareCustomerId, recordCount);
var result = new ASquare_CustomerSummaryList()
{
MSummaries = mCustomerSummaryList.Summaries
};
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
public async Task <ASquare_Customer> GetCustomerAsync(long squareCustomerId)
{
using var log = BeginFunction(nameof(SquareAdminService), nameof(GetCustomerAsync), squareCustomerId);
try
{
await Assert(SecurityPolicy.IsPrivileged).ConfigureAwait(false);
var mCustomer = await SquareMicroService.GetSquareCustomerAsync(squareCustomerId);
var result = new ASquare_Customer()
{
MCustomer = mCustomer
};
log.Result(result);
return(result);
}
catch (Exception ex)
{
log.Exception(ex);
throw;
}
}
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 <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;
}
}
