zm-ruby-client 0.18.5 → 2.0.0

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

@@ -6,470 +6,67 @@ require_relative 'soap_error'
 module Zm
   module Client
     class SoapAccountConnector < SoapBaseConnector
-      MAILSPACE = 'urn:zimbraMail'
-      ACCOUNTSPACE = 'urn:zimbraAccount'
-      A_NODE_PROC = ->(n) { { n: n.first, _content: n.last } }
-      A_NODE_PROC_NAME = ->(n) { { name: n.first, _content: n.last } }
-      A_NODE_PROC_ARROW_NAME = ->(n) { { :@name => n.first, content!: n.last } }
-
-      def initialize(scheme, host, port)
-        super(scheme, host, port, '/service/soap/')
-      end
-
-      def auth_template(mail)
-        {
-          Body: {
-            AuthRequest: {
-              _jsns: ACCOUNTSPACE,
-              account: {
-                _content: mail,
-                by: :name
-              }
-            }
-          }
-        }
-      end
-
-      def auth_preauth(mail, domainkey)
-        ts = (Time.now.to_i * 1000)
-        preauth = compute_preauth(mail, ts, domainkey)
-        body = auth_template(mail)
-        preauth_h = {
-          preauth: {
-            _content: preauth,
-            timestamp: ts
-          }
-        }
-        body[:Body][:AuthRequest].merge!(preauth_h)
-        do_auth(body)
-      end
-
-      def auth_password(mail, password)
-        body = auth_template(mail)
-        body[:Body][:AuthRequest].merge!({ password: password })
-        do_auth(body)
-      end
-
-      def do_auth(body)
-        res = curl_request(body, AuthError)
-        res[BODY][:AuthResponse][:authToken].first[:_content]
-      end
-
-      # -------------------------------
-      # APPOINTMENT
-
-      def get_appointment(token, id)
-        req = { id: id }
-        body = init_hash_request(token, :GetAppointmentRequest)
-        body[:Body][:GetAppointmentRequest].merge!(req)
-        curl_request(body)
-      end
-
-      def create_appointment(token, jsns)
-        soap_name = :CreateAppointmentRequest
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(jsns)
-        curl_request(body)
-      end
-
-      def modify_appointment(token, jsns)
-        soap_name = :ModifyAppointmentRequest
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(jsns)
-        curl_request(body)
-      end
-
-      def cancel_appointment(token, jsns)
-        soap_name = :CancelAppointmentRequest
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(jsns)
-        curl_request(body)
-      end
-
-      # -------------------------------
-      # CONTACT
-
-      def get_all_contacts(token, folder_id = nil)
-        body = init_hash_request(token, :GetContactsRequest)
-        unless folder_id.nil?
-          req = { l: folder_id }
-          body[:Body][:GetContactsRequest].merge!(req)
+      class << self
+        def create(config)
+          trans = new(
+            config.zimbra_public_scheme,
+            config.zimbra_public_host,
+            config.zimbra_public_port
+          )
+          trans.logger = config.logger
+          trans
         end
-        curl_request(body)
-      end
-
-      def create_contact(token, folder_id, attrs)
-        a = attrs.to_a.map(&A_NODE_PROC)
-        soap_name = :CreateContactRequest
-        req = { cn: { a: a, l: folder_id } }
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      def modify_contact(token, id, attrs)
-        a = attrs.to_a.map(&A_NODE_PROC)
-        soap_name = :ModifyContactRequest
-        req = { cn: { a: a, id: id } }
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      def create_group_contact(token, folder_id, attrs, members = [])
-        soap_name = :CreateContactRequest
-        a = attrs.to_a.map(&A_NODE_PROC)
-        req = { cn: { a: a, l: folder_id, m: members } }
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      def modify_group_contact(token, id, attrs, members = [])
-        soap_name = :ModifyContactRequest
-        a = attrs.to_a.map(&A_NODE_PROC)
-        req = { cn: { a: a, id: id, m: members } }
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      def contact_action(token, op, id, options = {})
-        soap_name = :ContactActionRequest
-        action = { op: op, id: id }.merge(options)
-        req = { action: action }
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      # -------------------------------
-      # DOCUMENT
-
-      def save_document(token, l, options = {})
-        soap_name = :SaveDocumentRequest
-        body = init_hash_request(token, soap_name)
-        req = { doc: { l: l } }
-        req[:doc].merge!(options)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      def item_action(token, op, id, options = {})
-        soap_name = :ItemActionRequest
-        action = { op: op, id: id }.merge(options)
-        req = { action: action }
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      # -------------------------------
-      # FOLDER
-
-      def get_folder(token, jsns)
-        jsns_request(:GetFolderRequest, token, jsns)
-      end
-
-      # def get_all_folders(token, view = nil, tr = nil)
-      #   soap_name = :GetFolderRequest
-      #   body = init_hash_request(token, soap_name)
-      #   req = { view: view, tr: tr }.reject { |_, v| v.nil? }
-      #   body[:Body][soap_name].merge!(req)
-      #   curl_request(body)
-      # end
-
-      def create_folder(token, jsns)
-        jsns_request(:CreateFolderRequest, token, jsns)
-      end
-
-      def folder_action(token, jsns)
-        jsns_request(:FolderActionRequest, token, jsns)
-      end
-
-      def get_all_search_folders(token)
-        soap_name = :GetSearchFolderRequest
-        body = init_hash_request(token, soap_name)
-        curl_request(body)
       end
 
-      # -------------------------------
-      # SEARCH FOLDER
-
-      def create_search_folder(token, jsns)
-        jsns_request(:CreateSearchFolderRequest, token, jsns)
+      def token
+        context.to_hash[:authToken]
       end
 
-      def modify_search_folder(token, jsns)
-        jsns_request(:ModifySearchFolderRequest, token, jsns)
+      def token=(value)
+        context.token(value)
       end
 
-      # -------------------------------
-      # TASK
-
-      def create_task(token, folder_id, name, description = nil, options = {})
-        comp = { name: name }
-        comp.merge!(options) if !options.nil? && !options.empty?
-
-        task = { su: name, l: folder_id, inv: { comp: [comp] } }
-
-        task[:mp] = { ct: 'text/plain', content: description } unless description.nil?
-
-        req = { m: task }
-
-        body = init_hash_request(token, :CreateTaskRequest)
-        body[:Body][:CreateTaskRequest].merge!(req)
-        curl_request(body)
-      end
-
-      # -------------------------------
-      # SHARE
-
-      def create_mountpoint(token, jsns)
-        jsns_request(:CreateMountpointRequest, token, jsns)
-      end
-
-      def get_share_info(token, options = {})
-        soap_name = :GetShareInfoRequest
-        req = { includeSelf: 0 }.merge!(options)
-        body = init_hash_request(token, soap_name, ACCOUNTSPACE)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      def get_rights(token, jsns)
-        jsns_request(:GetRightsRequest, token, jsns, ACCOUNTSPACE)
-      end
-
-      def grant_rights(token, jsns)
-        jsns_request(:GrantRightsRequest, token, jsns, ACCOUNTSPACE)
-      end
-
-      def revoke_rights(token, jsns)
-        jsns_request(:RevokeRightsRequest, token, jsns, ACCOUNTSPACE)
-      end
-
-      # -------------------------------
-      # MESSAGE
-
-      def get_msg(token, id, options = {})
-        req = { m: { id: id } }
-        req[:m].merge!(options) unless options.empty?
-        body = init_hash_request(token, :GetMsgRequest)
-        body[:Body][:GetMsgRequest].merge!(req)
-        curl_request(body)
-      end
-
-      def msg_action(token, op, id, options = {})
-        action = { op: op, id: id }.merge(options)
-        req = { action: action }
-        body = init_hash_request(token, :MsgActionRequest)
-        body[:Body][:MsgActionRequest].merge!(req)
-        curl_request(body)
-      end
-
-      def send_msg(token, m)
-        req = { m: m }
-        body = init_hash_request(token, :SendMsgRequest)
-        body[:Body][:SendMsgRequest].merge!(req)
-        # curl_request(body)
-      end
-
-      def add_msg(token, l, eml, d = nil, f = nil, tn = nil)
-        key = :AddMsgRequest
-        m = {
-          l: l,
-          d: d,
-          f: f,
-          tn: tn,
-          content: { _content: eml }
-        }.reject { |_, v| v.nil? }
-
-        req = { m: m }
-        body = init_hash_request(token, key)
-        body[:Body][key].merge!(req)
-
-        curl_request(body)
-      end
-
-      # -------------------------------
-      # TAG
-
-      def get_tag(token)
-        body = init_hash_request(token, :GetTagRequest)
-        curl_request(body)
-      end
-
-      def create_tag(token, jsns)
-        jsns_request(:CreateTagRequest, token, jsns)
-      end
-
-      def tag_action(token, jsns)
-        jsns_request(:TagActionRequest, token, jsns)
-      end
-
-      # -------------------------------
-      # IDENTITY
-
-      def get_all_identities(token)
-        body = init_hash_request(token, :GetIdentitiesRequest, ACCOUNTSPACE)
-        curl_request(body)
-      end
-
-      def create_identity(token, name, attrs = {})
-        soap_name = :CreateIdentityRequest
-        req = { identity: { name: name, _attrs: attrs } }
-        body = init_hash_request(token, soap_name, ACCOUNTSPACE)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      def modify_identity(token, id, attrs = {})
-        soap_name = :ModifyIdentityRequest
-        req = { identity: { id: id, _attrs: attrs } }
-        body = init_hash_request(token, soap_name, ACCOUNTSPACE)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      def delete_identity(token, id)
-        soap_name = :DeleteIdentityRequest
-        req = { identity: { id: id } }
-        body = init_hash_request(token, soap_name, ACCOUNTSPACE)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      # -------------------------------
-      # PREFERENCES
-
-      def get_prefs(token, *names)
-        req = { prefs: names.map { |name| { name: name } } }
-        body = init_hash_request(token, :GetPrefsRequest, ACCOUNTSPACE)
-        body[:Body][:GetPrefsRequest].merge!(req) if req.any?
-        curl_request(body)
-      end
-
-      def get_filter_rules(token)
-        soap_name = :GetFilterRulesRequest
-        body = init_hash_request(token, soap_name)
-        curl_request(body)
-      end
-
-      def modify_filter_rules(token, rules)
-        soap_name = :ModifyFilterRulesRequest
-        req = { filterRules: [{ filterRule: rules }] }
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(req)
-        curl_request(body)
-      end
-
-      def modify_prefs(token, hash)
-        soap_name = :ModifyPrefsRequest
-        body = init_hash_request(token, soap_name, ACCOUNTSPACE)
-
-        req = {
-          _attrs: hash
-        }
-
-        body[:Body][soap_name].merge!(req)
-
-        curl_request(body)
-      end
-
-      def get_signatures(token)
-        soap_name = :GetSignaturesRequest
-        body = init_hash_request(token, soap_name, ACCOUNTSPACE)
-        curl_request(body)
-      end
-
-      def create_signature(token, jsns)
-        soap_name = :CreateSignatureRequest
-        body = init_hash_request(token, soap_name, ACCOUNTSPACE)
-        body[:Body][soap_name].merge!(jsns)
-        curl_request(body)
-      end
-
-      def modify_signature(token, jsns)
-        soap_name = :ModifySignatureRequest
-        body = init_hash_request(token, soap_name, ACCOUNTSPACE)
-        body[:Body][soap_name].merge!(jsns)
-        curl_request(body)
+      def initialize(scheme, host, port)
+        super(scheme, host, port, SoapAccountConstants::ACCOUNT_SERVICE_URI)
       end
 
-      def delete_signature(token, jsns)
-        soap_name = :DeleteSignatureRequest
-        body = init_hash_request(token, soap_name, ACCOUNTSPACE)
-        body[:Body][soap_name].merge!(jsns)
-        curl_request(body)
-      end
+      def auth_preauth(content, by, expires, domainkey)
+        ts = (Time.now.to_i * 1000)
+        preauth = compute_preauth(content, by, ts, expires, domainkey)
 
-      # -------------------------------
-      # GENERIC
+        soap_request = SoapElement.account(SoapAccountConstants::AUTH_REQUEST)
+        node_account = SoapElement.create(SoapConstants::ACCOUNT).add_attribute(SoapConstants::BY,
+                                                                                by).add_content(content)
+        soap_request.add_node(node_account)
+        node_preauth = SoapElement.create(SoapConstants::PREAUTH).add_attribute(SoapConstants::TIMESTAMP,
+                                                                                ts).add_content(preauth)
+        soap_request.add_node(node_preauth)
 
-      def get_info(token, sections = 'mbox,prefs,attrs,zimlets,props,idents,sigs,dsrcs,children', rights = nil)
-        req = { rights: rights, sections: sections }.reject { |_, v| v.nil? }
-        body = init_hash_request(token, :GetInfoRequest, ACCOUNTSPACE)
-        body[:Body][:GetInfoRequest].merge!(req) if req.any?
-        curl_request(body)
+        do_login(soap_request)
       end
 
-      def search(token, types = nil, offset = nil, limit = nil, sortBy = nil, query = nil, options = {})
-        soap_name = :SearchRequest
-        # types: conversation|message|contact|appointment|task|wiki|document
-        req = {
-          types: types,
-          offset: offset,
-          limit: limit,
-          sortBy: sortBy,
-          query: query,
-          header: [{ n: 'messageIdHeader' }]
-        }.merge!(options)
-        req.reject! { |_, v| v.nil? }
+      def auth_password(content, by, password)
+        soap_request = SoapElement.account(SoapAccountConstants::AUTH_REQUEST)
+        node_account = SoapElement.create(SoapConstants::ACCOUNT).add_attribute(SoapConstants::BY,
+                                                                                by).add_content(content)
+        soap_request.add_node(node_account)
+        soap_request.add_attribute('password', password)
 
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(req) if req.any?
-        curl_request(body)
+        do_login(soap_request)
       end
 
-      def jsns_request(soap_name, token, jsns, namespace = MAILSPACE)
-        body = init_hash_request(token, soap_name, namespace)
-        body[:Body][soap_name].merge!(jsns) if jsns.is_a?(Hash)
-        curl_request(body)
-      end
-
-      def ranking_action(token, op, email = nil)
-        soap_name = :RankingActionRequest
-        req = {
-          action: {
-            op: op,
-            email: email
-          }
-        }
-        req[:action].delete_if { |_, v| v.nil? }
-
-        body = init_hash_request(token, soap_name)
-        body[:Body][soap_name].merge!(req) if req.any?
-
-        curl_request(body)
+      def do_login(soap_request)
+        invoke(soap_request)[:AuthResponse][:authToken].first[:_content]
       end
 
       private
 
-      def compute_preauth(mail, ts, domainkey)
-        data = "#{mail}|name|0|#{ts}"
+      def compute_preauth(content, by, ts, expires, domain_key)
+        data = "#{content}|#{by}|#{expires}|#{ts}"
         digest = OpenSSL::Digest.new('sha1')
-        hmac = OpenSSL::HMAC.hexdigest(digest, domainkey, data)
+        hmac = OpenSSL::HMAC.hexdigest(digest, domain_key, data)
         hmac.to_s
       end
-
-      def init_hash_request(token, soap_name, namespace = MAILSPACE)
-        {
-          Body: {
-            soap_name => { _jsns: namespace }
-          }
-        }.merge(hash_header(token))
-      end
     end
   end
 end