ruby_provisioning_api 0.0.1

data/.gitignore

@@ -0,0 +1,28 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+.idea
+#  Ignore wizzy configuration 
+.wizzy
+wizzy
+.wizzy-config

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@ruby_provisioning_api --create

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby_provisioning_api.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Davide Targa
+
+MIT License
+
+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/README.md

@@ -0,0 +1,30 @@
+# RubyProvisioningApi
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ruby_provisioning_api'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby_provisioning_api
+
+## Usage
+
+TODO: Write usage instructions here
+http://rdoc.info/github/digitalprog/ruby_provisioning_api/master/frames
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/ruby_provisioning_api/config/google_apps.yml

@@ -0,0 +1,3 @@
+:username: brgdmn
+:password: 23428dami
+:domain: damianobraga.com

data/lib/ruby_provisioning_api/configuration.rb

@@ -0,0 +1,51 @@
+module RubyProvisioningApi
+
+  class Configuration
+
+    attr_accessor :config_file, :user_path, :group_path, :user_actions, :group_actions, :base_apps_url, :base_path
+    attr_reader :config
+
+    def initialize
+      #@config_file = "/home/davide/sites/ruby_provisioning_api/lib/ruby_provisioning_api/config/google_apps.yml"
+      config_file = "#{Rails.root}/config/google_apps.yml"
+
+      if File.exist?(config_file)
+        @config = YAML.load_file(config_file)
+      else
+        raise "RubyProvisioningApi: File #{config_file} not found, maybe you forgot to define it ?"
+      end
+
+      @base_apps_url = 'https://apps-apis.google.com'
+      @base_path = '/a/feeds'
+      @user_path = "/#{@config[:domain]}/user/2.0"
+      @group_path = "/group/2.0/#{@config[:domain]}"
+      @user_actions = {
+          :create => {method: "POST", url: "#{user_path}"},
+          :retrieve_all => {method: "GET", url: "#{user_path}"},
+          :retrieve => {:method => "GET", :url => "#{user_path}/userName"},
+          :delete => {:method => "DELETE", :url => "#{user_path}/userName"},
+          :update => {:method => "PUT", :url => "#{user_path}/userName"},
+          :member_of => {method: "GET", url: "#{group_path}/groupId/member/memberId"}
+      }
+      @group_actions = {
+          :create =>  { method: "POST" , url: "#{group_path}"},
+          :update =>  { method: "PUT" , url: "#{group_path}/groupId"},
+          :delete =>  { method: "DELETE" , url: "#{group_path}/groupId"},
+          :retrieve_all => { method: "GET" , url: "#{group_path}" },
+          :retrieve_groups => { method: "GET" , url: "#{group_path}/?member=memberId" },
+          :retrieve => { method: "GET" , url: "#{group_path}/groupId" },
+          :add_member => { method: "POST" , url: "#{group_path}/groupId/member" },
+          :add_owner => { method: "POST" , url: "#{group_path}/groupId/owner" },
+          :delete_member => { method: "DELETE" , url: "#{group_path}/groupId/member/memberId" },
+          :has_member => {method: "GET", url: "#{group_path}/groupId/member/memberId"},
+          :has_owner => {method: "GET", url: "#{group_path}/groupId/owner/ownerId"},
+          :delete_owner => {method: "DELETE" , url: "#{group_path}/groupId/owner/ownerId"},
+          :member => {method: "GET", url: "#{group_path}/groupId/member/memberId"},
+          :members => {method: "GET", url: "#{group_path}/groupId/member"},
+          :owner => {method: "GET", url: "#{group_path}/groupId/owner/ownerId"},
+          :owners => {method: "GET", url: "#{group_path}/groupId/owner"}
+      }
+    end
+
+  end
+end

data/lib/ruby_provisioning_api/connection.rb

@@ -0,0 +1,24 @@
+module RubyProvisioningApi
+  class Connection
+
+    attr_reader :token
+
+    def initialize
+      client = client('https://www.google.com')
+      response = client.post '/accounts/ClientLogin', {:Email => "#{RubyProvisioningApi.configuration.config[:username]}@#{RubyProvisioningApi.configuration.config[:domain]}", :Passwd => RubyProvisioningApi.configuration.config[:password], :accountType =>  "HOSTED", :service => "apps"}
+      # Set the token
+      @token = response.body.split("\n").last.split('Auth=').last
+    end
+
+    def client(url)
+      # TODO: move ca_file option into initializer
+      client = Faraday.new(:url => url, :ssl => {:ca_file => '/usr/lib/ssl/certs/ca-certificates.crt'}) do |faraday|
+        faraday.request  :url_encoded             # form-encode POST params
+        # TODO :move log level into initializer
+        # faraday.response :logger                  # log requests to STDOUT
+        faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+      end
+    end
+
+  end
+end

data/lib/ruby_provisioning_api/entity.rb

@@ -0,0 +1,56 @@
+module RubyProvisioningApi
+  module Entity
+
+    def perform(action, params = nil)
+      connection = RubyProvisioningApi.connection
+      client = connection.client(RubyProvisioningApi.configuration.base_apps_url)
+      method = action[:method]
+      url = action[:url]
+
+      response = client.send(action[:method].downcase) do |req|
+        req.url "#{RubyProvisioningApi.configuration.base_apps_url}#{RubyProvisioningApi.configuration.base_path}#{action[:url]}"
+        req.headers['Content-Type'] = 'application/atom+xml'
+        req.headers['Authorization'] = "GoogleLogin auth=#{connection.token}"
+        req.body = params if params
+      end
+    end
+
+    def response_error?(response)
+      (400..600).include?(response.status)
+    end
+
+    def check_response(response)
+      if (400..600).include?(response.status)
+        xml = Nokogiri::XML(response.body)
+        error_code = xml.xpath('//error').first.attributes["errorCode"].value
+        error_description = xml.xpath('//error').first.attributes["reason"].value
+        RubyProvisioningApi.const_set(error_description, Class.new(RubyProvisioningApi::Error)) unless RubyProvisioningApi.const_defined? error_description
+        raise "RubyProvisioningApi::#{error_description}".constantize
+      end
+      true
+    end
+
+    def present?(id)
+      begin
+        self.find(id)
+        true
+      rescue
+        false
+      end
+    end
+
+    def prepare_params_for(action, options = {})
+      options.stringify_keys!
+      params = deep_copy(RubyProvisioningApi.configuration.send("#{self.name.demodulize.underscore}_actions")[action])
+      options.each_pair do |k,v|
+        params[:url].gsub!(k, v)
+      end
+      params
+    end
+
+    def deep_copy(element)
+      Marshal.load(Marshal.dump(element))
+    end
+
+  end
+end

data/lib/ruby_provisioning_api/error.rb

@@ -0,0 +1,24 @@
+module RubyProvisioningApi
+
+  # A general RubyProvisioningApi exception
+  # All RubyProvisioningApi exceptions are descendants of the error class.
+  #
+  # *NOTE:* Exceptions raised by google provisioning api protocol in Entity::check_response are generated on the fly and
+  # are also descendants of the Error class.
+  #
+  #
+  #
+  class Error < StandardError
+
+    # @param [String] message the message of the exception
+    def initialize(message = nil)
+      @message = message || self.class.to_s.split("::").last.underscore.humanize
+    end
+
+    def to_s
+      @message
+    end
+
+  end
+
+end

data/lib/ruby_provisioning_api/group.rb

@@ -0,0 +1,373 @@
+module RubyProvisioningApi
+
+  # @attr [String] group_id Group identification
+  # @attr [String] group_name Group name
+  # @attr [String] description Group description
+  # @attr [String] email_permission Group permission: Owner or Member 
+  #
+  class Group 
+    extend Entity
+    include Member
+    include Owner
+
+    include ActiveModel::Validations
+    include ActiveModel::Dirty
+
+    attr_accessor :group_id, :group_name, :description, :email_permission
+
+    GROUP_ATTRIBUTES = ['groupId','groupName','description','emailPermission']
+    
+    # @param [Hash] params the options to create a Group with.
+    # @option params [String] :group_id Group identification
+    # @option params [String] :group_name Group name
+    # @option params [String] :description Group description
+    # @option params [String] :email_permission Group permission: Owner or Member
+    #
+    def initialize(params = {})
+      params.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    # Retrieve all groups in the domain 
+    # @note This method executes a <b>GET</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain[?[start=]]</i>
+    #
+    # @example Retrieve all group in the current domain
+    #   RubyProvisioningApi::Group.all # => [Array<Group>]
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#retrieving_all_groups_in_a_domain
+    # @return [Array<Group>] all groups in the domain
+    #
+    def self.all
+      response = perform(RubyProvisioningApi.configuration.group_actions[:retrieve_all])
+      # Perform the request & Check if the response contains an error
+      check_response(response)       
+      # Parse the response
+      xml = Nokogiri::XML(response.body)
+      # Prepare a Groups array
+      groups = []
+      xml.children.css("entry").each do |entry|
+        group = Group.new
+        GROUP_ATTRIBUTES.each do |attribute_name|
+          group.send("#{attribute_name.underscore}=", entry.css("apps|property[name='#{attribute_name}']").attribute("value").value)
+        end
+        # Fill groups array        
+        groups << group
+      end
+      # Return the array of Groups
+      groups
+    end
+
+    # Retrieve a group
+    # @param [String] group_id Group identification
+    # @note This method executes a <b>GET</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId </i>
+    #
+    # @example Find the group "foo"
+    #   group = RubyProvisioningApi::Group.find("foo") # => [Group]
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#retrieving_a_group
+    # @return [Group] the group found
+    # @raise [Error] if group does not exist
+    #      
+    def self.find(group_id)
+      params = prepare_params_for(:retrieve, "groupId" => group_id)
+      response = perform(params)
+      # Check if the response contains an error
+      check_response(response)
+      # Parse the response
+      xml = Nokogiri::XML(response.body)
+      group = Group.new
+      for attribute_name in ['groupId','groupName','description','emailPermission']
+        group.send("#{attribute_name.underscore}=",xml.children.css("entry apps|property[name='#{attribute_name}']").attribute("value").value)
+      end
+      group
+    end
+
+    # Initialize and save a group 
+    # @param [Hash] params the options to create a Group with.
+    # @option params [String] :group_id Group identification
+    # @option params [String] :group_name Group name
+    # @option params [String] :description Group description 
+    # @option params [String] :email_permission Group permission: Owner or Member 
+    # @note This method executes a <b>POST</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain</i>
+    #
+    # @example Create the group "foo"
+    #   group = RubyProvisioningApi::Group.create(:group_id => "foo",
+    #                                             :group_name => "foo name" ,
+    #                                             :description => "bar",
+    #                                             :email_permission => "Owner") # => true
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#creating_a_group
+    # @return [Boolean] true if created, false if not valid or not created
+    # @raise [Error] if group already exists (group_id must be unique)
+    #    
+    def self.create(params = {})
+      group = Group.new(params).save    
+    end
+
+    # Save a group
+    # @note This method executes a <b>POST</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain</i>
+    #
+    # @example Save the group "foo"
+    #   group = RubyProvisioningApi::Group.new( :group_id => "foo", :group_name => "foo name" , :description => "bar", :email_permission => "Owner" ).save # => true
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#creating_a_group
+    # @return [Boolean] true if saved, false if not valid or not saved
+    # @raise [Error] if group already exists (group_id must be unique)
+    #
+    def save
+      return false unless valid?
+      # If group is present, this is an update
+      update = Group.present?(group_id)
+      # Creating the XML request
+      builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        xml.send(:'atom:entry', 'xmlns:atom' => 'http://www.w3.org/2005/Atom', 'xmlns:apps' => 'http://schemas.google.com/apps/2006') {
+          xml.send(:'atom:category', 'scheme' => 'http://schemas.google.com/g/2005#kind', 'term' => 'http://schemas.google.com/apps/2006#emailList')
+          xml.send(:'apps:property', 'name' => 'groupId', 'value' => group_id) if update
+          xml.send(:'apps:property', 'name' => 'groupName', 'value' => group_name)
+          xml.send(:'apps:property', 'name' => 'description', 'value' => description)
+          xml.send(:'apps:property', 'name' => 'emailPermission', 'value' => email_permission)
+        }
+      end
+      if !update
+        #Acting on a new object
+        # Check if the response contains an error
+        self.class.check_response(self.class.perform(RubyProvisioningApi.configuration.group_actions[:create],builder.to_xml))
+      else
+        #Acting on an existing object
+        params = self.class.prepare_params_for(:update, "groupId" => group_id)
+        # Perform the request & Check if the response contains an error
+        self.class.check_response(self.class.perform(params,builder.to_xml))  
+      end
+    end
+
+    # Update a group
+    # @note This method executes a <b>PUT</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId</i>
+    #
+    # @example Update the group "test" description from "foo" to "bar"
+    #   group = RubyProvisioningApi::Group.find("test") # => true
+    #   group.description # => "foo"
+    #   group.description = "bar" # => "bar"
+    #   group.update # => true
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#updating_a_group
+    # @return [Boolean] true if updated, false otherwise
+    # @raise [Error] if group does not exist
+    #
+    def update
+      save 
+    end
+
+    # Update attributes of a group 
+    # @param [Hash] params the options to update a Group
+    # @option params [String] :group_name Group name
+    # @option params [String] :description Group description 
+    # @option params [String] :email_permission Group permission: Owner or Member 
+    # @note This method executes a <b>PUT</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId</i>
+    #
+    # @example Update the group "test"
+    #   group = RubyProvisioningApi::Group.find("test")
+    #   group.update_attributes(:group_id => "foo", :group_name => "foo name" , :description => "bar", :email_permission => "Owner") # => true
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#updating_a_group
+    # @return [Boolean] true if updated, false if not valid or not updated
+    # @raise [Error] if group does not exist
+    #    
+    def update_attributes(params = {})
+      self.group_name = params[:group_name] if params[:group_name]
+      self.description = params[:description] if params[:description]
+      self.email_permission = params[:email_permission] if params[:email_permission]
+      update
+    end    
+
+    # Delete group  
+    # @note This method executes a <b>DELETE</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId </i>
+    #
+    # @example Delete the group "test"
+    #   group = RubyProvisioningApi::Group.find("test")
+    #   group.delete
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#deleting_a_group
+    # @return [Boolean] true if deleted, false otherwise
+    # @raise [Error] if group does not exist
+    # 
+    def delete
+      params = self.class.prepare_params_for(:delete, "groupId" => group_id)
+      # Perform the request & Check if the response contains an error
+      self.class.check_response(self.class.perform(params))
+    end
+
+    # Retrieve all groups for a given member 
+    # @param [String] member_id Member identification
+    # @note This method executes a <b>GET</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/?member=memberId[&directOnly=true|false]</i>
+    #
+    # @example Retrieve all groups for a member "foo"
+    #   groups = RubyProvisioningApi::Group.groups("foo") # => [Array<Group>]
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#retrieving_all_groups_for_a_member
+    # @return [Array<Group>] all groups for a given member
+    # @raise [Error] if member(user) does not exist
+    #
+    def self.groups(member_id)
+      params = prepare_params_for(:retrieve_groups, "memberId" => member_id)
+      response = perform(params)
+      # Perform the request & Check if the response contains an error
+      check_response(response)     
+      # Parse the response
+      xml = Nokogiri::XML(response.body)
+      # Prepare a Groups array
+      groups = []
+      xml.children.css("entry").each do |entry|
+        # Prepare a Group object
+        group = Group.new
+        GROUP_ATTRIBUTES.each do |attribute_name|
+          # Set group attributes
+          group.send("#{attribute_name.underscore}=", entry.css("apps|property[name='#{attribute_name}']").attribute("value").value)
+        end
+        # Fill groups array
+        groups << group
+      end
+      # Return the array of Groups
+      groups
+    end
+
+    # Add member to group 
+    # @param [String] member_id Member identification
+    # @note This method executes a <b>POST</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId/member </i>
+    #
+    # @example Add member "foo" to group "bar"
+    #   group = RubyProvisioningApi::Group.find("bar") # => [Group]
+    #   group.add_member("foo") # => [true]
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#adding_a_member_to_a_group
+    # @return [Boolean] true if added as a member, false otherwise
+    # @raise [Error] if member(user) does not exist
+    #
+    def add_member(member_id)
+      user = User.find(member_id)
+      # Creating the XML request
+      builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        xml.send(:'atom:entry', 'xmlns:atom' => 'http://www.w3.org/2005/Atom', 'xmlns:apps' => 'http://schemas.google.com/apps/2006') {
+          xml.send(:'atom:category', 'scheme' => 'http://schemas.google.com/g/2005#kind', 'term' => 'http://schemas.google.com/apps/2006#emailList')
+          xml.send(:'apps:property', 'name' => 'memberId', 'value' => member_id) 
+        }
+      end
+      params = self.class.prepare_params_for(:add_member, "groupId" => group_id)
+      # Perform the request & Check if the response contains an error
+      self.class.check_response(self.class.perform(params,builder.to_xml))  
+    end
+
+    # Group membership of a given member
+    # @param [String] member_id Member identification
+    # @note This method executes a <b>GET</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId/member/memberId</i>
+    #
+    # @example Check if user "foo" is member to the group "bar"
+    #   group = RubyProvisioningApi::Group.find("bar") # => [Group]
+    #   group.has_member?("foo") # => [true]
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#retrieving_all_members_of_a_group
+    # @return [Boolean] true if user is a member of the group
+    # @raise [Error] if member(user) does not exist
+    #
+    def has_member?(member_id)
+      params = self.class.prepare_params_for(:has_member, { "groupId" => group_id, "memberId" => member_id })
+      begin
+        # Perform the request & Check if the response contains an error
+        self.class.check_response(self.class.perform(params))
+      rescue
+        User.find(owner_id)
+        false
+      end    
+    end
+
+
+    # Delete group membership of a given member
+    # @param [String] member_id Member identification
+    # @note This method executes a <b>DELETE</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId/member/memberId</i>
+    #
+    # @example Delete user "foo" membership from group "bar"
+    #   group = RubyProvisioningApi::Group.find("bar") # => [Group]
+    #   group.delete_member("foo") # => [true]
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#deleting_member_from_an_group
+    # @return [Boolean] true if deleted, false otherwise
+    # @raise [Error] if member(user) does not exist
+    #
+    def delete_member(member_id)
+      params = self.class.prepare_params_for(:delete_member, { "groupId" => group_id, "memberId" => member_id })
+      # Perform the request & Check if the response contains an error
+      self.class.check_response(self.class.perform(params)) 
+    end
+
+    # Add owner to group 
+    # @param [String] owner_id Owner identification
+    # @note This method executes a <b>POST</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId/owner</i>
+    #
+    # @example Add owner "foo" to group "bar"
+    #   group = RubyProvisioningApi::Group.find("bar") # => [Group]
+    #   group.add_owner("foo") # => [true]
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#assigning_an_owner_to_a_group
+    # @return [Boolean] true if added as a owner, false otherwise
+    # @raise [Error] if owner(user) does not exist
+    #       
+    def add_owner(owner_id)
+      user = User.find(owner_id)
+      # Creating the XML request
+      builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        xml.send(:'atom:entry', 'xmlns:atom' => 'http://www.w3.org/2005/Atom', 'xmlns:apps' => 'http://schemas.google.com/apps/2006') {
+          xml.send(:'atom:category', 'scheme' => 'http://schemas.google.com/g/2005#kind', 'term' => 'http://schemas.google.com/apps/2006#emailList')
+          xml.send(:'apps:property', 'name' => 'email', 'value' => owner_id) 
+        }
+      end
+      params = self.class.prepare_params_for(:add_owner, "groupId" => group_id )
+      # Perform the request & Check if the response contains an error
+      self.class.check_response(self.class.perform(params,builder.to_xml))  
+    end
+
+    # Group ownership of a given owner
+    # @param [String] owner_id Owner identification
+    # @note This method executes a <b>GET</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId/owner/ownerEmail
+    # @example Check if user "foo" is owner to the group "bar"
+    #   group = RubyProvisioningApi::Group.find("bar") # => [Group]
+    #   group.has_owner?("foo") # => [true]
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#querying_if_a_user_or_group_is_owner
+    # @return [Boolean] true if user is a owner of the group, false otherwise
+    # @raise [Error] if owner(user) does not exist
+    #
+    def has_owner?(owner_id)
+      params = self.class.prepare_params_for(:has_owner, {"groupId" => group_id, "ownerId" => owner_id} )
+      begin
+        # Perform the request & Check if the response contains an error
+        self.class.check_response(self.class.perform(params))
+      rescue
+        User.find(owner_id)
+        false
+      end   
+    end
+
+
+    # Delete group ownership of a given owner
+    # @param [String] owner_id Owner identification
+    # @note This method executes a <b>DELETE</b> request to <i>apps-apis.google.com/a/feeds/group/2.0/domain/groupId/owner/ownerEmail</i>
+    #
+    # @example Delete user "foo" ownership from group "bar"
+    #   group = RubyProvisioningApi::Group.find("bar") # => [Group]
+    #   group.delete_owner("foo") # => [true]
+    #
+    # @see https://developers.google.com/google-apps/provisioning/#deleting_an_owner_from_a_group
+    # @return [Boolean] true if deleted, false otherwise
+    # @raise [Error] if owner(user) does not exist
+    #
+    def delete_owner(owner_id)
+      params = self.class.prepare_params_for(:delete_owner, {"groupId" => group_id, "ownerId" => owner_id} )
+      # Perform the request & Check if the response contains an error
+      self.class.check_response(self.class.perform(params))       
+    end
+
+  end
+end	
+
+
+