zimbra-soap-api 0.0.7.9

data/lib/zimbra/appointment/recur_exception.rb

@@ -0,0 +1,83 @@
+module Zimbra
+  class Appointment
+    class RecurException
+      class << self
+        def new_from_zimbra_attributes(zimbra_attributes)
+          return nil unless zimbra_attributes
+          new(parse_zimbra_attributes(zimbra_attributes))
+        end
+        
+        def parse_zimbra_attributes(zimbra_attributes)
+          zimbra_attributes = Zimbra::Hash.symbolize_keys(zimbra_attributes.dup, true)
+
+          {
+            :recurrence_id => zimbra_attributes[:d],
+            :timezone => zimbra_attributes[:tz],
+            :range_type => zimbra_attributes[:rangeType]
+          }
+        end
+      end
+      
+      ATTRS = [
+        :recurrence_id,
+        :timezone,
+        :range_type
+      ] unless const_defined?(:ATTRS)
+      
+      attr_accessor *ATTRS
+    
+      def range_type=(val)
+        @range_type = parse_range_type(val)
+      end
+    
+      def initialize(args = {})
+        self.attributes = args
+      end
+    
+      # take attributes by the xml name or our more descriptive name
+      def attributes=(args = {})
+        ATTRS.each do |attr_name|
+          self.send(:"#{attr_name}=", (args[attr_name] || args[attr_name.to_s]))
+        end
+      end
+      
+      def to_hash(options = {})
+        hash = ATTRS.inject({}) do |attr_hash, attr_name|
+          attr_hash[attr_name] = self.send(:"#{attr_name}")
+          attr_hash
+        end
+        hash.reject! { |key, value| options[:except].include?(key.to_sym) || options[:except].include?(key.to_s) } if options[:except]
+        hash.reject! { |key, value| !options[:only].include?(key.to_sym) && !options[:only].include?(key.to_s) } if options[:only]
+        hash
+      end
+      
+      def range_type_to_zimbra
+        possible_range_type_values.find { |k, v| v == range_type }.first rescue range_type
+      end
+      
+      def create_xml(document)
+        document.add "exceptId" do |except_element|
+          except_element.set_attr "d", recurrence_id
+          except_element.set_attr "tz", timezone
+          except_element.set_attr "rangeType", range_type_to_zimbra if range_type
+        end
+      end
+      
+      private
+      
+      def possible_range_type_values
+        @possible_range_type_values ||= {
+          1 => :none,
+          2 => :this_and_future,
+          3 => :this_and_prior
+        }
+      end
+      
+      def parse_range_type(val)
+        int_val = val.to_int rescue nil
+        
+        possible_range_type_values[int_val] || val
+      end
+    end
+  end
+end

data/lib/zimbra/appointment/recur_rule.rb

@@ -0,0 +1,184 @@
+module Zimbra
+  class Appointment
+    class RecurRule
+      class << self
+        def new_from_zimbra_attributes(zimbra_attributes)
+          return nil unless zimbra_attributes
+          new(parse_zimbra_attributes(zimbra_attributes))
+        end
+        
+        def parse_zimbra_attributes(zimbra_attributes)
+          attrs = {}
+          
+          zimbra_attributes = Zimbra::Hash.symbolize_keys(zimbra_attributes.dup, true)
+          zimbra_attributes = zimbra_attributes[:add][:rule]
+          
+          attrs[:frequency] = zimbra_attributes[:attributes][:freq] if zimbra_attributes[:attributes]
+          attrs[:until_date] = zimbra_attributes[:until][:attributes][:d] if zimbra_attributes[:until]
+          attrs[:interval] = zimbra_attributes[:interval][:attributes][:ival] if zimbra_attributes[:interval]
+          attrs[:count] = zimbra_attributes[:count][:attributes][:num] if zimbra_attributes[:count]
+          
+          if zimbra_attributes[:bysetpos]
+            attrs[:by_set_position] = zimbra_attributes[:bysetpos][:attributes][:poslist]
+            attrs[:by_set_position] = [attrs[:by_set_position]] unless attrs[:by_set_position].is_a?(Array)
+          end
+          
+          if zimbra_attributes[:byday] && zimbra_attributes[:byday][:wkday] && zimbra_attributes[:byday][:wkday].is_a?(Array)
+            attrs[:by_day] = zimbra_attributes[:byday][:wkday].collect do |wkday|
+              wkday = Zimbra::Hash.symbolize_keys(wkday, true)
+              wkday_hash = { day: wkday[:attributes][:day] }
+              wkday_hash[:week_number] = wkday[:attributes][:ordwk] if wkday[:attributes][:ordwk]
+              wkday_hash
+            end
+          elsif zimbra_attributes[:byday] && zimbra_attributes[:byday][:wkday]
+            day_hash = { day: zimbra_attributes[:byday][:wkday][:attributes][:day] }
+            day_hash[:week_number] = zimbra_attributes[:byday][:wkday][:attributes][:ordwk] if zimbra_attributes[:byday][:wkday][:attributes][:ordwk]
+            attrs[:by_day] = [day_hash]
+          end
+
+          if zimbra_attributes[:bymonth]
+            attrs[:by_month] = zimbra_attributes[:bymonth][:attributes][:molist]
+            attrs[:by_month] = [attrs[:by_month]] unless attrs[:by_month].is_a?(Array)
+          end
+          
+          if zimbra_attributes[:bymonthday]
+            attrs[:by_month_day] = zimbra_attributes[:bymonthday][:attributes][:modaylist]
+            attrs[:by_month_day] = [attrs[:by_month_day]] unless attrs[:by_month_day].is_a?(Array)
+          end
+          
+          attrs
+        end
+      end
+      
+      ATTRS = [
+        :frequency,
+        :interval,
+        :by_day,
+        :by_month,
+        :by_month_day,
+        :count,
+        :until_date,
+        :by_set_position
+      ] unless const_defined?(:ATTRS)
+      
+      attr_accessor *ATTRS
+    
+      def initialize(args = {})
+        self.attributes = args
+      end
+    
+      # take attributes by the xml name or our more descriptive name
+      def attributes=(args = {})
+        ATTRS.each do |attr_name|
+          if args.has_key?(attr_name)
+            self.send(:"#{attr_name}=", args[attr_name])
+          elsif args.has_key?(attr_name.to_s)
+            self.send(:"#{attr_name}=", args[attr_name.to_s])
+          end
+        end
+      end
+      
+      def frequency=(val)
+        frequency = Zimbra::DateHelpers::Frequency.find(val).name
+        @frequency = frequency || val
+      end
+      
+      def frequency_to_zimbra
+        Zimbra::DateHelpers::Frequency.find(frequency).zimbra_name rescue frequency
+      end
+      
+      def until_date=(val)
+        @until_date = Time.parse(val) rescue val
+      end
+      
+      def by_set_position=(val)
+        if val == [0]
+          @by_set_position = nil
+        else
+          @by_set_position = val
+        end
+      end
+      def by_day=(val)
+        @by_day = if val.is_a?(Array)
+          val.collect do |day_specification|
+            day_specification[:day] = Zimbra::DateHelpers::WeekDay.find(day_specification[:day]) rescue day_specification[:day]
+            day_specification
+          end
+        else
+          val
+        end
+      end
+      
+      def to_hash(options = {})
+        hash = {
+          :frequency => frequency ? frequency.to_sym : nil,
+          :interval => interval,
+          :by_month => by_month,
+          :by_month_day => by_month_day,
+          :count => count,
+          :until_date => until_date,
+          :by_set_position => by_set_position
+        }
+        hash[:by_day] = by_day.collect do |day_specification|
+          day_specification[:day] = day_specification[:day].to_sym if day_specification[:day]
+          day_specification
+        end if by_day
+        hash.reject! { |key, value| value.nil? }
+        hash.reject! { |key, value| options[:except].include?(key.to_sym) || options[:except].include?(key.to_s) } if options[:except]
+        hash.reject! { |key, value| !options[:only].include?(key.to_sym) && !options[:only].include?(key.to_s) } if options[:only]
+        hash
+      end
+      
+      def create_xml(document)
+        document.add "rule" do |rule_element|
+          rule_element.set_attr "freq", frequency_to_zimbra
+          
+          if until_date
+            rule_element.add "until" do |until_element|
+              until_element.set_attr "d", until_date.utc.strftime("%Y%m%dT%H%M%SZ")
+            end
+          end
+          
+          rule_element.add "interval" do |interval_element|
+            interval_element.set_attr "ival", interval
+          end
+          
+          if count && count > 0
+            rule_element.add "count" do |count_element|
+              count_element.set_attr "num", count
+            end
+          end
+          
+          if by_day && by_day.count > 0
+            rule_element.add "byday" do |by_day_element|
+              by_day.each do |day_spec|
+                by_day_element.add "wkday" do |wkday_element|
+                  wkday_element.set_attr "day", day_spec[:day].zimbra_name
+                  wkday_element.set_attr "ordwk", day_spec[:week_number] if day_spec.has_key?(:week_number)
+                end
+              end
+            end
+          end
+          
+          if by_month && by_month.count > 0
+            rule_element.add "bymonth" do |by_month_element|
+              by_month_element.set_attr "molist", by_month.join(',')
+            end
+          end
+          
+          if by_month_day && by_month_day.count > 0
+            rule_element.add "bymonthday" do |by_month_day_element|
+              by_month_day_element.set_attr "modaylist", by_month_day.join(',')
+            end
+          end
+          
+          if by_set_position
+            rule_element.add "bysetpos" do |bysetpos_element|
+              bysetpos_element.set_attr "poslist", by_set_position.join(',')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/appointment/reply.rb

@@ -0,0 +1,91 @@
+module Zimbra
+  class Appointment
+    class Reply
+      ATTRS = [
+        :sequence_number, :date, :email_address, :participation_status, :sent_by, :recurrence_range_type, :recurrence_id, :timezone, :recurrence_id_utc
+      ] unless const_defined?(:ATTRS)
+      
+      attr_accessor *ATTRS
+      
+      class << self
+        def new_from_zimbra_attributes(zimbra_attributes)
+          new(parse_zimbra_attributes(zimbra_attributes))
+        end
+        
+        def parse_zimbra_attributes(zimbra_attributes)
+          zimbra_attributes = Zimbra::Hash.symbolize_keys(zimbra_attributes.dup, true)
+          
+          {
+            :sequence_number       => zimbra_attributes[:seq],
+            :date                  => zimbra_attributes[:d],
+            :email_address         => zimbra_attributes[:at],
+            :participation_status  => zimbra_attributes[:ptst],
+            :sent_by               => zimbra_attributes[:sentBy],
+            :recurrence_range_type => zimbra_attributes[:rangeType],
+            :recurrence_id         => zimbra_attributes[:recurId],
+            :timezone              => zimbra_attributes[:tz],
+            :recurrence_id_utc     => zimbra_attributes[:ridZ]
+          }
+        end
+      end
+    
+      def initialize(args = {})
+        self.attributes = args
+      end
+    
+      # take attributes by the xml name or our more descriptive name
+      def attributes=(args = {})
+        ATTRS.each do |attr_name|
+          if args.has_key?(attr_name)
+            self.send(:"#{attr_name}=", args[attr_name])
+          elsif args.has_key?(attr_name.to_s)
+            self.send(:"#{attr_name}=", args[attr_name.to_s])
+          end
+        end
+      end
+      
+      def participation_status=(val)
+        @participation_status = parse_participation_status(val)
+      end
+    
+      def date=(val)
+        if val.is_a?(Integer)
+          @date = parse_date_in_seconds(val)
+        else
+          @date = val
+        end
+      end
+      
+      def to_hash(options = {})
+        hash = ATTRS.inject({}) do |hash, attr_name|
+          hash[attr_name] = self.send(attr_name)
+          hash
+        end
+        hash.reject! { |key, value| options[:except].include?(key.to_sym) || options[:except].include?(key.to_s) } if options[:except]
+        hash.reject! { |key, value| !options[:only].include?(key.to_sym) && !options[:only].include?(key.to_s) } if options[:only]
+        hash
+      end
+    
+      private
+    
+      def parse_participation_status(status)
+        possible_values = {
+          'NE' => :needs_action,
+          'AC' => :accept,
+          'TE' => :tentative,
+          'DE' => :declined,
+          'DG' => :delegated,
+          'CO' => :completed,
+          'IN' => :in_process,
+          'WE' => :waiting, 
+          'DF' => :deferred
+        }
+        possible_values[status] || status
+      end
+
+      def parse_date_in_seconds(seconds)
+        Time.at(seconds / 1000)
+      end
+    end
+  end
+end

data/lib/zimbra/auth.rb

@@ -0,0 +1,46 @@
+module Zimbra
+  class Auth
+    def self.login(username, password)
+      AuthService.login(username, password)
+    end
+  end
+
+  class AuthService < Handsoap::Service
+    include HandsoapErrors
+    include Zimbra::HandsoapNamespaces
+    extend HandsoapUriOverrides
+
+    def on_create_document(doc)
+      request_namespaces(doc)
+    end
+    def on_response_document(doc)
+      response_namespaces(doc)
+    end
+
+    def login(username, password)
+      xml = invoke('n2:AuthRequest') do |message|
+        Builder.auth(message, username, password)
+      end
+      [Parser.auth_token(xml), Parser.session_lifetime(xml)]
+    end
+
+    class Builder
+      class << self
+        def auth(message, username, password)
+          message.add 'name', username
+          message.add 'password', password
+        end
+      end
+    end
+    class Parser
+      class << self
+        def auth_token(response)
+          (response/'//n2:authToken').to_s
+        end
+        def session_lifetime(response)
+          (response/'//n2:lifetime').to_s
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/base.rb

@@ -0,0 +1,217 @@
+module Zimbra
+
+  # Doc Placeholder
+  class Base
+    NAMESPACES = {
+      'Domain' => 'domain',
+      'Account' => 'account',
+      'DistributionList' => 'dl'
+    }
+
+    class << self
+      def class_name
+        name.gsub(/Zimbra::/, '')
+      end
+
+      def all
+        BaseService.all(class_name)
+      end
+
+      def find_by_id(id)
+        BaseService.get_by_id(id, class_name)
+      end
+
+      def find_by_name(name)
+        BaseService.get_by_name(name, class_name)
+      end
+
+      def create(name, attrs = {})
+        BaseService.create(name, attrs, class_name)
+      end
+
+    end
+
+    attr_accessor :id, :name, :zimbra_attrs
+
+    def initialize(id, name, zimbra_attrs = {}, node = nil)
+      self.id = id
+      self.name = name
+      self.zimbra_attrs = zimbra_attrs
+    end
+
+    def acls
+      @acls ||= Zimbra::Directory.get_grants(self)
+    end
+
+    def delete
+      BaseService.delete(id, self.class.class_name)
+    end
+
+    def modify(attrs = {})
+      rename(attrs.delete('name')) if attrs['name']
+      BaseService.modify(id, attrs, self.class.class_name)
+    end
+
+    # Zimbra only allows renaming domains directly through LDAP
+    def rename(newname)
+      fail Zimbra::HandsoapErrors::NotImplemented.new('Rename domain only via LDAP') if self.is_a?(Zimbra::Domain)
+      BaseService.rename(id, newname, self.class.class_name)
+    end
+
+    def zimbra_type
+      Zimbra::Directory::TARGET_TYPES_MAPPING[self.class]
+    end
+
+  end
+
+  # Doc Placeholder
+  class BaseService < HandsoapService
+    def all(class_name)
+      request_name = "n2:GetAll#{class_name}sRequest"
+      xml = invoke(request_name)
+      Parser.get_all_response(class_name, xml)
+    end
+
+    def delete(id, class_name)
+      request_name = "n2:Delete#{class_name}Request"
+      xml = invoke(request_name) do |message|
+        Builder.delete(message, id)
+      end
+      true
+    end
+
+    def create(name, attributes = {}, class_name)
+      request_name = "n2:Create#{class_name}Request"
+      xml = invoke(request_name) do |message|
+        Builder.create(message, name, attributes)
+      end
+      namespace = Zimbra::Base::NAMESPACES[class_name]
+      Parser.response(class_name, xml/"//n2:#{namespace}")
+    end
+
+    def get_by_id(id, class_name)
+      request_name = "n2:Get#{class_name}Request"
+      xml = invoke(request_name) do |message|
+        Builder.get_by_id(message, id, class_name)
+      end
+      return nil if soap_fault_not_found?
+      namespace = Zimbra::Base::NAMESPACES[class_name]
+      Parser.response(class_name, xml/"//n2:#{namespace}")
+    end
+
+    def get_by_name(name, class_name)
+      request_name = "n2:Get#{class_name}Request"
+      xml = invoke(request_name) do |message|
+        Builder.get_by_name(message, name, class_name)
+      end
+      return nil if soap_fault_not_found?
+      namespace = Zimbra::Base::NAMESPACES[class_name]
+      Parser.response(class_name, xml/"//n2:#{namespace}")
+    end
+
+    def modify(id, attributes = {}, class_name)
+      request_name = "n2:Modify#{class_name}Request"
+      xml = invoke(request_name) do |message|
+        Builder.modify(message, id, attributes)
+      end
+      namespace = Zimbra::Base::NAMESPACES[class_name]
+      Parser.response(class_name, xml/"//n2:#{namespace}")
+    end
+
+    def rename(id, newname, class_name)
+      request_name = "n2:Rename#{class_name}Request"
+      xml = invoke(request_name) do |message|
+        Builder.rename(message, id, newname)
+      end
+      namespace = Zimbra::Base::NAMESPACES[class_name]
+      Parser.response(class_name, xml/"//n2:#{namespace}")
+    end
+
+  # Doc Placeholder
+    class Builder
+      class << self
+
+        def create(message, name, attributes = {})
+          message.add 'name', name
+          attributes.each do |k,v|
+            A.inject(message, k, v)
+          end
+        end
+
+        def delete(message, id)
+          message.set_attr 'id', id
+        end
+
+        def get_by_id(message, id, class_name)
+          namespace = Zimbra::Base::NAMESPACES[class_name]
+          message.add namespace, id do |c|
+            c.set_attr 'by', 'id'
+          end
+        end
+
+        def get_by_name(message, name, class_name)
+          namespace = Zimbra::Base::NAMESPACES[class_name]
+          message.add namespace, name do |c|
+            c.set_attr 'by', 'name'
+          end
+        end
+
+        def modify(message, id, attributes)
+          message.add 'id', id
+          modify_attributes(message, attributes)
+        end
+
+        def modify_attributes(message, attributes = {})
+          attributes.each do |k,v|
+            A.inject(message, k, v)
+          end
+        end
+
+        def rename(message, id, newname)
+          message.set_attr 'id', id
+          message.set_attr 'newName', newname
+        end
+
+      end
+    end
+
+  # Doc Placeholder
+    class Parser
+      class << self
+        def get_all_response(class_name, response)
+          namespace = Zimbra::Base::NAMESPACES[class_name]
+          (response/"//n2:#{namespace}").map do |node|
+            response(class_name, node, false)
+          end
+        end
+
+        def response(class_name, node, full = true)
+          attrs = full ? get_attributes(node) : {}
+          id = (node/'@id').to_s
+          name = (node/'@name').to_s
+
+          object = Object.const_get "Zimbra::#{class_name}"
+          object.new(id, name, attrs, node)
+        end
+
+        # This method run over the children of the node
+        # and for each one gets the value of the n attribute
+        # "<a n=\"zimbraMailAlias\">restringida@zbox.cl</a>"
+        # would be zimbraMailAlias
+        def get_attributes_names(node)
+          (node/'n2:a').map { |e| (e/'@n').to_s }.uniq
+        end
+
+        def get_attributes(node)
+          attr_hash = {}
+          attributes = get_attributes_names node
+          attributes.each do |attr|
+            attr_hash[attr] = Zimbra::A.read node, attr
+          end
+          attr_hash
+        end
+      end
+    end
+  end
+
+end