Ejemplo n.º 1
0
        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;
            }
        }
Ejemplo n.º 2
0
        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.");
        }
Ejemplo n.º 3
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();
        }
Ejemplo n.º 4
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();
        }
Ejemplo n.º 5
0
        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;
            }
        }