Beispiel #1
0
        public async Task TransferPrepayment()
        {
            Console.WriteLine("TransferPrepayment");

            var logger     = ServiceScope.ServiceProvider.GetService <ILogger <FundingTest> >();
            var unitOfWork = CreateUnitOfWork.Timestamp(GetUniqueNow());

            var incomeAmount         = 100m;
            var salesTaxAmount       = 5m;
            var totalAmount          = incomeAmount + salesTaxAmount;
            var salesTaxJurisdiction = "XX";

            // Create references.
            //
            var funderReference = CreateFunderReference.FromTimestamp(GetUniqueNow());

            logger.LogInformation($"Funder reference = {funderReference}");

            var fundableReference = CreateFundableReference.FromTimestamp(GetUniqueNow());

            logger.LogInformation($"Fundable reference = {fundableReference}");

            // Create funder and set funds received.
            //
            var funderId = await FundingMicroService.AllocateFunderAsync(funderReference);

            logger.LogInformation($"Funder ID = {funderId}");

            await FundingMicroService.SetFundsReceivedAsync(funderId, fundableReference, totalAmount, unitOfWork.Next());

            logger.LogInformation($"Set {totalAmount:c} funds received.");

            var eventCount = await EventProcessorMicroService.ProcessPendingEvents();

            logger.LogInformation($"{eventCount} events processed.");

            // Create fundable and set funds required.
            //
            var fundableId = await FundingMicroService.AllocateFundableAsync(fundableReference);

            logger.LogInformation($"Fundable ID = {fundableId}");

            await FundingMicroService.SetFundsRequiredAsync(fundableId, incomeAmount, salesTaxAmount, salesTaxJurisdiction, unitOfWork.Next());

            logger.LogInformation($"Set {incomeAmount:c} + {salesTaxAmount:c} funds required.");

            eventCount = await EventProcessorMicroService.ProcessPendingEvents();

            logger.LogInformation($"{eventCount} events processed.");

            // Ensure funds transferred.
            //
            var fundable = await FundingMicroService.GetFundableAsync(fundableId);

            Assert.IsNotNull(fundable);
            logger.LogInformation($"Fundable retrieved.  Fundable reference = {fundable.FundableReference}");
            Assert.AreEqual(fundableReference, fundable.FundableReference);
            Assert.AreEqual(fundable.FundsRequiredTotal, totalAmount);
            Assert.AreEqual(fundable.FundsReceived, totalAmount);
        }
Beispiel #2
0
        public async Task CreateFunder()
        {
            Console.WriteLine("CreateFunder");

            var logger = ServiceScope.ServiceProvider.GetService <ILogger <FundingTest> >();

            var funderReference = CreateFunderReference.FromTimestamp(GetUniqueNow());

            logger.LogInformation($"Funder reference = {funderReference}");

            var funderId = await FundingMicroService.AllocateFunderAsync(funderReference);

            logger.LogInformation($"Funder ID = {funderId}");

            var funder = await FundingMicroService.GetFunderAsync(funderId);

            Assert.IsNotNull(funder);
            logger.LogInformation($"Funder retrieved.  Funder reference = {funder.FunderReference}");
            Assert.AreEqual(funderReference, funder.FunderReference);

            var funders = await FundingMicroService.GetFunderSummariesAsync(null, null, null, null);

            Assert.IsNotNull(funders);
            Assert.IsNotNull(funders.Summaries);
            Assert.IsTrue(funders.Summaries.Any(r => r.FunderReference == funderReference));
        }
        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);
        }
Beispiel #4
0
        private async Task HandlePaymentEventAsync(MSquare_Event eventData)
        {
            var funderReference = CreateFunderReference.FromSquarePaymentId(eventData.SquarePaymentId);
            var funderId        = await FundingMicroService.AllocateFunderAsync(funderReference).ConfigureAwait(false);

            if (TryParseOrderId.FromSquarePaymentReference(eventData.SquarePaymentReference, out var orderId))
            {
                var fundableReference = CreateFundableReference.FromOrderId(orderId);

                await FundingMicroService.SetFundsReceivedAsync(funderId, fundableReference, eventData.PaymentAmount, eventData.UnitOfWork).ConfigureAwait(false);

                await FundingMicroService.SetProcessingFeeAsync(funderId, fundableReference, eventData.ProcessingFeeAmount, eventData.UnitOfWork).ConfigureAwait(false);

                await FundingMicroService.SetFundsRefundedAsync(funderId, fundableReference, eventData.RefundAmount, eventData.UnitOfWork).ConfigureAwait(false);
            }
        }
Beispiel #5
0
        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();
        }
Beispiel #6
0
        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();
        }