social_auth 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b73fa75b8a6c8200dfa7dd06516c356ed7bc6fa
+  data.tar.gz: 3df34c0d057b106e60658529905ad5b5d6a3258f
+SHA512:
+  metadata.gz: 1806f1a18ece05d1522f280a6746b675384708be1933bc87ac940c20f2eefb129af1ae11bb4c8f98272cfb5afbd02cb3fe8bbe4ea20aa4b39fe4e1fc024cd765
+  data.tar.gz: 6348918e0a59e0aced64adbb948fc72ca3d86f8658e38a5fa28aa932aee3a1eedd3a1dda83b621c34958e9ef67bb77c2ee000ef21eff00ebc57b4c4572d756b9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 William Porter
+
+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/Rakefile

@@ -0,0 +1,39 @@
+require "bundler"
+require 'rake'
+Bundler.setup
+Bundler::GemHelper.install_tasks
+
+def cmd(command)
+  puts command
+  raise unless system command
+end
+
+# Import all our rake tasks
+FileList['tasks/**/*.rake'].each { |task| import task }
+
+# 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    = 'SocialAuth'
+#   rdoc.options << '--line-numbers'
+#   rdoc.rdoc_files.include('README.rdoc')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+
+# APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+# load 'rails/tasks/engine.rake'
+
+
+# load 'rails/tasks/statistics.rake'
+
+
+
+# Bundler::GemHelper.install_tasks
+

data/app/models/social_auth/facebook_service.rb

@@ -0,0 +1,60 @@
+require 'fb_graph2'
+
+module SocialAuth
+  class FacebookService < Service
+    def name
+      "Facebook"
+    end
+
+    def self.init_with(auth_token={})
+      request = create_connection(auth_token)
+
+      return create_with_request(
+        request.id,
+        User.create_with_facebook_request(request),
+        "Authenticated",
+        {access_token: request.access_token}
+      )
+    end
+
+    def self.connect_with(user, auth_token={}, method="Connected")
+      request = create_connection(auth_token)
+
+      return create_with_request(
+        request.id,
+        user,
+        method,
+        {access_token: request.access_token}
+      )
+    end
+
+    def self.create_connection(auth_token={})
+      fb_user = FbGraph2::User.me(auth_token[:access_token])
+      fb_user.fetch
+
+    rescue FbGraph2::Exception::InvalidToken => e
+      raise InvalidToken.new(e.message)
+    rescue FbGraph2::Exception::BadRequest => e
+      raise BadRequest.new(e.message)
+    end
+
+    def friend_ids
+      if redis_instance.exists(redis_key(:friends))
+        friend_ids = redis_instance.smembers(redis_key(:friends))
+      else
+        friend_ids = self.class.create_connection(access_token).friends.map(&:id)
+        unless friend_ids.empty?
+          redis_instance.del(redis_key(:friends))
+          redis_instance.sadd(redis_key(:friends), friend_ids)
+          redis_instance.expire(redis_key(:friends), REDIS_CACHE)
+        end
+      end
+      friend_ids
+
+    rescue InvalidToken => e
+      disconnect(e)
+      return []
+    end
+
+  end
+end

data/app/models/social_auth/google_plus_service.rb

@@ -0,0 +1,106 @@
+require 'google_plus'
+require 'typhoeus'
+
+module SocialAuth
+  class GooglePlusService < Service
+
+    def name
+      "Google Plus"
+    end
+
+    def self.init_with(auth_token={})
+      access_token = fetch_access_token(auth_token)
+      request = create_connection(access_token).get('me')
+
+      return create_with_request(
+        request.id,
+        User.create_with_google_plus_request(request),
+        "Authenticated",
+        {refresh_token: access_token[:refresh_token]}
+      )
+    rescue GooglePlus::RequestError => e
+      raise InvalidToken.new(e.message)
+    end
+
+    def self.connect_with(user, auth_token={}, method="Connected")
+      access_token = fetch_access_token(auth_token)
+      request = create_connection(access_token).get('me')
+
+      return create_with_request(
+        request.id,
+        user,
+        method,
+        {refresh_token: access_token[:refresh_token]}
+      )
+    rescue GooglePlus::RequestError => e
+      raise InvalidToken.new(e.message)
+    end
+
+    def self.fetch_access_token(auth_token={})
+      params = {
+        client_id: SocialAuth.google_client_id,
+        client_secret: SocialAuth.google_client_secret,
+        redirect_uri: SocialAuth.google_redirect_uri
+      }
+      if auth_token[:auth_token].present?
+        params[:code] = auth_token[:auth_token]
+        params[:grant_type] = "authorization_code"
+        request = Typhoeus::Request.new(
+          "https://www.googleapis.com/oauth2/v3/token",
+          method: :post,
+          params: params
+        )
+      else
+        params[:refresh_token] = auth_token[:refresh_token]
+        params[:grant_type] = "refresh_token"
+        request = Typhoeus::Request.new(
+          "https://www.googleapis.com/oauth2/v3/token",
+          method: :post,
+          params: params
+        )
+      end
+
+      request.on_complete do |response|
+        body =  JSON.parse(response.body).with_indifferent_access
+        if response.success?
+          return body
+        else
+          raise InvalidToken.new(body[:error_description])
+        end
+      end
+
+      request.run
+    end
+
+    def self.create_connection(auth_token={})
+      GooglePlus.api_key = SocialAuth.google_api_key
+      GooglePlus.access_token = auth_token[:access_token]
+      GooglePlus::Person
+    end
+
+    def google_items
+      self.class.create_connection(self.class.fetch_access_token(access_token)).list.items
+    end
+
+    def friend_ids
+      if redis_instance.exists(redis_key(:friends))
+        friend_ids = redis_instance.smembers(redis_key(:friends))
+      else
+        items = google_items
+        friend_ids = items.map(&:id) if items.present?
+        if friend_ids.present?
+          redis_instance.del(redis_key(:friends))
+          redis_instance.sadd(redis_key(:friends), friend_ids)
+          redis_instance.expire(redis_key(:friends), REDIS_CACHE)
+        else
+          return []
+        end
+      end
+      friend_ids
+
+    rescue InvalidToken => e
+      disconnect
+      return []
+    end
+  end
+end

data/app/models/social_auth/service.rb

@@ -0,0 +1,152 @@
+module SocialAuth
+  class Service < ActiveRecord::Base
+    #validations
+    validates_presence_of :user, :access_token, :remote_id, :method
+    validates_uniqueness_of :remote_id, scope: [:type], :if => lambda { |service| service.method == 'Authenticated' }
+    validates_uniqueness_of :remote_id, scope: [:type, :user_id], :if => lambda { |service| service.method == 'Connected' }
+
+    before_validation :validate_methods
+
+    #relations
+    belongs_to :user
+
+    #settings
+    self.table_name = "social_auth_services"
+
+    #callbacks
+    after_create :append_to_associated_services
+
+    ACCEPTED_METHODS = %w(Authenticated Connected)
+    REDIS_CACHE = 2_592_000 # cache expiry in seconds
+
+    def name
+      raise "need to implement"
+    end
+
+    def access_token
+      if super.blank?
+        {}
+      else
+        super.with_indifferent_access
+      end
+    end
+
+    def self.init_with(auth_token)
+      raise "need to override"
+    end
+
+    def self.connect_with(user, auth_token)
+      raise "need to override"
+    end
+
+    def self.create_with_request(remote_id, user, method="Connected", access_token={})
+      remote_id = remote_id.to_s
+
+      unless (service = find_by_remote_id_and_method(remote_id, method)) && method == "Authenticated"
+        #attempts to look if some other user connected this same facebook account if its an authentication request
+        if count = where(remote_id: remote_id, method: "Connected").count == 1 and method == "Authenticated"
+          service = find_by_remote_id_and_method(remote_id, "Connected")
+        else
+          service = new
+          service.remote_id = remote_id
+
+          #gives the owner one last chance to perform some app level logic on the user before being created
+          user = user.validate_existing_user(remote_id, service.type) if user.respond_to?(:validate_existing_user)
+          service.user = user
+          service.method = method
+        end
+      end
+
+      service.access_token = access_token
+      service.save
+
+      return service
+    end
+
+    def services
+      self.class.where('remote_id IN (?)', friend_ids)
+    end
+
+    def self.append_to_associated_services(id)
+      service = find(id)
+      service.services.each do |s|
+        s.append_to_friends_list(service)
+      end
+    end
+
+    def append_to_friends_list(service)
+      if redis_instance.exists(self.redis_key(:friends))
+        redis_instance.sadd(self.redis_key(:friends), service.remote_id)
+      end
+      user.friend_joined_the_app_callback(service.user) if user.respond_to?(:friend_joined_the_app_callback)
+    end
+
+    def friend_ids
+      if redis_instance.exists(redis_key(:friends))
+        friend_ids = redis_instance.smembers(redis_key(:friends))
+      else
+        []
+      end
+    end
+
+    def self.disconnect_user(user)
+      service = find_by_user_id(user.id)
+      if service
+        raise Error.new("Cannot disconnect a service you used to authenticate with") if service.authenticated?
+
+        service.disconnect(nil, false)
+      else
+        raise ServiceDoesNotExist.new("Couldn't find service for this user")
+      end
+    end
+
+    def disconnect(e=nil, callback=true)
+      if connected?
+        #destroys service
+        self.destroy
+        #notifies the user that their service is about to be disconnected
+        user.service_disconnected_callback(self) if user.respond_to?(:service_disconnected_callback) and callback
+      else
+        #re_raises the exception
+        raise InvalidToken.new(e ? e.message : "Token has become invalid") #move to localization file
+      end
+    end
+
+    # helper method to generate redis keys
+    def redis_key(str)
+      "#{type}:#{id}:#{str}"
+    end
+
+    def redis_instance
+      $redis #need to change out for an configurable var
+    end
+
+    def authenticated?
+      return true if method == 'Authenticated'
+      false
+    end
+
+    def connected?
+      return true if method == 'Connected'
+      false
+    end
+
+    private
+
+    def validate_methods
+      errors.add(:method, 'not an accepted option') unless ACCEPTED_METHODS.include?(method)
+    end
+
+    def append_to_associated_services
+      self.class.delay.append_to_associated_services(self.id)
+    end
+
+  end
+
+  #exceptions
+  class InvalidToken < StandardError ; end
+  class BadRequest < StandardError ; end
+  class ServiceDoesNotExist < StandardError ; end
+  class Error < StandardError ; end
+
+end

data/app/models/social_auth/twitter_service.rb

@@ -0,0 +1,67 @@
+require 'twitter'
+
+module SocialAuth
+  class TwitterService < Service
+
+    def name
+      "Twitter"
+    end
+
+    def self.init_with(auth_token={})
+      request = create_connection(auth_token)
+
+      return create_with_request(
+        request.user.id,
+        User.create_with_twitter_request(request.user),
+        "Authenticated",
+        {access_token: request.access_token, access_token_secret: request.access_token_secret}
+      )
+
+    rescue Twitter::Error::Unauthorized => e
+      raise InvalidToken.new(e.message)
+    end
+
+    def self.connect_with(user, auth_token={}, method="Connected")
+      request = create_connection(auth_token)
+
+      return create_with_request(
+        request.user.id,
+        user,
+        method,
+        {access_token: request.access_token, access_token_secret: request.access_token_secret}
+      )
+
+    rescue Twitter::Error::Unauthorized => e
+      raise InvalidToken.new(e.message)
+    end
+
+    def self.create_connection(auth_token={})
+      Twitter::REST::Client.new do |config|
+        config.consumer_key        = SocialAuth.twitter_consumer_key
+        config.consumer_secret     = SocialAuth.twitter_consumer_secret
+        config.access_token        = auth_token[:access_token]
+        config.access_token_secret = auth_token[:access_token_secret]
+      end
+      #the reason why we don't catch any exceptions here is because it only initializes the connection no
+      #requests are actually made here
+    end
+
+    def friend_ids
+      if redis_instance.exists(redis_key(:friends))
+        friend_ids = redis_instance.smembers(redis_key(:friends))
+      else
+        friend_ids = self.class.create_connection(access_token).friend_ids.to_hash[:ids].map(&:to_s)
+        unless friend_ids.empty?
+          redis_instance.del(redis_key(:friends))
+          redis_instance.sadd(redis_key(:friends), friend_ids.to_s)
+          redis_instance.expire(redis_key(:friends), REDIS_CACHE)
+        end
+      end
+      friend_ids
+    rescue Twitter::Error::Unauthorized => e
+      disconnect
+      return []
+    end
+
+  end
+end