sync_attr_with_auth0 0.0.25 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c2ffc762b00c7c0b684b9569bfee0c4ed3a9316
-  data.tar.gz: 841110b23f01dd606bfc8c7d08aae62a87bac2f3
+  metadata.gz: 472500ed61386a758384a9f866359b1a6e600eb2
+  data.tar.gz: 6b8c4af3b271483ac0166386e024083d0627c6dc
 SHA512:
-  metadata.gz: 50cb1f6d46d46ec933da1f7b65b5c122cad18f6f7c87087753beb8b434bd76f8b843e273b1c466a1ebfb520f53e005b86c965668d59c1cd997432fb808c5bb92
-  data.tar.gz: 76f3cd16cf226ed4130f9c926948514412913d811f84f88bcc726e69308716365cc24bbf7ef27d57487759e0ab2ea51d44adc295c65ac703d2628ec2c7f985cf
+  metadata.gz: 2eca8c691f9d505910dd4b559545775ee3341194116b0d31b1157893a2f0e4e953b8406252ec6795aaa92703765445f42bb014a0a85dc4ccf1280dcbfec5a83e
+  data.tar.gz: 5744cf31a52c72770aaa123971c359bd57e3a7b9ac0879b2b548bd73e80165107497c5aa74da62d7c7c2a2bc345ad5b01952960a286b69ddd6c45d96041772ee

data/lib/sync_attr_with_auth0/adapters/active_record/sync.rb

@@ -0,0 +1,198 @@
+module SyncAttrWithAuth0
+  module Adapters
+    module ActiveRecord
+      module Sync
+
+        def sync_password_with_auth0?
+          !!(auth0_attributes_to_sync.index(auth0_sync_configuration.password_attribute))
+        end # sync_password_with_auth0?
+
+
+        def sync_email_with_auth0?
+          !!(auth0_attributes_to_sync.index(auth0_sync_configuration.email_attribute))
+        end # sync_email_with_auth0?
+
+
+        def sync_with_auth0_on_create?
+          !!((self.respond_to?(:sync_with_auth0_on_create) and !self.sync_with_auth0_on_create.nil?) ? self.sync_with_auth0_on_create : true)
+        end # sync_with_auth0_on_create?
+
+
+        def sync_with_auth0_on_update?
+          !!((self.respond_to?(:sync_with_auth0_on_update) and !self.sync_with_auth0_on_update.nil?) ? self.sync_with_auth0_on_update : true)
+        end # sync_with_auth0_on_update?
+
+
+        def save_to_auth0_on_create
+          return true unless sync_with_auth0_on_create?
+
+          save_to_auth0
+
+          true # don't abort the callback chain
+        end # save_to_auth0_on_create
+
+
+        def save_to_auth0_on_update
+          return true unless sync_with_auth0_on_update?
+          return true unless auth0_dirty?
+
+          save_to_auth0
+
+          true # don't abort the callback chain
+        end # save_to_auth0_on_update
+
+
+        def auth0_dirty?
+          is_dirty = !!(
+            auth0_attributes_to_sync.inject(false) do |memo, attrib|
+              memo || self.try("#{attrib}_changed?")
+            end
+          )
+
+          # If the password was changed, force is_dirty to be true
+          is_dirty = true if auth0_user_password_changed?
+
+          # If the email was changed, force is_dirty to be true
+          is_dirty = true if auth0_user_email_changed?
+
+          return is_dirty
+        end # auth0_dirty?
+
+
+        def save_to_auth0
+          # Determine if the user needs to be created or updated
+          user_uid = auth0_user_uid
+
+          if user_uid.nil? or user_uid.empty?
+            found_user = users_in_auth0_with_matching_email.first
+
+            user_uid = found_user['user_id'] if found_user
+          end
+
+          if user_uid.nil? or user_uid.empty?
+            # The user has no auth0 uid assigned and we can't find a user
+            # with a matching email address, so create.
+            create_in_auth0
+          else
+            # The user already has an auth0 UID assigned or we have a user
+            # with a matching email address, so update.
+            update_in_auth0(user_uid)
+          end
+        end # save_to_auth0
+
+
+        def create_in_auth0
+          params = auth0_create_params
+
+          response = SyncAttrWithAuth0::Auth0.create_user(auth0_user_name, params, auth0_sync_configuration)
+
+          # Update the record with the uid after_commit
+          @auth0_uid = response['user_id']
+        end # create_in_auth0
+
+
+        def update_in_auth0(user_uid)
+          return unless user_uid
+
+          params = auth0_update_params
+
+          begin
+            SyncAttrWithAuth0::Auth0.patch_user(user_uid, params, auth0_sync_configuration)
+
+            # Update the record with the uid after_commit (in case it doesn't match what's on file).
+            @auth0_uid = user_uid
+          rescue ::Auth0::NotFound => e
+            # For whatever reason, the passed in uid was invalid,
+            # determine how to proceed.
+            found_user = users_in_auth0_with_matching_email.first
+
+            if found_user.nil?
+              # We could not find a user with that email address, so create
+              # instead.
+              create_in_auth0
+            else
+              # The uid was incorrect, so re-attempt with the new uid
+              # and update the one on file.
+              SyncAttrWithAuth0::Auth0.patch_user(found_user['user_id'], params, auth0_sync_configuration)
+
+              # Update the record with the uid after_commit
+              @auth0_uid = found_user['user_id']
+            end
+
+          rescue Exception => e
+            ::Rails.logger.error e.message
+            ::Rails.logger.error e.backtrace.join("\n")
+
+            raise e
+          end
+        end # update_in_auth0
+
+
+        def auth0_create_params
+          user_metadata = auth0_user_metadata
+
+          password = auth0_user_password
+
+          if password.nil? or password.empty?
+            # We MUST include a password on create.
+            password = auth0_default_password
+          end
+
+          email_verified = auth0_email_verified?
+
+          params = {
+            'email' => auth0_user_email,
+            'password' => password,
+            'connection' => auth0_sync_configuration.connection_name,
+            'email_verified' => email_verified,
+            'user_metadata' => user_metadata
+          }
+
+          return params
+        end # auth0_create_params
+
+
+        def auth0_update_params
+          user_metadata = auth0_user_metadata
+          app_metadata = auth0_app_metadata
+
+          params = {
+            'app_metadata' => app_metadata,
+            'user_metadata' => user_metadata
+          }
+
+          if auth0_user_password_changed?
+            # The password needs to be updated.
+            params['password'] = auth0_user_password
+            params['verify_password'] = auth0_verify_password?
+          end
+
+          if auth0_user_email_changed?
+            # The email needs to be updated.
+            params['email'] = auth0_user_email
+            params['verify_email'] = auth0_email_verified?
+          end
+
+          return params
+        end # auth0_update_params
+
+
+        def update_uid_from_auth0
+          if @auth0_uid
+            self.sync_with_auth0_on_update = false if self.respond_to?(:sync_with_auth0_on_update=)
+            self.send("#{auth0_sync_configuration.auth0_uid_attribute}=", @auth0_uid)
+
+            # Nil the instance variable to prevent an infinite loop
+            @auth0_uid = nil
+
+            # Save!
+            self.save
+          end
+
+          true # don't abort the callback chain
+        end # update_uid_from_auth0
+
+      end
+    end
+  end
+end

data/lib/sync_attr_with_auth0/adapters/active_record/validation.rb

@@ -0,0 +1,31 @@
+module SyncAttrWithAuth0
+  module Adapters
+    module ActiveRecord
+      module Validation
+
+        def validate_with_auth0?
+          !!((self.respond_to?(:validate_with_auth0) and !self.validate_with_auth0.nil?) ? self.validate_with_auth0 : true)
+        end # validate_with_auth0?
+
+
+        def validate_email_with_auth0?
+          email_changed_method_name = "#{auth0_sync_configuration.email_attribute.to_s}_changed?"
+
+          !!(validate_with_auth0? and self.send(email_changed_method_name))
+        end # validate_email_with_auth0?
+
+
+        def validate_email_with_auth0
+          return true unless validate_email_with_auth0?
+
+          return users_in_auth0_with_matching_email.empty?
+        end # validate_email_with_auth0
+
+        def users_in_auth0_with_matching_email
+          return SyncAttrWithAuth0::Auth0.find_users_by_email(auth0_user_email, auth0_sync_configuration)
+        end # users_in_auth0_with_matching_email
+
+      end
+    end
+  end
+end

data/lib/sync_attr_with_auth0/adapters/active_record.rb

@@ -0,0 +1,161 @@
+require 'sync_attr_with_auth0/adapters/active_record/validation'
+require 'sync_attr_with_auth0/adapters/active_record/sync'
+
+module SyncAttrWithAuth0
+  module Adapters
+    module ActiveRecord
+      extend ::ActiveSupport::Concern
+
+      include SyncAttrWithAuth0::Adapters::ActiveRecord::Validation
+      include SyncAttrWithAuth0::Adapters::ActiveRecord::Sync
+
+      require "uuidtools"
+
+      module ClassMethods
+
+        def sync_attr_with_auth0(*fields)
+          options = fields.extract_options!
+
+          # Setup methods for accessing fields and options
+          define_method 'auth0_attributes_to_sync' do
+            fields
+          end
+
+          define_method 'setup_auth0_sync_configuration' do
+            config = SyncAttrWithAuth0.configuration.dup
+
+            options.each do |key, value|
+              config.send(:"#{key}=", value)
+            end
+
+            config
+          end
+
+          # Setup callbacks
+          after_validation :validate_email_with_auth0
+          after_create :save_to_auth0_on_create
+          after_update :save_to_auth0_on_update
+          after_commit :update_uid_from_auth0
+        end # sync_attr_with_auth0
+
+      end # ClassMethods
+
+
+      def auth0_sync_configuration
+        @auth0_sync_configuration ||= setup_auth0_sync_configuration
+      end # auth0_sync_configuration
+
+    private
+
+      def auth0_user_email
+        self.send(auth0_sync_configuration.email_attribute) if self.respond_to?(auth0_sync_configuration.email_attribute)
+      end # auth0_user_email
+
+
+      def auth0_user_email_changed?
+        return false unless self.respond_to?(auth0_sync_configuration.email_attribute)
+        # return false unless sync_email_with_auth0? # We don't care if it changed if we aren't syncing it.
+
+        return self.send("#{auth0_sync_configuration.email_attribute}_changed?")
+      end # auth0_email_changed?
+
+
+      def auth0_user_uid
+        self.send(auth0_sync_configuration.auth0_uid_attribute) if self.respond_to?(auth0_sync_configuration.auth0_uid_attribute)
+      end # auth0_user_uid
+
+
+      def auth0_user_name
+        self.send(auth0_sync_configuration.name_attribute) if self.respond_to?(auth0_sync_configuration.name_attribute)
+      end # auth0_user_name
+
+
+      def auth0_user_given_name
+        self.send(auth0_sync_configuration.given_name_attribute) if self.respond_to?(auth0_sync_configuration.given_name_attribute)
+      end # auth0_user_name
+
+
+      def auth0_user_family_name
+        self.send(auth0_sync_configuration.family_name_attribute) if self.respond_to?(auth0_sync_configuration.family_name_attribute)
+      end # auth0_user_name
+
+
+      def auth0_user_password
+        self.send(auth0_sync_configuration.password_attribute) if self.respond_to?(auth0_sync_configuration.password_attribute)
+      end # auth0_user_password
+
+
+      def auth0_user_password_changed?
+        return false unless self.respond_to?(auth0_sync_configuration.password_attribute)
+        # return false unless sync_password_with_auth0? # We don't care if it changed if we aren't syncing it.
+
+        if self.respond_to?(:"#{auth0_sync_configuration.password_attribute.to_s}_changed?")
+          # We have a changed method, use it
+          return self.send(:"#{auth0_sync_configuration.password_attribute.to_s}_changed?")
+        else
+          # We don't have a changed method, check if the attribute was set.
+          return !self.send(auth0_sync_configuration.password_attribute).nil?
+        end
+      end # auth0_user_password_changed?
+
+
+      def auth0_default_password
+        # Need a9 or something similar to guarantee one letter and one number in the password
+        "#{auth0_new_uuid[0..19]}aA9"
+      end # auth0_default_password
+
+
+      def auth0_new_uuid
+        ::UUIDTools::UUID.random_create().to_s
+      end # auth0_new_uuid
+
+
+      def auth0_email_verified?
+        # Unless we're explicitly told otherwise, don't consider the email verified.
+        return false unless self.respond_to?(auth0_sync_configuration.email_verified_attribute)
+
+        return self.send(auth0_sync_configuration.email_verified_attribute)
+      end # auth0_email_verified?
+
+
+      def auth0_verify_password?
+        # Unless we're explicitly told otherwise, verify the password changes.
+        return true unless self.respond_to?(auth0_sync_configuration.verify_password_attribute)
+
+        self.send(auth0_sync_configuration.verify_password_attribute)
+      end # auth0_verify_password?
+
+
+      def auth0_user_metadata
+        user_metadata = {}
+
+        non_metadata_keys = [
+          auth0_sync_configuration.name_attribute,
+          auth0_sync_configuration.family_name_attribute,
+          auth0_sync_configuration.given_name_attribute,
+          auth0_sync_configuration.email_attribute,
+          auth0_sync_configuration.password_attribute,
+          auth0_sync_configuration.email_verified_attribute
+        ]
+
+        auth0_attributes_to_sync.each do |key|
+          user_metadata[key.to_s] = self.send(key) if self.respond_to?(key) and non_metadata_keys.index(key).nil?
+        end
+
+        return user_metadata
+      end # auth0_user_metadata
+
+
+      def auth0_app_metadata
+        return {
+          'name' => auth0_user_name,
+          'nickname' => auth0_user_name,
+          'given_name' => auth0_user_given_name,
+          'family_name' => auth0_user_family_name
+        }
+      end # auth0_app_metadata
+
+
+    end
+  end
+end

data/lib/sync_attr_with_auth0/auth0.rb

@@ -1,5 +1,7 @@
 module SyncAttrWithAuth0
   module Auth0
+    class InvalidAuth0ConfigurationException < StandardError; end
+
     require "auth0"
     require "uuidtools"
 
@@ -18,26 +20,69 @@ module SyncAttrWithAuth0
       jwt = JWT.encode(payload, JWT.base64url_decode(global_client_secret))
 
       return jwt
-    end
+    end # ::create_auth0_jwt
+
 
     def self.create_auth0_client(
       api_version: 2,
-      global_client_id: ENV['AUTH0_GLOBAL_CLIENT_ID'],
-      global_client_secret: ENV['AUTH0_GLOBAL_CLIENT_SECRET'],
-      client_id: ENV['AUTH0_CLIENT_ID'],
-      client_secret: ENV['AUTH0_CLIENT_SECRET'],
-      namespace: ENV['AUTH0_DOMAIN']
+      config: SyncAttrWithAuth0.configuration
     )
+      validate_auth0_config_for_api(api_version, config)
+
       case api_version
       when 1
-        auth0 = Auth0Client.new(client_id: client_id, client_secret: client_secret, namespace: namespace)
+        auth0 = Auth0Client.new(client_id: config.auth0_client_id, client_secret: config.auth0_client_secret, namespace: config.auth0_namespace)
       when 2
-        jwt = SyncAttrWithAuth0::Auth0.create_auth0_jwt(global_client_id: global_client_id, global_client_secret: global_client_secret)
-        auth0 = Auth0Client.new(api_version: 2, access_token: jwt, namespace: namespace)
+        jwt = SyncAttrWithAuth0::Auth0.create_auth0_jwt(global_client_id: config.auth0_global_client_id, global_client_secret: config.auth0_global_client_secret)
+        auth0 = Auth0Client.new(api_version: 2, access_token: jwt, namespace: config.auth0_namespace)
       end
 
       return auth0
-    end
+    end # ::create_auth0_client
+
+
+    def self.validate_auth0_config_for_api(api_version, config = SyncAttrWithAuth0.configuration)
+      settings_to_validate = []
+      invalid_settings = []
+
+      case api_version
+      when 1
+        settings_to_validate = [:auth0_client_id, :auth0_client_secret, :auth0_namespace]
+      when 2
+        settings_to_validate = [:auth0_global_client_id, :auth0_global_client_secret, :auth0_namespace]
+      end
+
+      settings_to_validate.each do |setting_name|
+        unless config.send(setting_name)
+          invalid_settings << setting_name
+        end
+      end
+
+      if invalid_settings.length > 0
+        raise InvalidAuth0ConfigurationException.new("The following required auth0 settings were invalid: #{invalid_settings.join(', ')}")
+      end
+    end # ::validate_auth0_config_for_api
+
+
+    def self.find_users_by_email(email, config = SyncAttrWithAuth0.configuration)
+      auth0 = SyncAttrWithAuth0::Auth0.create_auth0_client(config: config)
+
+      return auth0.users(q: "email:\"#{email}\"")
+    end # ::find_users_by_email
+
+
+    def self.create_user(name, params, config = SyncAttrWithAuth0.configuration)
+      auth0 = SyncAttrWithAuth0::Auth0.create_auth0_client(config: config)
+
+      return auth0.create_user(name, params)
+    end # ::create_user
+
+
+    def self.patch_user(uid, params, config = SyncAttrWithAuth0.configuration)
+      auth0 = SyncAttrWithAuth0::Auth0.create_auth0_client(config: config)
+
+      return auth0.patch_user(uid, params)
+    end # ::patch_user
 
   end
 end

data/lib/sync_attr_with_auth0/configuration.rb

@@ -0,0 +1,56 @@
+require 'active_support/core_ext/module/attribute_accessors'
+
+module SyncAttrWithAuth0
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  # Start a SyncAttrWithAuth0 configuration block in an initializer
+  #
+  # example: Provide a default UID for the applicaiton
+  #   SyncAttrWithAuth0.configure do |config|
+  #     config.auth0_uid_attribute = :auth0_uid
+  #   end
+  def self.configure
+    yield configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset_configuration
+    @configuration = Configuration.new
+  end
+
+  # SyncAttrWithAuth0 configuration class.
+  # This is used by SyncAttrWithAuth0 to provide configuration settings.
+  class Configuration
+    attr_accessor :auth0_global_client_id, :auth0_global_client_secret,
+      :auth0_client_id, :auth0_client_secret, :auth0_namespace,
+      :auth0_uid_attribute, :name_attribute, :given_name_attribute,
+      :family_name_attribute, :email_attribute, :password_attribute,
+      :email_verified_attribute, :verify_password_attribute,
+      :connection_name
+
+
+    def initialize
+      @auth0_global_client_id = ENV['AUTH0_GLOBAL_CLIENT_ID']
+      @auth0_global_client_secret = ENV['AUTH0_GLOBAL_CLIENT_SECRET']
+      @auth0_client_id = ENV['AUTH0_CLIENT_ID']
+      @auth0_client_secret = ENV['AUTH0_CLIENT_SECRET']
+      @auth0_namespace = ENV['AUTH0_NAMESPACE']
+
+      @auth0_uid_attribute = :auth0_uid
+      @name_attribute = :name
+      @given_name_attribute = :given_name
+      @family_name_attribute = :family_name
+      @email_attribute = :email
+      @password_attribute = :password
+      @email_verified_attribute = :email_verified
+      @verify_password_attribute = :verify_password
+      @connection_name = 'Username-Password-Authentication'
+    end
+  end
+end

data/lib/sync_attr_with_auth0.rb

@@ -1,4 +1,8 @@
 require 'sync_attr_with_auth0/auth0'
-require 'sync_attr_with_auth0/model'
+# require 'sync_attr_with_auth0/model'
+require 'sync_attr_with_auth0/configuration'
+require 'sync_attr_with_auth0/adapters/active_record'
 
-::ActiveRecord::Base.send :include, ::SyncAttrWithAuth0::Model
+module SyncAttrWithAuth0
+  ::ActiveRecord::Base.send :include, ::SyncAttrWithAuth0::Adapters::ActiveRecord
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sync_attr_with_auth0
 version: !ruby/object:Gem::Version
-  version: 0.0.25
+  version: 0.1.0
 platform: ruby
 authors:
 - Patrick McGraw
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-30 00:00:00.000000000 Z
+date: 2016-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -145,8 +145,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/sync_attr_with_auth0.rb
+- lib/sync_attr_with_auth0/adapters/active_record.rb
+- lib/sync_attr_with_auth0/adapters/active_record/sync.rb
+- lib/sync_attr_with_auth0/adapters/active_record/validation.rb
 - lib/sync_attr_with_auth0/auth0.rb
-- lib/sync_attr_with_auth0/model.rb
+- lib/sync_attr_with_auth0/configuration.rb
 homepage: http://rubygems.org/gems/sync_attr_with_auth0
 licenses:
 - MIT
@@ -167,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Synchronize attributes on a local ActiveRecord user model with the user metadata

data/lib/sync_attr_with_auth0/model.rb

@@ -1,285 +0,0 @@
-module SyncAttrWithAuth0
-  module Model
-    extend ::ActiveSupport::Concern
-
-    require "uuidtools"
-
-    module ClassMethods
-
-      def sync_attr_with_auth0(options = {})
-        class_attribute :auth0_sync_options
-
-        verify_environment_variables
-        merge_default_options(options)
-
-        after_validation :validate_email_with_auth0
-        after_create :auth0_create
-        after_update :auth0_update, if: :auth0_dirty?
-        after_commit :auth0_set_uid
-      end
-
-    private
-
-      def verify_environment_variables
-        env_variables = %w(AUTH0_GLOBAL_CLIENT_ID AUTH0_GLOBAL_CLIENT_SECRET AUTH0_CLIENT_ID AUTH0_CLIENT_SECRET AUTH0_DOMAIN)
-        missing_env_variables = []
-
-        env_variables.each do |env_variable_name|
-          unless ENV[env_variable_name]
-            missing_env_variables << env_variable_name
-          end
-        end
-
-        if missing_env_variables.size > 0
-          raise Exception.new("Missing the following required environment variables: #{missing_env_variables.join(',')}")
-        end
-      end
-
-      def merge_default_options(options)
-        self.auth0_sync_options = {
-          uid_att: :uid,
-          name_att: :name,
-          given_name_att: :given_name,
-          family_name_att: :family_name,
-          email_att: :email,
-          password_att: :password,
-          email_verified_att: :email_verified,
-          verify_password_att: :verify_password,
-          connection_name: 'Username-Password-Authentication',
-          sync_atts: []
-        }
-
-        self.auth0_sync_options.merge!(options)
-      end
-
-    end
-
-    def validate_email_with_auth0
-      # If the email is being modified, verify the new email does not already
-      # exist in auth0.
-
-      ok_to_validate = (self.respond_to?(:validate_with_auth0) and !self.validate_with_auth0.nil? ? self.validate_with_auth0 : true)
-
-      if ok_to_validate and self.email_changed?
-        response = find_user_in_auth0
-
-        return response.empty?
-      end
-
-      return true
-    end
-
-    def auth0_create
-      # When creating a new user, create the user in auth0.
-
-      ok_to_sync = (self.respond_to?(:sync_with_auth0_on_create) and !self.sync_with_auth0_on_create.nil?  ? self.sync_with_auth0_on_create : true)
-
-      # Do not create a user in auth0 if the user already has a uid from auth0
-      if ok_to_sync
-        unless self.send(auth0_sync_options[:uid_att]).nil? or self.send(auth0_sync_options[:uid_att]).empty?
-          ok_to_sync = false
-        end
-      end
-
-      if ok_to_sync
-        create_user_in_auth0
-      end
-
-      true # don't abort the callback chain
-    end
-
-    def auth0_update
-      ok_to_sync = (self.respond_to?(:sync_with_auth0_on_update) and !self.sync_with_auth0_on_update.nil? ? self.sync_with_auth0_on_update : true)
-
-      if ok_to_sync
-
-        # Get the auth0 uid
-        uid = self.send(auth0_sync_options[:uid_att])
-
-        # TODO: create a user if the uid is nil
-        unless uid.nil?
-          # Update the user in auth0
-          update_user_in_auth0(uid)
-        end
-
-      end
-
-      true # don't abort the callback chain
-    end
-
-    def auth0_set_uid
-      if @auth0_uid
-        self.sync_with_auth0_on_update = false if self.respond_to?(:sync_with_auth0_on_update=)
-        self.send("#{auth0_sync_options[:uid_att]}=", @auth0_uid)
-
-        # Nil the instance variable to prevent an infinite loop
-        @auth0_uid = nil
-
-        # Save!
-        self.save
-      end
-
-      true # don't abort the callback chain
-    end
-
-    def create_user_in_auth0()
-      user_metadata = auth0_user_metadata
-
-      password = auth0_user_password
-
-      if password.nil?
-        password = auth0_default_password
-      end
-
-      email_verified = auth0_email_verified?
-      args = {
-        'email' => self.send(auth0_sync_options[:email_att]),
-        'password' => password,
-        'connection' => auth0_sync_options[:connection_name],
-        'email_verified' => email_verified,
-        'user_metadata' => user_metadata
-      }
-
-      auth0 = SyncAttrWithAuth0::Auth0.create_auth0_client
-
-      response = auth0.create_user(self.send(auth0_sync_options[:name_att]), args)
-
-      # Update the record with the uid after_commit
-      @auth0_uid = response['user_id']
-    end
-
-    def update_user_in_auth0(uid)
-      user_metadata = auth0_user_metadata
-
-      auth0 = SyncAttrWithAuth0::Auth0.create_auth0_client
-
-      args = {
-        'app_metadata' => {
-          'name' => self.send(auth0_sync_options[:name_att]),
-          'nickname' => self.send(auth0_sync_options[:name_att]),
-          'given_name' => self.send(auth0_sync_options[:given_name_att]),
-          'family_name' => self.send(auth0_sync_options[:family_name_att])
-        }
-      }
-
-      if (
-        auth0_sync_options[:sync_atts].index(auth0_sync_options[:password_att]) and
-        auth0_user_password_changed?
-      )
-        # The password should be sync'd and was changed
-        args['password'] = self.send(auth0_sync_options[:password_att])
-        args['verify_password'] = auth0_verify_password?
-      end
-
-      if (
-        auth0_sync_options[:sync_atts].index(auth0_sync_options[:email_att]) and
-        auth0_email_changed?
-      )
-        # The email should be sync'd and was changed
-        args['email'] = self.send(auth0_sync_options[:email_att])
-        args['verify_email'] = auth0_email_verified?
-      end
-
-      args['user_metadata'] = user_metadata
-
-      begin
-        auth0.patch_user(uid, args)
-
-      rescue ::Auth0::NotFound => e
-        response = find_user_in_auth0
-        found_user = response.first
-
-        if found_user.nil?
-          # Could not find the user, create it in auth0
-          create_user_in_auth0
-        else
-          # Update with the new uid and correct the one on file
-          auth0 = SyncAttrWithAuth0::Auth0.create_auth0_client
-          auth0.patch_user(found_user['user_id'], args)
-
-          # Update the record with the uid after_commit
-          @auth0_uid = found_user['user_id']
-        end
-
-      rescue Exception => e
-        ::Rails.logger.error e.message
-        ::Rails.logger.error e.backtrace.join("\n")
-
-        raise e
-      end
-    end
-
-    def find_user_in_auth0
-      auth0 = SyncAttrWithAuth0::Auth0.create_auth0_client(api_version: 1)
-
-      response = auth0.users("email:#{self.send(auth0_sync_options[:email_att])}")
-
-      return response
-    end
-
-    def auth0_user_password
-      self.respond_to?(auth0_sync_options[:password_att]) ? self.send(auth0_sync_options[:password_att]) : auth0_default_password
-    end
-
-    def auth0_user_password_changed?
-      if self.respond_to?(auth0_sync_options[:password_att])
-        if self.respond_to?(:"#{auth0_sync_options[:password_att].to_s}_changed?")
-          # We have a changed method, use it
-          return self.send(:"#{auth0_sync_options[:password_att].to_s}_changed?")
-        else
-          # We don't have a changed method, check if the attribute was set.
-          return !self.send(auth0_sync_options[:password_att]).nil?
-        end
-      end
-
-      return false
-    end
-
-    def auth0_email_verified?
-      !!(self.respond_to?(auth0_sync_options[:email_verified_att]) ? self.send(auth0_sync_options[:email_verified_att]) : false)
-    end
-
-    def auth0_email_changed?
-      !!(self.respond_to?(auth0_sync_options[:email_att]) ? self.send("#{auth0_sync_options[:email_att]}_changed?") : false)
-    end
-
-    def auth0_verify_password?
-      !!(self.respond_to?(auth0_sync_options[:verify_password_att]) ? self.send(auth0_sync_options[:verify_password_att]) : true)
-    end
-
-    def auth0_default_password
-      # Need a9 or something similar to guarantee one letter and one number in the password
-      "#{auth0_new_uuid[0..19]}aA9"
-    end
-
-    def auth0_new_uuid
-      ::UUIDTools::UUID.random_create().to_s
-    end
-
-    def auth0_user_metadata
-      user_metadata = {}
-      app_metadata_keys = [auth0_sync_options[:family_name_att],
-        auth0_sync_options[:given_name_att], auth0_sync_options[:email_att],
-        auth0_sync_options[:password_att],
-        auth0_sync_options[:email_verified_att], auth0_sync_options[:name_att]]
-
-      auth0_sync_options[:sync_atts].each do |key|
-        user_metadata[key] = self.send(key) if self.respond_to?(key) and app_metadata_keys.index(key).nil?
-      end
-
-      return user_metadata
-    end
-
-    def auth0_dirty?
-      is_dirty = !!(auth0_sync_options[:sync_atts].inject(false) do |memo, attrib|
-        memo || try("#{attrib}_changed?")
-      end)
-
-      # If the password was changed, force is_dirty to be true
-      is_dirty = true if auth0_user_password_changed?
-
-      return is_dirty
-    end
-
-  end
-end