swisspay 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1503403d48175f3f78a716d205373db04e20a892128fd1a020d5de2d5e726e1e
+  data.tar.gz: edf30f7e5be4e8f7e7bc802f08a21c556c6567e123b2c05310e74bd2cdbb5f64
+SHA512:
+  metadata.gz: df82a8c224bbf266f0c61273950f5398f3fe678c5858027b43af57d61ab2b4e1792704b4cdea0bdbbfcb113043b0f2b657c0e741728ed333884e3dbbfd0b97ed
+  data.tar.gz: ac6070a77da9e090ca31300176cf640eb3e0f48da97ee983cf007f24f511566297cecba3da45c28504541380d19f849fb9e7b57bd6c7f05aae2645871b2d2d1c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Lukas_Skywalker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,92 @@
+# Swisspay
+
+Rails integration for Swiss payment service providers.
+
+Swisspay is a gem that helps you accept payments using various Payment Processing Providers (PSPs). At the moment, it includes support vor Paypal, Stripe and Postfinance (card and e-finance) and SIX Payment Services (Saferpay) payments.
+
+It features a simple integration but stays flexible to fit your needs.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'swisspay'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+## Usage
+
+Embed the payment partial on your site:
+
+```erb
+<%= swisspay_payment_form(@order.id, 200, {
+  description: @order.id,
+  buyer: {
+    name: current_user.full_name,
+    email: current_user.email,
+    street: current_user.street,
+    country: 'Schweiz',
+    zip: current_user.zip,
+    city: current_user.city
+  },
+  image: asset_path('my_logo.jpg')
+}) %>
+```
+
+The first two parameters, `identifier` and `amount` are required. The amount must be in **Rappen**. The options are all optional.
+
+You can use the `identifier` parameter to keep track of the payment. The parameter you pass in here will be returned to you in the callbacks described below (still called `identifier`).
+
+Define after payment actions in the initializer, e.g. `config/initializers/swisspay.rb`:
+
+```ruby
+Swisspay.configure do |config|
+  config.payment_success = -> (controller, app, identifier) do
+    order = Order.find(identifier)
+    order.update(status: :paid)
+
+    controller.redirect_to app.order_confirmation_path
+  end
+
+  config.payment_error = -> (controller, app, identifier, error) do
+    Rails.logger.error "Payment error: #{error}"
+
+    controller.redirect_to app.checkout_error_path, alert: error
+  end
+
+  config.vendor_name = 'TRM Schweiz'
+
+  config.stripe = {
+    secret_key: "sk_test_78nv4zna03vnttab8nw93nsv",
+    public_key: "pk_test_nsven89s4nv3497vts9svfgg"
+  }
+
+  config.postfinance = {
+    pspid: 'mytestPSPID',
+    sha_in_pswd: 'dkjfhiurnviyfhjk'
+  }
+
+  config.saferpay = {
+    customer_id: '123456',
+    terminal_id: '87654321',
+    api_user: 'API_123456_12345678',
+    api_pass: 'a8379a37v9a37o9yv73wvc2r9'
+  }
+end
+```
+
+## License
+
+All rights reserved.
+
+## Terms of Service
+
+Usage of this gem is bound to the following TOS.
+
+1. Licences are granted for a single application. One application may be installed on multiple machines, for instance in a development setup and multistage / CI deploy.
+2. Licences are granted for an unlimited time.
+3. This gem's source code must not be published or modified.

data/Rakefile

@@ -0,0 +1,24 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Swisspay'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+require 'bundler/gem_tasks'
+

data/app/assets/config/swisspay_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/swisspay .js
+//= link_directory ../stylesheets/swisspay .css

data/app/assets/javascripts/swisspay/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/swisspay/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/swisspay/application_controller.rb

@@ -0,0 +1,5 @@
+module Swisspay
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/controllers/swisspay/paypals_controller.rb

@@ -0,0 +1,89 @@
+require 'paypal-sdk-rest'
+
+module Swisspay
+  class PaypalsController < ApplicationController
+    protect_from_forgery :except => [:create] #Otherwise the request from PayPal wouldn't make it to the controller
+    before_action :load_session
+
+    include PayPal::SDK::REST
+
+    def create
+      PayPal::SDK.configure(
+        mode: "sandbox",
+        client_id: Swisspay.configuration.paypal[:api_id],
+        client_secret: Swisspay.configuration.paypal[:api_secret],
+        ssl_options: { } )
+
+
+      case params[:step]
+      when 'create_payment'
+        create_payment
+      when 'execute_payment'
+        execute_payment
+      end
+    end
+
+    def show
+      if params[:action] == 'accept'
+        Swisspay.configuration.payment_success.call(self, main_app, @identifier, :paypal)
+      elsif params[:action] == 'cancel'
+        Swisspay.configuration.payment_error(self, main_app, @identifier, :paypal, :cancel)
+      end
+    end
+    
+    protected
+
+    def create_payment
+      # send a create payment request to the API
+      payment = Payment.new({
+        intent: 'sale',
+        payer: {
+          payment_method: 'paypal'
+        },
+        transactions: [{
+          amount: {
+            currency: 'CHF',
+            total: (@amount / 100.0)
+          },
+          invoice_number: @identifier
+        }],
+        # PayPal does not automatically call these URLs. PayPal invokes your onAuthorize function
+        # when the buyer authorizes the payment. At this point you can choose to redirect the buyer.
+        redirect_urls: {
+          return_url: Swisspay::Engine.routes.url_helpers.paypal_url(host: request.base_url, action: :return),
+          cancel_url: Swisspay::Engine.routes.url_helpers.paypal_url(host: request.base_url, action: :cancel)
+        }
+      })
+      if payment.create
+        # send payment id back to js script
+        render json: { paymentID: payment.id }
+      else
+        render json: { error: payment.error }, status: 400
+      end
+    end
+
+    def execute_payment
+      payment_id = params[:paymentID]
+      payer_id = params[:payerID]
+      payment = Payment.find(payment_id)
+      remote_identifier = payment.transactions.first.invoice_number
+      remote_amount = payment.transactions.first.amount.total
+
+      raise StandardError, 'AMOUNT MISMATCH' if (@amount / 100.to_f).to_f != remote_amount.to_f
+      raise StandardError, 'IDENTIFIER MISMATCH' if @identifier != remote_identifier
+
+      if payment.execute(payer_id: payer_id)
+        Swisspay.configuration.payment_success.call(self, main_app, @identifier, :paypal)
+      else
+        Swisspay.configuration.payment_error.call(self, main_app, @identifier, :paypal, payment.error)
+      end
+    end
+
+    private
+
+    def load_session
+      @amount = session['swisspay']['amount']
+      @identifier = session['swisspay']['identifier']
+    end
+  end
+end

data/app/controllers/swisspay/postfinances_controller.rb

@@ -0,0 +1,35 @@
+module Swisspay
+  class PostfinancesController < ApplicationController
+    before_action :load_session
+    
+    def accept
+      valid = Swisspay::Postfinance.check_signature(params.except(:action, :controller))
+
+      Rails.logger.error "SIGNATURE DOES NOT MATCH FINGERPRINT" if !valid
+
+      raise StandardError, 'AMOUNT MISMATCH' if (@amount / 100.to_f).to_f != params['amount'].to_f
+      raise StandardError, 'IDENTIFIER MISMATCH' if @identifier != params[:orderID]
+
+      Swisspay.configuration.payment_success.call(self, main_app, @identifier, :postfinance)
+    end
+
+    def cancel
+      Swisspay.configuration.payment_error.call(self, main_app, @identifier, :postfinance, :user_cancelled)
+    end
+
+    def decline
+      Swisspay.configuration.payment_error.call(self, main_app, @identifier, :postfinance, :card_declined)
+    end
+
+    def exception
+      Swisspay.configuration.payment_error.call(self, main_app, @identifier, :postfinance, :server_error)
+    end
+
+    private
+
+    def load_session
+      @amount = session['swisspay']['amount']
+      @identifier = session['swisspay']['identifier']
+    end
+  end
+end

data/app/controllers/swisspay/saferpays_controller.rb

@@ -0,0 +1,25 @@
+module Swisspay
+  class SaferpaysController < ApplicationController
+    before_action :load_session
+    
+    def success
+      token = session['swisspay']['token']
+      identifier = session['swisspay']['identifier']
+      valid = Swisspay::Saferpay.check_payment(identifier, token)
+      Rails.logger.error "NOT PAID" if !valid
+
+      Swisspay.configuration.payment_success.call(self, main_app, @identifier, :saferpay)
+    end
+
+    def fail
+      Swisspay.configuration.payment_error.call(self, main_app, @identifier, :saferpay, :fail)
+    end
+
+    private
+
+    def load_session
+      @amount = session['swisspay']['amount']
+      @identifier = session['swisspay']['identifier']
+    end
+  end
+end

data/app/controllers/swisspay/stripes_controller.rb

@@ -0,0 +1,34 @@
+module Swisspay
+  class StripesController < ApplicationController
+    protect_from_forgery except: [:create]
+    before_action :load_session
+    
+    def create
+      Stripe.api_key = Swisspay.configuration.stripe[:secret_key]
+
+      customer = Stripe::Customer.create(
+        email: params[:stripeEmail],
+        source: params[:stripeToken]
+      )
+
+      charge = Stripe::Charge.create(
+        customer:    customer.id,
+        amount:      @amount,
+        description: 'Bestellung ' + @identifier.to_s,
+        currency:    'chf'
+      )
+
+      Swisspay.configuration.payment_success.call(self, main_app, @identifier, :stripe)
+
+    rescue Stripe::CardError => e
+      Swisspay.configuration.payment_error(self, main_app, @identifier, :stripe, e.message)
+    end
+
+    private
+
+    def load_session
+      @amount = session['swisspay']['amount']
+      @identifier = session['swisspay']['identifier']
+    end
+  end
+end

data/app/helpers/swisspay/view_helpers.rb

@@ -0,0 +1,10 @@
+module Swisspay
+  module ViewHelpers
+    def swisspay_payment_form(identifier, amount, options = {})
+      identifier = identifier.to_s + Swisspay::order_id_suffix
+      session['swisspay'] = { 'amount' => amount, 'identifier' => identifier }
+      render  partial: 'swisspay/shop/payment',
+              locals: { identifier: identifier, amount: amount, base_url: request.base_url, options: options }
+    end
+  end
+end

data/app/jobs/swisspay/application_job.rb

@@ -0,0 +1,4 @@
+module Swisspay
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/swisspay/application_mailer.rb

@@ -0,0 +1,6 @@
+module Swisspay
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/swisspay/application_record.rb

@@ -0,0 +1,5 @@
+module Swisspay
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/swisspay/shop/_payment.html.erb

@@ -0,0 +1,15 @@
+<% if Swisspay.configuration.stripe? %>
+  <%= render partial: 'swisspay/shop/payment_stripe', locals: { identifier: identifier, amount: amount, options: options } %>
+<% end %>
+
+<% if Swisspay.configuration.paypal? %>
+  <%= render partial: 'swisspay/shop/payment_paypal', locals: { identifier: identifier, amount: amount, options: options } %>
+<% end %>
+
+<% if Swisspay.configuration.postfinance? %>
+  <%= render partial: 'swisspay/shop/payment_postfinance', locals: { base_url: base_url, identifier: identifier, amount: amount, options: options } %>
+<% end %>
+
+<% if Swisspay.configuration.saferpay? %>
+  <%= render partial: 'swisspay/shop/payment_saferpay', locals: { base_url: base_url, identifier: identifier, amount: amount, options: options } %>
+<% end %>

data/app/views/swisspay/shop/_payment_paypal.html.erb

@@ -0,0 +1,47 @@
+<script src="https://www.paypalobjects.com/api/checkout.js"></script>
+
+<div id="paypal-button"></div>
+
+<script>
+    paypal.Button.render({    
+        env: 'sandbox', // Optional: specify 'sandbox' environment
+        locale: 'de_DE',
+        commit: true,
+
+        style: {
+          size: 'small',
+          color: 'blue',  // gold, blue, silver
+          shape: 'rect',  // pill, rect
+          label: 'checkout'
+        },
+
+        payment: function(resolve, reject) {
+          // call Rails server
+          var CREATE_PAYMENT_URL = '<%= Swisspay::Engine.routes.url_helpers.paypal_path(step: 'create_payment').html_safe %>';
+
+          // passes the paymentID from the JSON response to the checkout.js script
+          // The Express Checkout flow is launched in a lightbox on your page and gets
+          // the buyer's approval for payment.
+          return paypal.request.post(CREATE_PAYMENT_URL)
+              .then(function(data) { resolve(data.paymentID); })
+              .catch(function(err) { reject(err); });
+        },
+
+        onAuthorize: function(data, actions) {
+          // Note: you can display a confirmation page before executing
+
+          var EXECUTE_PAYMENT_URL = '<%= Swisspay::Engine.routes.url_helpers.paypal_path(step: 'execute_payment').html_safe %>';
+
+          // When the buyer approves the payment, the checkout.js script calls your onAuthorize call back.
+          return paypal.request.post(EXECUTE_PAYMENT_URL,
+                  { paymentID: data.paymentID, payerID: data.payerID })
+                  
+              .then(function(data) { console.log(data); console.log(this); })
+              .catch(function(err) { console.log(err); });
+        },
+
+        onCancel: function(data, actions) {
+            return actions.redirect();
+        }
+    }, '#paypal-button');
+</script>

data/app/views/swisspay/shop/_payment_postfinance.html.erb

@@ -0,0 +1,12 @@
+<%= form_tag postfinance_payment_processing_url do %>
+
+  <% form_data = Swisspay::Postfinance.form_data(base_url, identifier, amount, options) %>
+
+  <% form_data.each do |name, value| %>
+    <%= hidden_field_tag(name, value) %>
+  <% end %>
+
+  <%= hidden_field_tag(:SHASIGN, Swisspay::Postfinance.generate_signature(form_data)) %>
+
+  <%= submit_tag t('payment.postcard'), class: 'button' %>
+<% end %>

data/app/views/swisspay/shop/_payment_saferpay.html.erb

@@ -0,0 +1,6 @@
+<% url, token = Swisspay::Saferpay.payment_url(base_url, identifier, amount, options) %>
+<% session['swisspay']['token'] = token %>
+
+<%= form_tag url, method: :get, enforce_utf8: false do %>
+  <%= submit_tag t('payment.saferpay'), class: 'button', name: nil %>
+<% end %>

data/app/views/swisspay/shop/_payment_stripe.html.erb

@@ -0,0 +1,55 @@
+<%= form_tag Swisspay::Engine.routes.url_helpers.stripe_path(identifier: identifier) do %>
+  
+  <script src="https://checkout.stripe.com/checkout.js"></script>
+
+  <%= submit_tag t('payment.creditcard'), class: 'button', id: 'stripe-button' %>
+
+  <script>
+    var handler = StripeCheckout.configure({
+      key: '<%= Swisspay.configuration.stripe[:public_key] %>',
+      image: 'https://stripe.com/img/documentation/checkout/marketplace.png',
+      locale: 'auto',
+      token: function(token) {
+        $.ajax({
+          type: 'POST',
+          url: '<%= Swisspay::Engine.routes.url_helpers.stripe_path(identifier: identifier) %>',
+          data: {
+            stripeEmail: token.email,
+            stripeToken: token.id
+          },
+          success: function(response) {
+            console.log('successful payment: ', response);
+          },
+          error: function(response) {
+            console.log('error payment: ', response);
+          }
+        })
+      }
+    });
+
+    document.getElementById('stripe-button').addEventListener('click', function(e) {
+      // Open Checkout with further options:
+      handler.open({
+        image: '<%= options[:image] %>',
+        name: '<%= Swisspay.configuration.vendor_name %>',
+        description: '<%= options[:description].to_s %>',
+        amount: <%= amount %>,
+        locale: 'auto',
+        //zipCode: false,
+        //billingAddress: false,
+        currency: 'CHF',
+        //panelLabel: '<%= t('stripe.popup_button_label') %>',
+        //shippingAddress: false,
+        email: '<%= options[:buyer][:email] %>',
+        //allowRememberMe: true,
+        //bitcoin: false
+      });
+      e.preventDefault();
+    });
+
+    // Close Checkout on page navigation:
+    window.addEventListener('popstate', function() {
+      handler.close();
+    });
+  </script>
+<% end %>

data/config/routes.rb

@@ -0,0 +1,16 @@
+Swisspay::Engine.routes.draw do
+  resource :paypal, only: [:create, :show]
+  resource :stripe, only: [:create]
+  resource :postfinance, only: [] do
+    get :accept
+    get :cancel
+    get :decline
+    get :exception
+  end
+
+  resource :saferpay, only: [] do
+    get :success
+    get :fail
+    post :start
+  end
+end

data/lib/swisspay.rb

@@ -0,0 +1,26 @@
+require "swisspay/engine"
+require 'swisspay/configuration'
+require 'swisspay/postfinance'
+require 'swisspay/saferpay'
+
+module Swisspay
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.order_id_suffix
+    if Rails.env.production?
+      ''
+    else
+      "_TEST_" + (100 + rand(899)).to_s
+    end
+  end
+end

data/lib/swisspay/configuration.rb

@@ -0,0 +1,34 @@
+module Swisspay
+  class Configuration
+    attr_accessor :payment_success, :payment_error,
+      :description, :vendor_name,
+      :stripe, :postfinance, :paypal, :saferpay
+
+    def initialize
+      @payment_success = -> { }
+      @payment_error = -> { }
+      @description = ''
+      @vendor_name = ''
+      @stripe = {}
+      @postfinance = {}
+      @paypal = {}
+      @saferpay = {}
+    end
+
+    def stripe?
+      @stripe != {}
+    end
+
+    def paypal?
+      @paypal != {}
+    end
+
+    def postfinance?
+      @postfinance != {}
+    end
+
+    def saferpay?
+      @saferpay != {}
+    end
+  end
+end

data/lib/swisspay/engine.rb

@@ -0,0 +1,9 @@
+module Swisspay
+  class Engine < ::Rails::Engine
+    isolate_namespace Swisspay
+
+    initializer "swisspay.view_helpers" do
+      ActiveSupport.on_load( :action_view ){ include Swisspay::ViewHelpers }
+    end
+  end
+end

data/lib/swisspay/postfinance.rb

@@ -0,0 +1,48 @@
+module Swisspay
+  class Postfinance
+    def self.form_data(base_url, identifier, amount, options)
+      { 
+        ACCEPTURL: Swisspay::Engine.routes.url_helpers.accept_postfinance_url(host: base_url, identifier: identifier),
+        AMOUNT: amount,
+        CANCELURL: Swisspay::Engine.routes.url_helpers.cancel_postfinance_url(host: base_url, identifier: identifier),
+        CN: options[:buyer][:name],
+        CURRENCY: 'CHF',
+        DECLINEURL: Swisspay::Engine.routes.url_helpers.decline_postfinance_url(host: base_url, identifier: identifier),
+        EMAIL: options[:buyer][:email],
+        EXCEPTIONURL: Swisspay::Engine.routes.url_helpers.exception_postfinance_url(host: base_url, identifier: identifier),
+        LANGUAGE: 'de_DE',
+        ORDERID: identifier,
+        OWNERADDRESS: options[:buyer][:street],
+        OWNERCTY: options[:buyer][:country],
+        #OWNERTELNO: '031 331 83 83',
+        OWNERTOWN: options[:buyer][:city],
+        OWNERZIP: options[:buyer][:zip],
+        PSPID: Swisspay.configuration.postfinance[:pspid]
+      }
+    end
+
+    def self.generate_signature(form_data)
+      self.sha_for(form_data)
+    end
+
+    def self.check_signature(params)
+      upper = []
+      params.each{|k,v| upper.push([k.upcase, v])}
+      up_sorted = upper.sort_by{|k,v| k}
+      shasig = up_sorted.select { |k,v| k == "SHASIGN" }.first.last.downcase
+      other_params = up_sorted.reject { |k,v| k == "SHASIGN" || v == "" }
+      calc_sig = self.sha_for(other_params)
+      shasig == calc_sig
+    end
+
+    private
+
+    def self.sha_for(data)
+      secret_sig = Swisspay.configuration.postfinance[:sha_in_pswd]
+      string = data.reject { |k,v| v.nil? }.map { |k, v| "#{k}=#{v}" }.join(secret_sig)
+      string << secret_sig
+      digest = Digest::SHA1.hexdigest(string)
+      digest
+    end
+  end
+end

data/lib/swisspay/saferpay.rb

@@ -0,0 +1,80 @@
+require 'net/http'
+require 'json'
+require 'securerandom'
+
+module Swisspay
+  class Saferpay
+    API_BASE = 'https://test.saferpay.com/api'
+    PAYMENT_PAGE_INIT = '/Payment/v1/PaymentPage/Initialize'
+    PAYMENT_PAGE_ASSERT = '/Payment/v1/PaymentPage/Assert'
+
+    def self.payment_url(base_url, identifier, amount, options)
+      response = post(API_BASE + PAYMENT_PAGE_INIT, payment_page_init_data(base_url, identifier, amount, options))
+      data = JSON.parse(response.delete("\\")[1..-2])
+      token = data['Token']
+      redirect_url = data['RedirectUrl']
+      return redirect_url, token
+    end
+
+    def self.check_payment(identifier, token)
+      response = post(API_BASE + PAYMENT_PAGE_ASSERT, payment_page_assert_data(identifier, token))
+      data = JSON.parse(response.delete("\\")[1..-2])
+      data["Transaction"]["Status"] == 'AUTHORIZED'
+    end
+
+    private
+
+    def self.payment_page_init_data(base_url, identifier, amount, options)
+      {
+        "RequestHeader": {
+          "SpecVersion": "1.6",
+          "CustomerId": Swisspay.configuration.saferpay[:customer_id],
+          "RequestId": identifier,
+          "RetryIndicator": 0
+        },
+        "TerminalId": Swisspay.configuration.saferpay[:terminal_id],
+        "Payment": {
+          "Amount": {
+            "Value": amount,
+            "CurrencyCode": "CHF"
+          },
+          "OrderId": identifier,
+          "Description": options[:description]
+        },
+        "ReturnUrls": {
+          "Success": Swisspay::Engine.routes.url_helpers.success_saferpay_url(host: base_url),
+          "Fail": Swisspay::Engine.routes.url_helpers.fail_saferpay_url(host: base_url)
+        }
+      }
+    end
+
+    def self.payment_page_assert_data(identifier, token)
+      {
+        "RequestHeader": {
+          "SpecVersion": "1.6",
+          "CustomerId": Swisspay.configuration.saferpay[:customer_id],
+          "RequestId": identifier,
+          "RetryIndicator": 0
+        },
+        "Token": token
+      }
+    end
+
+    def self.post(url, data)
+      uri = URI(url)
+      api_user = Swisspay.configuration.saferpay[:api_user]
+      api_pass = Swisspay.configuration.saferpay[:api_pass]
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.set_debug_output($stdout)
+      req = Net::HTTP::Post.new(uri.path, 'Content-Type' => 'application/json; charset=utf-8', 'Accept' => 'application/json')
+      req.body = data.to_json
+      req.basic_auth api_user, api_pass 
+      res = http.request(req)
+      res.body.inspect
+    rescue => e
+      puts "failed #{e.inspect}"
+      nil
+    end
+  end
+end

data/lib/swisspay/version.rb

@@ -0,0 +1,3 @@
+module Swisspay
+  VERSION = '0.2.0'
+end

data/lib/tasks/swisspay_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :swisspay do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: swisspay
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Lukas_Skywalker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-10-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: paypal-sdk-rest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Easily accept payments from different payment providers such as Stripe,
+  Paypal, Postfinance and SIX.
+email:
+- lukas.diener@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/swisspay_manifest.js
+- app/assets/javascripts/swisspay/application.js
+- app/assets/stylesheets/swisspay/application.css
+- app/controllers/swisspay/application_controller.rb
+- app/controllers/swisspay/paypals_controller.rb
+- app/controllers/swisspay/postfinances_controller.rb
+- app/controllers/swisspay/saferpays_controller.rb
+- app/controllers/swisspay/stripes_controller.rb
+- app/helpers/swisspay/view_helpers.rb
+- app/jobs/swisspay/application_job.rb
+- app/mailers/swisspay/application_mailer.rb
+- app/models/swisspay/application_record.rb
+- app/views/swisspay/shop/_payment.html.erb
+- app/views/swisspay/shop/_payment_paypal.html.erb
+- app/views/swisspay/shop/_payment_postfinance.html.erb
+- app/views/swisspay/shop/_payment_saferpay.html.erb
+- app/views/swisspay/shop/_payment_stripe.html.erb
+- config/routes.rb
+- lib/swisspay.rb
+- lib/swisspay/configuration.rb
+- lib/swisspay/engine.rb
+- lib/swisspay/postfinance.rb
+- lib/swisspay/saferpay.rb
+- lib/swisspay/version.rb
+- lib/tasks/swisspay_tasks.rake
+homepage: https://code-fabrik.ch
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Swiss PSP gem
+test_files: []