zimbra-soap-api 0.0.7.9

data/lib/zimbra/appointment/alarm.rb

@@ -0,0 +1,101 @@
+module Zimbra
+  class Appointment
+    class Alarm
+      class << self
+        def new_from_zimbra_attributes(zimbra_attributes)
+          new(parse_zimbra_attributes(zimbra_attributes))
+        end
+        
+        # <alarm action="DISPLAY">
+        #   <trigger>
+        #     <rel neg="1" m="5" related="START"/>
+        #   </trigger>
+        #   <desc/>
+        # </alarm>
+        def parse_zimbra_attributes(zimbra_attributes)
+          attrs = { appointment_invite: zimbra_attributes[:appointment_invite] }
+          zimbra_attributes = Zimbra::Hash.symbolize_keys(zimbra_attributes.dup, true)
+          zimbra_attributes = zimbra_attributes[:trigger][:rel][:attributes]
+          
+          duration_negative = (zimbra_attributes[:neg] && zimbra_attributes[:neg] == 1) ? true : false
+          
+          attrs.merge({
+            duration_negative: duration_negative, 
+            weeks: zimbra_attributes[:w], 
+            days: zimbra_attributes[:d], 
+            hours: zimbra_attributes[:h], 
+            minutes: zimbra_attributes[:m], 
+            seconds: zimbra_attributes[:s], 
+            when: zimbra_attributes[:related] == "START" ? :start : :end, 
+            repeat_count: zimbra_attributes[:count],
+            })
+        end
+      end
+      
+      ATTRS = [:appointment_invite, :duration_negative, :weeks, :days, :hours, :minutes, :seconds, :when, :repeat_count] unless const_defined?(:ATTRS)
+      
+      attr_accessor *ATTRS
+    
+      def initialize(args = {})
+        @duration_negative = true
+        @when = :start
+        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 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 create_xml(document)
+        document.add "trigger" do |trigger_element|
+          trigger_element.add "rel" do |rel_element|
+            rel_element.set_attr "neg", duration_negative ? 1 : 0
+            rel_element.set_attr "w", weeks if weeks && weeks > 0
+            rel_element.set_attr "d", days if days && days > 0
+            rel_element.set_attr "h", hours if hours && hours > 0
+            rel_element.set_attr "m", minutes if minutes && minutes > 0
+            rel_element.set_attr "s", seconds if seconds && seconds > 0
+            rel_element.set_attr "related", self.when.to_s.upcase
+            rel_element.set_attr "count", repeat_count if repeat_count && repeat_count > 0
+          end
+        end
+      end
+      
+      def date_time_of_alarm
+        return nil if appointment_invite.nil?
+        
+        date_to_calc_from = if self.when == :start
+          appointment_invite.start_date_time
+        else
+          appointment_invite.end_date_time
+        end
+        
+        total_seconds = seconds || 0
+        total_seconds += minutes * 60 if minutes
+        total_seconds += hours * 3600 if hours
+        total_seconds += days * 86400 if days
+        total_seconds += weeks * 86400 * 7 if weeks
+        total_seconds *= -1 if duration_negative
+        
+        date_to_calc_from + total_seconds
+      end
+    end
+  end
+end

data/lib/zimbra/appointment/attendee.rb

@@ -0,0 +1,97 @@
+module Zimbra
+  class Appointment
+    class Attendee
+      ATTRS = [
+        :email_address, :friendly_name, :rsvp, :role, :participation_status
+      ] 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)
+          
+          {
+            :email_address        => zimbra_attributes[:a],
+            :friendly_name        => zimbra_attributes[:d],
+            :rsvp                 => zimbra_attributes[:rsvp],
+            :role                 => zimbra_attributes[:role],
+            :participation_status => zimbra_attributes[:ptst]
+          }
+        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 participation_status_to_zimbra
+        possible_participation_status_values.find { |k, v| v == participation_status }.first rescue participiation_status
+      end
+      
+      def to_hash(options = {})
+        hash = {
+          :email_address => email_address,
+          :friendly_name => friendly_name,
+          :rsvp => rsvp,
+          :role => role,
+          :participation_status => participation_status
+        }
+        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 "at" do |at_element|
+          at_element.set_attr "a", email_address
+          at_element.set_attr "d", friendly_name
+          at_element.set_attr "ptst", participation_status_to_zimbra
+        end
+      end
+    
+      private
+    
+      def possible_participation_status_values
+        @possible_participation_status_values ||= {
+          'NE' => :needs_action,
+          'AC' => :accept,
+          'TE' => :tentative,
+          'DE' => :declined,
+          'DG' => :delegated,
+          'CO' => :completed,
+          'IN' => :in_process,
+          'WE' => :waiting, 
+          'DF' => :deferred,
+          'New' => :needs_action,
+          'Accepted' => :accept,
+          'Declined' => :declined
+        }
+      end
+    
+      def parse_participation_status(status)
+        possible_participation_status_values[status] || status
+      end
+    
+    end
+  end
+end

data/lib/zimbra/appointment/invite.rb

@@ -0,0 +1,360 @@
+module Zimbra
+  class Appointment
+    class Invite
+      ATTRS = [
+        :appointment, 
+        :id, :recurrence_id, :sequence_number, 
+        
+        :start_date_time, :end_date_time, :date,
+        :name, :fragment, :description, :alarm, :alarm_zimbra_attributes, :alarm_attributes, :recurrence_rule, :recurrence_rule_zimbra_attributes, :recurrence_rule_attributes, 
+        :attendees, :attendees_attributes, :attendees_zimbra_attributes, 
+        :organizer_email_address, :is_organizer, :computed_free_busy_status,
+        :free_busy_setting, :invite_status, :all_day, :visibility, :location, 
+        :transparency, :replies, :never_sent,
+        
+        :comment, :recurrence_id_utc, :exception
+      ] 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)
+      
+          attrs = {}
+          
+          attrs[:appointment] = zimbra_attributes[:appointment] if zimbra_attributes.has_key?(:appointment)
+          
+          if zimbra_attributes.has_key?(:attributes)
+            attrs.merge!({
+              :id              => zimbra_attributes[:attributes][:id],
+              :recurrence_id   => zimbra_attributes[:attributes][:recurId],
+              :sequence_number => zimbra_attributes[:attributes][:seq],
+              })
+          end
+          
+          zimbra_attributes = zimbra_attributes[:comp]
+          return attrs unless zimbra_attributes
+          
+          attrs.merge!({
+            :fragment                          => zimbra_attributes[:fr],
+            :description                       => zimbra_attributes[:desc],
+            :comment                           => zimbra_attributes[:comment],
+            :alarm_zimbra_attributes           => zimbra_attributes[:alarm],
+            :recurrence_rule_zimbra_attributes => zimbra_attributes[:recur],
+            :attendees_zimbra_attributes       => zimbra_attributes[:at],
+            :never_sent                        => zimbra_attributes[:neverSent]
+            })
+      
+          if zimbra_attributes[:s]
+            attrs[:start_date_time] = zimbra_attributes[:s][:attributes][:u]
+          else
+          
+          end
+        
+          if zimbra_attributes[:e]
+            attrs[:end_date_time] = zimbra_attributes[:e][:attributes][:u]
+          end
+          
+          if zimbra_attributes[:exceptId] && zimbra_attributes[:exceptId][:attributes]
+            attrs[:exception] = zimbra_attributes[:exceptId][:attributes]
+          end
+          
+          attrs[:organizer_email_address] = zimbra_attributes[:or][:attributes][:a] rescue nil
+        
+          return attrs unless zimbra_attributes.has_key?(:attributes)
+        
+          attrs.merge!({
+            :name                      => zimbra_attributes[:attributes][:name],
+            :computed_free_busy_status => zimbra_attributes[:attributes][:fba],
+            :free_busy_setting         => zimbra_attributes[:attributes][:fb],
+            :date                      => zimbra_attributes[:attributes][:d],
+            :invite_status             => zimbra_attributes[:attributes][:status],
+            :all_day                   => zimbra_attributes[:attributes][:allDay],
+            :visibility                => zimbra_attributes[:attributes][:class],
+            :location                  => zimbra_attributes[:attributes][:loc],
+            :date                      => zimbra_attributes[:attributes][:d],
+            :transparency              => zimbra_attributes[:attributes][:transp],
+            :is_organizer              => zimbra_attributes[:attributes][:isOrg],
+            :recurrence_id_utc         => zimbra_attributes[:attributes][:ridZ]
+            })
+          
+          attrs
+        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 save
+        return false unless appointment
+        
+        if appointment.new_record?
+          appointment.save
+        else
+          Zimbra::AppointmentService.update(appointment, id)
+        end
+      end
+      
+      def cancel
+        return false unless appointment
+        return false if appointment.new_record?
+        
+        Zimbra::AppointmentService.cancel(appointment, id)
+      end
+      
+      def exception=(exception_attributes)
+        return @exception = nil unless exception_attributes
+        
+        @exception = Zimbra::Appointment::RecurException.new_from_zimbra_attributes(exception_attributes)
+      end
+    
+      def recurrence_rule_attributes=(attributes)
+        @recurrence_rule = attributes ? Zimbra::Appointment::RecurRule.new(attributes) : nil
+      end
+    
+      def recurrence_rule_zimbra_attributes=(attributes)
+        @recurrence_rule = attributes ? Zimbra::Appointment::RecurRule.new_from_zimbra_attributes(attributes) : nil
+      end
+      
+      def attendees_zimbra_attributes=(attributes)
+        return @attendees = [] unless attributes
+      
+        attributes = attributes.is_a?(Array) ? attributes : [attributes]
+        @attendees = attributes.collect { |attrs| Zimbra::Appointment::Attendee.new_from_zimbra_attributes(attrs[:attributes]) }
+      end
+      
+      def attendees_attributes=(attributes)
+        return @attendees = [] unless attributes
+      
+        attributes = attributes.is_a?(Array) ? attributes : [attributes]
+        @attendees = attributes.collect { |attrs| Zimbra::Appointment::Attendee.new(attrs) }
+      end
+      
+      def alarm_attributes=(attributes)
+        @alarm = attributes ? Zimbra::Appointment::Alarm.new(attributes.merge(:appointment_invite => self)) : nil
+      end
+    
+      def alarm_zimbra_attributes=(attributes)
+        @alarm = attributes ? Zimbra::Appointment::Alarm.new_from_zimbra_attributes(attributes.merge(:appointment_invite => self)) : nil
+      end
+    
+      def computed_free_busy_status=(val)
+        @computed_free_busy_status = parse_free_busy_status(val)
+      end
+      
+      def free_busy_setting_to_zimbra
+        possible_free_busy_status_values.find { |k ,v| v == free_busy_setting }.first rescue free_busy_setting
+      end
+    
+      def free_busy_setting=(val)
+        @free_busy_setting = parse_free_busy_status(val)
+      end
+    
+      def invite_status=(val)
+        @invite_status = parse_invite_status(val)
+      end
+      
+      def invite_status_to_zimbra
+        possible_invite_status_values.find { |k, v| v == invite_status }.first rescue invite_status
+      end
+    
+      def visibility=(val)
+        @visibility = parse_visibility_status(val)
+      end
+      
+      def visibility_to_zimbra
+        possible_visibility_values.find { |k, v| v == visibility }.first rescue visibility
+      end
+      
+      def transparency_to_zimbra
+        possible_transparency_status_values.find { |k, v| v == transparency }.first rescue transparency
+      end
+    
+      def transparency=(val)
+        @transparency = parse_transparency_status(val)
+      end
+    
+      def all_day=(val)
+        @all_day = parse_all_day(val)
+      end
+      
+      def start_date_time=(val)
+        @start_date_time = val.is_a?(Integer) ? parse_date_in_seconds(val) : val
+      end
+      
+      def end_date_time=(val)
+        @end_date_time = val.is_a?(Integer) ? parse_date_in_seconds(val) : val
+      end
+      
+      def date=(val)
+        @date = val.is_a?(Integer) ? parse_date_in_seconds(val) : val
+      end
+      
+      def create_xml(document)
+        document.set_attr "id", id if id
+        document.set_attr "status", invite_status_to_zimbra if invite_status
+        document.set_attr "isOrg", is_organizer ? 1 : 0
+        #document.set_attr "d", date.to_i * 1000 if date
+        
+        document.add "comp" do |comp|
+          comp.set_attr "loc", location if location
+          comp.set_attr "allDay", all_day ? 1 : 0
+          comp.set_attr "class", visibility_to_zimbra if visibility
+          comp.set_attr "fb", free_busy_setting_to_zimbra if free_busy_setting
+          comp.set_attr "isOrg", is_organizer ? 1 : 0
+          comp.set_attr "name", name
+          comp.set_attr "transp", transparency_to_zimbra if transparency
+          comp.set_attr "d", date.to_i * 1000 if date
+          
+          if is_organizer
+            comp.set_attr "neverSent", never_sent ? 1 : 0
+          end
+          
+          if description && !description.empty?
+            comp.add "desc", description
+          end
+          
+          if comment && !comment.empty?
+            comp.add "comment", comment
+          end
+          
+          comp.add "s" do |s_element|
+            s_element.set_attr "u", start_date_time.to_i * 1000
+            s_element.set_attr "d", start_date_time.utc.strftime("%Y%m%dT%H%M%SZ")
+          end
+          
+          comp.add "e" do |e_element|
+            e_element.set_attr "u", end_date_time.to_i * 1000
+            e_element.set_attr "d", end_date_time.utc.strftime("%Y%m%dT%H%M%SZ")
+          end
+          
+          if alarm
+            comp.add "alarm" do |alarm_element|
+              alarm_element.set_attr "action", "DISPLAY"
+              
+              alarm.create_xml(alarm_element)
+            end
+          end
+          
+          if recurrence_rule
+            comp.add "recur" do |recur_element|
+              recur_element.add "add" do |add_element|
+                recurrence_rule.create_xml(add_element)
+              end
+            end
+          end
+          
+          if attendees && attendees.count > 0
+            attendees.each do |attendee|
+              attendee.create_xml(comp)
+            end
+          end
+          
+          if organizer_email_address
+            comp.add "or" do |or_element|
+              or_element.set_attr "a", organizer_email_address
+            end
+          end
+          
+          if exception
+            exception.create_xml(comp)
+          end
+        end
+        # 
+        # ATTRS = [
+        #  :recurrence_id, :sequence_number, :replies,
+        # 
+        #   :, :recurrence_id_utc, 
+      end
+        
+      private
+    
+      def parse_date_in_seconds(seconds)
+        Time.at(seconds / 1000)
+      end
+      
+      def possible_all_day_values
+        @possible_all_day_values ||= {
+          0 => false,
+          1 => true
+        }
+      end
+      
+      def parse_all_day(val)
+        return val if val == true || val == false
+        possible_all_day_values[val.to_i] || val
+      end
+    
+      def possible_free_busy_status_values
+        @possible_free_busy_status_values ||= {
+          'F' => :free,
+          'B' => :busy,
+          'T' => :busy_tentative,
+          'U' => :busy_unavailable
+        }
+      end
+    
+      def parse_free_busy_status(fb_status)
+        possible_free_busy_status_values[fb_status] || fb_status
+      end
+      
+      def possible_invite_status_values
+        @possible_invite_status_values ||= {
+          'TENT' => :tentative,
+          'CONF' => :confirmed,
+          'CANC' => :canceled,
+          'NEED' => :need, # Not sure about this one, it's not documented
+          'COMP' => :completed,
+          'INPR' => :in_progress,
+          'WAITING' => :waiting,
+          'DEFERRED' => :deferred
+        }
+      end
+    
+      def parse_invite_status(status)
+        possible_invite_status_values[status] || status
+      end
+      
+      def possible_visibility_values
+        @possible_visibility_values ||= {
+          'PUB' => :public,
+          'PRI' => :private,
+          'CON' => :confidential
+        }
+      end
+      
+      def parse_visibility_status(status)
+        possible_visibility_values[status] || status
+      end
+    
+      def possible_transparency_status_values
+        @possible_transparency_status_values ||= {
+          'O' => :opaque,
+          'T' => :transparent
+        }
+      end
+    
+      def parse_transparency_status(status)
+        possible_transparency_status_values[status] || status
+      end
+      
+    end
+  end
+end