sync_attr_with_auth0 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ea59d4081c3dac909f2961737233d4449dac051
-  data.tar.gz: 363875b8740c8d51ce939b39946e3b4f43b10698
+  metadata.gz: f961f26ec9f20c6320ad01bfa180f658fb976f94
+  data.tar.gz: 3bd86ae22d10e890b714dcdad22e124d08b705c8
 SHA512:
-  metadata.gz: b3f49ff99dac084c3d28d28ef4f0ca66055f60850d4d0c385985e1d7150b13e0f1c68a10b6d347634ed2314ec724f2350645508982c1ccd44c8f7b2674a5804f
-  data.tar.gz: b224370cc13a3992ec689979bbee330ca7578a44e2b14795487c75323f2fedb5fa08299c1dd7efd2d65c9481c40f99ef60d99f97a885d1a8d3fdabf284c22a46
+  metadata.gz: 5cb3227dd07170bb1b36ce16e95607c4b6354b920403f0dc18f868de2e671b0e51723d1e9ed5e50b606454e0bfbc1824e1dbc0a4c845cfaec38490a33294f196
+  data.tar.gz: 2b7da7127ab533773e50b3a669b4c1f768abe0d45777f17b951bc8ab1f0bac73ef9cdc626c793424901d9b19406bb7a98f3308318a9783612627d57b41bc421d

data/lib/sync_attr_with_auth0/auth0.rb

@@ -5,7 +5,7 @@ module SyncAttrWithAuth0
 
     def self.create_auth0_jwt
       payload = {
-        'aud' => ENV['AUTH0_CLIENT_ID'],
+        'aud' => ENV['AUTH0_GLOBAL_CLIENT_ID'],
         'scopes' => {
           'users' => {
             'actions' => ['create', 'update', 'read']
@@ -15,7 +15,7 @@ module SyncAttrWithAuth0
         'jti' => UUIDTools::UUID.timestamp_create.to_s
       }
 
-      jwt = JWT.encode(payload, ENV['AUTH0_CLIENT_SECRET'])
+      jwt = JWT.encode(payload, ENV['AUTH0_GLOBAL_CLIENT_SECRET'])
 
       return jwt
     end
@@ -25,7 +25,7 @@ module SyncAttrWithAuth0
       # auth0 = Auth0Client.new(client_id: ENV['AUTH0_CLIENT_ID'], client_secret: ENV['AUTH0_CLIENT_SECRET'], namespace: ENV['AUTH0_DOMAIN'])
 
       # v2
-      auth0 = Auth0Client.new(api_version: 2, token: SyncAttrWithAuth0::Auth0.create_auth0_jwt, namespace: ENV['AUTH0_DOMAIN'])
+      auth0 = Auth0Client.new(api_version: 2, access_token: SyncAttrWithAuth0::Auth0.create_auth0_jwt, namespace: ENV['AUTH0_DOMAIN'])
 
       return auth0
     end
@@ -34,38 +34,38 @@ module SyncAttrWithAuth0
     # This stuff is legacy now. It's probably best to remove this stuff once the
     # auth0 API stuff is working.
     ###
-    def self.get_access_token
-      payload = {
-        "client_id" =>        ENV['AUTH0_CLIENT_ID'],
-        "client_secret" =>    ENV['AUTH0_CLIENT_SECRET'],
-        "grant_type" =>       "client_credentials"
-      }
-
-      response = SyncAttrWithAuth0::Auth0.make_request(nil, 'post', '/oauth/token', payload)
-
-      response = JSON.parse( response.to_s ) unless response.nil? or response.to_s.empty?
-
-      response['access_token']
-    end
-
-    def self.make_request(access_token, method, path, payload=nil)
-      args = [method, "https://#{ENV['AUTH0_DOMAIN']}#{path}"]
-
-      # The post body wedges in between the request url
-      # and the request headers for POST and PUT methods
-      args << payload if payload
-
-      if access_token
-        args << { content_type: :json, authorization: "Bearer #{access_token}", accept: "application/json" }
-
-      else
-        args << { content_type: :json, accept: "application/json" }
-
-      end
-
-      # Handle variable length arg lists
-      _response = RestClient.send(*args)
-    end
+    # def self.get_access_token
+    #   payload = {
+    #     "client_id" =>        ENV['AUTH0_CLIENT_ID'],
+    #     "client_secret" =>    ENV['AUTH0_CLIENT_SECRET'],
+    #     "grant_type" =>       "client_credentials"
+    #   }
+    #
+    #   response = SyncAttrWithAuth0::Auth0.make_request(nil, 'post', '/oauth/token', payload)
+    #
+    #   response = JSON.parse( response.to_s ) unless response.nil? or response.to_s.empty?
+    #
+    #   response['access_token']
+    # end
+    #
+    # def self.make_request(access_token, method, path, payload=nil)
+    #   args = [method, "https://#{ENV['AUTH0_DOMAIN']}#{path}"]
+    #
+    #   # The post body wedges in between the request url
+    #   # and the request headers for POST and PUT methods
+    #   args << payload if payload
+    #
+    #   if access_token
+    #     args << { content_type: :json, authorization: "Bearer #{access_token}", accept: "application/json" }
+    #
+    #   else
+    #     args << { content_type: :json, accept: "application/json" }
+    #
+    #   end
+    #
+    #   # Handle variable length arg lists
+    #   _response = RestClient.send(*args)
+    # end
 
   end
 end

data/lib/sync_attr_with_auth0/model.rb

@@ -7,23 +7,25 @@ module SyncAttrWithAuth0
     module ClassMethods
 
       def sync_attr_with_auth0(options = {})
-        class_attribute :auth0_uid_att
-        class_attribute :auth0_name_att
-        class_attribute :auth0_email_att
-        class_attribute :auth0_password_att
-        class_attribute :auth0_email_verified_att
-        class_attribute :auth0_connection_name
-        class_attribute :auth0_sync_atts
-
-        _options = merge_default_options(options)
-
-        self.auth0_uid_att = _options[:auth0_uid_att]
-        self.auth0_name_att = _options[:auth0_name_att]
-        self.auth0_email_att = _options[:auth0_email_att]
-        self.auth0_password_att = _options[:auth0_password_att]
-        self.auth0_email_verified_att = _options[:auth0_email_verified_att]
-        self.auth0_connection_name = _options[:auth0_connection_name]
-        self.auth0_sync_atts = _options[:auth0_sync_atts].collect(&:to_s)
+        class_attribute :auth0_sync_options
+
+        # class_attribute :auth0_uid_att
+        # class_attribute :auth0_name_att
+        # class_attribute :auth0_email_att
+        # class_attribute :auth0_password_att
+        # class_attribute :auth0_email_verified_att
+        # class_attribute :auth0_connection_name
+        # class_attribute :auth0_sync_atts
+
+        merge_default_options(options)
+
+        # self.auth0_uid_att = _options[:uid_att]
+        # self.auth0_name_att = _options[:name_att]
+        # self.auth0_email_att = _options[:email_att]
+        # self.auth0_password_att = _options[:password_att]
+        # self.auth0_email_verified_att = _options[:auth0_email_verified_att]
+        # self.auth0_connection_name = _options[:auth0_connection_name]
+        # self.auth0_sync_atts = _options[:auth0_sync_atts].collect(&:to_s)
 
         after_validation :validate_email_with_auth0
         after_create :create_user_in_auth0
@@ -33,17 +35,19 @@ module SyncAttrWithAuth0
     private
 
       def merge_default_options(options)
-        _options = {
-          auth0_uid_att: :uid,
-          auth0_name_att: :name,
-          auth0_email_att: :email,
-          auth0_password_att: :password,
-          auth0_email_verified_att: :email_verified,
-          auth0_connection_name: 'Username-Password-Authentication',
-          auth0_sync_atts: []
+        self.auth0_sync_options = {
+          uid_att: :uid,
+          name_att: :name,
+          given_name_att: :given_name,
+          family_name_att: :familiy_name,
+          email_att: :email,
+          password_att: :password,
+          email_verified_att: :email_verified,
+          connection_name: 'Username-Password-Authentication',
+          sync_atts: []
         }
 
-        _options.merge!(options)
+        self.auth0_sync_options.merge!(options)
 
         return _options
       end
@@ -57,14 +61,6 @@ module SyncAttrWithAuth0
       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?
-        # # Get an access token
-        # access_token = SyncAttrWithAuth0::Auth0.get_access_token
-        #
-        # response = SyncAttrWithAuth0::Auth0.make_request(
-        #   access_token,
-        #   'get',
-        #   "/api/users?search=email:#{self.send(auth0_email_att)}")
-
         auth0 = SyncAttrWithAuth0::Auth0.create_auth0_client
 
         response = auth0.users(
@@ -72,10 +68,10 @@ module SyncAttrWithAuth0
           0,
           nil,
           nil,
-          auth0_connection_name,
+          auth0_sync_options[:connection_name],
           nil,
           nil,
-          "email:#{self.send(auth0_email_att)}"
+          "email:#{self.send(auth0_sync_options[:email_att])}"
         )
 
         return JSON.parse(response).empty?
@@ -91,58 +87,52 @@ module SyncAttrWithAuth0
 
       # Do not create a user in auth0 if the user already has a uid from auth0
       if ok_to_sync
-        unless self.send(auth0_uid_att).nil? or self.send(auth0_uid_att).empty?
+        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
-        # # Get an access token
-        # access_token = SyncAttrWithAuth0::Auth0.get_access_token
-
-        # Look for matches between what's changing
-        # and what needs to be transmitted to Auth0
-        matches = ( (self.class.auth0_sync_atts || []) & (self.changes.keys || []) )
-
-        # Figure out what needs to be sent to Auth0
-        changes = {}
-        matches.each do |m|
-          changes[m] = self.send(m) if self.respond_to?(m)
-        end
-
-        unless changes['email'].nil?
-          # Email is already being sent
-          changes.delete('email')
-        end
-
-        unless changes['password'].nil?
-          # Password is already being sent
-          changes.delete('password')
-        end
+        # # Look for matches between what's changing
+        # # and what needs to be transmitted to Auth0
+        # matches = ( (self.class.auth0_sync_options[:sync_atts] || []) & (self.changes.keys || []) )
+        #
+        # # Figure out what needs to be sent to Auth0
+        # changes = {}
+        # matches.each do |m|
+        #   changes[m] = self.send(m) if self.respond_to?(m)
+        # end
+
+        user_metadata = auth0_user_metadata
+
+        # unless user_metadata['email'].nil?
+        #   # Email is already being sent
+        #   user_metadata.delete('email')
+        # end
+        #
+        # unless user_metadata['password'].nil?
+        #   # Password is already being sent
+        #   user_metadata.delete('password')
+        # end
 
         password = auth0_user_password
         email_verified = auth0_email_verified?
         args = {
-          'email' => self.send(auth0_email_att),
+          'email' => self.send(auth0_sync_options[:email_att]),
           'password' => password,
-          'connection' => auth0_connection_name,
-          'email_verified' => email_verified
-        }.merge(changes)
-
-        # response = SyncAttrWithAuth0::Auth0.make_request(
-        #   access_token,
-        #   'post',
-        #   "/api/users",
-        #   args)
+          '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_name_att), args)
+        response = auth0.create_user(self.send(auth0_sync_options[:name_att]), args)
 
         response = JSON.parse(response)
 
         # Update the record with the uid
-        self.send("#{auth0_uid_att}=", response['user_id'])
+        self.send("#{auth0_sync_options[:uid_att]}=", response['user_id'])
         self.save
       end
 
@@ -153,89 +143,87 @@ module SyncAttrWithAuth0
       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
-        # Look for matches between what's changing
-        # and what needs to be transmitted to Auth0
-        matches = ( (self.class.auth0_sync_atts || []) & (self.changes.keys || []) )
-
-        # If we find matches
-        unless matches.empty?
-
-          # # Get an access token
-          # access_token = SyncAttrWithAuth0::Auth0.get_access_token
-
-          # Figure out what needs to be sent to Auth0
-          changes = {}
-          matches.each do |m|
-            changes[m] = self.send(m)
-          end
-
-          # If we actually have changes
-          unless changes.empty?
-            # Get the auth0 uid
-            uid = self.send(auth0_uid_att)
-
-            # Don't try to update auth0 if the user doesn't have a uid
-            unless uid.nil?
-              # # Determine if the email was changed
-              # unless changes['email'].nil?
-              #   email = changes.delete('email')
-              #
-              #   response = SyncAttrWithAuth0::Auth0.make_request(
-              #     access_token,
-              #     'put',
-              #     "/api/users/#{::URI.escape(uid)}/email",
-              #     {
-              #       'email' => email,
-              #       'verify' => false # If the user were to fail to verify it would create a discrepency between auth0 and the local database
-              #     })
-              #
-              #   response = JSON.parse(response)
-              #
-              #   # Update the record with the uid
-              #   self.send("#{auth0_uid_att}=", response['user_id'])
-              #   self.save
-              # end
-              #
-              # # Determine if the password was changed
-              # unless changes['password'].nil?
-              #   password = changes.delete('password')
-              #
-              #   response = SyncAttrWithAuth0::Auth0.make_request(
-              #     access_token,
-              #     'put',
-              #     "/api/users/#{::URI.escape(uid)}/password",
-              #     {
-              #       'password' => password,
-              #       'verify' => true
-              #     })
-              # end
-              #
-              # # Patch the changes
-              # response = SyncAttrWithAuth0::Auth0.make_request(
-              #   access_token,
-              #   'patch',
-              #   "/api/users/#{::URI.escape(uid)}/metadata",
-              #   changes)
-
-              auth0 = SyncAttrWithAuth0::Auth0.create_auth0_client
-
-              response = auth0.patch_user(uid, changes)
-            end
-
-          end
+        # # Look for matches between what's changing
+        # # and what needs to be transmitted to Auth0
+        # matches = ( (self.class.auth0_sync_options[:sync_atts] || []) & (self.changes.keys || []) )
+
+        # Get the auth0 uid
+        uid = self.send(auth0_sync_options[:uid_att])
+
+        # Don't try to update auth0 if the user doesn't have a uid
+        unless uid.nil?
+          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]),
+              'email' => self.send(auth0_sync_options[:email_att]),
+              'password' => self.send(auth0_sync_options[:password_att])
+            }
+          }
+
+          args['user_metadata'] = user_metadata
+
+          response = auth0.patch_user(uid, args)
         end
 
+        # # If we find matches
+        # unless matches.empty?
+        #   # Figure out what needs to be sent to Auth0
+        #   changes = {}
+        #   matches.each do |m|
+        #     changes[m] = self.send(m)
+        #   end
+        #
+        #   # If we actually have changes
+        #   unless changes.empty?
+        #     # Get the auth0 uid
+        #     uid = self.send(auth0_sync_options[:uid_att])
+        #
+        #     # Don't try to update auth0 if the user doesn't have a uid
+        #     unless uid.nil?
+        #       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])
+        #         }
+        #       }
+        #       unless changes['email'].nil?
+        #         args['app_metadata']['username'] = changes.delete('email')
+        #       end
+        #
+        #       unless changes['password'].nil?
+        #         args['app_metadata']['password'] = changes.delete('password')
+        #       end
+        #
+        #       args['user_metadata'] = changes
+        #
+        #       response = auth0.patch_user(uid, args)
+        #     end
+        #
+        #   end
+        # end
+
       end
 
       true # don't abort the callback chain
     end
 
     def auth0_user_password
-      self.respond_to?(auth0_password_att) ? self.send(auth0_password_att) : auth0_default_password
+      self.respond_to?(auth0_sync_options[:password_att]) ? self.send(auth0_sync_options[:password_att]) : auth0_default_password
     end
 
     def auth0_email_verified?
-      !!(self.respond_to?(auth0_email_verified_att) ? self.send(auth0_email_verified_att) : false)
+      !!(self.respond_to?(auth0_sync_options[:email_verified_att]) ? self.send(auth0_sync_options[:email_verified_att]) : false)
     end
 
     def auth0_default_password
@@ -247,5 +235,19 @@ module SyncAttrWithAuth0
       ::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
+
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sync_attr_with_auth0
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Patrick McGraw