tabbit

Mon Jun 10 2019
Copied to clipboard! Copy reply
const express = require("express")
const Stripe = require('stripe')
const Mailgun = require('mailgun-js')
const { Datastore } = require('@google-cloud/datastore')


const isEmail = require('validator/lib/isEmail')
const isLength = require('validator/lib/isLength')
const cors = require('cors')
const app = express()
const ds = new Datastore( { productId: 'bnbcrate1' })


// Only needed in dev, GCF already includes for you
var bodyParser = require('body-parser')
app.use(bodyParser.json())

app.use(cors())
app.listen(8080);


/**
 * By default, load prod values.
 */
var mailgunKey = '779a6a20423f010b0d9cfc76e177e5f6'
var stripeKey = 'sk_live_bQhKekL9Rzt6IPkN217YKlVu'

/**
 * For any route, determine if we are in dev or prod environment
 */
app.use(function(req, res, next) {
  req.environment = req.headers['x-environment'] == 'prod' ? 'prod' : 'dev'
    
  if (req.environment == 'dev') {
    stripeKey = 'sk_test_bypTtufI6HZA4YpaLBWLMEZX'
    mailgunKey = '779a6a20423f010b0d9cfc76e177e5f6'
  } 
  next()
})


/**
 * Define products:: TODO should actually be a bucket file
 */
const products = [
  {
    id: 1,
    name: "Basic",
    price: 6.99,
    items: [ "1 Shampoo", "1 Conditioner", "1 Soap", "1 Shower Cap" ]      
  },
  {
    id: 5,
    name: "Premium",
    price: 14.99,
    items: ["1 Shampoo", "1 Conditioner", "1 Soap", "1 Shower Cap", "2 Toothbrushes", "2 Toothpastes", "2 Towels"]
  }
]  



/**
 * Route to return our products
 */
app.get('/products', (req, res, next) => {
  res.status(200).json(products);
})


/**
 * Route checks user's cart out.
 */
app.post('/checkout', async (req, res, next) => {
  
  

  console.log('--- body')
  console.log(req.body)
  // Holds order's data, such as email, shipping info, products...
  const data = req.body.orderData || null

  // JWT token lets us know if user is logged in
  const jwtToken = req.body.jwt || null

  // Strike Token that is passed if paying with a new credit card
  const stripeToken = req.body.stripeToken || null
  
  // Stripe (customer) ID and card ID are sent if user is paying with a stored credit card   
  const stripeId = req.body.stripeId || null
  const cardId = req.body.cardId || null

  // Total amount of purchase
  let serverTotal = 0


  const stripe = Stripe(stripeKey)
  const emailDomain = 'mail.bnbcrate.com'
  const mailgun = Mailgun({ apiKey: mailgunKey, domain: emailDomain })

  var userId = null
    
  if (jwtToken)
  {
    let decoded= jwt.verify(jwtToken, process.env.JWT);
    userId = decoded.id      
  }   
    
  var invalidData = false   

    
  if (!stripeToken)
  {      
    if (!stripeId || !cardId)
    {
      invalidData = true
    }
  }

  if (!stripeId && cardId)
  {
    if (!stripeToken)
    {
      invalidData = true
    }
  }

  if (!data.crates.length)
  {
    invalidData = true
  }

  if (invalidData)
  {
    // TODO log
    return res.json({
      result: 0,
      payload: { 
        message: 'Something went wrong. Data is missing. Please reload the page and try again.'
      }
    })    
  }

  
  /**
   *
   * Client Sends: [ { id: 1, quantity: 2, price: 5.99} ]
   * We need to make sure that the ID of each crate sent by client
   * exists in the server, and that the price for that crate sent by
   * the client also matches the server. So if client sends a crate
   * of id 1 where price is $6, we need to make sure server has a crate
   * of id 1 and that its price is $6     
   */    
  
  // const clientTotal = data.crates
  //   .map(e => e.price * e.quantity)
  //   .reduce((acc,cv) => acc + cv)   
  for (let crate of data.crates)
  {
    let clientId = crate.id
    let clientPrice = crate.price    
    
    // Check if ID exists in the products "database"
    let [ serverCrate ]  = products.filter(c => c.id == clientId) || null

    // The crate id sent from client does not exist in the server.
    if (!serverCrate || clientPrice != serverCrate.price)
    {
      // TODO log
      return res.json({
        result: 0,
        payload: { 
          message: 'Product mismatch. Please try again' 
        }
      })    
    }
    else
    {
      // Gets passed to stripe
      serverTotal += serverCrate.price
    }
  }
     
    
  // Sanitize the data sent    
  if (!sanitizeInputs(data))
  {
    // TODO log
    return res.json({
      result: 0,
      payload: { 
        message: 'Bad input.' 
      }
    })     
  }

  // Validation passed.
  let email = data.email.toLowerCase()    

  // Not needed..just wasting datastore space
  delete data.shipping['id']  
      
  var charge = null
    
  try
  {
    const stripeData = {
      amount : (serverTotal * 100), // Stripe wants cents.
      currency : 'usd',
      description : `Charge for ${email}`,
      metadata: {          
        dsUserId: '',
        items: '',
        email: email,
        name: data.shipping.name,
        street: data.shipping.street,
        city: data.shipping.city,
        state: data.shipping.state,
        zip: data.shipping.zip,          
      }
    }

    if (stripeToken)
    {
      // New credit card
      stripeData.source = stripeToken.id
    }
    else
    {
      // Applying a saved credit card to a customer
      stripeData.source = cardId
      stripeData.customer = stripeId
    }

    
    charge = await stripe.charges.create(stripeData)

    // Now save in the datastore
    let datastoreOrder = await saveOrderInDB({
      email: email,
      userId: userId,
      items: data.crates,
      shippingAddress: data.shipping,
      currency: 'usd',
      guest: data.guest,
      total: serverTotal
    }, charge.id)

    // Now send email
    /*
    let templateUri = `${__dirname}/../email-templates/order-confirmation.html`
    let emailTemplate = readFileSync(templateUri, 'utf-8')
    let compiled = template(emailTemplate)
    let emaildata = {
      from: `bnbcrate <orders@${emailDomain}>`,
      to: email,
      subject: 'Your bnbcrate order',
      html: compiled({
        crates: data.crates,
        address: data.shippingAddress,
        orderId: datastoreOrder.payload.key.id 
      })
    } 

    mailgun.messages().send(emaildata, (e, body) => {
      if (e)
      {        
        // TODO log
      }        
    })
    */


    res.json({ result: 1 })
  }
  catch (e)
  {     
    console.log(e)
    // TODO log
    return res.json({
      result: 0,
      payload: { 
        message: 'Could not charge card. Please try again' 
      }
    })  
  }




});







  /**
   * Sanitizes all user inputs from the client.
   * Best way to know all the inputs is to take
   * a look at the client store.
   *
   * @param {Object} data: ctx.request.body
   */
  function sanitizeInputs(data)
  {
    const email = data.email
    //const crates = data.crates
    const shipping = data.shipping
    
    var error = []    
    
    if (!isEmail(email))
    {
      error.push('Invalid email.')
    }

    // Shipping Fields
    if (!isLength(shipping.street, {min: 1}))
    {
      error.push('Invalid shipping address.')
    }

    if (!isLength(shipping.zip, {min: 3}))
    {
      error.push('Invalid shipping zip code.')
    }

    if (!isLength(shipping.country, {min: 2, max: 2}) || shipping.country != 'us')
    {
      error.push('Invalid shipping country.')
    }  

    
    if (error.length)
    {
      return false
    }
    return true

  }


  /**
   * Saves an order into the datastore.
   * 
   * @param {String} email - buyer's email
   * @param {Int} userId - user's id, if logged in
   * @param {String} chargeId - charge ID generated by Stripe
   * @param {String} shippingAddress - shipping address
   * @param {Object} items - Items being purchased {crate: qty}
   * @param {Int} total - total price charged
   * @param {String} currency - charge currency
   * @param {String} paymentMethod - payment method. cc or paypal
   * @param {Date} date - date and time
   * @param {String} status - order status. 'new' by default
   * @param {String|int} dsId - unique ID for datastore's key. (order's ID)
   */
  function saveOrderInDB(data, dsId)
  { 
    const orderEntity = {
      key: ds.key(['Order', dsId]),
      data: [
        {
          name: 'email',
          value: data.email
        },
        {
          name: 'userId',
          value: data.userId || null
        },        
        {
          name: 'shippingAddress',
          value: data.shippingAddress,
          excludeFromIndexes: true
        },
        {
          name: 'items',
          value: data.items,
          excludeFromIndexes: true,
        },
        {
          name: 'total',
          value: data.total,
          excludeFromIndexes: true
        },
        {
          name: 'currency',
          value: 'usd',
          excludeFromIndexes: true
        },
        {
          name: 'guest',
          value: data.guest || null
        },
        {
          name: 'paymentMethod',
          value: 'credit card'
        },
        {
          name: 'date',
          value: new Date()
        },
        {
          name: 'status',
          value: 'new'
        },
        {
          name: 'dateShipped',
          value: null
        }
      ]
    }
    
    return ds.insert(orderEntity)
      .then(result => { 
        
        // We return the order entity so we can use it to update
        return { result: 1, payload: orderEntity }
      })
      .catch(e => {        
        // TODO log
        console.log(e)
        return {
          result: 0,
          payload: {
            message: `Could not save order. Please try again. ${e}`
          }
        }
      })
    
    
  }





module.exports = {
  checkout: app
}

// Server makes a GC functions api call to fetch products - since it's internal, cant be intefered