I am using Square Payment API, I couldn't find anything in documents for the same,
Let say I want to charge 52.50 CAD.
As we all know It does not allow decimal amount (I am using Node.js SDK v2).
When I go through the documentation it says that amount must be in the smaller denomination.
I have own custom form, I want to know, do I need to pass amount in smaller denomination when the passing value from payment form (generating card nonce), or only in the API side, or both.
I am asking amount from the user without smaller denomination i.e. (52.50 CAD), How do I pass amount in SDK and in the frontend as well.
The smallest denomination of the Canadian Dollar (CAD), like the US Dollar (USD), is cents.
Your custom/front-end form may elect to show the amount in dollars, but the API call must be in the smallest denomination.
As you can see in the below example code, the nonce is taken from the payment form and the charged amount is hard coded. If you wanted to take the charged amount from the form, you would need to sanitize it, convert it to cents (if in dollars) and make sure that the currency ID is correct.
Example Code
Source: Payment processing example: Node JS
router.post('/process-payment', function(req,res,next){
var request_params = req.body;
var idempotency_key = require('crypto').randomBytes(64).toString('hex');
// Charge the customer's card
var transactions_api = new squareConnect.TransactionsApi();
var request_body = {
card_nonce: request_params.nonce,
amount_money: {
amount: 100, // $1.00 charge
currency: 'USD'
},
idempotency_key: idempotency_key
};
transactions_api.charge(config.squareLocationId, request_body).then(function(data) {
console.log(util.inspect(data, false, null));
res.render('process-payment', {
'title': 'Payment Successful',
'result': "Payment Successful (see console for transaction output)"
});
}, function(error) {
console.log(util.inspect(error.status, false, null));
res.render('process-payment', {
'title': 'Payment Failure',
'result': "Payment Failed (see console for error output)"
});
});
});
Relevant documentation:
SquareConnect.TransactionsApi
SquareConnect.ChargeRequest
SquareConnect.Money
Related
I'm doing a small project in Node and React
And I'm building a payment system with the help of Stripe
Now everything works fine I have only one small problem I want at the end of the process to update the quantity in the database the problem is that I can't make the right condition to do it
and I must a condition Because if I don't set a condition as soon as I activated Stripe and got to the payment page, even if I didn't pay and did a return to the previous page, my quantity is updated
I add here the code I try to implement
exports.getCheckoutSessionBook = async (req, res, next) => {
const book = req.body.bookID[0]
console.log(book._id)
const quantity = req.body.quantityBooks
if (book.quantity < quantity) return next(new AppError(`there is only ${book.quantity} in stuck `))
if (book.quantity <= 0) return next(new AppError(`this book is over please try another book `))
const session = await stripe.checkout.sessions.create({
payment_method_types: ['card'],
success_url: `http://127.0.0.1:3001`,
cancel_url: `http://127.0.0.1:3001/account`,
customer_email: req.user.email,
client_reference_id: req.user.id,
line_items: [{
price_data: {
currency: 'usd',
product_data: {
name: book.title,
description: book.description,
images: [book.image],
},
unit_amount: book.price * 100,
},
quantity: quantity,
}],
mode: 'payment',
});
res.status(200).json({
status: 'suceess',
session
})
//here is my problem
if (res.status == 200) {
console.log(321)
const doc = await Book.findByIdAndUpdate(book._id, { $inc: { quantity: - quantity } }, {
new: true,
runValidators: true
})
console.log(333)
}
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.6.3/umd/react.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.6.3/umd/react-dom.production.min.js"></script>
The code you shared calls the Create Checkout Session API first. This creates a Session that indicates what you are trying to sell to your Customer. At that point, no payment has been taken yet though. After that call, you seem to immediately increase the quantity in your database, before the payment happened.
There's no condition you can add here because the payment will happen later so you need to delete that part of the code or move it elsewhere entirely.
After the Checkout Session is created, you get the url property back in the response. That is the URL that you should redirect your customer to in the browser. There, they'll see Checkout's UI and decide if they want to pay.
What you should do, is listen for the checkout.session.completed Event that will be sent to your webhook endpoint when a Session gets paid/completed successfully. At that point, you can update the quantity in your database.
Stripe has a detailed documentation on fulfillment with Checkout in this doc.
I must confess I'm not familiar with the Stripe API, but your approach to what is essentially a distributed transaction is giving me anxiety.
Your system needs assume it may crash at any point and still be able to any transaction.
Basically you need a series of interconnected backend systems using a ledger system in the database.
A ledger is an ordered set of actions taken on a transaction that allows you to see what has happened so far and pick up the transaction from where it was left.
Basic steps in an order transaction could be:
Create the order.
Allocate the inventory to the order.
Get an ID from the payment provider and associate it with the order.
Send the customer to complete the payment.
When payment is complete move the order ready for shipping.
Handle shipping.
Close the order and update inventory.
Some notes:
Inventory is not changed up/down for every order open/cancelled/closed inventory is updated once the item is actually shipped. Inventory for sale is inventory on hand minus any inventory allocated to orders.
Note also that if your system crashes (or the client disconnects) at any point you can reconcile the orders.
Failure after step 1 -> close the order.
Failure after step 2 -> close the order (inventory becomes immediately available since it is no longer allocated).
Failure after step 3 -> check the status of the payment using the session ID with the payment provider and either close the order or continue to step 4.
etc.
Final note: whether orders fails if inventory cannot be allocated to orders varies based on whether you can order more inventory or not.
If all this sounds complex it's because it is. Making an online store front system is not a weekend project.
For my first implementation, I transfer the amount of the transaction directly to a beneficiary from a paymentMethod Id retrieved from my app (Flutter). Now my goal would be to split the payment between several beneficiaries on the same transaction.
First implementation code:
var clonedPaymentMethod = await stripe.paymentMethods.create(
{
payment_method: paym,
},
{
stripeAccount: stripeVendorAccount,
}
);
var paymentIntent = await stripe.paymentIntents.create(
{
amount: amount,
currency: currency,
payment_method: clonedPaymentMethod.id,
confirmation_method: "automatic",
confirm: true,
application_fee_amount: fee,
description: "desc",
},
{
stripeAccount: stripeVendorAccount,
}
);
const paymentIntentReference = paymentIntent;
By checking the documentation, I noticed that the stripe.paymentMethods.create method was no longer specified, and that the stripe.transfers.create methods were added.
This code is attempting to clone a payment method to a connected account and then create a direct charge on that account. In order to create charges and then to split the funds of that charge to separate connected accounts a different approach would be needed. The model would be closer to "Separate charges and transfers", where the charge is made on that platform and then some amounts are shared among the connected accounts using transfers. A full description is outlined here [1].
[1] https://stripe.com/docs/connect/charges-transfers
This feature is like storing real-life money in a bank (using bot) for each server, called wallet and only admins can addmoney or removemoney from someone's wallet. 1st cmd is wallet open for admin to open the wallet for their server.
Second is
wallet register which will be used by the users. A wallet will be opened for them in the server and it will be stored inside the wallet array so anyone can check their balance by wallet balance #Ping/name. Admins can addmoney and removemoney from their bank. Another admin command to get a list of all users' names and how much money they have in their wallet.
There will be another command to reset every user's wallet to 0. I mean 0 amount.
Why is this wallet? Many Indian servers do daily 4-5 and weekly tournaments. So they need to pay the users and to pay, they need to store how much did the users win. This wallet idea is for the Indian servers. When someone wins they can just add and remove money to their account. After everything is paid they can set it again to 0 amount and generate a list when they need to pay them.
Schema file
https://sourceb.in/08007d1d2d
{
"_id":"dabtabase stuff",
"guild":"guild ID",
"wallets":[
{
"id":"user ID",
"amount":0,
"date":"date"
},
{
"id":"everytime a new user registers a bank his data will be created like this",
"amount":0,
"date":"date"
},
{
"id":"everytime a new user registers a bank his data will be created like this",
"amount":0,
"date":"date"
}
]
}
This is how the doc looks like in MongoDB
and this is my main wallets.js code :/
https://sourceb.in/674aa83ed6
and yes, I am a beginner, I mean not a pro, and I am still learning JS
To set everyone's amount to zero, you can use Array.prototype.forEach()
// example array
const wallets = [
{
amount: 0,
}, {
amount: 5,
}, {
amount: 7,
}, {
amount: 15,
}, {
amount: 22
}
];
console.log('Before Reset: ', wallets);
wallets.forEach((wallet) => wallet.amount = 0);
console.log('After Reset: ', wallets);
I'm building an AOG (actions on google) project that will do basic transaction functionality. Since I'm still a bit new to AOG, I'm completely stuck on how to take what the user selects (whether it be a carousel, a basic card etc.) and pass that argument value/key that they selected into the proposed order or the order preview before they finish their transaction.
Here is basically what I have tried (This isn't the actual code because it's rather long, but it still gets the idea across)
app.intent('delivery_address_complete', (conv) => {
const arg = conv.arguments.get('DELIVERY_ADDRESS_VALUE');
if (arg.userDecision ==='ACCEPTED') {
conv.ask('Ok, what would you like to order?');
conv.ask(new Suggestions(intentSuggestions));
conv.ask(new Carousel({
items: {
// Add the first item to the carousel
SELECTION_KEY_COFFEE: {
synonyms: [
'Coffee'
],
title: 'Coffee',
description: 'Sweet cream and sugar coffee.',
image: new Image({
url: IMG_URL_COFFEE,
alt: 'Image alternate text',
}),
},
}));
}
});
const yesOrno = [
'Yes',
'No'
];
app.intent('actions.intent.OPTION', (conv ) => {
conv.ask('Okay, are you ready to proceed?');
conv.ask(new Suggestions(yesOrno));
});
app.intent('transaction_decision_action', (conv) => {
const order = {
id: UNIQUE_ORDER_ID,
cart: {
merchant: {
id: 'coffee',
name: 'Coffee Store',
},
lineItems: [
{
name: 'My Memoirs',
id: 'coffee_1',
price: {
amount: {
currencyCode: 'USD',
nanos: 990000000,
units: 3,
},
type: 'ACTUAL',
},
quantity: 1,
subLines: [
{
note: 'coffee',
},
],
type: 'REGULAR',
},
otherItems: [
{
name: 'Subtotal',
id: 'subtotal',
price: {
amount: {
currencyCode: 'USD',
nanos: 220000000,
units: 32,
},
type: 'ESTIMATE',
},
type: 'SUBTOTAL',
},
{
name: 'Tax',
id: 'tax',
price: {
amount: {
currencyCode: 'USD',
nanos: 780000000,
units: 2,
},
type: 'ESTIMATE',
},
type: 'TAX',
},
],
totalPrice: {
amount: {
currencyCode: 'USD',
nanos: 0,
units: 35,
},
type: 'ESTIMATE',
},
};
Please note: This is mostly dummy code, so if some things like over charging or prices not making sense is happening, it's not the problem I'm trying to fix.
How can I take what the user selected from whatever method, and get it so it will appear on the order preview or proposed order? I do not need help with anything regarding making carousels or basic cards ect. Just how to get this selected information to the order preview.
To be more specific:
I can create an order object that is required, and I know how to send it to Google (and then to the user) as part of a ProposedOrder object that becomes part of the TransactionDecision object. (The "transaction_decision_action" Intent handler in the code above.)
What I don't understand is how to build the order based on the user saying things or by selecting on carousel or list items that I've shown them. (What do I do in the "actions.intent.OPTION" Intent handler above, for example?)
edit: This also may clear up any confusion. This is a video representation of what I'm attempting to do (mentioned in comments below):
youtube.com/watch?v=LlgMcJBnNN8 from 1:02 to 1:29 I know how to do, I'm confused (In the video example) how they were able to get the 'turkey sandwich' and the 'Green smoothie' added to the order preview at 1:35 ish from the carousel selections
What you're looking to do is what Google refers to as building the order. As it notes at that link
Once you have the user information you need, you'll build a "cart
assembly" experience that guides the user to build an order. Every
Action will likely have a slightly different cart assembly flow as
appropriate for your product or service.
You could build a cart assembly experience that enables the user to
re-order their most recent purchase via a simple yes or no question.
You could also present the user a carousel or list card of the top
"featured" or "recommended" items. We recommend using rich responses
to present the user's options visually, but also design the
conversation such that the user can build their cart using only their
voice.
For more information on how to build a high-quality cart assembly
experience, see the Transactions Design Guidelines.
So there is no one way to do what you're asking about. However, there are a few tips of things you can and should be doing to build the proposed order.
Managing the order
The big thing you need to do is to keep track of all the things that the user is ordering as you go through the process. There are a number of ways you can store this information:
In a Dialogflow Context
In the user session store
In a database or data store for the session
In short, any of the current ways you have to store session information. All of the information below assumes you've picked some way to do this.
Since everything will become one of the lineItems, an easy solution is to build this array as you go along, and then you can just copy the array directly into the order object. Another approach is to just store a list of item IDs, and then populate the rest of the information later when we build the order.
For this example, we're going to go with this latter scheme (because its easier to show) and store it in the session storage object using the actions-on-google library.
So for starters, when we start the Action, or when we know we'll be taking the order, we need to initialize our list of items being ordered with something like
conv.user.data.items = [];
Now that we have our initial item list, we can explore different ways to add to this list.
Adding an item: "my regular"
For some types of orders, it may make sense for the user to be able to say "I'll have my usual". In cases like this, we want an Intent that handles this phrase (or handles a "yes" response to our prompting), and an Intent Handler that looks up the user's regular order and adds it to the items. Perhaps something like this:
app.intent('order.usual', conv => {
// Get their user profile from our database
// The "loadUser" function is up to you, and has little to do with AoG
return loadUser( conv )
.then( user => {
// Add each item in their usual order to the current items
let usualOrder = user.usualOrder;
usualOrder.forEach( item => conv.user.data.items.push( item ) );
// Send a message back to the user
conv.add( "You got it! Do you want anything else?" );
});
});
Adding an item from a list
If you've presented a carousel or a list to the user of possible items, your life is a little easier (although you may not think it at the moment). You do need to setup a Dialogflow Intent that handles the actions_intent_OPTION event (which I'll call order.option in this case).
In the handler for this, we'll assume that the key you used for the option also happens to be the item ID, so you can just add it to the list
app.intent('order.option', (conv, params, option) => {
// The item is the option sent
let item = option;
// Add the item to the list of items
conv.user.data.items.push( item );
// Send a message back to the user
conv.add( "I've put that in your cart. Anything else?" );
});
Adding an item by name
But remember, the user can take the conversation in any direction at any time. So they may ask for an item that you currently aren't showing in the carousel. The best way to handle this is by creating an Entity Type in Dialogflow (which I'll call item, as an example)
And then an Intent that captures some phrases that expresses the user asking to add them (which I'll call order.name and which has an itemName parameter that the user has to include).
[
In the handler, you need to get the name that they spoke, look up what the item is, and add this to the list of items they've ordered.
app.intent('order.name', (conv, params) => {
// Get the name
let itemName = params['itemName'];
// Look it up to find out what they ordered
// You need to implement the itemFromName function
return itemFromName( itemName )
.then( item => {
// Add the item
conv.user.data.items.push( item );
// And reply
conv.add( "You got it! Anything else?" );
});
});
Finish building the order
Once you've finished collecting everything they want, your Intent Handler should put the order together, assembling the full list of lineItems from the conv.user.data.items array that we've been putting together, calculating tax, totals, and all the other parts of the order.
We then need to propose the order by sending a TransactionDecision object that contains our order in the proposedOrder parameter. Clever, no? Possibly something like this:
app.intent('review', conv => {
// Get the items the user has saved
let items = conv.user.data.items;
// Turn these into more complete lineItems
// You will need to provide the "itemToLineItem" function
let lineItems = items.map( itemToLineItem );
// Get some other objects we need
// You'll need to define these functions, too
let orderId = generateOrderId();
let subtotal = computeSubtotal( lineItems );
let tax = computeTax( lineItems );
let total = computerTotal( subtotal, tax );
// Build the order object
let order = buildOrder( lineItems, subtotal, tax, total );
conv.ask(new TransactionDecision({
orderOptions: {
requestDeliveryAddress: false,
},
paymentOptions: {
googleProvidedOptions: {
prepaidCardDisallowed: false,
supportedCardNetworks: ['VISA', 'AMEX'],
// These will be provided by payment processor,
// like Stripe, Braintree, or Vantiv.
tokenizationParameters: {
tokenizationType: 'PAYMENT_GATEWAY',
parameters: {
'gateway': 'stripe',
'stripe:publishableKey': (conv.sandbox ? 'pk_test_key' : 'pk_live_key'),
'stripe:version': '2017-04-06'
},
},
},
},
proposedOrder: order,
}));
});
I broke most of the stuff out as a function since there is nothing specific about them, except the format of the order (which you illustrate in your example). You can really build it any way you want.
Conclusion
Much of what you need to do really boils down to
Collecting the information of what the user wants to order, mostly storing the IDs of these items
Turning this list of items into the complete order object
Sending this order for the user to review
Using node-recurly. The idea is to create a charge without generating an invoice, then create a subscription and have recurly attach the charge to the subscription invoice. However, when I create a charge, the invoice gets generated automatically for it, so the user gets two separate invoices in the email: one for the charge, and one for the subscription.
This is the charge object that I use:
const shippingCharge = {
amount_in_cents: parseFloat(shippingMethod.amount) * 100,
currency: 'USD',
description: `${shippingMethod.provider} ${shippingMethod.servicelevel_name} shipping`,
account: {
account_code: activationCode,
},
};
I pass it to this function that creates a charge:
recurly.transactions.create(chargeObject, (response) => {
... blah blah blah
});
recurly.subscriptions.create is being called next (calls are being made sequentially using promises). The end result is two invoices instead of one.
Recurly's documentation is confusing. When I was trying to create a charge, I made an assumption that I have to create a transaction. After contacting support, I was provided with the link to create a charge. If you look at the code examples on the right, they reference Recurly_Adjustment, not transaction object. So to create a charge I have to create an adjustment, not a transaction. Switching to proper API call fixed the issue and I received a single invoice.
Alex is correct. You will also need to use revenue_schedule_type: at_invoice if you want the charges together. The Recurly API docs do not include NodeJS examples. Here you go:
return recurly.adjustments.create(accountId, {
unit_amount_in_cents: parseFloat(shippingMethod.amount) * 100,
currency: 'USD',
description: `${shippingMethod.provider} ${shippingMethod.servicelevel_name} shipping`,
revenue_schedule_type: 'at_invoice',
accounting_code: accountingCode,
}).then(() => {
// ...create an invoice, subscription, or whatever
});