zm-ruby-client 0.10.4

data/lib/zm/client/message/message.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # class message for account
+    class Message < Base::AccountObject
+      INSTANCE_VARIABLE_KEYS = %i[id date l su fr]
+      attr_accessor *INSTANCE_VARIABLE_KEYS
+
+      attr_accessor :subject
+      attr_reader :recipients, :attachments, :body, :folder
+
+      def initialize(parent, json = nil)
+        @parent = parent
+        @recipients = Recipients.new
+        @subject = ''
+        @body = Body.new
+        @attachments = Attachments.new
+
+        init_from_json(json) if json.is_a?(Hash)
+
+        yield(self) if block_given?
+      end
+
+      def from
+        @from ||= @recipients.find { |r| r.field == Recipient::FROM }
+      end
+
+      def folder=(folder)
+        @folder = folder
+        @l = folder.id
+      end
+
+      def to_jsns
+        {
+          attach: @attachments.to_jsns,
+          e: @recipients.to_jsns,
+          su: { _content: @subject },
+          mp: @body.to_jsns
+        }
+      end
+
+      def delete!
+        msg_action('delete')
+      end
+
+      def move!(folder_id = l)
+        msg_action('move', l: folder_id)
+        l = folder_id if l != folder_id
+      end
+
+      def unread!
+        msg_action('!read')
+      end
+
+      def read!
+        msg_action('read')
+      end
+
+      def unflag!
+        msg_action('!flag')
+      end
+
+      def flag!
+        msg_action('flag')
+      end
+
+      def untag!(tag_name)
+        msg_action('!tag', tn: tag_name)
+      end
+
+      def tag!(tag_name)
+        msg_action('tag', tn: tag_name)
+      end
+
+      def unspam!
+        msg_action('!spam')
+      end
+
+      def spam!
+        msg_action('spam')
+      end
+
+      def trash!
+        msg_action('trash')
+      end
+
+      def send!
+        @parent.sacc.send_msg(@parent.token, to_jsns)
+      end
+
+      def init_from_json(json)
+        # puts json
+        @id   = json[:id]
+        @date = Time.at(json[:d]/1000)
+        @l    = json[:l]
+        @su   = json[:su]
+        @fr   = json[:fr]
+
+        json[:e].each do |e|
+          recipient = Recipient.new(e[:t], e[:a], e[:p])
+          @recipients.add(recipient)
+        end
+      end
+
+      def msg_action(action_name, options = {})
+        @parent.sacc.msg_action(@parent.token, action_name, id, options)
+        true
+      end
+
+      # content fo an email
+      class Body
+        attr_accessor :text, :html
+
+        def text_jsns
+          { ct: 'text/plain', content: { _content: @text } }
+        end
+
+        def html_jsns
+          { ct: 'text/html', content: { _content: @html } }
+        end
+
+        def to_jsns
+          [
+            {
+              ct: 'multipart/alternative',
+              mp: [text_jsns, html_jsns]
+            }
+          ]
+        end
+      end
+
+      # collection attachments
+      class Attachments
+        def initialize
+          @attachments = []
+        end
+
+        def add(attachment)
+          return unless attachment.is_a?(Attachment)
+
+          @attachments.push(attachment)
+        end
+
+        def to_jsns
+          @attachments.map(&:to_jsns)
+        end
+      end
+
+      # class attachment for email
+      class Attachment
+        attr_accessor :aid, :part, :mid
+
+        def initialize
+          yield(self) if block_given?
+        end
+
+        def to_jsns
+          {
+            part: @part,
+            mid: @mid,
+            aid: @aid
+          }.reject { |_, v| v.nil? }
+        end
+      end
+
+      # Collection recipients
+      class Recipients
+        def initialize
+          @recipients = []
+        end
+
+        def to_jsns
+          @recipients.map(&:to_jsns)
+        end
+
+        def add(recipient)
+          return unless recipient.is_a?(Recipient)
+
+          @recipients.push(recipient)
+        end
+
+        def to
+          @recipients.select { |r| r.field == Recipient::TO }
+        end
+
+        def cc
+          @recipients.select { |r| r.field == Recipient::CC }
+        end
+
+        def bcc
+          @recipients.select { |r| r.field == Recipient::BCC }
+        end
+
+        def from
+          @recipients.select { |r| r.field == Recipient::FROM }
+        end
+      end
+
+      # Class one recipient for email
+      class Recipient
+        FROM = :f
+        TO = :t
+        CC = :c
+        BCC = :b
+
+        attr_accessor :field, :email, :display_name
+
+        def initialize(field, email, display_name = nil)
+          @email = email
+          @field = field.to_sym
+          @display_name = display_name
+        end
+
+        def to_jsns
+          {
+            t: @field,
+            a: @email,
+            p: @display_name
+          }.reject { |_, v| v.nil? }
+        end
+      end
+    end
+  end
+end

data/lib/zm/client/message/messages_builder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # class factory [messages]
+    class MessagesBuilder < Base::ObjectsBuilder
+      def initialize(account, json)
+        @account = account
+        @json = json
+      end
+
+      def make
+        root.map do |s|
+          Message.new(@account, s)
+        end
+      end
+
+      def ids
+        root.map { |s| s[:id] }
+      end
+
+      def root
+        root = @json[:Body][:SearchResponse][:m]
+        return [] if root.nil?
+
+        root = [root] unless root.is_a?(Array)
+        root
+      end
+    end
+  end
+end

data/lib/zm/client/message/messages_collection.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # Collection Messages
+    class MessagesCollection < Base::ObjectsCollection
+      attr_accessor :more
+
+      def initialize(parent)
+        @parent = parent
+        @more = true
+        reset_query_params
+      end
+
+
+      def find(id)
+        rep = @parent.sacc.get_msg(@parent.token, id, { part: 0 })
+        entry = rep[:Body][:GetMsgResponse][:m].first
+        # puts entry
+        msg = Message.new(@parent)
+        msg.init_from_json(entry)
+        msg
+      end
+
+      def new
+        message = Message.new(@parent)
+        yield(message) if block_given?
+        message
+      end
+
+      def start_at(start_at)
+        @start_at = start_at
+        self
+      end
+
+      def end_at(end_at)
+        @end_at = end_at
+        self
+      end
+
+      def folders(folders)
+        @folders = folders
+        @folder_ids = @folders.map(&:id)
+        self
+      end
+
+      def folder_ids(folder_ids)
+        @folder_ids = folder_ids
+        self
+      end
+
+      def where(query)
+        @query = query
+        self
+      end
+
+      def ids
+        search_builder.ids
+      end
+
+      def all
+        build_response
+      end
+
+      private
+
+      def search_response
+        rep = @parent.sacc.search(@parent.token, 'message', @offset, @limit, 'dateDesc', query, build_options)
+        @more = rep[:Body][:SearchResponse][:more]
+        rep
+      end
+
+      def search_builder
+        MessagesBuilder.new(@parent, search_response)
+      end
+
+      def build_response
+        messages = search_builder.make
+        messages.each { |msg| msg.folder = find_folder(msg) } unless @folders.empty?
+        messages
+      end
+
+      def build_options
+        {
+          recip: 2
+        }
+      end
+
+      def query
+        return @query unless @query.nil?
+
+        return nil if @folder_ids.empty?
+
+        @folder_ids.map { |id| %Q{inid:"#{id}"} }.join(' OR ')
+      end
+
+      def find_folder(message)
+        @folders.find { |folder| folder.id == message.l }
+      end
+
+      def reset_query_params
+        super
+        @start_at = nil
+        @end_at = nil
+        @query = nil
+        @folder_ids = []
+        @folders = []
+      end
+    end
+  end
+end

data/lib/zm/client/message.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'zm/client/message/message'
+require 'zm/client/message/messages_builder'
+require 'zm/client/message/messages_collection'

data/lib/zm/client/mountpoint/mountpoint.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # class for account mountpoint
+    class MountPoint < Base::AccountObject
+      INSTANCE_VARIABLE_KEYS = %i[
+        owner rev reminder ms deletable l rid uuid url f broken
+        luuid ruuid activesyncdisabled absFolderPath view zid name id
+        webOfflineSyncDays color rgb
+      ].freeze
+
+      attr_accessor(*INSTANCE_VARIABLE_KEYS)
+
+      def concat
+        INSTANCE_VARIABLE_KEYS.map { |key| instance_variable_get(arrow_name(key)) }
+      end
+
+      alias parent_id l
+
+      def initialize(parent, json = nil)
+        @parent = parent
+        @l = 1
+        init_from_json(json) if json.is_a?(Hash)
+        yield(self) if block_given?
+      end
+
+      def create!
+        rep = @parent.sacc.create_mountpoint(@parent.token, build_create_options)
+        init_from_json(rep[:Body][:CreateMountpointResponse][:link].first)
+      end
+
+      def build_create_options
+        {
+          l: @l,
+          name: @name,
+          view: @view,
+          zid: @zid,
+          rid: @rid,
+          url: @url,
+          color: @color,
+          rgb: @rgb,
+          f: @f
+        }.delete_if { |_, v| v.nil? }
+      end
+
+      def modify!
+        update!(build_update_options)
+      end
+
+      def update!(options)
+        @parent.sacc.folder_action(@parent.token, 'update', @id, options)
+      end
+
+      def build_update_options
+        {
+          f: @f,
+          name: @name,
+          l: @l,
+          color: @color,
+          rgb: @rgb
+        }.delete_if { |_, v| v.nil? }
+      end
+
+      def rename!(new_name)
+        @parent.sacc.folder_action(@parent.token, 'rename', @id, name: new_name)
+        @name = new_name
+      end
+
+      def move!(folder_id)
+        @parent.sacc.folder_action(@parent.token, 'move', @id, l: folder_id)
+        @l = folder_id
+      end
+
+      def color!(new_color)
+        key = new_color.to_i.zero? ? :rgb : :color
+        options = {}
+        options[key] = new_color
+        @parent.sacc.folder_action(@parent.token, 'color', @id, options)
+        instance_variable_set("@#{key}", new_color)
+      end
+
+      def delete!
+        @parent.sacc.folder_action(@parent.token, :delete, @id)
+      end
+
+      def init_from_json(json)
+        INSTANCE_VARIABLE_KEYS.each do |key|
+          var_name = "@#{key}"
+          instance_variable_set(var_name, json[key])
+        end
+      end
+    end
+  end
+end

data/lib/zm/client/mountpoint/mountpoints_builder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # class factory [mountpoints]
+    class MountPointsBuilder < Base::ObjectsBuilder
+      def initialize(account, json)
+        @account = account
+        @json = json
+        @key_link = :link
+        @key_folder = :folder
+        @list = []
+      end
+
+      def make
+        root = @json[:Body][:GetFolderResponse][@key_folder]
+
+        construct_tree(root)
+
+        @list
+      end
+
+      def construct_tree(json_folders)
+        json_folders.each do |json_folder|
+          if json_folder[@key_link].is_a?(Array)
+            @list += json_folder[@key_link].map do |json_link|
+              MountPoint.new(@account, json_link)
+            end
+          end
+
+          next if json_folder[@key_folder].nil? || json_folder[@key_folder].empty?
+
+          construct_tree(json_folder[@key_folder])
+        end
+      end
+    end
+  end
+end

data/lib/zm/client/mountpoint/mountpoints_collection.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # collection of mountpoints
+    class MountPointsCollection < Base::ObjectsCollection
+      METHODS_MISSING_LIST = %i[select each map length].to_set.freeze
+
+      attr_reader :root
+
+      def initialize(parent)
+        @parent = parent
+        @root = nil
+        reset_query_params
+      end
+
+      def new
+        mountpoint = MountPoint.new(@parent)
+        yield(mountpoint) if block_given?
+        mountpoint
+      end
+
+      def where(view: nil, tr: nil)
+        @view = view
+        @tr = tr
+        @all = nil
+        self
+      end
+
+      def all
+        @all || all!
+      end
+
+      def all!
+        build_response
+      end
+
+      def clear
+        @all = nil
+        @root = nil
+        reset_query_params
+      end
+
+      private
+
+      def build_response
+        @all = MountPointsBuilder.new(@parent, make_query).make
+        @all
+      end
+
+      def make_query
+        @parent.sacc.get_all_folders(@parent.token, @view, @tr)
+      end
+
+      def reset_query_params
+        @view = nil
+        @tr = nil
+      end
+    end
+  end
+end

data/lib/zm/client/mountpoint.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'zm/client/mountpoint/mountpoint'
+require 'zm/client/mountpoint/mountpoints_builder'
+require 'zm/client/mountpoint/mountpoints_collection'

data/lib/zm/client/mta_queue/mta_queue.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'zm/client/mta_queue_item'
+
+module Zm
+  module Client
+    class MtaQueue < Base::AdminObject
+      attr_reader :name, :n
+
+      alias nb_items n
+
+      def server
+        parent
+      end
+
+      def to_h
+        hashmap = Hash[all_instance_variable_keys.map { |key| [key, instance_variable_get(arrow_name(key))] }]
+        hashmap.delete_if { |_, v| v.nil? }
+        hashmap
+      end
+
+      def to_s
+        to_h.to_s
+      end
+
+      def all_instance_variable_keys
+        %w[name n]
+      end
+
+      def items
+        @items ||= MtaQueueItemsCollection.new self
+      end
+
+      def do_action(action_name, ids)
+        sac.mail_queue_action(parent.name, name, action_name, ids)
+      end
+
+      def hold!(ids)
+        do_action(Zm::Client::MtaQueueAction::HOLD, ids)
+      end
+
+      def release!(ids)
+        do_action(Zm::Client::MtaQueueAction::RELEASE, ids)
+      end
+
+      def delete!(ids)
+        do_action(Zm::Client::MtaQueueAction::DELETE, ids)
+      end
+
+      def requeue!(ids)
+        do_action(Zm::Client::MtaQueueAction::REQUEUE, ids)
+      end
+
+      def init_from_json(json)
+        @name = json[:name]
+        @n = json[:n].to_i
+      end
+    end
+  end
+end

data/lib/zm/client/mta_queue/mta_queues_builder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # class factory [MtaQueue]
+    class MtaQueuesBuilder < Base::ObjectsBuilder
+      def make
+        records = []
+        return records if json_items.nil?
+
+        json_items.each do |entry|
+          mta_queue = MtaQueue.new(@parent)
+          mta_queue.init_from_json(entry)
+          records << mta_queue
+        end
+        records
+      end
+
+      private
+
+      def json_items
+        @json_items ||= @json[:Body][json_key][:server].first[:queue]
+      end
+    end
+  end
+end