zimbra 0.0.4 → 0.0.5

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/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/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/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