zm-ruby-client 0.14.0

data/lib/zm/client/connector/soap_admin.rb

@@ -0,0 +1,532 @@
+# frozen_string_literal: true
+
+require_relative 'soap_base'
+require_relative 'soap_error'
+require_relative 'soap_xml_builder'
+
+module Zm
+  module Client
+    class SoapAdminConnector < SoapBaseConnector
+
+      SOAP_PATH = '/service/admin/soap/'
+      ADMINSPACE = 'urn:zimbraAdmin'
+      A_NODE_PROC = lambda { |n| { n: n.first, _content: n.last } }
+
+      attr_accessor :token
+
+      def initialize(scheme, host, port)
+        @verbose = false
+        @uri = URI::HTTP.new(scheme, nil, host, port, nil, SOAP_PATH, nil, nil, nil)
+        init_curl_client
+      end
+
+      def auth(mail, password)
+        body = { Body: { AuthRequest: { _jsns: ADMINSPACE, name: mail, password: password } } }
+        res = curl_request(body, AuthError)
+        @token = res[BODY][:AuthResponse][:authToken][0][:_content]
+      end
+
+      def noop
+        body = init_hash_request(:NoOpRequest)
+        curl_request(body)
+      end
+
+      def delegate_auth(name, by = :name, duration = nil)
+        req = { duration: duration, account: { by: by, _content: name } }.reject { |_, v| v.nil? }
+        body = init_hash_request(:DelegateAuthRequest)
+        body[:Body][:DelegateAuthRequest].merge!(req)
+        res = curl_request(body)
+        res[BODY][:DelegateAuthResponse][:authToken][0][:_content]
+      end
+
+      def get_license
+        body = init_hash_request(:GetLicenseRequest)
+        curl_request(body)
+      end
+
+      def count_object(type)
+        soap_name = :CountObjectsRequest
+        body = init_hash_request(soap_name)
+        req = { type: type}
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def create_gal_sync_account(name, domain_name, type, server_name, folder_name, account_name, attrs = {})
+        req = {
+          name: name,
+          domain: domain_name,
+          type: type,
+          server: server_name,
+          folder: folder_name,
+          account: { by: :name, _content: account_name },
+          a: attrs.to_a.map(&A_NODE_PROC)
+          # a: attrs.to_a.map { |n| { n: n.first, _content: n.last } }
+        }.reject { |_, v| v.nil? }
+        body = init_hash_request(:CreateGalSyncAccountRequest)
+        body[:Body][:CreateGalSyncAccountRequest].merge!(req)
+        curl_request(body)
+      end
+
+      def sync_gal_account(gal_account_id, data_source, by = :name, full_sync = 1, reset = 1)
+        req = {
+          account: {
+            id: gal_account_id,
+            datasource: {
+              by: by,
+              fullSync: full_sync,
+              reset: reset,
+              _content: data_source
+            }
+          }
+        }
+        body = init_hash_request(:SyncGalAccountRequest)
+        body[:Body][:SyncGalAccountRequest].merge!(req)
+        curl_request(body)
+      end
+
+      def get_all_domains
+        body = init_hash_request(:GetAllDomainsRequest)
+        curl_request(body)
+      end
+
+      def create_data_source(name, account_id, type, attrs = { })
+        req = {
+          id: account_id,
+          dataSource: {
+            type: type,
+            name: name,
+            a: attrs.to_a.map(&A_NODE_PROC)
+            # a: attrs.to_a.map { |n| { n: n.first, _content: n.last } }
+          }
+        }
+        body = init_hash_request(:CreateDataSourceRequest)
+        body[:Body][:CreateDataSourceRequest].merge!(req)
+        curl_request(body)
+      end
+
+      def get_data_sources(id)
+        req = { id: id }
+        body = init_hash_request(:GetDataSourcesRequest)
+        body[:Body][:GetDataSourcesRequest].merge!(req)
+        curl_request(body)
+      end
+
+      def delete_data_source(account_id, data_source_id)
+        req = { id: account_id, dataSource: { id: data_source_id } }
+        body = init_hash_request(:DeleteDataSourceRequest)
+        body[:Body][:DeleteDataSourceRequest].merge!(req)
+        curl_request(body)
+      end
+
+      def get_all_servers(services = nil)
+        req = { service: services }.reject { |_, v| v.nil? }
+        body = init_hash_request(:GetAllServersRequest)
+        body[:Body][:GetAllServersRequest].merge!(req)
+        curl_request(body)
+      end
+
+      def get_server(name, by = :name, attrs = nil)
+        req = { server: { by: by, _content: name }, attrs: attrs }
+        body = init_hash_request(:GetServerRequest)
+        body[:Body][:GetServerRequest].merge!(req)
+        curl_request(body)
+      end
+
+      def get_cos(name, by = :name, attrs = nil)
+        req = { cos: { by: by, _content: name } }
+        req[:attrs] = attrs unless attrs.nil? || attrs.empty?
+        body = init_hash_request(:GetCosRequest)
+        body[:Body][:GetCosRequest].merge!(req)
+        curl_request(body)
+      end
+
+      def create_cos(name, attrs = nil)
+        req = { name: name }
+        body = init_hash_request(:CreateCosRequest)
+        body[:Body][:CreateCosRequest].merge!(req)
+        # a: attrs.to_a.map(&A_NODE_PROC)
+        # a: attrs.to_a.map { |n| { n: n.first, _content: n.last } }
+        # puts SoapXmlBuilder.new(body).to_xml
+        # todo ne fonctionne pas !
+        curl_xml(SoapXmlBuilder.new(body).to_xml)
+      end
+
+      def modify_cos(id, attrs = nil)
+        # req = { _jsns: ADMINSPACE, id: id, a: attrs.to_a.map{ |n| { n: n.first, _content: n.last } } }
+        req = { _jsns: ADMINSPACE, id: id }
+        body = { Body: { ModifyCosRequest: req } }.merge(hash_header(@token))
+        # puts body
+        # todo ne fonctionne pas !
+        # peut-être seul la version xml fonctionne. Il faudrait créer une fonction qui converti le json en xml
+        curl_request(body)
+      end
+
+      def create_account(name, password = nil, attrs = [])
+        soap_name = :CreateAccountRequest
+        req = { name: name, password: password }.reject { |_, v| v.nil? }
+        req[:a] = attrs.map { |i| i.last.is_a?(Array) ? i.last.map{|j|[i.first, j]} : [i] }.flatten(1).map(&A_NODE_PROC)
+        # req[:a] = attrs.map{|i|i.last.is_a?(Array) ? i.last.map{|j|[i.first, j]} : [i]}.flatten(1).map { |n| { n: n.first, _content: n.last } }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        # puts body
+        curl_request(body)
+      end
+
+      def create_resource(name, password = nil, attrs = [])
+        soap_name = :CreateCalendarResourceRequest
+        req = { name: name, password: password }
+        req.reject! { |_, v| v.nil? }
+        req[:a] = attrs.map { |i| i.last.is_a?(Array) ? i.last.map{|j|[i.first, j]} : [i] }.flatten(1).map(&A_NODE_PROC)
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def create_distribution_list(name, attrs = [])
+        soap_name = :CreateDistributionListRequest
+        req = { name: name }
+        req[:a] = attrs.map { |i| i.last.is_a?(Array) ? i.last.map{|j|[i.first, j]} : [i] }.flatten(1).map(&A_NODE_PROC)
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        # puts body
+        curl_request(body)
+      end
+
+      def modify_account(id, attrs = [])
+        generic_modify(:ModifyAccountRequest, id, attrs)
+      end
+
+      def modify_resource(id, attrs = [])
+        generic_modify(:ModifyCalendarResourceRequest, id, attrs)
+      end
+
+      def modify_distribution_list(id, attrs = [])
+        generic_modify(:ModifyDistributionListRequest, id, attrs)
+      end
+
+      def generic_modify(soap_name, id, attrs)
+        req = {
+          id: id,
+          a: attrs.map(&A_NODE_PROC)
+        }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def set_password(id, new_password)
+        soap_name = :SetPasswordRequest
+        req = { id: id, newPassword: new_password }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def add_account_alias(id, email)
+        generic_alias(:AddAccountAliasRequest, id, email)
+      end
+
+      def remove_account_alias(id, email)
+        generic_alias(:RemoveAccountAliasRequest, id, email)
+      end
+
+
+      def rename_account(id, email)
+        generic_rename(:RenameAccountRequest, id, email)
+      end
+
+      def add_distribution_list_members(id, emails)
+        generic_members(:AddDistributionListMemberRequest, id, emails)
+      end
+
+      def remove_distribution_list_members(id, emails)
+        generic_members(:RemoveDistributionListMemberRequest, id, emails)
+      end
+
+      def generic_members(soap_name, id, emails)
+        req = { id: id, dlm: emails.map { |email| {_content: email} } }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def add_distribution_list_alias(id, email)
+        generic_alias(:AddDistributionListAliasRequest, id, email)
+      end
+
+      def remove_distribution_list_alias(id, email)
+        generic_alias(:RemoveDistributionListAliasRequest, id, email)
+      end
+
+      def generic_alias(soap_name, id, email)
+        req = { id: id, alias: email }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        # puts body
+        curl_request(body)
+      end
+
+      def rename_distribution_list(id, email)
+        generic_rename(:RenameDistributionListRequest, id, email)
+      end
+
+      def generic_rename(soap_name, id, email)
+        req = { id: id, newName: email }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def get_domain(name, by = :name, attrs = nil)
+        req = { domain: { by: by, _content: name } }
+        req[:_attrs] = attrs unless attrs.nil?
+        body = init_hash_request(:GetDomainRequest)
+        body[:Body][:GetDomainRequest].merge!(req)
+        # TODO: tester param attrs
+        # puts body
+        curl_request(body)
+      end
+
+      def create_domain(name, attrs = [])
+        soap_name = :CreateDomainRequest
+        req = {
+          name: name,
+          a: attrs.map(&A_NODE_PROC)
+        }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def modify_domain(id, attrs = [])
+        generic_modify(:ModifyDomainRequest, id, attrs)
+      end
+
+      def get_account(name, by = :name, attrs = nil, applyCos = 1)
+        soap_name = :GetAccountRequest
+        req = { account: { by: by, _content: name }, applyCos: applyCos }
+        req[:attrs] = attrs unless attrs.nil? || attrs.empty?
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        # puts body
+        curl_request(body)
+      end
+
+      def get_account_membership(name, by = :name)
+        soap_name = :GetAccountMembershipRequest
+        req = { account: { by: by, _content: name } }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def get_resource(name, by = :name, attrs = nil)
+        soap_name = :GetCalendarResourceRequest
+        req = { calresource: { by: by, _content: name } }
+        req[:attrs] = attrs unless attrs.nil?
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        # p body
+        curl_request(body)
+      end
+
+      def get_distribution_list(name, by = :name, attrs = nil)
+        soap_name = :GetDistributionListRequest
+        req = { dl: { by: by, _content: name } }
+        req[:attrs] = attrs unless attrs.nil?
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        # p body
+        curl_request(body)
+      end
+
+      def delete_account(id)
+        generic_delete(:DeleteAccountRequest, id)
+      end
+
+      def delete_resource(id)
+        generic_delete(:DeleteCalendarResourceRequest, id)
+      end
+
+      def delete_distribution_list(id)
+        generic_delete(:DeleteDistributionListRequest, id)
+      end
+
+      def distribution_list_action(name, by = :name, action = {})
+        soap_name = :DistributionListActionRequest
+        req = { dl: { by: by, _content: name }, action: action }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name][:_jsns] = Zm::Client::SoapAccountConnector::ACCOUNTSPACE
+        body[:Body][soap_name].merge!(req)
+        # p body
+        curl_request(body)
+      end
+
+      def generic_delete(soap_name, id)
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name][:id] = id
+        curl_request(body)
+      end
+
+      def search_directory(query = nil, maxResults = nil, limit = nil, offset = nil, domain = nil, applyCos = nil, applyConfig = nil, sortBy = nil, types = nil, sortAscending = nil, countOnly = nil, attrs = nil)
+
+        # Désactivé car moins performant !
+        # req = Hash[method(__method__).parameters.map{ |p|[p.last, (eval p.last.to_s)] }].select!{ |k,v|!v.nil? }
+
+        soap_name = :SearchDirectoryRequest
+
+        req = {
+          query: query,
+          maxResults: maxResults,
+          limit: limit,
+          offset: offset,
+          domain: domain,
+          applyCos: applyCos,
+          applyConfig: applyConfig,
+          sortBy: sortBy,
+          types: types,
+          sortAscending: sortAscending,
+          countOnly: countOnly,
+          attrs: attrs
+        }.reject { |_, v| v.nil? }
+
+        # body = { Body: { SearchDirectoryRequest: { _jsns: ADMINSPACE } } }.merge(hash_header(@token))
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        # puts body
+
+        curl_request(body)
+      end
+
+      def get_quota_usage(domain = nil, allServers = nil, limit = nil, offset = nil, sortBy = nil, sortAscending = nil, refresh = nil, target_server_id = nil)
+        soap_name = :GetQuotaUsageRequest
+        req = {
+          domain: domain,
+          allServers: allServers,
+          limit: limit,
+          offset: offset,
+          sortBy: sortBy,
+          sortAscending: sortAscending,
+          refresh: refresh
+        }.reject { |_, v| v.nil? }
+
+        # body = { Body: { GetQuotaUsageRequest: { _jsns: ADMINSPACE } } }.merge(hash_header(@token))
+        body = init_hash_request(soap_name, target_server_id)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def get_mailbox(id)
+        soap_name = :GetMailboxRequest
+        req = {
+            mbox: {
+                id: id
+            }
+        }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def flush_cache(type, all_servers, id = nil)
+        soap_name = :FlushCacheRequest
+        req = { cache: { type: type, allServers: all_servers } }
+        req[:cache].merge!({ entry: { by: :id, _content: id } }) unless id.nil?
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def get_share_info(id)
+        soap_name = :GetShareInfoRequest
+        req = { owner: { by: :id, _content: id } }
+        body = init_hash_request(soap_name)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def move_mailbox(name, src, dest, dest_id)
+        soap_name = :MoveMailboxRequest
+        req = { account: { name: name, dest: dest, src: src } }
+        body = init_hash_request(soap_name, dest_id)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def query_mailbox_move(name, dest_id)
+        soap_name = :QueryMailboxMoveRequest
+        req = { account: { name: name } }
+        body = init_hash_request(soap_name, dest_id)
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def get_mail_queue_info(server_name)
+        soap_name = :GetMailQueueInfoRequest
+        body = init_hash_request(soap_name)
+        req = { server: { name: server_name } }
+        body[:Body][soap_name].merge!(req)
+        # puts body.to_json
+        curl_request(body)
+      end
+
+      def get_mail_queue(server_name, queue_name, offset = 0, limit = 1000, fields = {})
+        # fields = { fromdomain: 'domain.tld', todomain: 'domain.tld' }
+        # AND operator
+
+        query = {
+          offset: offset,
+          limit: limit
+        }
+        query[:field] = fields.map { |k, v| { name: k, match: { value: v } } } unless fields.empty?
+        query.reject! { |_, v| v.nil? || v.empty? }
+
+        soap_name = :GetMailQueueRequest
+        body = init_hash_request(soap_name)
+        req = {
+          server: {
+            name: server_name,
+            queue: {
+              name: queue_name,
+              scan: 1,
+              query: query
+            }
+          }
+        }
+        body[:Body][soap_name].merge!(req)
+        # puts body.to_json
+        curl_request(body)
+      end
+
+      def mail_queue_action(server_name, queue_name, op, value, by = :id)
+        # op: hold|release|delete|requeue
+        # by: id|query
+        soap_name = :MailQueueActionRequest
+        value = [value] unless value.is_a?(Array)
+        body = init_hash_request(soap_name)
+        req = { server: { name: server_name, queue: { name: queue_name, action: { op: op, by: by, _content: value.join(',') } } } }
+        body[:Body][soap_name].merge!(req)
+        curl_request(body)
+      end
+
+      def backup_query(dest_id)
+        soap_name = :BackupQueryRequest
+        body = init_hash_request(soap_name, dest_id)
+        req = { query: {} }
+        body[:Body][soap_name].merge!(req)
+        # puts body
+        curl_request(body)
+        # curl_xml(SoapXmlBuilder.new(body).to_xml)
+      end
+
+      def init_hash_request(soap_name, target_server = nil)
+        {
+          Body: {
+            soap_name => { _jsns: ADMINSPACE }
+          }
+        }.merge(hash_header(@token, target_server))
+      end
+    end
+  end
+end

data/lib/zm/client/connector/soap_base.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'openssl'
+require 'curb'
+require 'uri'
+
+require_relative 'soap_error'
+
+module Zm
+  module Client
+    class SoapBaseConnector
+      BASESPACE = 'urn:zimbra'
+      HTTP_HEADERS = {
+        'Content-Type' => 'application/json; charset=utf-8'
+      }.freeze
+      BODY = :Body
+
+      def verbose!
+        @verbose = true
+        @curl.verbose = @verbose
+      end
+
+      private
+
+      def init_curl_client
+        @curl = ::Curl::Easy.new(@uri.to_s) do |curl|
+          curl.timeout = 300
+          curl.enable_cookies = false
+          curl.encoding = ''
+          curl.headers = HTTP_HEADERS
+          curl.ssl_verify_peer = false
+          curl.ssl_verify_host = 0
+          # curl.verbose = @verbose
+        end
+      end
+
+      def curl_request(body, error_handler = SoapError)
+        puts body.to_json if @verbose
+        @curl.http_post(body.to_json)
+
+        puts @curl.body_str if @verbose
+        soapbody = JSON.parse(@curl.body_str, symbolize_names: true)
+        raise(error_handler, soapbody) if @curl.status.to_i >= 400
+
+        soapbody
+      end
+
+      def curl_xml(xml, error_handler = SoapError)
+        # puts xml
+        @curl.http_post(xml)
+
+        soapbody = JSON.parse(@curl.body_str, symbolize_names: true)
+        raise(error_handler, soapbody) if @curl.status.to_i >= 400
+
+        soapbody
+      end
+
+      def hash_header(token, target_server = nil)
+        context = { authToken: token, userAgent: { name: :zmsoap }, targetServer: target_server }.delete_if { |_, v| v.nil? }
+        { Header: { context: context, _jsns: BASESPACE } }
+      end
+    end
+  end
+end

data/lib/zm/client/connector/soap_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    class ZmError < StandardError
+    end
+
+    class SoapError < StandardError
+      attr_reader :reason, :code
+      def initialize(soapbody)
+        @reason = soapbody[:Body][:Fault][:Reason][:Text]
+        @code = soapbody[:Body][:Fault][:Detail][:Error][:Code]
+        super "[#{@code}] [#{@reason}]"
+      end
+    end
+
+    class AuthError < SoapError
+    end
+
+    class RestError < StandardError
+      def initialize(restbody)
+        super(restbody)
+      end
+    end
+  end
+end

data/lib/zm/client/connector/soap_xml_builder.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+# https://stackoverflow.com/questions/11933451/converting-nested-hash-into-xml-using-nokogiri
+
+class SoapXmlBuilder
+  ATTRS_NODE_PROC = ->(k, _) { k.to_s.start_with?('_') }
+
+  def initialize(hash)
+    @hash = hash
+  end
+
+  def to_xml
+    builder = Nokogiri::XML::Builder.new do |xml|
+      xml.Envelope('xmlns' => 'http://schemas.xmlsoap.org/soap/envelope/', 'xmlns:urn' => 'urn:zimbra') do
+        header(xml)
+        body(xml)
+      end
+    end
+    builder.to_xml
+  end
+
+  private
+
+  def header(xml)
+    return unless @hash[:Header]
+
+    xml.Header do
+      xml.context_('xmlns' => 'urn:zimbra') do
+        xml.authToken @hash[:Header][:context][:authToken]
+        if @hash[:Header][:context][:targetServer]
+          xml.targetServer @hash[:Header][:context][:targetServer]
+        end
+        xml.format('type' => 'js')
+      end
+    end
+  end
+
+  def body(xml)
+    return unless @hash[:Body]
+
+    xml.Body do
+      generate_xml(@hash[:Body], xml)
+    end
+  end
+
+  def generate_xml(hash, xml)
+    hash.each do |req_name, req_h|
+      xml.send(req_name, transform_keys(req_h.select(&ATTRS_NODE_PROC))) do
+        req_h.reject(&ATTRS_NODE_PROC).each do |label, value|
+          if value.is_a?(Hash)
+            generate_xml(value, xml)
+          elsif value.is_a?(Array)
+            value.each do |el|
+              xml.send(label, el.reject(&ATTRS_NODE_PROC), el[:_content])
+            end
+          else
+            xml.send(label, value)
+          end
+        end
+      end
+    end
+  end
+
+  def transform_keys(hash)
+    Hash[hash.map { |k, v| [k.to_s.sub(/\A_/, '').sub('jsns', 'xmlns'), v] }]
+  end
+end