zimbra-soap-api 0.0.7.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2c290f23c8fc11e17f8246a10d6272a38daedc3
+  data.tar.gz: cdc7b8ed6e55a96aeb8f7b0d83164ba014742c4b
+SHA512:
+  metadata.gz: f180678a46a734e9fdf2d662d797a3f8a063be93519da28302c601527463cb35175f5495c6546092db486ada7928ec344638465d0f5923dd2b9a39f2072e5a34
+  data.tar.gz: 60eb433cb481fb18414316d3c0d00bef8643abaab3c2559b31aeb4e51e54e8fc1d95690a85b076464f5cd578c605ea8a1ac67ac12f4e5cccbb3f8769407ce5bf

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

@@ -0,0 +1,21 @@
+EXAMPLE USAGE
+=============
+
+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')
+
+dl = Zimbra::DistributionList.create('info@luser.com')
+dl.admin_group = true
+dl.save
+
+Zimbra.account_login('user@example.com')
+
+calendar = Zimbra::Calendar.all.first
+appointment = calendar.appointments.first
+
+# Get Account info
+account = Zimbra::Account.find_by_name("pbruna@example.com")
+account.get_attributes ["displayName", "sn", "zimbraMailAlias"]

data/Rakefile

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

data/lib/zimbra.rb

@@ -0,0 +1,94 @@
+$:.unshift(File.join(File.dirname(__FILE__)))
+require 'zimbra/handsoap_service'
+require 'zimbra/handsoap_account_service'
+require 'zimbra/base'
+require 'zimbra/auth'
+require 'zimbra/cos'
+require 'zimbra/domain'
+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/directory'
+require 'zimbra/alias'
+require 'zimbra/ext/hash'
+require 'zimbra/ext/string'
+require 'zimbra/ext/handsoap_curb_driver'
+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 admin_api_url
+      @@admin_api_url
+    end
+    # Sets the URL of the Zimbra SOAP service
+    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
+    def debug=(val)
+      Handsoap::Service.logger = (val ? $stdout : nil)
+      @@debug = val
+    end
+
+    # Whether debugging is enabled
+    def debug
+      @@debug ||= false
+    end
+
+    # Checking if we can update the token
+    def auth_token=(token)
+      @@auth_token = token
+    end
+
+    # Authorization token - obtained after successful login
+    def auth_token
+      @@auth_token
+    end
+
+    def session_lifetime
+      @@session_lifetime
+    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
+    def login(username, password)
+      return @@auth_token if defined?(@@auth_token) && @@auth_token
+      reset_login(username, password)
+    end
+
+    # re-log into the zimbra SOAP service
+    def reset_login(username, password)
+      @@auth_token, @@session_lifetime = 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/account.rb

@@ -0,0 +1,94 @@
+module Zimbra
+  class Account < Zimbra::Base
+    class << self
+
+      def create(name, password, attributes = {})
+        AccountService.create(name, password, attributes)
+      end
+
+      def acl_name
+        'usr'
+      end
+
+    end
+
+    attr_accessor :cos_id
+
+    def initialize(id, name, zimbra_attrs = {}, node = nil)
+      super
+      self.cos_id = zimbra_attrs['zimbraCOSId']
+      self.delegated_admin = zimbra_attrs['zimbraIsDelegatedAdminAccount']
+    end
+
+    def delegated_admin=(val)
+      @delegated_admin = Zimbra::Boolean.read(val)
+    end
+
+    def delegated_admin?
+      @delegated_admin
+    end
+
+    def save
+      AccountService.modify(self)
+    end
+
+    def set_password(new_password)
+      AccountService.set_password(id, new_password)
+    end
+
+    def add_alias(alias_name)
+      AccountService.add_alias(self, alias_name)
+    end
+  end
+
+  # Doc Placeholder
+  class AccountService < HandsoapService
+    def create(name, password, attributes)
+      xml = invoke("n2:CreateAccountRequest") do |message|
+        Builder.create(message, name, password, attributes)
+      end
+      class_name = Zimbra::Account.class_name
+      Zimbra::BaseService::Parser.response(class_name, xml/"//n2:account")
+    end
+
+    def set_password(id, new_password)
+      xml = invoke('n2:SetPasswordRequest') do |message|
+        Builder.set_password(message, id, new_password)
+      end
+      true
+    end
+
+    def add_alias(account,alias_name)
+      xml = invoke('n2:AddAccountAliasRequest') do |message|
+        Builder.add_alias(message,account.id,alias_name)
+      end
+    end
+
+    # Doc Placeholder
+    class Builder
+      class << self
+        def create(message, name, password, attributes)
+          message.add 'name', name
+          message.add 'password', password
+          attributes.each do |k,v|
+            A.inject(message, k, v)
+          end
+        end
+
+        def set_password(message, id, new_password)
+          message.set_attr 'id', id
+          message.set_attr 'newPassword', new_password
+        end
+
+        def add_alias(message,id,alias_name)
+          message.add 'id', id
+          message.add 'alias', alias_name
+        end
+      end
+    end
+    class Parser
+      class << self
+      end
+    end
+  end
+end

data/lib/zimbra/acl.rb

@@ -0,0 +1,63 @@
+module Zimbra
+  class ACL
+    class TargetObjectNotFound < StandardError; end
+
+    TARGET_CLASSES = [Zimbra::Domain, Zimbra::DistributionList, Zimbra::Cos, Zimbra::Account]
+    TARGET_MAPPINGS = TARGET_CLASSES.inject({}) do |hsh, klass|
+      hsh[klass.acl_name] = klass
+      hsh[klass] = klass.acl_name
+      hsh
+    end
+
+    class << self
+      def delete_all(xmldoc)
+        A.inject(xmldoc, 'zimbraACE', '', 'c' => '1')
+      end
+
+      def read(node)
+        list = A.read(node, 'zimbraACE')
+        return nil if list.nil?
+        list = [list] unless list.respond_to?(:map)
+        acls = list.map do |ace|
+          from_s(ace)
+        end
+      end
+
+      def from_zimbra(node)
+        from_s(node.to_s)
+      end
+
+      def from_s(value)
+        grantee_id, grantee_name, name = value.split(' ')
+        grantee_class = TARGET_MAPPINGS[grantee_name]
+        return "Target object not found for acl #{value}" if target_class.nil?
+        new(grantee_id: grantee_id, grantee_class: grantee_class, name: name)
+      end
+    end
+
+    attr_accessor :grantee_id, :grantee_class, :name, :grantee_name
+
+    def initialize(options = {})
+      if options[:grantee]
+        self.grantee_id = options[:grantee].id
+        self.grantee_class = options[:grantee].class
+        self.grantee_name = options[:grantee].grantee_name unless options[:grantee].grantee_name.nil?
+      else
+        self.grantee_id = options[:grantee_id]
+        self.grantee_class = options[:grantee_class]
+        self.grantee_name = options[:grantee_name] unless options[:grantee_name].nil?
+      end
+      self.name = options[:name]
+    end
+
+    def to_zimbra_acl_value
+      id = grantee_id
+      type = grantee_class.acl_name
+      "#{id} #{type} #{name}"
+    end
+
+    def apply(xmldoc)
+      A.inject(xmldoc, 'zimbraACE', to_zimbra_acl_value, 'c' => '1')
+    end
+  end
+end

data/lib/zimbra/alias.rb

@@ -0,0 +1,4 @@
+module Zimbra
+  class Alias
+  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