zm-ruby-client 2.2.6 → 3.0.0

data/lib/zm/client/tag/tag.rb

@@ -4,60 +4,24 @@ module Zm
   module Client
     # class account tag
     class Tag < Base::Object
-      # include Zm::Model::AttributeChangeObserver
+      include RequestMethodsMailbox
+      include MailboxItemConcern
 
-      attr_accessor :id, :name, :color, :rgb
-
-      # define_changed_attributes :name, :color, :rgb
+      attr_accessor :name, :color, :rgb
 
       def create!
-        rep = @parent.sacc.invoke(jsns_builder.to_jsns)
+        rep = @parent.soap_connector.invoke(build_create)
         json = rep[:CreateTagResponse][:tag].first
         TagJsnsInitializer.update(self, json)
-        @id
-      end
-
-      def modify!
-        # return unless color_changed? || rgb_changed?
-
-        @parent.sacc.invoke(jsns_builder.to_update)
-        true
-      end
-
-      def update!(hash)
-        return false if hash.delete_if { |k, v| v.nil? || !respond_to?(k) }.empty?
-
-        do_update!(hash)
-
-        hash.each do |key, value|
-          update_attribute(key, value)
-        end
-
-        true
-      end
-
-      def rename!(new_name)
-        return false if new_name == @name
-
-        @parent.sacc.invoke(jsns_builder.to_rename(new_name))
-        @name = new_name
-      end
-
-      def delete!
-        return false if @id.nil?
-
-        @parent.sacc.invoke(jsns_builder.to_delete)
-        @id = nil
+        id
       end
 
       private
 
-      def do_update!(hash)
-        @parent.sacc.invoke(jsns_builder.to_patch(hash))
-      end
-
       def jsns_builder
-        @jsns_builder ||= TagJsnsBuilder.new(self)
+        return @jsns_builder if defined? @jsns_builder
+
+        @jsns_builder = TagJsnsBuilder.new(self)
       end
     end
   end

data/lib/zm/client/tag/tag_jsns_builder.rb

@@ -9,7 +9,8 @@ module Zm
           name: @item.name,
           color: @item.color,
           rgb: @item.rgb
-        }.delete_if { |_, v| v.nil? }
+        }
+        attrs.compact!
 
         soap_request = SoapElement.mail(SoapMailConstants::CREATE_TAG_REQUEST)
         node_tag = SoapElement.create(SoapConstants::TAG).add_attributes(attrs)
@@ -25,7 +26,8 @@ module Zm
           id: @item.id,
           color: @item.color,
           rgb: @item.rgb
-        }.reject { |_, v| v.nil? }
+        }
+        attrs.compact!
 
         build(attrs)
       end

data/lib/zm/client/tag/tag_jsns_initializer.rb

@@ -6,15 +6,16 @@ module Zm
     class TagJsnsInitializer
       class << self
         def create(parent, json)
-          item = Tag.new(parent)
-          update(item, json)
+          Tag.new(parent).tap do |item|
+            update(item, json)
+          end
         end
 
         def update(item, json)
-          item.id = json[:id].to_i
-          item.name = json[:name]
-          item.color = json[:color].to_i
-          item.rgb = json[:rgb]
+          item.id = json.delete(:id)
+          item.name = json.delete(:name)
+          item.color = json.delete(:color)
+          item.rgb = json.delete(:rgb)
 
           item
         end

data/lib/zm/client/tag/tags_builder.rb

@@ -5,7 +5,7 @@ module Zm
     # class factory [tags]
     class TagBuilder < Base::ObjectsBuilder
       def initialize(parent, json)
-        super(parent, json)
+        super
         @json_item_key = :tag
       end
 

data/lib/zm/client/tag/tags_collection.rb

@@ -7,14 +7,15 @@ module Zm
       def initialize(parent)
         @child_class = Tag
         @builder_class = TagBuilder
-        super(parent)
+        super
       end
 
-      private
-
       def make_query
-        soap_request = SoapElement.mail(SoapMailConstants::GET_TAG_REQUEST)
-        @parent.sacc.invoke(soap_request)
+        @parent.soap_connector.invoke(build_query)
+      end
+
+      def build_query
+        SoapElement.mail(SoapMailConstants::GET_TAG_REQUEST)
       end
     end
   end

data/lib/zm/client/task/task.rb

@@ -7,12 +7,13 @@ module Zm
       include BelongsToFolder
       include BelongsToTag
 
-      attr_accessor :uid, :priority, :ptst, :percentComplete, :name, :loc, :alarm, :isOrg, :id, :invId, :compNum, :l,
-                    :status, :class, :allDay, :f, :tn, :t, :rev, :s, :d, :md, :ms, :cm, :sf
+      attr_accessor :uid, :priority, :ptst, :percentComplete, :name, :loc, :alarm, :isOrg,
+                    :id, :invId, :compNum, :l, :status, :class, :allDay, :f, :tn, :t, :rev,
+                    :s, :d, :md, :ms, :cm, :sf
 
-      def download(dest_file_path, fmt = 'ics')
-        uploader = Upload.new(@parent, RestAccountConnector.new)
-        uploader.download_file(Zm::Client::FolderDefault::ROOT[:path], fmt, [Zm::Client::FolderView::TASK], [@id], dest_file_path)
+      def download(dest_file_path, fmt: 'ics')
+        uploader = @parent.build_uploader
+        uploader.download_file(dest_file_path, id, FolderView::APPOINTMENT, fmt:)
       end
 
       def create!

data/lib/zm/client/task/task_jsns_initializer.rb

@@ -6,36 +6,37 @@ module Zm
     class TaskJsnsInitializer
       class << self
         def create(parent, json)
-          item = Task.new(parent)
-          update(item, json)
+          Task.new(parent).tap do |item|
+            update(item, json)
+          end
         end
 
         def update(item, json)
-          item.uid = json[:uid]
-          item.priority = json[:priority].to_i
-          item.ptst = json[:ptst]
-          item.percentComplete = json[:percentComplete].to_f
-          item.name = json[:name]
-          item.loc = json[:loc]
-          item.alarm = json[:alarm]
-          item.isOrg = json[:isOrg]
-          item.id = json[:id].to_i
-          item.invId = json[:invId]
-          item.compNum = json[:compNum]
-          item.l = json[:l].to_i
-          item.status = json[:status]
-          item.class = json[:class]
-          item.allDay = json[:allDay]
-          item.f = json[:f]
-          item.tn = json[:tn]
-          item.t = json[:t]
-          item.rev = json[:rev]
-          item.s = json[:s]
-          item.d = json[:d]
-          item.md = json[:md]
-          item.ms = json[:ms]
-          item.cm = json[:cm]
-          item.sf = json[:sf]
+          item.uid = json.delete(:uid)
+          item.priority = json.delete(:priority)
+          item.ptst = json.delete(:ptst)
+          item.percentComplete = json.delete(:percentComplete)
+          item.name = json.delete(:name)
+          item.loc = json.delete(:loc)
+          item.alarm = json.delete(:alarm)
+          item.isOrg = json.delete(:isOrg)
+          item.id = json.delete(:id).to_i
+          item.invId = json.delete(:invId)
+          item.compNum = json.delete(:compNum)
+          item.l = json.delete(:l).to_i
+          item.status = json.delete(:status)
+          item.class = json.delete(:class)
+          item.allDay = json.delete(:allDay)
+          item.f = json.delete(:f)
+          item.tn = json.delete(:tn)
+          item.t = json.delete(:t)
+          item.rev = json.delete(:rev)
+          item.s = json.delete(:s)
+          item.d = json.delete(:d)
+          item.md = json.delete(:md)
+          item.ms = json.delete(:ms)
+          item.cm = json.delete(:cm)
+          item.sf = json.delete(:sf)
 
           item
         end

data/lib/zm/client/task/tasks_builder.rb

@@ -5,7 +5,7 @@ module Zm
     # class factory [tasks]
     class TasksBuilder < Base::ObjectsBuilder
       def initialize(parent, json)
-        super(parent, json)
+        super
         @json_item_key = :task
       end
 

data/lib/zm/client/task/tasks_collection.rb

@@ -7,7 +7,7 @@ module Zm
       DEFAULT_QUERY = 'in:tasks'
 
       def initialize(parent)
-        super(parent)
+        super
         @child_class = Task
         @builder_class = TasksBuilder
         @type = 'task'
@@ -15,7 +15,7 @@ module Zm
       end
 
       def find_each(offset: 0, limit: 500, &block)
-        (1970..(Time.now.year + 10)).each do |year|
+        (Time.at(0).year..(Time.now.year + 10)).each do |year|
           @start_at = Time.new(year, 1, 1)
           @end_at = Time.new(year, 12, 31)
           @more = true

data/lib/zm/client/token.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    class Token
+      def initialize(str)
+        @str = str
+        @key_id, @hmac, @encoded = @str.split('_')
+      end
+
+      def to_s
+        @str
+      end
+
+      def decoded
+        return @decoded if defined? @decoded
+
+        @decoded = [@encoded].pack('H*')
+      end
+
+      def metadatas
+        return @metadatas if defined? @metadatas
+
+        @metadatas = decoded.split(';').to_h { |part| part.split(/=\d+:/) }.freeze
+      end
+
+      def zimbra_id
+        metadatas['id']
+      end
+
+      def admin?
+        return @admin if defined? @admin
+
+        @admin = metadatas['admin'] == '1'
+      end
+
+      def server_version
+        metadatas['version']
+      end
+
+      def expire_at
+        return @expire_at if defined? @expire_at
+
+        @expire_at = Time.at(metadatas['exp'].to_f / 1000).freeze
+      end
+
+      def expired?
+        expire_at < Time.now
+      end
+    end
+  end
+end

data/lib/zm/client/upload/upload.rb

@@ -2,148 +2,158 @@
 
 module Zm
   module Client
-    # class for upload account file
+    # class for upload mailbox file
     class Upload
       FMT_TYPES_H = {
-        'ics' => ['appointment'],
-        'vcard' => ['contact']
+        'ics' => FolderView::APPOINTMENT,
+        'vcard' => FolderView::CONTACT,
+        'eml' => FolderView::MESSAGE,
+        'vcf' => FolderView::CONTACT
       }.freeze
 
-      def initialize(parent, rac = nil)
-        @parent = parent
-        @rac = rac || @parent.rac
-        @rac.cookies("ZM_AUTH_TOKEN=#{@parent.token}")
-      end
+      AUTHORIZED_FOLDER_FMT = %w[zip tgz ics csv tar xml json rss atom html ifb].freeze
 
-      def download_file_with_url(url, dest_file_path)
-        raise ZmError, 'home_url is not defined' if @parent.home_url.nil?
+      AUTHORIZED_PARAMS = %i[charset auth fmt id list types emptyname disp resolve query meta csvfmt].freeze
 
-        url = File.join(@parent.home_url, url) unless url.start_with?('http')
-        @rac.download(url, dest_file_path)
-      end
+      AUTHORIZED_RESOLVE = %w[replace modify reset skip].freeze
+
+      attr_reader :rest_connector
+      attr_accessor :charset, :auth, :emptyname, :disp
+
+      def initialize(base_url, token, is_token_admin: false, **rest_options)
+        raise ZmError, 'base_url must to be present' if base_url.nil?
 
-      def download_file(folder_path, fmt, types, ids, dest_file_path)
-        @rac.download(download_file_url(folder_path, fmt, types, ids), dest_file_path)
+        @charset = 'UTF-8'
+        @auth = 'co'
+        @emptyname = 'Empty'
+        @disp = 'a'
+
+        yield(self) if block_given?
+
+        @base_url = base_url
+
+        @rest_connector = RestConnector.new(**rest_options) do |conn|
+          conn.cookies = if is_token_admin
+                           "ZM_ADMIN_AUTH_TOKEN=#{token}"
+                         else
+                           "ZM_AUTH_TOKEN=#{token}"
+                         end
+        end
       end
 
-      def download_folder(id, fmt, dest_file_path)
-        @rac.download(download_folder_url(id, fmt), dest_file_path)
+      def download_file(dest_file_path, file_id, type, fmt: nil)
+        fmt ||= File.extname(dest_file_path)[1..]
+        type ||= FMT_TYPES_H[fmt]
+
+        raise RestError, 'Invalid fmt type' if type.nil? && fmt.nil?
+
+        remote_url = download_file_url(fmt, type, file_id)
+        @rest_connector.download(remote_url, dest_file_path)
       end
 
-      def download_folder_url(id, fmt)
-        raise ZmError, 'home_url is not defined' if @parent.home_url.nil?
+      def read_file(file_id, type, fmt: nil)
+        type ||= FMT_TYPES_H[fmt]
 
-        url_folder_path = @parent.home_url.dup
+        raise RestError, 'Invalid fmt type' if type.nil? && fmt.nil?
 
-        h = {
-          fmt: fmt,
-          id: id,
-          emptyname: 'Empty',
-          charset: 'UTF-8',
-          auth: 'co',
-          disp: 'a'
-        }
+        remote_url = download_file_url(fmt, type, file_id)
+        @rest_connector.read(remote_url)
+      end
+
+      def download_files(dest_file_path, file_ids, type, fmt: nil)
+        fmt ||= File.extname(dest_file_path)[1..]
+        type ||= FMT_TYPES_H[fmt]
 
-        url_folder_path << '?' << Utils.format_url_params(h)
+        raise RestError, 'Invalid fmt type' if type.nil? && fmt.nil?
 
-        url_folder_path
+        remote_url = download_files_url(fmt, type, file_ids)
+        @rest_connector.download(remote_url, dest_file_path)
       end
 
-      def download_file_url(folder_path, fmt, types, ids = [])
-        raise ZmError, 'home_url is not defined' if @parent.home_url.nil?
+      def download_folder(dest_file_path, folder_id, fmt: nil)
+        fmt ||= File.extname(dest_file_path)[1..]
 
-        url_folder_path = File.join(@parent.home_url, folder_path.to_s)
+        raise RestError, 'Unauthorized fmt parameter' unless AUTHORIZED_FOLDER_FMT.include?(fmt)
 
-        h = {
-          fmt: fmt,
-          types: query_value_types(types, fmt),
-          emptyname: 'Empty',
-          charset: 'UTF-8',
-          auth: 'co',
-          disp: 'a'
-        }
+        remote_url = download_folder_url(folder_id, fmt)
+        @rest_connector.download(remote_url, dest_file_path)
+      end
 
-        h.merge!(query_ids(ids))
+      def send_file(src_file_path, folder_id, fmt: nil, type: nil, resolve: nil)
+        fmt ||= File.extname(src_file_path)[1..]
+        type ||= FMT_TYPES_H[fmt]
+        resolve ||= AUTHORIZED_RESOLVE.first
 
-        h.reject! { |_, v| is_blank?(v) }
+        raise RestError, 'Unauthorized resolve parameter' unless AUTHORIZED_RESOLVE.include?(resolve)
 
-        url_folder_path << '?' << Utils.format_url_params(h)
+        raise RestError, 'Invalid fmt type' if type.nil? && fmt.nil?
 
-        url_folder_path
+        remote_url = send_file_url(folder_id, fmt:, type:, resolve:)
+        @rest_connector.upload(remote_url, src_file_path)
       end
 
-      def send_file(folder_path, fmt, types, resolve, src_file_path)
-        @rac.upload(send_file_url(folder_path, fmt, types, resolve), src_file_path)
+      def upload_attachment(src_file_path)
+        @rest_connector.upload(upload_attachment_url, src_file_path)
       end
 
-      def send_file_url(folder_path, fmt, types, resolve)
-        raise ZmError, 'home_url is not defined' if @parent.home_url.nil?
+      def build_params(**params)
+        params.select! { |k, _| AUTHORIZED_PARAMS.include?(k) }
 
-        # resolve=[modfy|replace|reset|skip]
-        url_folder_path = File.join(@parent.home_url, Utils.format_url_path(folder_path.to_s))
+        params[:charset] ||= @charset
+        params[:auth] ||= @auth
+        params[:emptyname] ||= @emptyname
+        params[:disp] ||= @disp
 
-        h = {
-          fmt: fmt,
-          types: query_value_types(types, fmt),
-          resolve: resolve,
-          auth: 'co'
-        }
-
-        h.reject! { |_, v| is_blank?(v) }
+        params.compact!
 
-        url_folder_path << '?' << Utils.format_url_params(h)
+        params
+      end
 
-        url_folder_path
+      def format_url_params(params)
+        params.map { |k, v| "#{k}=#{v}" }.join('&')
       end
 
-      def send_attachment(src_file_path)
-        str = upload_attachment(src_file_path)
-        AttachmentResponse.new(str)
+      def format_url(url, str_params)
+        return url if str_params.nil? || str_params.empty?
+
+        "#{url}?#{str_params}"
       end
 
-      def upload_attachment(src_file_path)
-        @rac.upload(upload_attachment_url, src_file_path)
+      def download_file_with_url(url, dest_file_path)
+        url = File.join(@base_url, url) unless url.start_with?('http')
+        @rest_connector.download(url, dest_file_path)
       end
 
-      def upload_attachment_url
-        h = {
-          fmt: 'extended,raw'
-        }
+      def download_folder_url(folder_id, fmt)
+        h = build_params(fmt:, id: folder_id)
 
-        File.join(@parent.public_url, 'service/upload') << '?' << Utils.format_url_params(h)
+        format_url(@base_url, format_url_params(h))
       end
 
-      def query_ids(ids)
-        return {} if ids.nil?
-        return { id: ids } unless ids.is_a?(Array)
-        return { id: ids.first } if ids.length == 1
+      def download_file_url(fmt, type, id)
+        h = build_params(fmt:, types: type, id:)
 
-        { list: ids.join(',') }
+        format_url(@base_url, format_url_params(h))
       end
 
-      def query_value_types(types, fmt)
-        types = FMT_TYPES_H[fmt] if types.nil?
+      def download_files_url(fmt, type, ids)
+        h = build_params(fmt:, types: type, list: ids.join(','))
 
-        types = [types] unless types.is_a?(Array)
-        types.join(',')
+        format_url(@base_url, format_url_params(h))
       end
 
-      def is_blank?(v)
-        return false if v.is_a?(Numeric)
+      def send_file_url(folder_id, fmt:, type:, resolve:)
+        h = build_params(fmt:, types: type, resolve:, id: folder_id)
 
-        v.nil? || v.empty?
+        format_url(@base_url, format_url_params(h))
       end
-    end
 
-    # class to parse upload attachment response
-    class AttachmentResponse
-      def initialize(str)
-        @str = str
-        @str_h = JSON.parse(str[str.index('['), str.length], symbolize_names: true).first
-      end
+      def upload_attachment_url
+        h = {
+          fmt: 'extended,raw'
+        }
 
-      def aid
-        @str_h[:aid]
+        File.join(@base_url, 'service/upload') << '?' << format_url_params(h)
       end
     end
   end

data/lib/zm/client/zm_logger.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Zm
+  module Client
+    class ZmLogger < ::Logger
+      def initialize(*args, **kwargs)
+        super
+        @formatter ||= ZmFormatter.new
+      end
+
+      def colorize!
+        extend(ZmLoggerColorized)
+      end
+
+      class ZmFormatter < ::Logger::Formatter
+        Format = "[%s] %5s : %s\n"
+
+        def call(severity, time, _, msg)
+          format(Format, format_datetime(time), severity, msg2str(msg))
+        end
+      end
+
+      module ZmLoggerColorized
+        # ANSI sequence modes
+        MODES = {
+          clear: 0,
+          bold: 1,
+          italic: 3,
+          underline: 4
+        }.freeze
+
+        # ANSI sequence colors
+        BLACK   = "\e[30m"
+        RED     = "\e[31m"
+        GREEN   = "\e[32m"
+        YELLOW  = "\e[33m"
+        BLUE    = "\e[34m"
+        MAGENTA = "\e[35m"
+        CYAN    = "\e[36m"
+        WHITE   = "\e[37m"
+
+        def severity_color(severity)
+          case severity
+          when 'DEBUG'
+            CYAN
+          when 'INFO'
+            GREEN
+          when 'WARN'
+            YELLOW
+          when 'ERROR'
+            RED
+          when 'FATAL'
+            mode_code(:bold)
+          when 'ANY'
+            mode_code(:clear)
+          else
+            mode_code(:clear)
+          end
+        end
+
+        def mode_code(mode)
+          mode = mode.to_sym if mode.is_a?(String)
+          return unless (value = MODES[mode])
+
+          "\e[#{value}m"
+        end
+
+        def colorize_message(severity, str)
+          "#{severity_color(severity)}#{str}#{mode_code(:clear)}"
+        end
+
+        def format_message(severity, datetime, progname, msg)
+          colorize_message(
+            severity,
+            super
+          )
+        end
+      end
+    end
+  end
+end

data/lib/zm/client.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require 'date'
+
+require 'zm/client/soap_request'
 require 'zm/modules/inspector'
+require 'zm/support/cache'
+require 'zm/client/zm_logger'
 require 'zm/client/version'
 require 'zm/client/constant'
+require 'zm/client/token'
 require 'zm/client/base'
 require 'zm/client/cluster'
-require 'zm/client/soap_request'

data/lib/zm/modules/base.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'zm/modules/zm_logger'
 require 'zm/modules/zm_model'
 require 'zm/modules/missing_method_static_collection'