google_apps 0.4.9 → 0.4.9.1

data/lib/google_apps/apps_request.rb

@@ -0,0 +1,77 @@
+require 'net/http'
+
+module GoogleApps
+  class AppsRequest
+    attr_reader :uri
+
+    def initialize(verb, uri, headers)
+      @uri = URI uri
+      @ssl = (@uri.scheme == 'https')
+      @http_request = initialize_http(verb)
+
+      set_headers(headers)
+    end
+
+
+    # send_request does the actual work of sending @http_request as
+    # it is currently constructed.
+    #
+    # send_request
+    #
+    # send_request returns a Net::HTTPResponse object.
+    def send_request
+      Net::HTTP.start(@uri.host, @uri.port, use_ssl: @ssl) do |http|
+        http.request(@http_request)
+      end
+    end
+
+
+    # add_body sets the body the provided content.
+    #
+    # add_body 'bob'
+    #
+    # add_body returns the content added.
+    def add_body(content)
+      @http_request.body = content
+    end
+
+
+    private
+
+
+    # intialize_http builds the proper type of HTTP object for the
+    # request.  It takes an HTTP verb as it's argument.
+    #
+    # initialize_http :get
+    #
+    # initialize_http returns a Net::HTTP object of the specified type.
+    def initialize_http(verb)
+      build_constant(verb.to_s).new(@uri.request_uri)
+    end
+
+
+    # build_constant returns the proper constant for the specified
+    # http verb.  It takes a HTTP verb as it's argument.
+    #
+    # build_constant :get
+    #
+    # build_constant returns the constant corresponding to the Net::HTTP
+    # class of the specified type.
+    def build_constant(verb)
+      "Net::HTTP::#{verb.capitalize}".split('::').inject(Object) do |context, constant|
+        context.const_get constant
+      end
+    end
+
+
+    # set_headers sets the headers on @http_request.  set_headers takes
+    # an array of header/value pairs as it's only argument.
+    #
+    # set_headers [['content-type', 'application/xml']]
+    def set_headers(headers)
+      headers.each do |field, value|
+        @http_request[field] = value
+      end
+    end
+  end
+end

data/lib/google_apps/atom/atom.rb

@@ -44,7 +44,7 @@ module GoogleApps
 
     ENTRY_TAG = ["<atom:entry xmlns:atom=\"#{NAMESPACES[:atom]}\" xmlns:apps=\"#{NAMESPACES[:apps]}\" xmlns:gd=\"#{NAMESPACES[:gd]}\">", '</atom:entry>']
 
-    DOCUMENTS = %w(user export group group_member message_attributes public_key feed)
+    DOCUMENTS = %w(user export group group_member message_attributes public_key feed nickname)
 
     # The idea is to make document distribution more dynamic.
     # Might be pointless but it's here for now.

data/lib/google_apps/atom/export.rb

@@ -7,7 +7,7 @@ module GoogleApps
       HEADER = 'HEADER_ONLY'
       FULL = 'FULL_MESSAGE'
 
-      def initialize
+      def initialize(xml = nil)
         @document = Atom::XML::Document.new
         @document.root = build_root
       end

data/lib/google_apps/atom/group.rb

@@ -4,6 +4,8 @@ module GoogleApps
       include Atom::Node
       include Atom::Document
 
+      attr_accessor :id, :name, :description, :permissions
+
       #ATTRIBUTES = %w(id name description perms).map(&:to_sym)
 
       def initialize(xml = nil)
@@ -49,6 +51,44 @@ module GoogleApps
         @document.root
       end
 
+
+      def change_value(name, old_value, new_value)
+        find_and_update @document, '//apps:property', { name => [old_value, new_value] }
+      end
+
+      # TODO:  This needs to check all attributes of the element
+      def id=(value)
+        @id ? change_value(:value, @id, value) : set_values(id: value)
+
+        @id = value
+        @document = parse(@document)
+      end
+
+
+      def name=(value)
+        @name ? change_value(:value, @name, value) : set_values(name: value)
+
+        @name = value
+        @document = parse(@document)
+      end
+
+
+      def permissions=(value)
+        @permissions ? change_value(:value, @permissions, value) : set_values(perms: value)
+
+        @permissions = value
+        @document = parse(@document)
+      end
+
+
+      def description=(value)
+        @description ? change_value(:value, @description, value) : set_values(description: value)
+
+        @description = value
+        @document = parse(@document)
+      end
+
+
       # to_s returns @document as a String.
       def to_s
         @document.to_s

data/lib/google_apps/atom/message_attributes.rb

@@ -1,11 +1,15 @@
 module GoogleApps
   module Atom
     class MessageAttributes
+      attr_reader :labels
+      attr_accessor :property
+
       def initialize
+        @labels = []
         @document = Atom::XML::Document.new
         set_header
       end
-      
+
       def add_property(prop)
         property = Atom::XML::Node.new 'apps:mailItemProperty'
         property['value'] = prop
@@ -13,11 +17,25 @@ module GoogleApps
         @document.root << property
       end
 
+      def property=(value)
+        @property.nil? ? add_property(value) : change_property(value)
+      end
+
       def add_label(name)
         label = Atom::XML::Node.new 'apps:label'
         label['labelName'] = name
 
         @document.root << label
+        @labels << name
+      end
+
+      def <<(value)
+        add_label(value) unless @labels.include?(value)
+      end
+
+      def remove_label(value)
+        @labels.delete(value)
+        # Need a way to remove a node from the document.
       end
 
       def to_s

data/lib/google_apps/atom/nickname.rb

@@ -8,7 +8,7 @@ module GoogleApps
 
       ELEMENTS = { nick: ['apps:nickname', 'name'], user: ['apps:login', 'userName'] }
 
-      def initialize
+      def initialize(xml = nil)
         @document = Atom::XML::Document.new
         @document.root = build_root
       end

data/lib/google_apps/atom/node.rb

@@ -65,13 +65,24 @@ module GoogleApps
       # update_node document, '/apps:nickname', name: ['Bob', 'Tom']
       def find_and_update(document, xpath, attributes)
         document.find(xpath).each do |node|
-          attributes.each_key do |attrib|
-            node.attributes[attrib.to_s] = attributes[attrib][1] if node.attributes[attrib.to_s].to_s == attributes[attrib][0].to_s
+          if node_match?(node, attributes)
+            attributes.each_key do |attrib|
+              node.attributes[attrib.to_s] = attributes[attrib][1]
+            end
           end
         end
       end
 
 
+      # node_match? checks that each value for each specified
+      # attribute matches the specified value.
+      def node_match?(node, attributes)
+        attributes.keys.inject(true) do |result, key|
+          result and node.attributes[key.to_s] == attributes[key][0]
+        end
+      end
+
+
       # get_content returns the content of the specified node.
       # If multiple nodes match the xpath value get_content
       # will return the content of the first occurance.
@@ -82,6 +93,17 @@ module GoogleApps
       def get_content(document, xpath)
         document.find(xpath).first.content
       end
+
+
+      # get_values returns an array of all the value attributes
+      # on elements matching the given key_attrib pair on the
+      # specified element type.
+      def get_values(element, key_attrib, value = 'value')
+        self.find('//' + element).inject([]) do |values, element|
+          values << element.attributes[value] if element.attributes[key_attrib[0]].match key_attrib[1]
+          values
+        end
+      end
     end
   end
 end

data/lib/google_apps/document_handler.rb

@@ -0,0 +1,65 @@
+module GoogleApps
+  class DocumentHandler
+    attr_accessor :format
+
+    def initialize(args)
+      set_format args[:format]
+    end
+    
+
+    # create_doc creates a document of the specified format
+    # from the given string.
+    def create_doc(text, type = nil)
+      @documents.include?(type) ? doc_of_type(text, type) : unknown_type(text)
+    end
+
+
+    # unknown_type takes a string and returns a document of
+    # of the corresponding @format.
+    def unknown_type(text)
+      case @format
+      when :atom, :xml
+        Atom::XML::Document.string(text)
+      end
+    end
+
+
+    # format= sets the format for the DocumentHandler
+    def format=(format)
+      set_format format
+    end
+
+
+    # doc_of_type takes a document type and a string and
+    # returns a document of that type in the current format.
+    def doc_of_type(text, type)
+      raise "No #{@format.to_s.capitalize} document of type: #{type}" unless @documents.include?(type.to_s)
+
+      case @format
+      when :atom, :xml
+        GoogleApps::Atom.send(type, text)
+      end
+    end
+
+
+
+    private
+
+
+    # look_up_doc_types returns a list of document types the
+    # library supports in the current format.
+    def look_up_doc_types
+      case @format
+      when :atom, :xml
+        Atom::DOCUMENTS
+      end
+    end
+
+
+    # set_format Sets @format and @documents
+    def set_format(format)
+      @format = format
+      @documents = look_up_doc_types
+    end
+  end
+end

data/lib/google_apps/transport.rb

@@ -1,4 +1,3 @@
-require 'net/http'
 require 'cgi'
 require 'openssl'
 require 'rexml/document'
@@ -6,8 +5,9 @@ require 'rexml/document'
 module GoogleApps
   class Transport
     attr_reader :request, :response, :domain, :feeds
-    attr_accessor :auth, :user, :group, :nickname, :export
+    attr_accessor :auth, :user, :group, :nickname, :export, :group, :requester, :migration
 
+    SUCCESS_CODES = [200, 201, 202]
     BOUNDARY = "=AaB03xDFHT8xgg"
     PAGE_SIZE = {
       user: 100,
@@ -23,6 +23,8 @@ module GoogleApps
       @nickname = targets[:nickname] || "https://apps-apis.google.com/a/feeds/#{domain}/nickname/2.0"
       @export = targets[:export] || "https://apps-apis.google.com/a/feeds/compliance/audit/mail/export/#{domain}"
       @domain = domain
+      @requester = AppsRequest || targets[:requester]
+      @doc_handler = DocumentHandler.new format: (targets[:format] || :atom)
       @token = nil
       @response = nil
       @request = nil
@@ -39,18 +41,14 @@ module GoogleApps
     # authenticate returns the HTTP response received
     # from Google
     def authenticate(account, pass)
-      uri = URI(@auth)
-      @request = Net::HTTP::Post.new(uri.path)
-      @request.body = auth_body(account, pass)
-      set_headers :auth
-
-      @response = request uri
+      add(@auth, nil, auth_body(account, pass), :auth)
 
       set_auth_token
 
       @response
     end
 
+
     # request_export performs the GoogleApps API call to
     # generate a mailbox export.  It takes the username
     # and an GoogleApps::Atom::Export instance as
@@ -58,52 +56,77 @@ module GoogleApps
     #
     # request_export 'username', document
     #
-    # request_export returns the HTTP response received
-    # from Google.
+    # request_export returns the request ID on success or
+    # the HTTP response object on failure.
     def request_export(username, document)
-      add(@export + "/#{username}", document)
+      result = add(@export + "/#{username}", :export_response, document)
+      
+      get_values(result, 'apps:property', ['name', 'requestId'], 'value')[0].to_i
+      #success_response? ? get_values('apps:property', ['name', 'requestId'], 'value')[0].to_i : @response
     end
 
+
     # export_status checks the status of a mailbox export
     # request.  It takes the username and the request_id
     # as arguments
     #
     # export_status 'username', 847576
     #
-    # export_status will return the status of the HTTP
-    # response from Google
+    # export_status will return the body of the HTTP response
+    # from Google
     def export_status(username, req_id)
-      get(@export + "/#{username}", req_id)
+      get(@export + "/#{username}", :export_status, req_id)
     end
 
-    def fetch_export(username, req_id, filename) # :nodoc:
-      # TODO: Shouldn't rely on export_status being run first.  Self, this is lazy and stupid.
+
+    # export_ready? checks the export_status response for the
+    # presence of an apps:property element with a fileUrl name
+    # attribute.
+    #
+    # export_ready? 'lholcomb2', 82834
+    #
+    # export_ready? returns true if there is a fileUrl present
+    # in the response and false if there is no fileUrl present
+    # in the response.
+    def export_ready?(username, req_id)
       export_status(username, req_id)
-      doc = REXML::Document.new(@response.body)
-      urls = []
-      doc.elements.each('entry/apps:property') do |property|
-        urls << property.attributes['value'] if property.attributes['name'].match 'fileUrl'
-      end
 
-      urls.each do |url|
-        download(url, filename + "#{urls.index(url)}")
+      !(export_file_urls.empty?)
+    end
+
+
+    # fetch_export downloads the mailbox export from Google.
+    # It takes a username, request id and a filename as
+    # arguments.  If the export consists of more than one file
+    # the file name will have numbers appended to indicate the
+    # piece of the export.
+    #
+    # fetch_export 'lholcomb2', 838382, 'lholcomb2'
+    #
+    # fetch_export reutrns nil in the event that the export is
+    # not yet ready.
+    def fetch_export(username, req_id, filename)
+      if export_ready?(username, req_id)
+        download_export(filename).each_with_index { |url, index| url.gsub!(/.*/, "#{filename}#{index}")}
+      else
+        nil
       end
     end
 
+
     # download makes a get request of the provided url
     # and writes the body to the provided filename.
     #
     # download 'url', 'save_file'
     def download(url, filename)
-      uri = URI(url)
-      @request = Net::HTTP::Get.new uri.path
-      set_headers :user
+      @request = @requester.new :get, URI(url), headers(:other)
 
       File.open(filename, "w") do |file|
-        file.puts request(uri).body
+        file.puts @request.send_request.body
       end
     end
 
+
     # get is a generic target for method_missing.  It is
     # intended to handle the general case of retrieving a
     # record from the Google Apps Domain.  It takes an API
@@ -112,13 +135,13 @@ module GoogleApps
     # get 'endpoint', 'username'
     #
     # get returns the HTTP response received from Google.
-    def get(endpoint, id = nil)
-      # TODO:  Need to handle <link rel='next' for pagination if wanting all users
+    def get(endpoint, type, id = nil)
       id ? uri = URI(endpoint + build_id(id)) : uri = URI(endpoint)
-      @request = Net::HTTP::Get.new(uri.request_uri)
-      set_headers :user
+      @request = @requester.new :get, uri, headers(:other)
+
+      @response = @request.send_request
 
-      @response = request uri
+      process_response(type)
     end
 
 
@@ -153,20 +176,13 @@ module GoogleApps
     #
     # get_all returns the HTTP response received from Google.
     def get_all(type, options = {})
-      @feeds, current_page = [], 0
-      type = type.to_s
-      type.gsub!(/\w*s$/) { |match| match[0..-2] }
+      @feeds, page = [], 0
+      type = normalize_type type
 
       options[:limit] ? limit = options[:limit] : limit = 1000000
-      options[:start] ? get(instance_variable_get("@#{type}") + "?#{start_query(type)}=#{options[:start]}") : get(instance_variable_get("@#{type}"))
+      options[:start] ? get(instance_variable_get("@#{type}") + "?#{start_query(type)}=#{options[:start]}", :feed) : get(instance_variable_get("@#{type}"), :feed)
 
-      add_feed
-      current_page += 1
-
-      while (@feeds.last.next_page) and (current_page * PAGE_SIZE[:user] < limit)
-        get_next_page
-        current_page += 1
-      end
+      fetch_feed(page, limit)
 
       @response
     end
@@ -180,7 +196,7 @@ module GoogleApps
     #
     # add_member_to returns the response received from Google.
     def add_member_to(group_id, document)
-      add(@group + "/#{group_id}/member", document)
+      add(@group + "/#{group_id}/member", nil, document)
     end
 
 
@@ -214,13 +230,15 @@ module GoogleApps
     # add 'endpoint', document
     #
     # add returns the HTTP response received from Google.
-    def add(endpoint, document)
+    def add(endpoint, type, document, header_type = nil)
+      header_type = :others unless header_type
       uri = URI(endpoint)
-      @request = Net::HTTP::Post.new(uri.path)
-      @request.body = document.to_s
-      set_headers :user
+      @request = @requester.new :post, uri, headers(header_type)
+      @request.add_body document.to_s
+
+      @response = @request.send_request
 
-      @response = request uri
+      process_response type
     end
 
     # update is a generic target for method_missing.  It is
@@ -232,14 +250,14 @@ module GoogleApps
     # update 'endpoint', document
     #
     # update returns the HTTP response received from Google
-    def update(endpoint, target, document)
-    	# TODO: Username needs to come from somewhere for uri
+    def update(endpoint, type, target, document)
       uri = URI(endpoint + "/#{target}")
-      @request = Net::HTTP::Put.new(uri.path)
-      @request.body = document.to_s
-      set_headers :user
+      @request = @requester.new :put, uri, headers(:other)
+      @request.add_body document.to_s
+
+      @response = @request.send_request
 
-      @response = request uri
+      process_response type
     end
 
     # delete is a generic target for method_missing.  It is
@@ -252,10 +270,9 @@ module GoogleApps
     # delete returns the HTTP response received from Google.
     def delete(endpoint, id)
       uri = URI(endpoint + "/#{id}")
-      @request = Net::HTTP::Delete.new(uri.path)
-      set_headers :user
+      @request = @requester.new :delete, uri, headers(:other)
 
-      @response = request uri
+      @response = @request.send_request
     end
 
     # migration performs mail migration from a local
@@ -267,28 +284,26 @@ module GoogleApps
     #
     # migrate returns the HTTP response received from Google.
     def migrate(username, properties, message)
-      uri = URI(@migration + "/#{username}/mail")
-      @request = Net::HTTP::Post.new(uri.path)
-      @request.body = multi_part(properties.to_s, message)
-      set_headers :migrate
+      @request = @requester.new(:post, URI(@migration + "/#{username}/mail"), headers(:migration))
+      @request.add_body multi_part(properties.to_s, message)
 
-      @response = request uri
+      @request.send_request
     end
 
 
-    # TODO: This should perform the instance_variable_get and pass the value to the appropriate method.
+
     def method_missing(name, *args)
       super unless name.match /([a-z]*)_([a-z]*)/
 
       case $1
       when "new", "add"
-        self.send(:add, instance_variable_get("@#{$2}"), *args)
+        self.send(:add, instance_variable_get("@#{$2}"), $2, *args)
       when "delete"
         self.send(:delete, instance_variable_get("@#{$2}"), *args)
       when "update"
-        self.send(:update, instance_variable_get("@#{$2}"), *args)
+        self.send(:update, instance_variable_get("@#{$2}"), $2, *args)
       when "get"
-        self.send(:get, instance_variable_get("@#{$2}"), *args)
+        self.send(:get, instance_variable_get("@#{$2}"), $2, *args)
       else
         super
       end
@@ -318,6 +333,43 @@ module GoogleApps
     end
 
 
+    # export_file_urls searches @response for any apps:property elements with a
+    # fileUrl name attribute and returns an array of the values.
+    def export_file_urls
+      Atom::XML::Document.string(@response.body).find('//apps:property').inject([]) do |urls, prop|
+        urls << prop.attributes['value'] if prop.attributes['name'].match 'fileUrl'
+        urls
+      end
+    end
+
+
+    def download_export(filename)
+      export_file_urls.each_with_index do |url, index|
+        download(url, filename + "#{index}")
+      end
+    end
+
+
+    # process_response takes the HTTPResponse and either returns a
+    # document of the specified type or in the event of an error it
+    # returns the HTTPResponse.
+    def process_response(doc_type = nil)
+      case doc_type
+      when nil
+        success_response? ? true : raise("Error: #{response.code}, #{response.message}")
+      else
+        success_response? ? @doc_handler.create_doc(@response.body, doc_type) : raise("Error: #{response.code}, #{response.message}")
+      end
+    end
+
+
+    # error_response? checks to see if Google Responded with a success
+    # code.
+    def success_response?
+      SUCCESS_CODES.include?(@response.code.to_i)
+    end
+
+
     # Grab the auth token from the response body
     def set_auth_token
       @response.body.split("\n").grep(/auth=(.*)/i)
@@ -326,12 +378,26 @@ module GoogleApps
     end
 
 
+    # get_next_page retrieves the next page in the response.
     def get_next_page
       get @feeds.last.next_page
       add_feed
     end
 
 
+    # fetch_feed retrieves the remaining pages in the request.
+    # It takes a page and a limit as arguments.
+    def fetch_feed(page, limit)
+      add_feed
+      page += 1
+
+      while (@feeds.last.next_page) and (page * PAGE_SIZE[:user] < limit)
+        get_next_page
+        page += 1
+      end
+    end
+
+
     # start_query builds the value for the starting point
     # query string used for retrieving batches of objects
     # from Google.
@@ -345,32 +411,39 @@ module GoogleApps
     end
 
 
+    def normalize_type(type)
+      type.to_s.gsub!(/\w*s$/) { |match| match[0..-2] }
+    end
+
+
     # add_feed adds a feed to the @feeds array.
     def add_feed
       @feeds << GoogleApps::Atom.feed(@response.body)
     end
 
-
-    def request(uri)
-      # TODO: Clashes with @request reader
-      Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
-        http.request(@request)
+    # get_values returns an array of all the value attributes
+    # on elements matching the given key_attrib pair on the
+    # specified element type.
+    def get_values(document, element, key_attrib, value = 'value')
+      document.find('//' + element).inject([]) do |values, element|
+        values << element.attributes[value] if element.attributes[key_attrib[0]].match key_attrib[1]
+        values
       end
     end
 
-    def set_headers(request_type)
-      case request_type
+
+    def headers(category)
+      case category
       when :auth
-        @request['content-type'] = "application/x-www-form-urlencoded"
-      when :migrate
-        @request['content-type'] = "multipart/related; boundary=\"#{BOUNDARY}\""
-        @request['authorization'] = "GoogleLogin auth=#{@token}"
+        [['content-type', 'application/x-www-form-urlencoded']]
+      when :migration
+        [['content-type', "multipart/related; boundary=\"#{BOUNDARY}\""], ['authorization', "GoogleLogin auth=#{@token}"]]
       else
-        @request['content-type'] = "application/atom+xml"
-        @request['authorization'] = "GoogleLogin auth=#{@token}"
+        [['content-type', 'application/atom+xml'], ['authorization', "GoogleLogin auth=#{@token}"]]
       end
     end
 
+
     def multi_part(properties, message)
       post_body = []
       post_body << "--#{BOUNDARY}\n"

data/lib/google_apps.rb

@@ -1,7 +1,9 @@
+require 'google_apps/apps_request'
 require 'google_apps/transport'
 require 'google_apps/atom/atom'
 require 'google_apps/atom/node'
 require 'google_apps/atom/document'
+require 'google_apps/document_handler'
 require 'google_apps/atom/feed'
 require 'google_apps/atom/user'
 require 'google_apps/atom/group'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: google_apps
 version: !ruby/object:Gem::Version
-  version: 0.4.9
+  version: 0.4.9.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-18 00:00:00.000000000 Z
+date: 2012-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libxml-ruby
@@ -33,6 +33,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/google_apps/apps_request.rb
 - lib/google_apps/atom/atom.rb
 - lib/google_apps/atom/document.rb
 - lib/google_apps/atom/export.rb
@@ -45,6 +46,7 @@ files:
 - lib/google_apps/atom/node.rb
 - lib/google_apps/atom/public_key.rb
 - lib/google_apps/atom/user.rb
+- lib/google_apps/document_handler.rb
 - lib/google_apps/transport.rb
 - lib/google_apps.rb
 homepage: https://github.com/LeakyBucket/google_apps
@@ -72,3 +74,4 @@ signing_key:
 specification_version: 3
 summary: Google Apps APIs
 test_files: []
+has_rdoc: