zimbra 0.0.4 → 0.0.5

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.irbrc

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+require 'zimbra.rb'
+
+puts "* Loaded Zimbra Gem"
+
+

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development do
+end

data/README

@@ -1,7 +1,8 @@
 EXAMPLE USAGE
 =============
 
-Zimbra.url = 'http://example.com:7071/soap/service'
+Zimbra.admin_api_url = 'https://mail.server.test:7071/service/admin/soap'
+Zimbra.account_api_url = 'https://mail.server.test/service/soap'
 Zimbra.login('admin@example.com','secret')
 
 d = Zimbra::Domain.create('luser.com')
@@ -10,4 +11,4 @@ dl = Zimbra::DistributionList.create('info@luser.com')
 dl.admin_group = true
 dl.save
 
-
+Zimbra.account_login('user@example.com')

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/zimbra.rb

@@ -1,5 +1,6 @@
 $:.unshift(File.join(File.dirname(__FILE__)))
 require 'zimbra/handsoap_service'
+require 'zimbra/handsoap_account_service'
 require 'zimbra/auth'
 require 'zimbra/cos'
 require 'zimbra/domain'
@@ -7,20 +8,34 @@ require 'zimbra/distribution_list'
 require 'zimbra/account'
 require 'zimbra/acl'
 require 'zimbra/common_elements'
+require 'zimbra/delegate_auth_token'
+require 'zimbra/folder'
+require 'zimbra/calendar'
+require 'zimbra/appointment'
+require 'zimbra/ext/hash'
+require 'zimbra/extra/date_helpers'
 
 # Manages a Zimbra SOAP session.  Offers ability to set the endpoint URL, log in, and enable debugging.
 module Zimbra
   class << self
 
     # The URL that will be used to contact the Zimbra SOAP service
-    def url
-      @@url
+    def admin_api_url
+      @@admin_api_url
     end
     # Sets the URL of the Zimbra SOAP service
-    def url=(url)
-      @@url = url
+    def admin_api_url=(url)
+      @@admin_api_url = url
     end
-
+    
+    def account_api_url
+      @@account_api_url
+    end
+    
+    def account_api_url=(url)
+      @@account_api_url = url
+    end
+    
     # Turn debugging on/off.  Outputs full SOAP conversations to stdout.
     #   Zimbra.debug = true
     #   Zimbra.debug = false
@@ -38,6 +53,10 @@ module Zimbra
     def auth_token
       @@auth_token
     end
+    
+    def account_auth_token
+      @@account_auth_token
+    end
 
     # Log into the zimbra SOAP service.  This is required before any other action is performed
     # If a login has already been performed, another login will not be attempted
@@ -48,8 +67,14 @@ module Zimbra
 
     # re-log into the zimbra SOAP service
     def reset_login(username, password)
-      puts "Logging into zimbra as #{username}"
       @@auth_token = Auth.login(username, password)
     end
+    
+    def account_login(username)
+      delegate_auth_token = DelegateAuthToken.for_account_name(username)
+      return false unless delegate_auth_token
+      @@account_auth_token = delegate_auth_token.token
+      true
+    end
   end
 end

data/lib/zimbra/appointment.rb

@@ -0,0 +1,274 @@
+# zmsoap -z -m mail03@greenviewdata.com SearchRequest @types="appointment" @query="inid:10"
+# http://files.zimbra.com/docs/soap_api/8.0.4/soap-docs-804/api-reference/zimbraMail/Search.html
+# GetRecurRequest
+
+module Zimbra
+  class Appointment
+    autoload :RecurRule, 'zimbra/appointment/recur_rule'
+    autoload :Alarm, 'zimbra/appointment/alarm'
+    autoload :Attendee, 'zimbra/appointment/attendee'
+    autoload :Reply, 'zimbra/appointment/reply'
+    autoload :Invite, 'zimbra/appointment/invite'
+    autoload :RecurException, 'zimbra/appointment/recur_exception'
+    
+    class << self
+      def find_all_by_calendar_id(calendar_id)
+        AppointmentService.find_all_by_calendar_id(calendar_id).collect { |attrs| new_from_zimbra_attributes(attrs.merge(:loaded_from_search => true)) }
+      end
+      
+      def find_all_by_calendar_id_since(calendar_id, since_date)
+        AppointmentService.find_all_by_calendar_id_since(calendar_id, since_date).collect { |attrs| new_from_zimbra_attributes(attrs.merge(:loaded_from_search => true)) }
+      end
+      
+      def find(appointment_id)
+        attrs = AppointmentService.find(appointment_id)
+        return nil unless attrs
+        new_from_zimbra_attributes(attrs)
+      end
+      
+      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)
+        
+        return {} unless zimbra_attributes.has_key?(:appt) && zimbra_attributes[:appt].has_key?(:attributes)
+        
+        {
+          :id                        => zimbra_attributes[:appt][:attributes][:id],
+          :uid                       => zimbra_attributes[:appt][:attributes][:uid],
+          :revision                  => zimbra_attributes[:appt][:attributes][:rev],
+          :calendar_id               => zimbra_attributes[:appt][:attributes][:l],
+          :size                      => zimbra_attributes[:appt][:attributes][:s],
+          :replies                   => zimbra_attributes[:appt][:replies],
+          :invites_zimbra_attributes => zimbra_attributes[:appt][:inv],
+          :date                      => zimbra_attributes[:appt][:attributes][:d],
+          :loaded_from_search        => zimbra_attributes[:loaded_from_search]
+        }
+      end
+    end
+    
+    ATTRS = [
+      :id, :uid, :date, :revision, :size, :calendar_id, 
+      :replies, :invites, :invites_zimbra_attributes, :invites_attributes
+    ] unless const_defined?(:ATTRS)
+    
+    attr_accessor *ATTRS
+    attr_reader :loaded_from_search
+    
+    def initialize(args = {})
+      self.attributes = args
+      @loaded_from_search = args[:loaded_from_search] || false
+    end
+    
+    def attributes=(args = {})
+      ATTRS.each do |attr_name|
+        self.send(:"#{attr_name}=", args[attr_name]) if args.has_key?(attr_name)
+      end
+    end
+    
+    def reload
+      raw_attributes = AppointmentService.find(id)
+      self.attributes = Zimbra::Appointment.parse_zimbra_attributes(raw_attributes)
+      @loaded_from_search = false
+    end
+
+    def replies
+      reload if loaded_from_search
+      @replies
+    end
+    
+    def replies=(replies_attributes)
+      return @replies = [] unless replies_attributes
+      
+      replies_attributes = replies_attributes[:reply].is_a?(Array) ? replies_attributes[:reply] : [ replies_attributes[:reply] ]
+      @replies = replies_attributes.collect { |attrs| Zimbra::Appointment::Reply.new_from_zimbra_attributes(attrs[:attributes]) }
+    end
+    
+    def invites
+      reload if loaded_from_search
+      @invites
+    end
+    
+    def invites_attributes=(attributes)
+      return @invites = nil unless attributes
+      
+      attributes = attributes.is_a?(Array) ? attributes : [ attributes ]
+      @invites = attributes.collect { |attrs| Zimbra::Appointment::Invite.new(attrs.merge( { :appointment => self } )) }
+    end
+    
+    def invites_zimbra_attributes=(attributes)
+      return @invites = nil unless attributes
+      
+      attributes = attributes.is_a?(Array) ? attributes : [ attributes ]
+      @invites = attributes.collect { |attrs| Zimbra::Appointment::Invite.new_from_zimbra_attributes(attrs.merge( { :appointment => self } )) }
+    end
+  
+    def date=(val)
+      if val.is_a?(Integer)
+        @date = parse_date_in_seconds(val)
+      else
+        @date = val
+      end
+    end
+    
+    def create_xml(document, invite_id = nil)
+      document.add "m" do |mime|
+        mime.set_attr "l", calendar_id
+        
+        invites.each do |invite|
+          next unless invite_id.nil? || invite_id == invite.id
+          
+          mime.add "inv" do |invite_element|
+            invite.create_xml(invite_element)
+          end
+        end
+      end
+      
+      document
+    end
+
+    def destroy
+      invites.each do |invite|
+        AppointmentService.cancel(self, invite.id)
+      end
+    end
+    
+    def save
+      if new_record?
+        response = Zimbra::AppointmentService.create(self)
+        invites.first.id = response[:invite_id]
+        @id = response[:id]
+      else
+        invites.each do |invite|
+          Zimbra::AppointmentService.update(self, invite.id)
+        end
+      end
+    end
+    
+    def new_record?
+      id.nil?
+    end
+    
+    def id_with_invite_id
+      "#{id}-#{invites.first.id}"
+    end
+    
+    def last_instance_time
+      instance_times = Zimbra::AppointmentService.find_all_instances_of_an_appointment(self)
+      return nil unless instance_times && instance_times.count > 0
+      instance_times.max
+    end
+    
+    private
+    
+    def parse_date_in_seconds(seconds)
+      Time.at(seconds / 1000)
+    end
+    
+  end
+  
+  class AppointmentService < HandsoapAccountService
+    def find_all_by_calendar_id(calendar_id)
+      xml = invoke("n2:SearchRequest") do |message|
+        Builder.find_all_with_query(message, "inid:#{calendar_id}")
+      end
+      Parser.get_search_response(xml)
+    end
+    
+    def find_all_instances_of_an_appointment(appointment)
+      xml = invoke("n2:SearchRequest") do |message|
+        message.set_attr 'query', "date:#{appointment.date.to_i * 1000}"
+        message.set_attr 'types', 'appointment'
+        message.set_attr 'calExpandInstStart', '1'
+        message.set_attr 'calExpandInstEnd', (Time.now + (86400 * 365 * 10)).to_i * 1000
+      end
+      response_hash = Zimbra::Hash.from_xml(xml.document.to_s)
+      response_hash = response_hash[:Envelope][:Body][:SearchResponse]
+      appointments = response_hash[:appt].is_a?(Array) ? response_hash[:appt] : [response_hash[:appt]]
+      appt_hash = appointments.find { |appt| appt[:attributes][:id] == appointment.id }
+      instances = appt_hash[:inst].is_a?(Array) ? appt_hash[:inst] : [appt_hash[:inst]]
+      instances.collect { |inst| Time.at(inst[:attributes][:s] / 1000) }
+    end
+    
+    def find_all_by_calendar_id_since(calendar_id, since_date)
+      xml = invoke("n2:SearchRequest") do |message|
+        Builder.find_all_with_query(message, "inid:#{calendar_id} AND date:>#{since_date.to_i}")
+      end
+      Parser.get_search_response(xml)
+   end
+    
+    def find(appointment_id)
+      xml = invoke("n2:GetAppointmentRequest") do |message|
+        Builder.find_by_id(message, appointment_id)
+      end
+      return nil unless xml
+      Parser.appointment_response(xml/"//n2:appt")
+    end
+
+    def create(appointment)
+      xml = invoke("n2:CreateAppointmentRequest") do |message|
+        Builder.create(message, appointment)
+      end
+      response_hash = Zimbra::Hash.from_xml(xml.document.to_s)
+      id = response_hash[:Envelope][:Body][:CreateAppointmentResponse][:attributes][:apptId] rescue nil
+      invite_id = response_hash[:Envelope][:Body][:CreateAppointmentResponse][:attributes][:invId].gsub(/#{id}\-/, '').to_i rescue nil
+      { :id => id, :invite_id => invite_id }
+    end
+    
+    def update(appointment, invite_id)
+      xml = invoke("n2:ModifyAppointmentRequest") do |message|
+        Builder.update(message, appointment, invite_id)
+      end
+    end
+    
+    def cancel(appointment, invite_id)
+      xml = invoke("n2:CancelAppointmentRequest") do |message|
+        Builder.cancel(message, appointment.id, invite_id)
+      end
+    end
+    
+    class Builder
+      class << self
+        def find_all_with_query(message, query)
+          message.set_attr 'query', query
+          message.set_attr 'types', 'appointment'
+        end
+        
+        def find_by_id(message, id)
+          message.set_attr 'id', id
+        end
+
+        def create(message, appointment)
+          appointment.create_xml(message)
+        end
+        
+        def update(message, appointment, invite_id)
+          message.set_attr 'id', "#{appointment.id}-#{invite_id}"
+          appointment.create_xml(message, invite_id)
+        end
+        
+        def cancel(message, appointment_id, invite_id)
+          message.set_attr 'id', "#{appointment_id}-#{invite_id}"
+          message.set_attr 'comp', 0
+        end
+      end
+    end
+    
+    class Parser
+      class << self
+        def get_search_response(response)
+          (response/"//n2:appt").collect do |node|
+            Zimbra::Hash.from_xml(node.to_xml)
+          end
+        end
+        
+        def appointment_response(node)
+          # It's much easier to deal with this as a hash
+          Zimbra::Hash.from_xml(node.to_xml)
+        end
+      end
+    end
+  end
+end

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