bookingsync-engine 3.0.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa68e5ba114ee9b351c0dfacaec2c0d56f2cc64a
-  data.tar.gz: 99916f007b04601ccb170e133a1470830eab6d1e
+  metadata.gz: bafa080b2693177194be61b73fb8fbc32ba466d0
+  data.tar.gz: 4c5254207f7fd9dfadb7f843c51e6bb5181b807c
 SHA512:
-  metadata.gz: f97b8fc8de54d27ba06dc978b9d04e109642e54217525e92572d2b37f6f12d7e328a50e948192896b47f1154ff05a12aafa2a6312aacba36491c6d9d9db7686a
-  data.tar.gz: 748de1f1bf239b791435258e214ad704092f67bad7e5ff61d266b5961fbc35563f2c0707ff6017b842303a81d1f9650af540aa3fbca611b52b9ba13e68585936
+  metadata.gz: 2f823f488456547aecf91ddc065b4b0533961efea5b634516468b2d19bbb14ee2a2c16119624481676576da70411a5896575d1ecccd9cea94cb492cd4f3e6738
+  data.tar.gz: 715bba185b33ae77fd182af8ad5b8a0ea851766dc148eb438ffd0f8b22414c8885afdb96469fec08d2c57e8a20a144052a722e86b1e3c87e0cb39538b8c632a4

data/README.md

@@ -5,7 +5,7 @@
 
 ## Requirements
 
-This engine requires Rails `>= 5.0.0` and Ruby `>= 2.2.0`.
+This engine requires Rails `>= 5.0.0` and Ruby `>= 2.3.0`.
 
 ## Documentation
 
@@ -36,12 +36,15 @@ This will add the following routes:
 * `/auth/failure`
 * `/signout`
 
+
 BookingSync Engine uses the `Account` model to authenticate each BookingSync Account, if you do not have an `Account` model yet, create one:
 
 ```console
 rails g model Account
 ```
 
+### For single application setup
+
 Then, generate a migration to add OAuth fields for the `Account` class:
 
 ```console
@@ -56,15 +59,100 @@ and migrate:
 rake db:migrate
 ```
 
-Also include `BookingSync::Engine::Account` in your `Account` model:
+Also include `BookingSync::Engine::Models::Account` in your `Account` model:
+
+```ruby
+class Account < ActiveRecord::Base
+  include BookingSync::Engine::Models::Account
+end
+```
+
+### For multi application setup
+
+Then, generate a migration to add OAuth fields for the `Account` class:
+
+```console
+rails g migration AddOAuthFieldsToAccounts provider:string synced_id:integer:index \
+  name:string oauth_access_token:string oauth_refresh_token:string \
+  oauth_expires_at:string  host:string:uniq:index
+```
+
+Add manually `null: false` to the `host` field on the newly created migration file, then migrate:
+
+```console
+rake db:migrate
+```
+
+Also include `BookingSync::Engine::Models::MultiApplicationsAccount` in your `Account` model:
 
 ```ruby
 class Account < ActiveRecord::Base
-  include BookingSync::Engine::Model
+  include BookingSync::Engine::Models::MultiApplicationsAccount
+end
+```
+
+You also need to create applications
+
+```console
+rails g model Application
+```
+
+Then, generate a migration to add credentials fields for the `Application` class:
+
+```console
+rails g migration AddCredentialsFieldsToApplications host:string:uniq:index client_id:text:uniq:index \
+  client_secret:text:uniq:index
+```
+
+Add `null: false` to this 3 attributes, then migrate:
+
+```console
+rake db:migrate
+```
+
+Also include `BookingSync::Engine::Models::Application` in your `Application` model:
+
+```ruby
+class Application < ActiveRecord::Base
+  include BookingSync::Engine::Models::Application
+end
+```
+
+Activate the multi app mode in an initializer:
+
+```ruby
+BookingSyncEngine.setup do |setup|
+  setup.support_multi_applications = true
+end
+```
+
+#### Use different models for single app and multiple app setup
+
+To make transition between the two modes on the fly, you can use different model name for your
+accounts.
+
+For the following example:
+
+```ruby
+class MySingleAppAccount < ActiveRecord::Base
+  include BookingSync::Engine::Models::Account
+end
+
+class MyMultiAppAccount < ActiveRecord::Base
+  include BookingSync::Engine::Models::MultiApplicationsAccount
+end
+```
+
+You just need to define which model goes with which mode in an initializer.
+
+
+```ruby
+BookingSyncEngine.setup do |setup|
+  setup.single_app_model = -> { ::MySingleAppAccount }
+  setup.multi_app_model = -> { ::MyMultiAppAccount }
 end
 ```
 
-When saving new token, this gem uses a separate thread with new db connection to ensure token save (in case of a rollback in the main transaction). To make room for the new connections, it is recommended to increase db `pool` size by 2-3.
 
 ## Configuration
 
@@ -77,7 +165,7 @@ The engine is configured by the following ENV variables:
 * `BOOKINGSYNC_SCOPE` - Space separated list of required scopes. Defaults to nil, which means the public scope.
 
 You might want to use [dotenv-rails](https://github.com/bkeepers/dotenv)
-to make ENV variables management easy.
+to make ENV variables management easy. See `spec/dummy/.env.sample`.
 
 ## Embedded vs Standalone apps
 
@@ -168,3 +256,11 @@ We would love to see you contributing. Please, just follow the guidelines from [
 ### Testing
 
 By default, your tests will run against the Rails version used in the main Gemfile.lock, to test against all supported Rails version, please run the tests with Appraisals with: `appraisal rake spec`
+
+#### Testing with docker
+
+You can choose to run PostgreSQL in a Docker container. At the moment, you should use [Beta channel](https://docs.docker.com/docker-for-mac/) on a Mac - so you can reach the docker machine on localhost. It is possible to set it up with stable, but then you have to configure it another way.
+
+Use `spec/dummy/config/database.yml.docker` instead of `spec/dummy/config/database.yml`.
+
+Once intalled, setup the DB with `docker-compose create`, `docker-compose start` and `rake db:setup`

data/app/controllers/sessions_controller.rb

@@ -1,7 +1,7 @@
 class SessionsController < ApplicationController
   def create
     auth = request.env["omniauth.auth"]
-    account = ::Account.from_omniauth(auth)
+    account = BookingSyncEngine.account_model.from_omniauth(auth, request.host)
     account_authorized(account)
     redirect_to after_bookingsync_sign_in_path
   end

data/lib/bookingsync-engine.rb

@@ -1 +1,24 @@
-require 'bookingsync'
+require "bookingsync"
+
+module BookingSyncEngine
+  cattr_accessor :support_multi_applications
+  self.support_multi_applications = false
+
+  cattr_accessor :single_app_model
+  self.single_app_model = -> { ::Account }
+
+  cattr_accessor :multi_app_model
+  self.multi_app_model = -> { ::Account }
+
+  def self.setup
+    yield self
+  end
+
+  def self.support_multi_applications?
+    support_multi_applications
+  end
+
+  def self.account_model
+    support_multi_applications? ? multi_app_model.call : single_app_model.call
+  end
+end

data/lib/bookingsync/engine.rb

@@ -1,22 +1,30 @@
-require 'omniauth'
-require 'omniauth-bookingsync'
-require 'bookingsync-api'
+require "omniauth"
+require "omniauth-bookingsync"
+require "bookingsync-api"
 
 module BookingSync
   class Engine < ::Rails::Engine
     initializer "bookingsync.add_omniauth" do |app|
       app.middleware.use OmniAuth::Builder do
         provider :bookingsync,
-          ENV['BOOKINGSYNC_APP_ID'],
-          ENV['BOOKINGSYNC_APP_SECRET'],
-          scope: ENV['BOOKINGSYNC_SCOPE'],
+          BookingSyncEngine.support_multi_applications? ? nil : ENV["BOOKINGSYNC_APP_ID"],
+          BookingSyncEngine.support_multi_applications? ? nil : ENV["BOOKINGSYNC_APP_SECRET"],
+          scope: ENV["BOOKINGSYNC_SCOPE"],
           setup: -> (env) {
-            if url = ENV['BOOKINGSYNC_URL']
-              env['omniauth.strategy'].options[:client_options].site = url
+            if url = ENV["BOOKINGSYNC_URL"]
+              env["omniauth.strategy"].options[:client_options].site = url
             end
-            env['omniauth.strategy'].options[:client_options].ssl = {
-              verify: ENV['BOOKINGSYNC_VERIFY_SSL'] != 'false'
+            env["omniauth.strategy"].options[:client_options].ssl = {
+              verify: ENV["BOOKINGSYNC_VERIFY_SSL"] != "false"
             }
+
+            if BookingSyncEngine.support_multi_applications?
+              credentials = BookingSync::Engine::CredentialsResolver.new(env["HTTP_HOST"]).call
+              if credentials.valid?
+                env["omniauth.strategy"].options[:client_id] = credentials.client_id
+                env["omniauth.strategy"].options[:client_secret] = credentials.client_secret
+              end
+            end
           }
       end
     end
@@ -67,21 +75,22 @@ module BookingSync
     # The ENV variables used for configuration are described in {file:README.md}.
     #
     # @return [OAuth2::Client] configured OAuth client
-    def self.oauth_client
+    def self.oauth_client(client_id: ENV["BOOKINGSYNC_APP_ID"], client_secret: ENV["BOOKINGSYNC_APP_SECRET"])
       client_options = {
-        site: ENV['BOOKINGSYNC_URL'] || 'https://www.bookingsync.com',
+        site: ENV["BOOKINGSYNC_URL"] || 'https://www.bookingsync.com',
         connection_opts: { headers: { accept: "application/vnd.api+json" } }
       }
       client_options[:ssl] = { verify: ENV['BOOKINGSYNC_VERIFY_SSL'] != 'false' }
-      OAuth2::Client.new(ENV['BOOKINGSYNC_APP_ID'], ENV['BOOKINGSYNC_APP_SECRET'],
-        client_options)
+      OAuth2::Client.new(client_id, client_secret, client_options)
     end
 
-    def self.application_token
-      oauth_client.client_credentials.get_token
+    def self.application_token(client_id: ENV["BOOKINGSYNC_APP_ID"], client_secret: ENV["BOOKINGSYNC_APP_SECRET"])
+      oauth_client(client_id: client_id, client_secret: client_secret).client_credentials.get_token
     end
   end
 end
 
+require "bookingsync/engine/application_credentials"
+require "bookingsync/engine/credentials_resolver"
 require "bookingsync/engine/api_client"
-require "bookingsync/engine/model"
+require "bookingsync/engine/models"

data/lib/bookingsync/engine/application_credentials.rb

@@ -0,0 +1,15 @@
+class BookingSync::Engine::ApplicationCredentials
+  attr_reader :client_id
+  attr_reader :client_secret
+
+  def initialize(application = nil)
+    if application.present?
+      @client_id = application.client_id
+      @client_secret = application.client_secret
+    end
+  end
+
+  def valid?
+    client_id.present? && client_secret.present?
+  end
+end

data/lib/bookingsync/engine/auth_helpers.rb

@@ -11,7 +11,10 @@ module BookingSync::Engine::AuthHelpers
 
   # @return [Account, nil] currently authorized Account or nil if unauthorized
   def current_account
-    @current_account ||= ::Account.find_by(synced_id: session[:account_id]) if session[:account_id].present?
+    return if session[:account_id].nil?
+
+    @current_account ||=
+      BookingSyncEngine.account_model.find_by_host_and_synced_id(request.host, session[:account_id])
   end
 
   # Callback after account is authorized.
@@ -130,7 +133,7 @@ module BookingSync::Engine::AuthHelpers
     store_bookingsync_account_id if BookingSync::Engine.embedded
     sign_out_if_inactive
     enforce_requested_account_authorized!
-    request_authorization! unless current_account
+    request_authorization! if current_account.nil?
   end
 
   def store_bookingsync_account_id # :nodoc:

data/lib/bookingsync/engine/credentials_resolver.rb

@@ -0,0 +1,18 @@
+class BookingSync::Engine::CredentialsResolver
+  attr_reader :host
+  private :host
+
+  def initialize(host)
+    @host = host
+  end
+
+  def call
+    BookingSync::Engine::ApplicationCredentials.new(application)
+  end
+
+  private
+
+  def application
+    @application ||= ::Application.find_by_host(host)
+  end
+end

data/lib/bookingsync/engine/models.rb

@@ -0,0 +1,11 @@
+module BookingSync
+  class Engine
+    module Models
+    end
+  end
+end
+
+require "bookingsync/engine/models/base_account"
+require "bookingsync/engine/models/account"
+require "bookingsync/engine/models/multi_applications_account"
+require "bookingsync/engine/models/application"

data/lib/bookingsync/engine/models/account.rb

@@ -0,0 +1,36 @@
+module BookingSync::Engine::Models::Account
+  extend ActiveSupport::Concern
+  include BookingSync::Engine::Models::BaseAccount
+
+  included do
+    validates :synced_id, uniqueness: true
+  end
+
+  module ClassMethods
+    def from_omniauth(auth, _host)
+      account = find_or_initialize_by(synced_id: auth.uid, provider: auth.provider)
+
+      account.tap do |account|
+        account.name = auth.info.business_name
+        account.update_token(auth.credentials)
+        account.save!
+      end
+    end
+
+    def find_by_host_and_synced_id(_host, synced_id)
+      find_by(synced_id: synced_id)
+    end
+  end
+
+  def application_token
+    BookingSync::Engine.application_token
+  end
+
+  def oauth_client
+    BookingSync::Engine.oauth_client
+  end
+
+  def application
+    nil
+  end
+end

data/lib/bookingsync/engine/models/application.rb

@@ -0,0 +1,9 @@
+module BookingSync::Engine::Models::Application
+  extend ActiveSupport::Concern
+
+  included do
+    validates :host, presence: true, uniqueness: true
+    validates :client_id, presence: true, uniqueness: true
+    validates :client_secret, presence: true, uniqueness: true
+  end
+end

data/lib/bookingsync/engine/{model.rb → models/base_account.rb}

@@ -1,21 +1,10 @@
-module BookingSync::Engine::Model
+module BookingSync::Engine::Models::BaseAccount
   extend ActiveSupport::Concern
 
   included do
-    validates :synced_id, uniqueness: true
     scope :authorized, -> { where.not(oauth_access_token: nil) }
   end
 
-  module ClassMethods
-    def from_omniauth(auth)
-      find_or_initialize_by(synced_id: auth.uid, provider: auth.provider).tap do |account|
-        account.name = auth.info.business_name
-        account.update_token(auth.credentials)
-        account.save!
-      end
-    end
-  end
-
   def token
     @token ||= begin
       token_options = {}
@@ -24,8 +13,7 @@ module BookingSync::Engine::Model
         token_options[:expires_at]    = oauth_expires_at
       end
 
-      token = OAuth2::AccessToken.new(BookingSync::Engine.oauth_client,
-        oauth_access_token, token_options)
+      token = OAuth2::AccessToken.new(oauth_client, oauth_access_token, token_options)
 
       if token.expired?
         refresh_token!(token)
@@ -35,29 +23,29 @@ module BookingSync::Engine::Model
     end
   end
 
-  def refresh_token!(current_token = token)
-    @token = current_token.refresh!.tap { |new_token| update_token!(new_token) }
-  end
-
   def api
     @api ||= BookingSync::Engine::APIClient.new(token.token, account: self)
   end
 
+  def clear_token!
+    self.oauth_access_token   = nil
+    self.oauth_refresh_token  = nil
+    self.oauth_expires_at     = nil
+    save!
+  end
+
   def update_token(token)
     self.oauth_access_token   = token.token
     self.oauth_refresh_token  = token.refresh_token
     self.oauth_expires_at     = token.expires_at
   end
 
-  def update_token!(token)
-    update_token(token)
-    save!
-  end
+  private
 
-  def clear_token!
-    self.oauth_access_token   = nil
-    self.oauth_refresh_token  = nil
-    self.oauth_expires_at     = nil
-    save!
+  def refresh_token!(current_token = token)
+    @token = current_token.refresh!.tap do |new_token|
+      update_token(new_token)
+      save!
+    end
   end
 end