Esempio n. 1
0
        /// <summary>
        /// Creates url with encoded payment data to redirect to perform payment
        /// </summary>
        /// <param name="message">Payment data</param>
        /// <param name="getOrderId">Callback to retrieve order Id after verifying entire message</param>
        /// <param name="getOrderIdDisplayValue">Callback to retrieve order Id display value</param>
        /// <returns>Url to redirect to</returns>
        public async Task <PaymentRequestDescriptor> BuildPaymentRequestAsync(
            PaymentMessage message,
            [NotNull] Func <Task <string> > getOrderId,
            Func <string, string> getOrderIdDisplayValue = null)
        {
            if (Debug)
            {
                message.Details = "[Debug mode] " + message.Details;
            }

            message.CheckStringPropertyLength(m => m.Details);
            message.CheckStringPropertyLength(m => m.CustomerComment);
            message.CheckStringPropertyLength(m => m.OrderIdDisplayValue);
            foreach (var receiptItem in message.Data.Receipt.Items)
            {
                receiptItem.CheckStringPropertyLength(r => r.Name);
            }
            message.SuccessUrl ??= _configuration.DefaultSuccessUrl;
            message.FailUrl ??= _configuration.DefaultFailUrl;
            Validator.ValidateObject(message, new ValidationContext(message)
            {
                MemberName = nameof(message)
            });

            message.OrderId = await getOrderId() ?? message.OrderId;

            message.ValidateProperty(m => m.OrderId);

            message.OrderIdDisplayValue = getOrderIdDisplayValue?.Invoke(message.OrderId) ?? message.OrderIdDisplayValue;
            message.ValidateProperty(m => m.OrderIdDisplayValue);

            System.Diagnostics.Debug.WriteLineIf(
                Debug,
                JsonConvert.SerializeObject(message, Formatting.Indented));

            var messageAsJson     = JsonConvert.SerializeObject(message, Formatting.None);
            var messageAsJsonUtf8 = messageAsJson.ToUtf8Bytes();
            var messageWithKey    = messageAsJsonUtf8.Concat(_keyAsUtf8).ToArray();

            var result = new PaymentRequestDescriptor
            {
                Debug       = Debug,
                Url         = $"{ActualApiEndpoint}/pay",
                QueryParams = new PaymentQueryParams
                {
                    marketPlace = message.PaymentMethod == PscbPaymentMethod.FastPaymentsSystem
                        ? _configuration.MerchantIdFastPayments ?? _configuration.MerchantId
                        : _configuration.MerchantId,
                    message   = Convert.ToBase64String(messageAsJsonUtf8),
                    signature = messageWithKey.Sha256Encode().ToHexString()
                }
            };

            System.Diagnostics.Debug.WriteLineIf(Debug, result.Url);

            return(result);
        }
Esempio n. 2
0
        /// <inheritdoc />
        public async Task <ClaimPaymentContext> InitiateClaimPaymentAsync(ClaimPaymentRequest request)
        {
            // Loading claim
            var claim = await GetClaimAsync(request.ProjectId, request.ClaimId);

            // Checking access rights
            if (claim.PlayerUserId != CurrentUserId)
            {
                throw new NoAccessToProjectException(claim.Project, CurrentUserId);
            }

            PaymentType onlinePaymentType =
                claim.Project.ActivePaymentTypes.SingleOrDefault(
                    pt => pt.TypeKind == PaymentTypeKind.Online);

            if (onlinePaymentType == null)
            {
                throw new OnlinePaymentsNotAvailable(claim.Project);
            }

            if (request.Money <= 0)
            {
                throw new PaymentException(claim.Project, $"Money amount must be positive integer");
            }

            User user = await GetCurrentUser();

            var message = new PaymentMessage
            {
                Amount          = request.Money,
                Details         = $"Билет (организационный взнос) участника на «{claim.Project.ProjectName}»",
                CustomerAccount = CurrentUserId.ToString(),
                CustomerEmail   = user.Email,
                CustomerPhone   = user.Extra?.PhoneNumber,
                CustomerComment = request.CommentText,
                PaymentMethod   = PscbPaymentMethod.BankCards,
                SuccessUrl      = _uriService.Get(new PaymentSuccessUrl(request.ProjectId, request.ClaimId)),
                FailUrl         = _uriService.Get(new PaymentFailUrl(request.ProjectId, request.ClaimId)),
                Data            = new PaymentMessageData
                {
                    Receipt = new Receipt
                    {
                        CompanyEmail = User.OnlinePaymentVirtualUser,
                        TaxSystem    = TaxSystemType.SimplifiedIncomeOutcome,
                        Items        = new List <ReceiptItem>
                        {
                            new ReceiptItem
                            {
                                ObjectType  = PaymentObjectType.Service,
                                PaymentType = ItemPaymentType.FullPayment,
                                Price       = request.Money,
                                Quantity    = 1,
                                TotalPrice  = request.Money,
                                VatType     = VatSystemType.None,
                                Name        = claim.Project.ProjectName,
                            }
                        }
                    }
                }
            };

            // Creating request to bank
            PaymentRequestDescriptor result = await GetApi(request.ProjectId, request.ClaimId)
                                              .BuildPaymentRequestAsync(
                message,
                async() => (await AddPaymentCommentAsync(claim.CommentDiscussion, onlinePaymentType, request))
                .CommentId
                .ToString()
                .PadLeft(10, '0')
                );

            return(new ClaimPaymentContext
            {
                Accepted = true,
                RequestDescriptor = result
            });
        }