google-gmail-api 0.0.14

data/TODO.md

@@ -0,0 +1,3 @@
+# TODO
+
+*proper errors handling

data/account.yml.example

@@ -0,0 +1,17 @@
+# Auth Method
+google_api_auth_method: ENV['GOOGLE_API_AUTH_METHOD']
+
+#App Info
+application_name: ENV['APP_NAME']
+application_version: ENV['APP_VERSION']
+
+# Web Application Auth
+client_id: ENV['GOOGLE_API_CLIENT_ID']
+client_secret: ENV['GOOGLE_API_CLIENT_SECRET']
+refresh_token: ENV['GOOGLE_API_REFRESH_TOKEN']
+
+# Service Account Auth
+google_api_key: ENV['GOOGLE_API_KEY']
+google_api_email: ENV['GOOGLE_API_EMAIL']
+email_account: ENV['GOOGLE_ACCOUNT']
+auth_scopes: ENV['GOOGLE_AUTH_SCOPES']

data/gmail.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path('../lib', __FILE__)
+require 'gmail/version'
+
+Gem::Specification.new do |s|
+  s.name = "google-gmail-api"
+  s.summary = "A Ruby interface to Gmail API (NO IMAP, NO SMTP), with all the tools you will need."
+  s.description = "A Ruby interface to Gmail API (NO IMAP, NO SMTP).
+  Search, read and send multipart emails; archive, mark as read/unread,
+  delete emails; and manage labels. Everything is done through the Gmail API without going through IMAP or SMTP Protocol
+  "
+  s.version = Gmail::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Julien Hobeika","Keiran Betteley", 'Evaldas Grudzinskas']
+  s.homepage = "https://github.com/evaldasg/google-gmail-api"
+  s.licenses = ['MIT']
+
+  # runtime dependencies
+  s.required_ruby_version = '>= 1.9.3'
+  s.add_dependency "mime", ">= 0.1"
+  s.add_dependency "mail", ">= 2.2.1"
+  s.add_dependency "activesupport"
+  s.add_dependency 'google-api-client', "0.8.6"
+  s.add_dependency "hooks", ">=0.4.0"
+  s.add_dependency "hashie", ">=3.3.2"
+  s.add_dependency "stringex"
+
+  # development dependencies
+  s.add_development_dependency "rake"
+  s.add_development_dependency "test-unit"
+  s.add_development_dependency('mocha', '~> 1.0.0')
+  s.add_development_dependency('shoulda', '~> 3.5.0')
+
+  s.add_development_dependency "gem-release"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/gmail.rb

@@ -0,0 +1,159 @@
+require 'mail'
+require 'hashie'
+require 'hooks'
+require 'google/api_client'
+require 'gmail/gmail_object'
+require 'gmail/api_resource'
+#base
+require 'gmail/base/create'
+require 'gmail/base/delete'
+require 'gmail/base/get'
+require 'gmail/base/list'
+require 'gmail/base/update'
+require 'gmail/base/modify'
+require 'gmail/base/trash'
+
+#object
+require 'gmail/util'
+require 'gmail/message'
+require 'gmail/draft'
+require 'gmail/thread'
+require 'gmail/label'
+
+module Gmail
+
+  class << self
+    attr_accessor :auth_method, :client_id, :client_secret, 
+      :refresh_token, :auth_scopes, :email_account, :application_name, :application_version
+    attr_reader :service, :client, :mailbox_email
+    def new hash
+      [:auth_method, :client_id, :client_secret, :refresh_token, :auth_scopes, :email_account, :application_name, :application_version].each do |accessor|
+        Gmail.send("#{accessor}=", hash[accessor.to_s])
+      end
+    end
+  end
+
+  Google::APIClient.logger.level = 3
+  @service = Google::APIClient.new.discovered_api('gmail', 'v1')
+  Google::APIClient.logger.level = 2
+
+  begin
+    Gmail.new  YAML.load_file("account.yml")  # for development purpose
+  rescue
+
+  end
+
+  def self.request(method, params={}, body={}, auth_method=@auth_method)
+    
+    params[:userId] ||= "me"
+    case auth_method
+      when "web_application" 
+        if @client.nil?
+          self.connect
+        end
+      when "service_account"
+        if @client.nil?
+          self.service_account_connect
+        elsif self.client.authorization.principal != @email_account
+          self.service_account_connect
+        end
+    end
+  
+    if body.empty?
+      response = @client.execute(
+          :api_method => method,
+          :parameters => params,
+
+          :headers => {'Content-Type' => 'application/json'})
+    else
+
+     response =  @client.execute(
+          :api_method => method,
+          :parameters => params,
+          :body_object => body,
+          :headers => {'Content-Type' => 'application/json'})
+    end
+    parse(response)
+
+  end
+
+  def self.mailbox_email
+    @mailbox_email ||= self.request(@service.users.to_h['gmail.users.getProfile'])[:emailAddress]
+  end
+
+
+
+  def self.connect(client_id=@client_id, client_secret=@client_secret, refresh_token=@refresh_token)
+    unless client_id
+      raise 'No client_id specified'
+    end
+
+    unless client_secret
+      raise 'No client_secret specified'
+    end
+
+    unless refresh_token
+      raise 'No refresh_token specified'
+    end
+
+    @client = Google::APIClient.new(
+        application_name: @application_name,
+        application_version: @application_version
+    )
+    @client.authorization.client_id = client_id
+    @client.authorization.client_secret = client_secret
+    @client.authorization.refresh_token = refresh_token
+    @client.authorization.grant_type = 'refresh_token'
+    @client.authorization.fetch_access_token!
+    @client.auto_refresh_token = true
+
+    #@service = @client.discovered_api('gmail', 'v1')
+
+  end
+
+  def self.service_account_connect(
+    client_id=@client_id, client_secret=@client_secret,
+    email_account=@email_account, auth_scopes=@auth_scopes, 
+    application_name=@application_name, application_version=@application_version
+    )
+    puts "Authenticating service account - #{email_account}"
+    
+
+    @client = Google::APIClient.new(application_name: application_name, application_version: application_version)
+      
+      
+    
+    key = Google::APIClient::KeyUtils.load_from_pem(
+        client_secret,
+        'notasecret')
+    asserter = Google::APIClient::JWTAsserter.new(
+        client_id,
+        auth_scopes, 
+        key
+    )
+    @client.authorization = asserter.authorize(email_account)
+    
+  end
+
+  def self.parse(response)
+    begin
+
+      if response.body.empty?
+        return response.body
+      else
+        response = JSON.parse(response.body)
+      end
+
+    rescue JSON::ParserError
+      raise "error code: #{response.error},body: #{response.body})"
+    end
+
+    r = Gmail::Util.symbolize_names(response)
+    if r[:error]
+      raise "#{r[:error]}"
+    end
+    r
+  end
+
+
+end # Gmail

data/lib/gmail/api_resource.rb

@@ -0,0 +1,12 @@
+module Gmail
+  class APIResource < GmailObject
+    def self.class_name
+      self.name.split('::')[-1]
+    end
+
+    def self.base_method
+      Gmail.service.users.send("#{class_name.downcase}s")
+    end
+
+  end
+end

data/lib/gmail/base/create.rb

@@ -0,0 +1,16 @@
+module Gmail
+  module Base
+    module Create
+      module ClassMethods
+        def create(body, opts={})
+          response = Gmail.request(base_method.send("create"), {}, body)
+          Util.convert_to_gmail_object(response, class_name.downcase)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/gmail/base/delete.rb

@@ -0,0 +1,31 @@
+module Gmail
+  module Base
+    module Delete
+      def delete(opts={})
+        response = Gmail.request(self.class.base_method.send("delete"),{id: id})
+        if response == ""
+          true
+        else
+          false
+        end
+      end
+
+      module ClassMethods
+        def delete(id, opts={})
+         response = Gmail.request(base_method.send("delete"),{id: id})
+         if response == ""
+           true
+         else
+           false
+         end
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+
+    end
+  end
+end

data/lib/gmail/base/get.rb

@@ -0,0 +1,17 @@
+module Gmail
+  module Base
+    module Get
+      module ClassMethods
+        def get(id)
+          response = Gmail.request(base_method.send("get"), {id: id})
+          Util.convert_to_gmail_object(response, class_name.downcase)
+
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/gmail/base/list.rb

@@ -0,0 +1,54 @@
+module Gmail
+  module Base
+    module List
+      module ClassMethods
+        def all(filters={}, opts={})
+          max_results = filters[:maxResults] || 100
+          opts[:items] ||= []
+
+          if max_results == -1
+            filters.merge!({maxResults: 100})
+          end
+          response = Gmail.request(base_method.send("list"), filters)
+          items = response["#{class_name.downcase}s".to_sym] || []
+          next_page_token = response[:nextPageToken]
+          opts[:items] = opts[:items] + items
+
+          if items.count < 100 || items.count < max_results
+            Util.convert_to_gmail_object(opts[:items], class_name.downcase)
+          else
+            max_results = (max_results == -1)?-1:max_results-items.count
+            all(filters.merge({maxResults: max_results, pageToken: next_page_token}), opts)
+          end
+        end
+
+        def search(q={})
+          if q.is_a? String
+            all({q: q})
+          else
+            query = ""
+            [:from, :to, :subject].each do |prop|
+              query += "#{prop.to_s}:(#{q[prop].downcase}) "  unless q[prop].nil?
+              q.delete(prop)
+            end
+            [:in, :before, :after].each do |prop|
+              query += "#{prop.to_s}:#{q[prop]} " unless q[prop].nil?
+              q.delete(prop)
+            end
+
+            query += "#{q[:has_words]} " unless q[:has_words].nil?
+            query += "-{#{q[:has_not_words]}}" unless q[:has_not_words].nil?
+            q.delete(:has_words)
+            q.delete(:has_not_words)
+
+            all(q.merge({q: query}))
+          end
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/gmail/base/modify.rb

@@ -0,0 +1,66 @@
+module Gmail
+  module Base
+    module Modify
+      def modify!(addLabelIds=[], removeLabelIds=[])
+        response = Gmail.request(self.class.base_method.send("modify"),{id: id}, {addLabelIds: addLabelIds, removeLabelIds: removeLabelIds})
+        d = Util.convert_to_gmail_object(response, self.class.class_name.downcase)
+        @values = d.values
+        self
+      end
+
+      def modify(addLabelIds=[], removeLabelIds=[])
+        response = Gmail.request(self.class.base_method.send("modify"),{id: id}, {addLabelIds: addLabelIds, removeLabelIds: removeLabelIds})
+        d = Util.convert_to_gmail_object(response, self.class.class_name.downcase)
+      end
+
+      def archive
+        modify([], ["INBOX"])
+      end
+
+      def archive!
+        modify!([], ["INBOX"])
+      end
+
+      def unarchive
+        modify(["INBOX"], [] )
+      end
+
+      def unarchive!
+        modify!(["INBOX"], [] )
+      end
+
+      def star
+        modify(["STARRED"], [] )
+      end
+
+      def star!
+        modify!(["STARRED"], [] )
+      end
+
+      def unstar
+        modify([],["STARRED"] )
+      end
+
+      def unstar!
+        modify!([],["STARRED"] )
+      end
+
+      def mark_as_read
+        modify([],["UNREAD"] )
+      end
+
+      def mark_as_read!
+        modify!([],["UNREAD"] )
+      end
+
+      def mark_as_unread
+        modify(["UNREAD"],[] )
+      end
+
+      def mark_as_unread!
+        modify!(["UNREAD"],[] )
+      end
+
+    end
+  end
+end

data/lib/gmail/base/trash.rb

@@ -0,0 +1,33 @@
+module Gmail
+  module Base
+    module Trash
+      def trash(opts={})
+        response = Gmail.request(self.class.base_method.send("trash"),{id: id})
+        Util.convert_to_gmail_object(response, self.class.class_name.downcase)
+      end
+
+      def untrash(opts={})
+        response = Gmail.request(self.class.base_method.send("untrash"),{id: id})
+        Util.convert_to_gmail_object(response, self.class.class_name.downcase)
+      end
+
+      module ClassMethods
+        def trash(id, opts={})
+          response = Gmail.request(base_method.send("trash"),{id: id})
+          Util.convert_to_gmail_object(response, class_name.downcase)
+        end
+
+        def untrash(id, opts={})
+          response = Gmail.request(base_method.send("untrash"),{id: id})
+          Util.convert_to_gmail_object(response, class_name.downcase)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+
+    end
+  end
+end