zimbra-soap-api 0.0.7.9

data/lib/zimbra/calendar.rb

@@ -0,0 +1,27 @@
+module Zimbra
+  class Calendar < Folder
+    class << self
+      def all
+        CalendarService.find_all_by_view('appointment').reject { |c| c.view.nil? || c.view != 'appointment' }
+      end
+    end
+    
+    def appointments
+      Zimbra::Appointment.find_all_by_calendar_id(id)
+    end
+  end
+  
+  class CalendarService < FolderService
+    def parse_xml_responses(xml)
+      Parser.get_all_response(xml)
+    end
+    
+    class Parser < Zimbra::FolderService::Parser
+      class << self
+        def initialize_from_attributes(folder_attributes)
+          Zimbra::Calendar.new(folder_attributes)
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/common_elements.rb

@@ -0,0 +1,51 @@
+module Zimbra
+  class A
+    class << self
+      def inject(xmldoc, name, value, extra_attributes = {})
+        new(name, value, extra_attributes).inject(xmldoc)
+      end
+      
+      def read(xmldoc, name)
+        nodes = (xmldoc/"//n2:a[@n='#{name}']")
+        return nil if nodes.nil?
+        if nodes.size > 1
+          nodes.map { |n| from_node(n, name).value }
+        else
+          from_node(nodes, name).value
+        end
+      end
+
+      def from_node(node, name)
+        new(name, node.to_s)
+      end
+    end
+
+    attr_accessor :name, :value, :extra_attributes
+
+    def initialize(name, value, extra_attributes = {})
+      self.name = name
+      self.value = value
+      self.extra_attributes = extra_attributes || {}
+    end
+
+    def inject(xmldoc)
+      xmldoc.add 'a', value do |a|
+        a.set_attr 'n', name
+        extra_attributes.each do |eaname, eavalue|
+          a.set_attr eaname, eavalue
+        end
+      end
+    end
+  end
+
+  class Boolean
+    def self.read(value)
+      case value
+      when 'TRUE' then true
+      when 'FALSE' then false
+      when true then true
+      else false
+      end
+    end
+  end
+end

data/lib/zimbra/cos.rb

@@ -0,0 +1,124 @@
+module Zimbra
+  class Cos
+    class << self
+      def find_by_id(id)
+        CosService.get_by_id(id)
+      end
+
+      def find_by_name(name)
+        CosService.get_by_name(name)
+      end
+
+      def create(name)
+        CosService.create(name)
+      end
+
+      def acl_name
+        'cos'
+      end
+    end
+
+    attr_accessor :id, :name, :acls
+
+    def initialize(id, name, acls = [])
+      self.id = id
+      self.name = name
+      self.acls = acls || []
+    end
+
+    def save
+      CosService.modify(self)
+    end
+    
+    def delete
+      CosService.delete(self)
+    end
+  end
+
+  class CosService < HandsoapService
+    def get_by_id(id)
+      response = invoke("n2:GetCosRequest") do |message|
+        Builder.get_by_id(message, id)
+      end
+      return nil if soap_fault_not_found?
+      Parser.cos_response(response/"//n2:cos")
+    end 
+
+    def get_by_name(name)
+      response = invoke("n2:GetCosRequest") do |message|
+        Builder.get_by_name(message, name)
+      end
+      return nil if soap_fault_not_found?
+      Parser.cos_response(response/"//n2:cos")
+    end 
+
+    def create(name)
+      response = invoke("n2:CreateCosRequest") do |message|
+        Builder.create(message, name)
+      end
+      Parser.cos_response(response/"//n2:cos")
+    end
+
+    def modify(cos)
+      xml = invoke("n2:ModifyCosRequest") do |message|
+        Builder.modify(message, cos)
+      end
+      Parser.cos_response(xml/'//n2:cos')
+    end 
+
+    def delete(cos)
+      xml = invoke("n2:DeleteCosRequest") do |message|
+        Builder.delete(message, cos)
+      end
+    end
+
+    class Builder
+      class << self
+        def get_by_id(message, id)
+          message.add 'cos', id do |c|
+            c.set_attr 'by', 'id'
+          end
+        end
+
+        def get_by_name(message, name)
+          message.add 'cos', name do |c|
+            c.set_attr "by", 'name'
+          end
+        end
+
+        def create(message, name)
+          message.add 'name', name
+        end
+
+        def modify(message, cos)
+          message.add 'id', cos.id
+          modify_attributes(message, cos)
+        end
+        def modify_attributes(message, cos)
+          if cos.acls.empty?
+            ACL.delete_all(message)
+          else
+            cos.acls.each do |acl|
+              acl.apply(message)
+            end
+          end
+        end
+
+        def delete(message, cos)
+          message.add 'id', cos.id
+        end
+      end
+    end
+
+    class Parser
+      class << self
+        def cos_response(node)
+          id = (node/'@id').to_s
+          name = (node/'@name').to_s
+          acls = Zimbra::ACL.read(node)
+          Zimbra::Cos.new(id, name, acls) 
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/delegate_auth_token.rb

@@ -0,0 +1,49 @@
+# http://files.zimbra.com/docs/soap_api/8.0.4/soap-docs-804/api-reference/zimbraAdmin/DelegateAuth.html
+
+module Zimbra
+  class DelegateAuthToken
+    class << self
+      def for_account_name(account_name)
+        DelegateAuthTokenService.get_by_account_name(account_name)
+      end
+    end
+
+    attr_accessor :account_name, :token, :lifetime
+
+    def initialize(args = {})
+      self.account_name = args[:account_name]
+      self.token = args[:token]
+      self.lifetime = args[:lifetime]
+    end
+  end
+  
+  class DelegateAuthTokenService < HandsoapService
+    def get_by_account_name(account_name)
+      xml = invoke("n2:DelegateAuthRequest") do |message|
+        Builder.get_by_account_name(message, account_name)
+      end
+      return nil unless xml
+      Parser.delegate_auth_token_response(account_name, xml)
+    end
+    
+    class Builder
+      class << self
+        def get_by_account_name(message, account_name)
+          message.add 'account', account_name do |c|
+            c.set_attr 'by', 'name'
+          end
+        end
+      end
+    end
+    class Parser
+      class << self
+        def delegate_auth_token_response(account_name, response)
+          auth_token = (response/'//n2:authToken').to_s
+          lifetime = (response/'//n2:lifetime').to_i
+          
+          Zimbra::DelegateAuthToken.new(account_name: account_name, token: auth_token, lifetime: lifetime) 
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/directory.rb

@@ -0,0 +1,175 @@
+module Zimbra
+  module Directory
+
+    TARGET_TYPES_MAPPING = {
+      Zimbra::Account => 'account',
+      Zimbra::DistributionList => 'dl',
+      Zimbra::Domain => 'domain'
+    }
+
+    class << self
+      # Run a search over the Ldap server of Zimbra
+      # query: is a valid LDAP search query
+      # types: a comma separated string of types of objects to look for
+      # domain: the email domain you want to limit the search to
+      # options[:limit]: max results of the search
+      # options[:offset]
+      # options[:sort_by]
+      # options[:sort_ascending]: 1=true , 0=false
+      def search(query = '', type: 'account', domain: nil, **options)
+        options[:limit] ||= 25
+        DirectoryService.search(query, type.to_sym, domain, options)
+      end
+
+      def add_grant(target, acl)
+        DirectoryService.add_grant(target.id, target.zimbra_type, acl)
+      end
+
+      def get_grants(target)
+        DirectoryService.get_grants(target.id, target.zimbra_type)
+      end
+
+      def revoke_grant(target, acl)
+        DirectoryService.revoke_grant(target.id, target.zimbra_type, acl)
+      end
+
+    end
+  end
+
+  class DirectoryService < HandsoapService
+    # This are the type off types (objects) that Zimbra has
+    # "distributionlists,aliases,accounts,dynamicgroups,resources,domains"
+    ZIMBRA_TYPES_HASH = {
+      distribution_list: { zimbra_type: 'distributionlists', node_name: 'dl', class: Zimbra::DistributionList },
+      distributionlist: { zimbra_type: 'distributionlists', node_name: 'dl', class: Zimbra::DistributionList },
+      #alias: { zimbra_type: 'aliases', node_name: 'alias', class: Zimbra::Alias },
+      account: { zimbra_type: 'accounts', node_name: 'account', class: Zimbra::Account },
+      domain: { zimbra_type: 'domains', node_name: 'domain', class: Zimbra::Domain }
+    }
+
+    def add_grant(id, type, acl)
+      xml = invoke("n2:GrantRightRequest") do |message|
+        Builder.add_grant(message, id, type, acl)
+      end
+      return nil if soap_fault_not_found?
+      true
+    end
+
+    def search(query, type, domain, options = {})
+      xml = invoke("n2:SearchDirectoryRequest") do |message|
+        Builder.search_directory(message, query, type, domain, options)
+      end
+      return nil if soap_fault_not_found?
+      Parser.search_directory_response(xml, type)
+    end
+
+    # method to get the grants on an object
+    # check https://files.zimbra.com/docs/soap_api/8.5.0/api-reference/zimbraAdmin/GetGrants.html
+    def get_grants(id, type)
+      xml = invoke('n2:GetGrantsRequest') do |message|
+        Builder.get_grants(message, id, type)
+      end
+      return nil if soap_fault_not_found?
+      Parser.get_grants_response(xml, type)
+    end
+
+    def revoke_grant(id, type, acl)
+      xml = invoke("n2:RevokeRightRequest") do |message|
+        Builder.revoke_grant(message, id, type, acl)
+      end
+      return nil if soap_fault_not_found?
+      true
+    end
+
+    module Builder
+      class << self
+        def search_directory(message, query, type, domain, options)
+          message.set_attr 'types', ZIMBRA_TYPES_HASH[type][:zimbra_type]
+          message.set_attr 'query', query
+          message.set_attr('domain', domain) if domain
+          message.set_attr('limit', options[:limit]) if options[:limit]
+          message.set_attr('offset', options[:offset]) if options[:offset]
+          message.set_attr('sort_by', options[:sort_by]) if options[:sort_by]
+          message.set_attr('sort_ascending', options[:sort_ascending]) if options[:sort_ascending]
+        end
+
+        def get_grants(message, id, type)
+          message.add 'target', id do |c|
+            c.set_attr 'by', 'id'
+            c.set_attr 'type', type
+          end
+        end
+
+        def add_grant(message, id, type, acl)
+          message.add 'target', id do |c|
+            c.set_attr 'by', 'id'
+            c.set_attr 'type', type
+          end
+          message.add 'grantee', acl.grantee_name do |grantee|
+            grantee.set_attr 'by', 'name'
+            grantee.set_attr 'type', acl.grantee_class.acl_name
+          end
+          message.add 'right', acl.name
+        end
+
+        def revoke_grant(message, id, type, acl)
+          message.add 'target', id do |c|
+            c.set_attr 'by', 'id'
+            c.set_attr 'type', type
+          end
+          message.add 'grantee', acl.grantee_name do |grantee|
+            grantee.set_attr 'by', 'name'
+            grantee.set_attr 'type', acl.grantee_class.acl_name
+          end
+          message.add 'right', acl.name
+        end
+
+      end
+    end
+
+    module Parser
+      class << self
+        def search_directory_response(response, type)
+          # look for the node given by the type
+          items = (response/"//n2:#{ZIMBRA_TYPES_HASH[type][:node_name]}")
+          items.map { |i| object_list_response(i, type) }
+        end
+
+        def get_grants_response(response, type)
+          result = []
+          grants = (response/"//n2:grant")
+          grants.each do |n|
+            hash = {}
+            hash[:grantee_id] = (n/'n2:grantee'/'@id').to_s
+            hash[:grantee_class] = Zimbra::ACL::TARGET_MAPPINGS[(n/'n2:grantee'/'@type').to_s]
+            hash[:grantee_name] = (n/'n2:grantee'/'@name').to_s
+            hash[:name] = (n/'n2:right').to_s
+            result << Zimbra::ACL.new(hash)
+          end
+          result
+        end
+
+        # This just call the parser_response method of the object
+        # in the case of the account type, it will call
+        # Zimbra::AccountService::Parser.account_response(node)
+        def object_list_response(node, type)
+          node = clean_node node
+          class_name = ZIMBRA_TYPES_HASH[type][:class].name.gsub(/Zimbra::/, '')
+          Zimbra::BaseService::Parser.response(class_name, node, true)
+        end
+
+        # This method is to erase all others nodes from document
+        # so the xpath search like (//xxxx) works, beacuse (//) always start
+        # at the beginning of the document, not the current element
+        def clean_node(node)
+          element = node.instance_variable_get("@element")
+          directory_response = element.document.css("n2|SearchDirectoryResponse", 'n2' => 'urn:zimbraAdmin').first
+          directory_response.children.each {|c| c.remove}
+          directory_response.add_child element
+          node
+        end
+
+      end
+    end
+  end
+end

data/lib/zimbra/distribution_list.rb

@@ -0,0 +1,147 @@
+module Zimbra
+  class DistributionList < Zimbra::Base
+    class << self
+      def acl_name
+        'grp'
+      end
+    end
+
+    attr_accessor :id, :name, :admin_console_ui_components, :admin_group
+    attr_accessor :members, :restricted, :display_name, :cn, :mail
+
+    def initialize(id, name, zimbra_attrs = {}, node = nil)
+      super
+      @cn = zimbra_attrs['cn']
+      @display_name = zimbra_attrs['displayName']
+      self.admin_group = zimbra_attrs['zimbraIsAdminGroup']
+      @members = Zimbra::DistributionListService::Parser.get_members node
+      @restricted = !acls.nil?
+      @original_members = self.members.dup
+    end
+
+    def admin_console_ui_components
+      @admin_console_ui_components ||= []
+    end
+
+    def modify_members(members_group = [])
+      return unless members_group.any?
+      self.members = members_group
+      DistributionListService.modify_members(self)
+    end
+
+    def members
+      @members ||= []
+    end
+
+    def new_members
+      self.members - @original_members
+    end
+
+    def removed_members
+      @original_members - self.members
+    end
+
+    def admin_group=(val)
+      @admin_group = Zimbra::Boolean.read(val)
+    end
+    def admin_group?
+      @admin_group
+    end
+
+    def restricted?
+      @restricted
+    end
+
+    def add_alias(alias_name)
+      DistributionListService.add_alias(self,alias_name)
+    end
+
+    def save
+      DistributionListService.modify(self)
+    end
+  end
+
+  class DistributionListService < HandsoapService
+    def create(name)
+      xml = invoke("n2:CreateDistributionListRequest") do |message|
+        Builder.create(message, name)
+      end
+      Parser.distribution_list_response(xml/'//n2:dl')
+    end
+
+    def modify_members(distribution_list)
+      distribution_list.new_members.each do |member|
+        add_member(distribution_list, member)
+      end
+      distribution_list.removed_members.each do |member|
+        remove_member(distribution_list, member)
+      end
+      return true
+    end
+
+    def add_member(distribution_list, member)
+      xml = invoke("n2:AddDistributionListMemberRequest") do |message|
+        Builder.add_member(message, distribution_list.id, member)
+      end
+    end
+
+    def remove_member(distribution_list, member)
+      xml = invoke("n2:RemoveDistributionListMemberRequest") do |message|
+        Builder.remove_member(message, distribution_list.id, member)
+      end
+    end
+
+    def add_alias(distribution_list,alias_name)
+      xml = invoke('n2:AddDistributionListAliasRequest') do |message|
+        Builder.add_alias(message,distribution_list.id,alias_name)
+      end
+    end
+
+    module Builder
+      class << self
+        def modify_admin_console_ui_components(message, distribution_list)
+          if distribution_list.admin_console_ui_components.empty?
+            A.inject(message, 'zimbraAdminConsoleUIComponents', '')
+          else
+            distribution_list.admin_console_ui_components.each do |component|
+              A.inject(message, 'zimbraAdminConsoleUIComponents', component)
+            end
+          end
+        end
+
+        def modify_is_admin_group(message, distribution_list)
+          A.inject(message, 'zimbraIsAdminGroup', (distribution_list.admin_group? ? 'TRUE' : 'FALSE'))
+        end
+
+        def add_member(message, distribution_list_id, member)
+          message.add 'id', distribution_list_id
+          message.add 'dlm', member
+        end
+
+        def remove_member(message, distribution_list_id, member)
+          message.add 'id', distribution_list_id
+          message.add 'dlm', member
+        end
+
+        def add_alias(message,id,alias_name)
+          message.add 'id', id
+          message.add 'alias', alias_name
+        end
+      end
+    end
+
+    # Doc Placeholder
+    module Parser
+      class << self
+        def get_members(node)
+          # Return this if we are getting here by find_by_*
+          return (node/"//n2:dlm").map(&:to_s).compact if (node/"//n2:dlm").any?
+
+          # Return this if we get here by DirectorySearch
+          fwds = A.read(node, 'zimbraMailForwardingAddress')
+          fwds.is_a?(Array) ? fwds.map(&:to_s).compact : [fwds].compact
+        end
+      end
+    end
+  end
+end