zimbra-soap-api 0.0.7.9

data/lib/zimbra/domain.rb

@@ -0,0 +1,63 @@
+module Zimbra
+  class Domain < Zimbra::Base
+    class << self
+      def acl_name
+        'domain'
+      end
+    end
+
+    def count_accounts
+      DomainService.count_accounts(id)
+    end
+
+    def save
+      DomainService.modify(self)
+    end
+
+  end
+
+  class DomainService < HandsoapService
+
+    def count_accounts(id)
+      xml = invoke("n2:CountAccountRequest") do |message|
+        Builder.count_accounts(message, id)
+      end
+      Parser.count_accounts_response(xml)
+    end
+
+    def delete
+      xml = invoke("n2:DeleteDomainRequest") do |message|
+        Builder.delete(message, id)
+      end
+    end
+
+    class Builder
+      class << self
+        
+
+        def count_accounts(message, id)
+          message.add 'domain', id do |c|
+            c.set_attr 'by', 'id'
+          end
+        end
+
+        def delete(message, id)
+          message.add 'id', id
+        end
+      end
+    end
+    class Parser
+      class << self
+        def count_accounts_response(response)
+          hash = {}
+          (response/"//n2:cos").map do |node|
+            cos_id = (node/'@id').to_s
+            hash[cos_id] = node.to_s.to_i
+          end
+          hash
+        end
+
+      end
+    end
+  end
+end

data/lib/zimbra/ext/handsoap_curb_driver.rb

@@ -0,0 +1,21 @@
+class Handsoap::Http::Drivers::CurbDriver
+  def get_curl(url)
+    if @curl
+      @curl.url = url
+    else
+      @curl                 = ::Curl::Easy.new(url)
+      @curl.timeout         = Handsoap.timeout
+      @curl.enable_cookies  = @enable_cookies
+
+      # enables both deflate and gzip compression of responses
+      @curl.encoding = ''
+
+      if Handsoap.follow_redirects?
+        @curl.follow_location = true
+          @curl.max_redirects = Handsoap.max_redirects
+        end
+      end
+    @curl.ssl_verify_peer = false
+    @curl
+  end
+end

data/lib/zimbra/ext/hash.rb

@@ -0,0 +1,72 @@
+module Zimbra
+  class Hash < ::Hash
+    # Thanks to https://gist.github.com/dimus/335286 for this code
+    
+    class << self
+      def symbolize_keys(hash, recursive = false)
+        hash.keys.each do |key|
+          value = hash.delete(key)
+          key = key.respond_to?(:to_sym) ? key.to_sym : key
+          hash[key] = (recursive && value.is_a?(::Hash)) ? symbolize_keys(value.dup, recursive) : value
+        end
+        hash
+      end
+      
+      def from_xml(xml_io) 
+        begin
+          result = Nokogiri::XML(xml_io)
+          return { result.root.name.to_sym => xml_node_to_hash(result.root)} 
+        rescue Exception => e
+          # raise your custom exception here
+        end
+      end 
+ 
+      def xml_node_to_hash(node) 
+        # If we are at the root of the document, start the hash 
+        if node.element?
+          result_hash = {}
+          if node.attributes != {}
+            result_hash[:attributes] = {}
+            node.attributes.keys.each do |key|
+              result_hash[:attributes][node.attributes[key].name.to_sym] = prepare(node.attributes[key].value)
+            end
+          end
+          if node.children.size > 0
+            node.children.each do |child| 
+              result = xml_node_to_hash(child) 
+ 
+              if child.name == "text"
+                unless child.next_sibling || child.previous_sibling
+                  if result_hash[:attributes]
+                    result_hash['value'] = prepare(result)
+                    return result_hash
+                  else 
+                    return prepare(result)
+                  end 
+                end
+              elsif result_hash[child.name.to_sym]
+                if result_hash[child.name.to_sym].is_a?(Object::Array)
+                  result_hash[child.name.to_sym] << prepare(result)
+                else
+                  result_hash[child.name.to_sym] = [result_hash[child.name.to_sym]] << prepare(result)
+                end
+              else 
+                result_hash[child.name.to_sym] = prepare(result)
+              end
+            end
+ 
+            return result_hash 
+          else 
+            return result_hash
+          end 
+        else 
+          return prepare(node.content.to_s) 
+        end 
+      end          
+ 
+      def prepare(data)
+        (data.class == String && data.to_i.to_s == data) ? data.to_i : data
+      end
+    end
+  end
+end

data/lib/zimbra/ext/string.rb

@@ -0,0 +1,10 @@
+module Zimbra
+  class String < ::String
+
+    class << self
+      def camel_case_lower(string)
+        string.split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
+      end
+    end
+  end
+end

data/lib/zimbra/extra/date_helpers.rb

@@ -0,0 +1,111 @@
+module Zimbra
+  class DateHelpers
+    class Frequency
+      FREQUENCIES = [
+        { name: :secondly, zimbra_name: 'SEC', abbreviations: [] },
+        { name: :minutely, zimbra_name: 'MIN', abbreviations: [] },
+        { name: :hourly,   zimbra_name: 'HOU', abbreviations: [] },
+        { name: :daily,    zimbra_name: 'DAI', abbreviations: [] },
+        { name: :weekly,   zimbra_name: 'WEE', abbreviations: [] },
+        { name: :monthly,  zimbra_name: 'MON', abbreviations: [] },
+        { name: :yearly,   zimbra_name: 'YEA', abbreviations: [] }
+      ]
+      
+      class << self
+        def all
+          @all ||= FREQUENCIES.inject([]) do |frequencies, data|
+            frequencies << new(data)
+          end
+        end
+        
+        def find(name_or_abbreviation)
+          all.find { |frequency| frequency.match?(name_or_abbreviation) }
+        end
+      end
+      
+      attr_accessor :name, :zimbra_name, :abbreviations
+      
+      def initialize(args = {})
+        @name = args[:name]
+        @zimbra_name = args[:zimbra_name]
+        @abbreviations = args[:abbreviations]
+      end
+      
+      def match?(name_or_abbreviation)
+        downcased_matcher = name_or_abbreviation.to_s.downcase
+        ([name.to_s, zimbra_name.to_s] + abbreviations).map(&:downcase).include?(downcased_matcher)
+      end
+      
+      def to_sym
+        name.downcase.to_sym
+      end
+    end
+    
+    class WeekDay
+      WEEK_DAYS = [
+        {
+          id: 1, name: :Sunday, zimbra_name: 'SU',
+          abbreviations: ['su', 'sun']
+        },
+        {
+          id: 2, name: :Monday, zimbra_name: 'MO', 
+          abbreviations: ['mo', 'mon']
+        },
+        {
+          id: 3, name: :Tuesday, zimbra_name: 'TU', 
+          abbreviations: ['tu', 'tue']
+        },
+        {
+          id: 4, name: :Wednesday, zimbra_name: 'WE', 
+          abbreviations: ['we', 'wed']
+        },
+        {
+          id: 5, name: :Thursday, zimbra_name: 'TH', 
+          abbreviations: ['th', 'thu', 'thur', 'thurs']
+        },
+        {
+          id: 6, name: :Friday, zimbra_name: 'FR', 
+          abbreviations: ['fr', 'fri']
+        },
+        {
+          id: 7, name: :Saturday, zimbra_name: 'SA', 
+          abbreviations: ['sa', 'sat']
+        }
+      ] unless const_defined?(:WEEK_DAYS)
+      
+      class << self
+        def all
+          @all ||= WEEK_DAYS.inject([]) do |week_days, data|
+            week_days << new(data)
+          end
+        end
+        
+        def find(id_name_or_abbreviation)
+          all.find { |week_day| week_day.match?(id_name_or_abbreviation) }
+        end
+      end
+      
+      attr_accessor :id, :name, :abbreviations, :zimbra_name
+      
+      def initialize(args = {})
+        @id = args[:id]
+        @name = args[:name]
+        @zimbra_name = args[:zimbra_name]
+        @abbreviations = args[:abbreviations]
+      end
+      
+      def match?(id_name_or_abbreviation)
+        if id_name_or_abbreviation.is_a?(Fixnum)
+          id_name_or_abbreviation == id
+        else
+          downcased_matcher = id_name_or_abbreviation.to_s.downcase
+          ([name.to_s, zimbra_name.to_s] + abbreviations).map(&:downcase).include?(downcased_matcher)
+        end
+      end
+      
+      def to_sym
+        name.downcase.to_sym
+      end
+    end
+  end
+end

data/lib/zimbra/folder.rb

@@ -0,0 +1,100 @@
+# http://files.zimbra.com/docs/soap_api/8.0.4/soap-docs-804/api-reference/zimbraMail/GetFolder.html
+module Zimbra
+  class Folder
+    class << self
+      def all
+        FolderService.all
+      end
+
+      def find_all_by_view(view)
+        FolderService.find_all_by_view(view)
+      end
+    end
+    
+    ATTRS = [
+      :id, :uuid, :name, :view, :absolute_folder_path,
+      :parent_folder_id, :parent_folder_uuid,
+      :non_folder_item_count, :non_folder_item_size,
+      :revision, :imap_next_uid, :imap_modified_sequence, :modified_sequence, :activesync_disabled,
+      :modified_date
+    ] unless const_defined?(:ATTRS)
+    
+    attr_accessor *ATTRS
+    
+    def initialize(args = {})
+      self.attributes = args
+    end
+    
+    def attributes=(args = {})
+      ATTRS.each do |attr_name|
+        self.send(:"#{attr_name}=", (args[attr_name] || args[attr_name.to_s])) if args.has_key?(attr_name) || args.has_key?(attr_name.to_s)
+      end
+    end
+  end
+  
+  class FolderService < HandsoapAccountService
+    def all
+      xml = invoke("n2:GetFolderRequest")
+      parse_xml_responses(xml)
+    end
+    
+    def find_all_by_view(view)
+      xml = invoke("n2:GetFolderRequest") do |message|
+        Builder.find_all_by_view(message, view)
+      end
+      parse_xml_responses(xml)
+    end
+    
+    def parse_xml_responses(xml)
+      Parser.get_all_response(xml)
+    end
+
+    class Builder
+      class << self
+        def find_all_by_view(message, view)
+          message.set_attr 'view', view
+        end
+      end
+    end
+    
+    class Parser
+      ATTRIBUTE_MAPPING = {
+        :id => :id, 
+        :uuid => :uuid, 
+        :name => :name, 
+        :view => :view, 
+        :absFolderPath => :absolute_folder_path, 
+        :l => :parent_folder_id, 
+        :luuid => :parent_folder_uuid, 
+        :n => :non_folder_item_count, 
+        :s => :non_folder_item_size, 
+        :rev => :revision, 
+        :i4next => :imap_next_uid, 
+        :i4ms => :imap_modified_sequence, 
+        :ms => :modified_sequence, 
+        :activesyncdisabled => :activesync_disabled, 
+        :md => :modified_date
+      }
+      
+      class << self
+        def get_all_response(response)
+          (response/"//n2:folder").map do |node|
+            folder_response(node)
+          end
+        end
+
+        def folder_response(node)
+          folder_attributes = ATTRIBUTE_MAPPING.inject({}) do |attrs, (xml_name, attr_name)|
+            attrs[attr_name] = (node/"@#{xml_name}").to_s
+            attrs
+          end
+          initialize_from_attributes(folder_attributes)
+        end
+
+        def initialize_from_attributes(folder_attributes)
+          Zimbra::Folder.new(folder_attributes)
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/handsoap_account_service.rb

@@ -0,0 +1,44 @@
+require 'handsoap'
+
+module Zimbra
+  module HandsoapAccountNamespaces
+    def request_namespaces(doc)
+      doc.alias 'n1', "urn:zimbra"
+      doc.alias 'n2', "urn:zimbraMail"
+      doc.alias 'env', 'http://schemas.xmlsoap.org/soap/envelope/'
+    end
+    def response_namespaces(doc)
+      doc.add_namespace 'n2', "urn:zimbraMail"
+    end
+  end
+  
+  module HandsoapAccountUriOverrides
+    def uri
+      Zimbra.account_api_url
+    end
+    def envelope_namespace
+      'http://www.w3.org/2003/05/soap-envelope'
+    end
+    def request_content_type
+      "application/soap+xml"
+    end
+  end
+
+  class HandsoapAccountService < Handsoap::Service
+    include HandsoapErrors
+    include HandsoapAccountNamespaces
+    extend HandsoapAccountUriOverrides
+
+    def on_create_document(doc)
+      request_namespaces(doc)
+      header = doc.find("Header")
+      header.add "n1:context" do |s|
+        s.set_attr "env:mustUnderstand", "0"
+        s.add "n1:authToken", Zimbra.account_auth_token
+      end
+    end
+    def on_response_document(doc)
+      response_namespaces(doc)
+    end
+  end
+end

data/lib/zimbra/handsoap_service.rb

@@ -0,0 +1,75 @@
+require 'handsoap'
+
+module Zimbra
+  module HandsoapErrors
+    class SOAPFault < StandardError; end
+    class NotFound < StandardError; end
+    class NotImplemented < StandardError; end
+
+    @@response = nil
+
+    def on_http_error(response)
+      @@response = response
+      return nil if soap_fault_not_found?
+      report_error(response) if http_error?
+    end
+    def report_error(response)
+      message = response.body.scan(/<faultstring>(.*)<\/faultstring>/).first.first
+      raise SOAPFault, message
+    end
+    def on_after_create_http_request(request)
+      @@response = nil
+    end
+
+    def soap_fault_not_found?
+      @@response && @@response.body =~ /no such/
+    end
+    def http_error?
+      @@response && (500..599).include?(@@response.status)
+    end
+    def http_not_found?
+      @@response && (400..499).include?(@@response.status)
+    end
+  end
+
+  module HandsoapNamespaces
+    def request_namespaces(doc)
+      doc.alias 'n1', "urn:zimbra"
+      doc.alias 'n2', "urn:zimbraAdmin"
+      doc.alias 'env', 'http://schemas.xmlsoap.org/soap/envelope/'
+    end
+    def response_namespaces(doc)
+      doc.add_namespace 'n2', "urn:zimbraAdmin"
+    end
+  end
+
+  module HandsoapUriOverrides
+    def uri
+      Zimbra.admin_api_url
+    end
+    def envelope_namespace
+      'http://www.w3.org/2003/05/soap-envelope'
+    end
+    def request_content_type
+      "application/soap+xml"
+    end
+  end
+
+  class HandsoapService < Handsoap::Service
+    include HandsoapErrors
+    include HandsoapNamespaces
+    extend HandsoapUriOverrides
+
+    def on_create_document(doc)
+      request_namespaces(doc)
+      header = doc.find("Header")
+      header.add "n1:context" do |s|
+        s.set_attr "env:mustUnderstand", "0"
+        s.add "n1:authToken", Zimbra.auth_token
+      end
+    end
+    def on_response_document(doc)
+      response_namespaces(doc)
+    end
+  end
+end