zm-ruby-client 0.18.5 → 2.0.0

data/lib/zm/client/base/account_search_objects_collection.rb

@@ -14,12 +14,13 @@ module Zm
         end
 
         def find(id)
-          rep = @parent.sacc.get_msg(@parent.token, id, { html: 1 })
-          entry = rep[:Body][:GetMsgResponse][:m].first
+          jsns = { m: { id: id, html: 1 } }
 
-          msg = @child_class.new(@parent)
-          msg.init_from_json(entry)
-          msg
+          soap_request = SoapElement.mail(SoapMailConstants::GET_MSG_REQUEST).add_attributes(jsns)
+          rep = @parent.sacc.invoke(soap_request)
+          entry = rep[:GetMsgResponse][:m].first
+
+          MessageJsnsInitializer.create(@parent, entry)
         end
 
         def start_at(start_at)
@@ -32,13 +33,18 @@ module Zm
           self
         end
 
-        def folders(folders)
+        def folders(*folders)
+          folders.select! { |folder| folder.is_a?(Zm::Client::Folder) }
+          return self if folders.empty?
+
           @folders = folders
-          @folder_ids = @folders.map(&:id)
-          self
+          folder_ids(*@folders.map(&:id))
         end
 
-        def folder_ids(folder_ids)
+        def folder_ids(*folder_ids)
+          folder_ids.uniq!
+          return self if @folder_ids == folder_ids
+
           @folder_ids = folder_ids
           self
         end
@@ -68,7 +74,21 @@ module Zm
         private
 
         def make_query
-          @parent.sacc.search(@parent.token, @type, @offset, @limit, @sort_by, query, build_options)
+          jsns = {
+            types: @type,
+            offset: @offset,
+            limit: @limit,
+            sortBy: @sort_by,
+            query: query,
+            header: @headers
+          }
+
+          jsns.merge!(build_options)
+
+          jsns.reject! { |_, v| v.nil? }
+
+          soap_request = SoapElement.mail(SoapMailConstants::SEARCH_REQUEST).add_attributes(jsns)
+          @parent.sacc.invoke(soap_request)
         end
 
         def search_builder
@@ -77,7 +97,7 @@ module Zm
 
         def search_response
           rep = make_query
-          @more = rep[:Body][:SearchResponse][:more]
+          @more = rep[:SearchResponse][:more]
           rep
         end
 
@@ -96,7 +116,7 @@ module Zm
 
           return nil if @folder_ids.empty?
 
-          @folder_ids.map { |id| %Q{inid:"#{id}"} }.join(' OR ')
+          @folder_ids.map { |id| %(inid:"#{id}") }.join(' OR ')
         end
 
         def build_options
@@ -106,7 +126,7 @@ module Zm
           {
             resultMode: @resultMode,
             calExpandInstStart: start_at_ts,
-            calExpandInstEnd: end_at_ts,
+            calExpandInstEnd: end_at_ts
           }.delete_if { |_, v| v.nil? }
         end
 
@@ -118,6 +138,7 @@ module Zm
           @query = nil
           @folder_ids = []
           @folders = []
+          @headers = [{ n: 'messageIdHeader' }]
         end
       end
     end

data/lib/zm/client/base/admin_objects_collection.rb

@@ -7,22 +7,42 @@ module Zm
       class AdminObjectsCollection < ObjectsCollection
         def initialize(parent)
           @parent = parent
+          @persistent = false
           reset_query_params
         end
 
+        def find_by(hash)
+          item = find_in_cache(hash)
+          return item unless item.nil?
+
+          find_by!(hash)
+        end
+
+        def find_by_or_nil(hash, error_handler = SoapError)
+          find_by(hash)
+        rescue error_handler => _e
+          nil
+        end
+
         def ldap
-          @apply_cos = 0
+          @all = nil
+          @apply_cos = SoapUtils::OFF
           self
         end
 
         def where(ldap_query)
-          @all = nil
-          ldap_filter.add(ldap_query)
+          @all = nil if ldap_filter.add(ldap_query)
 
           self
         end
 
         def attrs(*attrs)
+          attrs.map!(&:to_s)
+          attrs.map!(&:strip)
+          attrs.sort!
+          attrs.uniq!
+          attrs.delete_if { |attr| attr.nil? || attr.empty? }
+
           return self if @attrs == attrs
 
           @all = nil
@@ -31,33 +51,78 @@ module Zm
         end
 
         def count
+          reset_query_params
           @count_only = SoapUtils::ON
-          make_query[:Body][:SearchDirectoryResponse][:num]
+          json = make_query
+          @count_only = SoapUtils::OFF
+          json[:SearchDirectoryResponse][:num]
+        end
+
+        def clear
+          @all = nil
+          ldap_filter.clear
+          reset_query_params
+          self
+        end
+
+        def find_each(step = 1_000)
+          previous_persistent = @persistent.dup
+          @persistent = true
+
+          total = count
+
+          @all = []
+          @offset = 0
+          @limit = step
+
+          while @offset < total
+            @all += build_response
+            @offset += @limit
+          end
+
+          ldap_filter.clear
+          reset_query_params
+
+          @persistent = previous_persistent
+
+          @all
         end
 
         private
 
         def make_query
-          json = sac.search_directory(
-            ldap_filter.join, @max_result, @limit, @offset,
-            @domain_name, @apply_cos, @apply_config, @sort_by, @search_type,
-            @sort_ascending, @count_only, attrs_comma
-          )
-          reset_query_params
-          json
+          soap_request = SoapElement.admin(SoapAdminConstants::SEARCH_DIRECTORY_REQUEST)
+          soap_request.add_attributes(jsns)
+          response = sac.invoke(soap_request)
+          clear unless @persistent
+          response
         end
 
         def ldap_filter
           @ldap_filter ||= LdapFilter.new
         end
 
-        # def build_response
-        #   @builder_class.new(@parent, make_query).make
-        # end
+        def find_in_cache(hash)
+          return nil if @all.nil?
 
-        def reset_query_params
-          super
-          ldap_filter.clear
+          @all.find { |item| item.send(hash.keys.first) == hash.values.first }
+        end
+
+        def jsns
+          {
+            query: ldap_filter.join,
+            maxResults: @max_result,
+            limit: @limit,
+            offset: @offset,
+            domain: @domain_name,
+            applyCos: @apply_cos,
+            applyConfig: @apply_config,
+            sortBy: @sort_by,
+            types: @search_type,
+            sortAscending: @sort_ascending,
+            countOnly: @count_only,
+            attrs: attrs_comma
+          }.reject { |_, v| v.nil? }
         end
       end
     end

data/lib/zm/client/base/base_account_jsns_builder.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # class for account tag jsns builder
+    class BaseAccountJsnsBuilder
+      def initialize(item)
+        @item = item
+      end
+
+      def to_tag(tag_name = nil)
+        tag_name ||= @item.tn
+
+        attrs = {
+          op: :tag,
+          id: @item.id,
+          tn: tag_name
+        }
+
+        build(attrs)
+      end
+
+      def to_move(new_folder_id = nil)
+        new_folder_id ||= @item.l
+
+        attrs = {
+          op: :move,
+          id: @item.id,
+          l: new_folder_id
+        }
+
+        build(attrs)
+      end
+
+      def to_patch(hash)
+        attrs = {
+          op: :update,
+          id: @item.id
+        }.merge(hash)
+
+        attrs.reject! { |_, v| v.nil? }
+
+        build(attrs)
+      end
+
+      def to_delete
+        attrs = {
+          op: :delete,
+          id: @item.id
+        }
+
+        build(attrs)
+      end
+
+      def to_rename(new_name = nil)
+        new_name ||= @item.name
+
+        attrs = {
+          op: :rename,
+          id: @item.id,
+          name: new_name
+        }
+
+        build(attrs)
+      end
+
+      def to_color
+        attrs = {
+          op: :color,
+          id: @item.id,
+          rgb: @item.rgb,
+          color: @item.color
+        }
+
+        # attrs[:rgb] = @item.rgb if @item.rgb_changed?
+        # attrs[:color] = @item.color if @item.color_changed?
+
+        build(attrs)
+      end
+
+      def to_trash
+        attrs = {
+          op: :trash,
+          id: @item.id
+        }
+
+        build(attrs)
+      end
+
+      def build(attrs)
+        soap_request = SoapElement.mail(SoapMailConstants::ITEM_ACTION_REQUEST)
+        node_action = SoapElement.create(SoapConstants::ACTION).add_attributes(attrs)
+        soap_request.add_node(node_action)
+        soap_request
+      end
+    end
+  end
+end

data/lib/zm/client/base/base_jsns_builder.rb

@@ -5,14 +5,61 @@ module Zm
     module Base
       # class for account object jsns builder
       class BaseJsnsBuilder
+        A_ARRAY_PROC = ->(i) { i.last.is_a?(Array) ? i.last.map { |j| [i.first, j] } : [i] }
+        A_NODE_PROC = ->(n) { { n: n.first, _content: n.last } }
 
         def initialize(item)
           @item = item
         end
 
+        def to_jsns
+          {
+            name: @item.name,
+            a: instance_variables_array.map(&A_ARRAY_PROC).flatten(1).map(&A_NODE_PROC)
+          }
+        end
+
+        alias to_create to_jsns
+
+        def to_update
+          {
+            id: @item.id,
+            a: instance_variables_array.map(&A_ARRAY_PROC).flatten(1).map(&A_NODE_PROC)
+          }
+        end
+
+        def to_patch(hash)
+          {
+            id: @item.id,
+            a: hash.map(&A_ARRAY_PROC).flatten(1).map(&A_NODE_PROC)
+          }
+        end
+
         def to_delete
           { id: @item.id }
         end
+
+        def instance_variables_array
+          selected_attrs = @item.attrs_write.map { |a| arrow_name(a).to_sym }
+          attrs_only_set = @item.instance_variables & selected_attrs
+
+          arr = attrs_only_set.map do |name|
+            n = name.to_s[1..]
+            value = @item.instance_variable_get(name)
+            [n, value]
+          end
+
+          multi_value = arr.select { |a| a.last.is_a?(Array) }
+          arr.reject! { |a| a.last.is_a?(Array) || a.last.nil? }
+          multi_value.each { |a| arr += a.last.map { |v| [a.first, v] } }
+          arr
+        end
+
+        def arrow_name(name)
+          return name if name.to_s.start_with?('@')
+
+          "@#{name}"
+        end
       end
     end
   end

data/lib/zm/client/base/base_jsns_initializer.rb

@@ -5,23 +5,54 @@ module Zm
     module Base
       # class for account object jsns initializer
       class BaseJsnsInitializer
+        class << self
+          def update(item, json)
+            item.id = json[:id]
+            item.name = json[:name]
 
-        def initialize(parent, json)
-          @parent = parent
-          @json = json
-        end
+            formatted_json(json).each do |k, v|
+              valorise(item, k, v)
+            end
 
-        def create
-          @item ||= @child_class.new(@parent)
+            item
+          end
 
-          @item.instance_variable_set(:@id, @json[:id])
-          @item.instance_variable_set(:@name, @json[:name])
-        end
+          def formatted_json(json)
+            return [] if json[:a].nil?
+
+            json[:a].reject! { |n| n[:n].nil? }
+            json_map = json[:a].map { |n| [n[:n], n[:_content]] }.freeze
+
+            hash_multivalued = json_map.each_with_object({}) do |(k, v), h|
+              h[k] ||= []
+              h[k].push(v)
+            end
+
+            hash_multivalued.transform_values do |v|
+              v.length == 1 ? v.first : v
+            end
+          end
+
+          def valorise(item, k, v)
+            setter_method_name = "#{k}="
+            return unless item.respond_to?(setter_method_name)
+
+            item.send(setter_method_name, convert_json_string_value(v))
+          end
+
+          def convert_json_string_value(value)
+            return value unless value.is_a?(String)
+            return 0 if value == '0'
 
-        def arrow_name(name)
-          return name if name.to_s.start_with?('@')
+            c = value.to_i
+            c.to_s == value ? c : value
+          end
 
-          "@#{name}"
+          # def arrow_name(name)
+          #   return name if name.to_s.start_with?('@')
+          #
+          #   "@#{name}"
+          # end
         end
       end
     end

data/lib/zm/client/base/ldap_filter.rb

@@ -3,17 +3,19 @@
 module Zm
   module Client
     class LdapFilter
+      include Zm::Inspector
+
       def initialize(base_filter = nil)
         @base_filter = base_filter
         @parts = []
       end
 
       def add(filter)
-        if filter.is_a?(String) && !filter.empty?
-          @parts << filter
-        elsif filter.is_a?(Hash)
-          @parts += filter.map { |k, v| "(#{k}=#{v})" }
-        end
+        new_filter = stringify_filter(filter)
+        return false if new_filter.nil? || @parts.include?(new_filter)
+
+        @parts << new_filter
+        true
       end
 
       def clear
@@ -28,6 +30,19 @@ module Zm
 
         "(&#{arr.join})"
       end
+
+      private
+
+      def stringify_filter(filter)
+        return nil if !filter.is_a?(String) && !filter.is_a?(Hash)
+
+        return filter.map { |k, v| "(#{k}=#{v})" }.join if filter.is_a?(Hash)
+
+        new_filter = filter.strip
+        return nil if new_filter.empty?
+
+        new_filter
+      end
     end
   end
 end

data/lib/zm/client/base/mailbox_infos_collection.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    class MailboxInfosCollection
+      def initialize(parent)
+        @parent = parent
+        @sections = []
+        @rights = []
+      end
+
+      def all
+        @all || all!
+      end
+
+      def all!
+        build_response
+      end
+
+      def clear
+        reset_query_params
+        @all.clear
+      end
+
+      def sections(*entries)
+        @sections += entries
+        self
+      end
+
+      def rights(*entries)
+        @rights += entries
+        self
+      end
+
+      def read
+        reset_query_params
+        @sections = ['mbox']
+        rep = build_response
+        @parent.id = rep[:id]
+        @parent.used = rep[:used]
+        @parent.public_url = rep[:publicURL]
+        @parent.zimbraCOSId = rep[:cos][:id]
+        @parent.home_url = rep[:rest]
+        rep
+      end
+
+      private
+
+      def build_response
+        @all = make_query[:GetInfoResponse]
+      end
+
+      def make_query
+        soap_request = SoapElement.account(SoapAccountConstants::GET_INFO_REQUEST).add_attributes(jsns)
+        @parent.sacc.invoke(soap_request)
+      end
+
+      def jsns
+        { rights: @rights.join(','), sections: @sections.join(',') }.reject { |_, v| v.empty? }
+      end
+
+      def reset_query_params
+        @sections.clear
+        @rights.clear
+      end
+    end
+  end
+end