solidus_paypal_commerce_platform 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8d729015bdddd523c8210fb8276c47d11a79b6a3e91ef1107a51c9ced0e9a840
+  data.tar.gz: ed5a4f61038c0596b75ae0d6914f3a98a225b3408911bdc64eb287d5131fcde7
+SHA512:
+  metadata.gz: 48a8ac2f5d03d0d0e32f0a5d36d53a78ea1baccc6bd4a59e09b24a6d8820d92a4e2a98e0a30fb22c5d969d5bf75a423ed7c8f3bdbbab937ecb7857e270a0778f
+  data.tar.gz: e714276710dea1c6538cd46e475a0b689060c905ca0d3a69743e0d8236b16dc8d55b5226012ddc365fc8c0339836cc2b4e3c2662be5e77ccf357c7464c9dc7f7

data/.circleci/config.yml

@@ -0,0 +1,41 @@
+version: 2.1
+
+orbs:
+  # Always take the latest version of the orb, this allows us to
+  # run specs against Solidus supported versions only without the need
+  # to change this configuration every time a Solidus version is released
+  # or goes EOL.
+  solidusio_extensions: solidusio/extensions@volatile
+
+jobs:
+  run-specs-with-postgres:
+    executor: solidusio_extensions/postgres
+    steps:
+      - solidusio_extensions/run-tests
+  run-specs-with-mysql:
+    executor: solidusio_extensions/mysql
+    steps:
+      - solidusio_extensions/run-tests
+  lint-code:
+    executor: solidusio_extensions/sqlite-memory
+    steps:
+      - solidusio_extensions/lint-code
+
+workflows:
+  "Run specs on supported Solidus versions":
+    jobs:
+      - run-specs-with-postgres
+      - run-specs-with-mysql
+      - lint-code
+
+  "Weekly run specs against master":
+    triggers:
+      - schedule:
+          cron: "0 0 * * 4" # every Thursday
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+      - run-specs-with-postgres
+      - run-specs-with-mysql

data/.gem_release.yml

@@ -0,0 +1,5 @@
+bump:
+  recurse: false
+  file: 'lib/solidus_paypal_commerce_platform/version.rb'
+  message: Bump SolidusPaypalCommercePlatform to %{version}
+  tag: true

data/.github/stale.yml

@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.project
+.sass-cache
+coverage
+Gemfile.lock
+tmp
+nbproject
+pkg
+*.swp
+spec/dummy
+spec/examples.txt
+/sandbox
+.rvmrc
+.ruby-version
+.ruby-gemset

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,56 @@
+require:
+  - solidus_dev_support/rubocop
+
+AllCops:
+  Exclude:
+    - sandbox/**/*
+    - spec/dummy/**/*
+    - vendor/bundle/**/*
+
+Layout/IndentFirstArgument:
+  EnforcedStyle: consistent
+
+Layout/IndentFirstArrayElement:
+  EnforcedStyle: consistent
+
+Metrics/LineLength:
+  Max: 120
+
+# We use this extensively, the alternatives are not viable or desirable.
+RSpec/AnyInstance:
+  Enabled: false
+
+# Feature specs are not describing any class or module.
+RSpec/DescribeClass:
+  Exclude:
+    - spec/features/**/*
+
+# No need to make the code more complex for no real gain.
+RSpec/MessageSpies:
+  Enabled: false
+
+# Let's consider legitimate to have multiple expectations within an example.
+RSpec/MultipleExpectations:
+  Enabled: false
+
+# Allow to use subject as is, no big deal.
+RSpec/NamedSubject:
+  Enabled: false
+
+# Let's set this to some really exagerate value.
+RSpec/NestedGroups:
+  Max: 8
+
+RSpec/VerifiedDoubles:
+  # Sometimes you really need an "anything" double
+  IgnoreSymbolicNames: true
+
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - spec/**/*
+    - db/migrate/**/*
+    - bin/**/*
+
+Security/YAMLLoad:
+  Exclude:
+    - spec/**/*

data/Gemfile

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+branch = ENV.fetch('SOLIDUS_BRANCH', 'master')
+gem 'solidus', github: 'solidusio/solidus', branch: branch
+
+# Needed to help Bundler figure out how to resolve dependencies,
+# otherwise it takes forever to resolve them.
+# See https://github.com/bundler/bundler/issues/6677
+gem 'rails', '>0.a'
+
+# Provides basic authentication functionality for testing parts of your engine
+gem 'solidus_auth_devise'
+
+case ENV['DB']
+when 'mysql'
+  gem 'mysql2'
+when 'postgresql'
+  gem 'pg'
+else
+  gem 'sqlite3'
+end
+
+gemspec
+
+# Use a local Gemfile to include development dependencies that might not be
+# relevant for the project or for other contributors, e.g. pry-byebug.
+#
+# We use `send` instead of calling `eval_gemfile` to work around an issue with
+# how Dependabot parses projects: https://github.com/dependabot/dependabot-core/issues/1658.
+send(:eval_gemfile, 'Gemfile-local') if File.exist? 'Gemfile-local'

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2020 Nebulab srls
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Solidus nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,173 @@
+# SolidusPaypalCommercePlatform
+
+[![CircleCI](https://circleci.com/gh/nebulab/solidus_paypal_commerce_platform.svg?style=shield)](https://circleci.com/gh/nebulab/solidus_paypal_commerce_platform)
+[![codecov](https://codecov.io/gh/nebulab/solidus_paypal_commerce_platform/branch/master/graph/badge.svg)](https://codecov.io/gh/nebulab/solidus_paypal_commerce_platform)
+
+The official PayPal integration of Solidus.
+
+## Installation
+
+Add solidus_paypal_commerce_platform to your Gemfile:
+
+```ruby
+gem 'solidus_paypal_commerce_platform'
+```
+
+Bundle your dependencies and run the installation generator:
+
+```shell
+bundle
+bundle exec rails g solidus_paypal_commerce_platform:install
+```
+
+### PayPal Sandbox/Live Environment
+
+This extension will automatically select a PayPal environment based on Rails environment so that "production" will be mapped to the "live" PayPal environment, and everything else will be routed to the "sandbox" PayPal environment.
+
+If you want to override these values you can either set `SolidusPaypalCommercePlatform.config.env` to `"live"` or `"sandbox"` inside an initializer. Or, alternatively, you can set the `PAYPAL_ENV` environment variable to one of the same two values.
+
+### Custom PartnerID & PartnerClientID
+
+You can declare your PayPal Partner-ID and Partner-Client-ID as environment
+variables or set their values directly on `SolidusPaypalCommercePlatform.config`
+or by using the configuration method detailed in the Customization section.
+
+#### Use ENV variables
+
+```shell
+export PAYPAL_PARTNER_ID="xxxxxxxxxxKG2"
+export PAYPAL_PARTNER_CLIENT_ID="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxVSX"
+```
+
+#### Set them directly
+
+```ruby
+SolidusPaypalCommercePlatform.config.partner_id = "xxxxxxxxxxKG2"
+SolidusPaypalCommercePlatform.config.partner_client_id = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxVSX"
+```
+
+## Address Phone Number Validation
+
+Since PayPal is being used as the checkout if the user checks out on the product or cart page, and PayPal doesn't collect phone numbers, this extension disables phone number required validation for `Spree::Address`. To turn phone number validation back on, you'll need to either:
+
+A) Turn off cart and product page checkout - configurable on the admin payment method page for PayPal Commerce Platform.
+-OR-
+B) Collect the users phone number seperately
+
+and then override the `Spree::Address` method `require_phone?` to return `true`.
+
+## Usage
+
+### I already have API credentials
+
+If you already have API credentials, then you'll need to store them somewhere. You can do this directly in the
+preferences of the payment method, but we recommend storing your API credentials as an ENV variable and loading
+them in as a preference on initialization.
+
+```ruby
+# config/initializers/spree.rb
+Spree::Config.configure do |config|
+  config.static_model_preferences.add(
+    SolidusPaypalCommercePlatform::PaymentMethod,
+    'paypal_commerce_platform_credentials', {
+      test_mode: !Rails.env.production?,
+      client_id: ENV['PAYPAL_CLIENT_ID'],
+      client_secret: ENV['PAYPAL_CLIENT_SECRET'],
+      paypal_email_confirmed: true,
+      display_on_product_page: true,
+      display_on_cart: true,
+    }
+  )
+end
+```
+
+### I don't have API credentials
+
+In this case, we still recommend following the above flow for security, but we have made a payment method setup
+wizard to make it easier to get started. On the payment_methods index page, you'll see a button to set up your
+PayPal Commerce Platform payment method. Click on this button and follow the instructions provided by PayPal.
+When you return to your app, your payment method should be set up and ready to go.
+
+### Email Confirmation
+
+A confirmed email is required to get paid by PayPal. You'll need to check `Paypal Email Confirmed` on your new
+payment method before being able to select `Available To Users`.
+
+## Wizards
+
+This gem adds support for payment method wizards to be set up. Payment wizards can be used to automatically set up
+payment methods by directing the user to a sign-in page for whatever service they're connecting. In this gem, the
+user is directed to sign up/in for PayPal, and then give their app access to their credentials, which is store in
+preferences.
+
+To add a payment wizard, add the class where your wizard is stored on initialization:
+
+```ruby
+initializer "register_solidus_paypal_commerce_platform_wizard", after: "spree.register.payment_methods" do |app|
+  app.config.spree.payment_setup_wizards << "SolidusPaypalCommercePlatform::Wizard"
+end
+```
+
+The instances of your wizard class should respond to `#name` and `#partial_name`, where `partial_name` will return the path to the partial you'd like to display on the wizard setup section. In our case, we just display a button to direct the user to PayPal.
+
+## Custom Checkout Steps
+
+With product and cart page checkout, the user is directed to the checkout confirmation step when they return from PayPal. If you've removed the confirmation step, you'll need to override the `SolidusPaypalCommercePlatform.finalizeOrder` JavaScript method to instead complete the order.
+
+## Backend Payments
+
+PayPals API does not allow for admin-side payments. Instead, backend users taking payments for customers will need to use the PayPal Virtual Terminal to take payments. [More info is available on the PayPal website.](https://www.paypal.com/merchantapps/appcenter/acceptpayments/virtualterminal?locale.x=en_US)
+
+## Development
+
+### Testing the extension
+
+First bundle your dependencies, then run `bin/rake`. `bin/rake` will default to building the dummy
+app if it does not exist, then it will run specs. The dummy app can be regenerated by using
+`bin/rake extension:test_app`.
+
+```shell
+bundle
+bin/rake
+```
+
+To run [Rubocop](https://github.com/bbatsov/rubocop) static code analysis run
+
+```shell
+bundle exec rubocop
+```
+
+When testing your application's integration with this extension you may use its factories.
+Simply add this require statement to your spec_helper:
+
+```ruby
+require 'solidus_paypal_commerce_platform/factories'
+```
+
+### Running the sandbox
+
+To run this extension in a sandboxed Solidus application, you can run `bin/sandbox`. The path for
+the sandbox app is `./sandbox` and `bin/rails` will forward any Rails commands to
+`sandbox/bin/rails`.
+
+Here's an example:
+
+```shell
+$ bin/rails server
+=> Booting Puma
+=> Rails 6.0.2.1 application starting in development
+* Listening on tcp://127.0.0.1:3000
+Use Ctrl-C to stop
+```
+
+### Releasing new versions
+
+Your new extension version can be released using `gem-release` like this:
+
+```shell
+bundle exec gem bump -v VERSION --tag --push --remote upstream && gem release
+```
+
+## License
+
+Copyright (c) 2020 Nebulab srls, released under the New BSD License

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'solidus_dev_support/rake_tasks'
+SolidusDevSupport::RakeTasks.install
+
+task default: 'extension:specs'

data/app/assets/javascripts/spree/backend/solidus_paypal_commerce_platform.js

@@ -0,0 +1,2 @@
+//= require spree/backend/solidus_paypal_commerce_platform/namespace
+//= require spree/backend/solidus_paypal_commerce_platform/wizard

data/app/assets/javascripts/spree/backend/solidus_paypal_commerce_platform/namespace.js

@@ -0,0 +1 @@
+window.SolidusPaypalCommercePlatform = {}

data/app/assets/javascripts/spree/backend/solidus_paypal_commerce_platform/wizard.js

@@ -0,0 +1,28 @@
+/* global Spree, SolidusPaypalCommercePlatform */
+
+// This needs to be filled before using the callback
+SolidusPaypalCommercePlatform.nonce = null
+
+// Returning from the setup wizard
+SolidusPaypalCommercePlatform.onboardCallback = function(authCode, sharedId) {
+  var nonce = SolidusPaypalCommercePlatform.nonce
+  
+  if (!nonce) 
+    throw new Error("Please set SolidusPaypalCommercePlatform.nonce before calling this function.")
+
+  Spree.ajax({
+      url: '/solidus_paypal_commerce_platform/wizard',
+      type: 'POST',
+      data: {
+        authCode: authCode,
+        sharedId: sharedId,
+        nonce: nonce
+      },
+      success: function(response) {
+        window.location.href = response.redirectUrl;
+      },
+      error: function(response) {
+        alert("Something went wrong!")
+      }
+  });
+};

data/app/assets/javascripts/spree/frontend/solidus_paypal_commerce_platform.js

@@ -0,0 +1,3 @@
+//= require spree/frontend/solidus_paypal_commerce_platform/namespace
+//= require spree/frontend/solidus_paypal_commerce_platform/button_actions
+//= require spree/frontend/solidus_paypal_commerce_platform/buttons

data/app/assets/javascripts/spree/frontend/solidus_paypal_commerce_platform/button_actions.js

@@ -0,0 +1,191 @@
+SolidusPaypalCommercePlatform.showOverlay = function() {
+  document.getElementById("paypal_commerce_platform_overlay").style.display = "block";
+}
+
+SolidusPaypalCommercePlatform.hideOverlay = function() {
+  document.getElementById("paypal_commerce_platform_overlay").style.display = "none";
+}
+
+SolidusPaypalCommercePlatform.sendOrder = function(payment_method_id) {
+  return Spree.ajax({
+    url: '/solidus_paypal_commerce_platform/paypal_orders/' + Spree.current_order_id,
+    method: 'GET',
+    data: {
+      payment_method_id: payment_method_id,
+      order_token: Spree.current_order_token
+    }
+  }).then(function(response) {
+    return response.table.id;
+  })
+}
+
+SolidusPaypalCommercePlatform.createAndSendOrder = function(payment_method_id) {
+  return SolidusPaypalCommercePlatform.createOrder().then(function(){
+    return SolidusPaypalCommercePlatform.sendOrder(payment_method_id)
+  })
+}
+
+SolidusPaypalCommercePlatform.createOrder = function() {
+  var data = {
+    order: {
+      line_items_attributes: [{
+        variant_id: SolidusPaypalCommercePlatform.getVariantId(),
+        quantity: SolidusPaypalCommercePlatform.getQuantity()
+      }]
+    }
+  }
+
+  return Spree.ajax({
+    url: "/solidus_paypal_commerce_platform/orders",
+    method: 'POST',
+    data: data,
+    error: function(response) {
+      message = response.responseJSON
+      alert('A problem has occurred while creating your order - ' + message);
+    }
+  }).then(function(response) {
+    Spree.current_order_id = response.number
+    Spree.current_order_token = response.guest_token
+  });
+}
+
+SolidusPaypalCommercePlatform.getVariantId = function() {
+  var variants = document.getElementsByName("variant_id")
+  var variant_id;
+  if(variants.length == 1){
+    variant_id = variants[0].value
+  }else{
+    var i;
+    for (i = 0; i < variants.length; i++) {
+      if (variants[i].checked) {
+        variant_id = variants[i].value
+      }
+    }
+  }
+  return variant_id
+}
+
+SolidusPaypalCommercePlatform.getQuantity = function() {
+  return document.getElementById("quantity").value
+}
+
+SolidusPaypalCommercePlatform.approveOrder = function(data, actions) {
+  SolidusPaypalCommercePlatform.showOverlay()
+  actions.order.get().then(function(response){
+    SolidusPaypalCommercePlatform.updateAddress(response).then(function() {
+      SolidusPaypalCommercePlatform.verifyTotal(response.purchase_units[0].amount.value).then(function(){
+        $("#payments_source_paypal_order_id").val(data.orderID)
+        $("#payments_source_paypal_email").val(response.payer.email_address)
+        $("#checkout_form_payment").submit()
+      })
+    })
+  })
+}
+
+SolidusPaypalCommercePlatform.shippingChange = function(data, actions) {
+  Spree.ajax({
+    url: '/solidus_paypal_commerce_platform/shipping_rates',
+    method: 'GET',
+    data: {
+      order_id: Spree.current_order_id,
+      order_token: Spree.current_order_token,
+      address: data.shipping_address
+    },
+    error: function(response) {
+      message = response.responseJSON;
+      console.log('There were some problems with your payment address - ' + message);
+      actions.reject()
+    }
+  }).then(function(response) {
+    actions.order.patch([response]);
+  });
+}
+
+SolidusPaypalCommercePlatform.verifyTotal = function(paypal_total) {
+  return Spree.ajax({
+    url: '/solidus_paypal_commerce_platform/verify_total',
+    method: 'GET',
+    data: {
+      order_id: Spree.current_order_id,
+      order_token: Spree.current_order_token,
+      paypal_total: paypal_total
+    },
+    error: function(response) {
+      SolidusPaypalCommercePlatform.hideOverlay()
+      alert('There were some problems with your payment - ' + response.responseJSON.errors.expected_total);
+    }
+  })
+}
+
+SolidusPaypalCommercePlatform.finalizeOrder = function(payment_method_id, data, actions) {
+  SolidusPaypalCommercePlatform.showOverlay()
+  actions.order.get().then(function(response){
+    SolidusPaypalCommercePlatform.updateAddress(response).then(function() {
+      var paypal_amount = response.purchase_units[0].amount.value
+      SolidusPaypalCommercePlatform.advanceOrder().then(function() {
+        SolidusPaypalCommercePlatform.verifyTotal(paypal_amount).then(function(){
+          SolidusPaypalCommercePlatform.addPayment(paypal_amount, payment_method_id, data, response.payer.email_address).then(function() {
+            window.location.href = SolidusPaypalCommercePlatform.checkout_url
+          })
+        })
+      })
+    })
+  })
+}
+
+SolidusPaypalCommercePlatform.advanceOrder = function() {
+  return Spree.ajax({
+    url: '/api/checkouts/' + Spree.current_order_id + '/advance',
+    method: 'PUT',
+    data: {
+      order_token: Spree.current_order_token
+    },
+    error: function(response) {
+      SolidusPaypalCommercePlatform.hideOverlay()
+      alert('There were some problems with your order');
+    }
+  })
+}
+
+SolidusPaypalCommercePlatform.addPayment = function(paypal_amount, payment_method_id, data, email) {
+  return Spree.ajax({
+    url: '/api/checkouts/' + Spree.current_order_id + '/payments',
+    method: 'POST',
+    data: {
+      order_token: Spree.current_order_token,
+      payment: {
+        amount: paypal_amount,
+        payment_method_id: payment_method_id,
+        source_attributes: {
+          paypal_order_id: data.orderID,
+          paypal_email: email
+        }
+      }
+    },
+    error: function(response) {
+      SolidusPaypalCommercePlatform.hideOverlay()
+      alert('There were some problems with your payment');
+    }
+  })
+}
+
+SolidusPaypalCommercePlatform.updateAddress = function(response) { 
+  var updated_address = response.purchase_units[0].shipping.address
+  return Spree.ajax({
+    url: '/solidus_paypal_commerce_platform/update_address',
+    method: 'POST',
+    data: {
+      address: {
+        updated_address: updated_address,
+        recipient: response.payer
+      },
+      order_id: Spree.current_order_id,
+      order_token: Spree.current_order_token
+    },
+    error: function(response) {
+      SolidusPaypalCommercePlatform.hideOverlay()
+      message = response.responseJSON;
+      alert('There were some problems with your payment address - ' + message);
+    }
+  })
+}