zm-ruby-client 0.18.3 → 2.0.2

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

@@ -3,312 +3,84 @@
 module Zm
   module Client
     # class message for account
-    class Message < Base::AccountObject
-      INSTANCE_VARIABLE_KEYS = %i[id date l su fr autoSendTime mid idnt]
-      attr_accessor *INSTANCE_VARIABLE_KEYS
+    class Message < Base::Object
+      include BelongsToFolder
+      include BelongsToTag
 
-      attr_accessor :subject
-      attr_reader :recipients, :attachments, :body, :folder
+      attr_accessor :id, :d, :l, :f, :su, :fr, :autoSendTime, :mid, :idnt, :tn, :subject
+      attr_reader :recipients, :attachments, :body
 
-      def initialize(parent, json = nil)
+      def initialize(parent)
         @parent = parent
-        @recipients = Recipients.new
         @subject = ''
-        @body = Body.new
-        @attachments = Attachments.new
 
-        init_from_json(json) if json.is_a?(Hash)
+        @recipients = Recipients.new
+        @body = Body.new
+        @attachments = AttachmentsCollection.new
 
         yield(self) if block_given?
       end
 
-      def has_attachment?
-        @has_attachment ||= @attachments.all.any?
+      def download(dest_file_path, fmt = 'eml')
+        uploader = Upload.new(@parent, RestAccountConnector.new)
+        uploader.download_file( Zm::Client::FolderDefault::ROOT[:path], fmt, [Zm::Client::FolderView::MESSAGE], [@id], dest_file_path)
       end
 
-      def all_instance_variable_keys
-        INSTANCE_VARIABLE_KEYS
+      def date
+        @date ||= Time.at(d.to_i / 1000)
       end
 
-      def from
-        @from ||= @recipients.find { |r| r.field == Recipient::FROM }
+      def flags
+        @flags ||= FlagsCollection.new(self)
       end
 
-      def folder=(folder)
-        @folder = folder
-        @l = folder.id
+      def create!(*args)
+        raise NotImplementedError
       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
+      def modify!(*args)
+        raise NotImplementedError
       end
 
-      def unread!
-        msg_action('!read')
+      def update!(*args)
+        raise NotImplementedError
       end
 
-      def read!
-        msg_action('read')
+      def rename!(*args)
+        raise NotImplementedError
       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 delete!
+        return false if @id.nil?
 
-      def tag!(tag_name)
-        msg_action('tag', tn: tag_name)
+        @parent.sacc.invoke(jsns_builder.to_delete)
+        @id = nil
       end
 
       def unspam!
-        msg_action('!spam')
+        @parent.sacc.invoke(jsns_builder.to_unspam)
       end
 
       def spam!
-        msg_action('spam')
-      end
-
-      def trash!
-        msg_action('trash')
+        @parent.sacc.invoke(jsns_builder.to_spam)
       end
 
       def send!
-        @parent.sacc.send_msg(@parent.token, to_jsns)
-      end
-
-      def to_jsns
-        h = {
-          id: @id,
-          attach: @attachments.to_jsns,
-          e: @recipients.to_jsns,
-          su: { _content: @su },
-          mp: @body.to_jsns
-        }.delete_if { |_, v| v.nil? }
-
-        h[:did] = @id if l.to_i == FolderDefault::DRAFTS[:id]
-
-        h
-      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]
-        @autoSendTime   = json[:autoSendTime]
-        @mid  = json[:mid]
-        @idnt = json[:idnt]
-        @has_attachment = json[:f].to_s.include?('a')
-
-        json[:e].each do |e|
-          recipient = Recipient.new(e[:t], e[:a], e[:p])
-          @recipients.add(recipient)
-        end
-
-        init_part_from_json(json[:mp])
-      end
-
-      def init_part_from_json(json)
-        return if json.nil?
-        # puts json
-        json = [json] unless json.is_a?(Array)
-
-        json.each do |json_part|
-          if ['text/plain', 'text/html'].include?(json_part[:ct])
-            init_body_from_json(json_part)
-          elsif json_part[:cd] == 'attachment'
-            init_attachment_from_json(json_part)
-          else
-            init_part_from_json(json_part[:mp])
-          end
-        end
-      end
-
-      def init_body_from_json(json)
-        # puts "\ninit_body_from_json #{json}\n"
-        body.text = json[:content] if json[:ct] == 'text/plain'
-        body.html = json[:content] if json[:ct] == 'text/html'
-      end
-
-      def init_attachment_from_json(json)
-        # puts "\ninit_attachment_from_json #{json}\n"
-        pj = Zm::Client::Message::Attachment.new(self)
-        # pj.part = json[:part],
-        pj.mid  = json[:mid]
-        pj.aid  = json[:aid]
-        pj.ct   = json[:ct]
-        pj.s    = json[:s]
-        pj.filename = json[:filename]
-        pj.ci   = json[:ci]
-        pj.cd   = json[:cd]
-        pj.part = json[:part]
-        attachments.add(pj)
-      end
-
-      def msg_action(action_name, options = {})
-        @parent.sacc.msg_action(@parent.token, action_name, id, options)
-        true
+        soap_request = SoapElement.mail(SoapMailConstants::SEND_MSG_REQUEST).add_attributes(jsns_builder.to_jsns)
+        @parent.sacc.invoke(soap_request)
       end
 
       # content fo an email
       class Body
         attr_accessor :text, :html
-
-        def text_jsns
-          @text.nil? ? nil : { ct: 'text/plain', content: { _content: @text } }
-        end
-
-        def html_jsns
-          @html.nil? ? nil : { ct: 'text/html', content: { _content: @html } }
-        end
-
-        def to_jsns
-          [
-            {
-              ct: 'multipart/alternative',
-              mp: [text_jsns, html_jsns].compact
-            }
-          ]
-        end
-      end
-
-      # collection attachments
-      class Attachments
-        attr_reader :all
-        def initialize
-          @all = []
-        end
-
-        def add(attachment)
-          return unless attachment.is_a?(Attachment)
-
-          @all.push(attachment)
-        end
-
-        def to_jsns
-          @all.map(&:to_jsns)
-        end
-      end
-
-      # class attachment for email
-      class Attachment
-        attr_accessor :aid, :part, :mid, :ct, :s, :filename, :ci, :cd
-
-        def initialize(parent)
-          @parent = parent
-          yield(self) if block_given?
-        end
-
-        def download(dest_file_path)
-          h = {
-            id: @parent.id,
-            part: part,
-            auth: 'qp',
-            zauthtoken: account.token,
-            disp: 'a'
-          }
-
-          url = account.home_url
-
-          uri = Addressable::URI.new
-          uri.query_values = h
-          url << '?' << uri.query
-
-          uploader = Upload.new(@parent, RestAccountConnector.new)
-          uploader.download_file_with_url(url, dest_file_path)
-        end
-
-        def to_jsns
-          {
-            part: part,
-            mid: mid,
-            aid: aid,
-            ct: ct,
-            s: s,
-            filename: filename,
-            ci: ci,
-            cd: cd
-          }.reject { |_, v| v.nil? }
-        end
-
-        def account
-          @parent.parent
-        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
+      def sacc
+        @parent.sacc
       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_s
-          "#{@email} (#{@display_name})"
-        end
-
-        def to_jsns
-          {
-            t: @field,
-            a: @email,
-            p: @display_name
-          }.reject { |_, v| v.nil? }
-        end
+      def jsns_builder
+        @jsns_builder ||= MessageJsnsBuilder.new(self)
       end
     end
   end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # class message for account
+    class Message
+      class FlagsCollection
+        def initialize(parent)
+          @parent = parent
+        end
+
+        def all
+          @all || all!
+        end
+
+        def all!
+          @parent.f.to_s.chars
+        end
+
+        # properties
+
+        def unread?
+          all.include?('u')
+        end
+
+        def flagged?
+          all.include?('f')
+        end
+
+        def attachment?
+          all.include?('a')
+        end
+
+        def replied
+          all.include?('r')
+        end
+
+        def sent_by_me?
+          all.include?('s')
+        end
+
+        def forwarded?
+          all.include?('w')
+        end
+
+        def calendar_invite?
+          all.include?('v')
+        end
+
+        def draft?
+          all.include?('d')
+        end
+
+        def imap_deleted?
+          all.include?('x')
+        end
+
+        def notification?
+          all.include?('n')
+        end
+
+        def urgent?
+          all.include?('!')
+        end
+
+        def low_priority?
+          all.include?('?')
+        end
+
+        def priority?
+          all.include?('+')
+        end
+
+        # actions
+
+        def unread!
+          attrs = { op: '!read', id: @parent.id }
+          @parent.sacc.invoke(build(attrs))
+        end
+
+        def read!
+          attrs = { op: 'read', id: @parent.id }
+          @parent.sacc.invoke(build(attrs))
+        end
+
+        def unflag!
+          attrs = { op: '!flag', id: @parent.id }
+          @parent.sacc.invoke(build(attrs))
+        end
+
+        def flag!
+          attrs = { op: 'flag', id: @parent.id }
+          @parent.sacc.invoke(build(attrs))
+        end
+
+        private
+
+        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
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # class for account message jsns builder
+    class MessageJsnsBuilder < BaseAccountJsnsBuilder
+      def initialize(item)
+        @item = item
+      end
+
+      def to_jsns
+        jsns = {
+          id: @item.id,
+          attach: attachments_jsns,
+          e: recipients_jsns,
+          su: { _content: @item.su },
+          mp: body_jsns
+        }.delete_if { |_, v| v.nil? }
+
+        jsns[:did] = @item.id if @item.l.to_i == FolderDefault::DRAFTS[:id]
+
+        jsns
+      end
+
+      def attachments_jsns
+        @item.attachments.all.map do |attachment|
+          {
+            part: attachment.part,
+            mid: attachment.mid,
+            aid: attachment.aid,
+            ct: attachment.ct,
+            s: attachment.s,
+            filename: attachment.filename,
+            ci: attachment.ci,
+            cd: attachment.cd
+          }.reject { |_, v| v.nil? }
+        end
+      end
+
+      def recipients_jsns
+        return nil if @item.recipients.all.empty?
+
+        @item.recipients.all.map do |recipient|
+          {
+            t: recipient.field,
+            a: recipient.email,
+            p: recipient.display_name
+          }.reject { |_, v| v.nil? }
+        end
+      end
+
+      def body_jsns
+        return nil if @item.body.text.nil? && @item.body.html.nil?
+
+        text_jsns = @item.body.text.nil? ? nil : { ct: ContentType::TEXT, content: { _content: @item.body.text } }
+        html_jsns = @item.body.html.nil? ? nil : { ct: ContentType::HTML, content: { _content: @item.body.html } }
+
+        [
+          {
+            ct: ContentPart::ALTERNATIVE,
+            mp: [text_jsns, html_jsns].compact
+          }
+        ]
+      end
+
+      def to_spam
+        attrs = {
+          op: :spam,
+          id: @item.id
+        }
+
+        build(attrs)
+      end
+
+      def to_unspam
+        attrs = {
+          op: '!spam',
+          id: @item.id
+        }
+
+        build(attrs)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    # class for initialize account message
+    class MessageJsnsInitializer
+      class << self
+        def create(parent, json)
+          item = Message.new(parent)
+          update(item, json)
+        end
+
+        def update(item, json)
+          item.id = json[:id]
+          item.d = json[:d]
+          item.l    = json[:l]
+          item.su   = json[:su]
+          item.fr   = json[:fr]
+          item.autoSendTime = json[:autoSendTime]
+          item.mid  = json[:mid]
+          item.idnt = json[:idnt]
+          item.f = json[:f]
+          item.tn = json[:tn].to_s.split(',')
+
+          json[:e].each do |e|
+            recipient = Recipient.new(e[:t], e[:a], e[:p])
+            item.recipients.add(recipient)
+          end
+
+          update_mps(item, json[:mp])
+
+          item
+        end
+
+        def update_mps(item, mps)
+          return if mps.nil?
+
+          mps = [mps] unless mps.is_a?(Array)
+
+          mps.each do |mp|
+            if ContentType::ALL.include?(mp[:ct])
+              update_body(item, mp)
+            elsif mp[:cd] == 'attachment'
+              update_attachment(item, mp)
+            else
+              update_mps(item, mp[:mp])
+            end
+          end
+        end
+
+        def update_body(item, json)
+          item.body.text = json[:content] if json[:ct] == ContentType::TEXT
+          item.body.html = json[:content] if json[:ct] == ContentType::HTML
+        end
+
+        def update_attachment(item, json)
+          pj = Zm::Client::Message::Attachment.new(self)
+          pj.mid  = json[:mid]
+          pj.aid  = json[:aid]
+          pj.ct   = json[:ct]
+          pj.s    = json[:s]
+          pj.filename = json[:filename]
+          pj.ci   = json[:ci]
+          pj.cd   = json[:cd]
+          pj.part = json[:part]
+          item.attachments.add(pj)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    class Message
+      # Collection recipients
+      class Recipients
+        attr_reader :all
+
+        def initialize
+          @all = []
+        end
+
+        def add(recipient)
+          return unless recipient.is_a?(Zm::Client::Recipient)
+
+          @all.push(recipient)
+        end
+
+        def to
+          @all.select { |r| r.field == Zm::Client::Recipient::TO }
+        end
+
+        def cc
+          @all.select { |r| r.field == Zm::Client::Recipient::CC }
+        end
+
+        def bcc
+          @all.select { |r| r.field == Zm::Client::Recipient::BCC }
+        end
+
+        def from
+          @all.select { |r| r.field == Zm::Client::Recipient::FROM }
+        end
+      end
+
+      # Class one recipient for email
+      class Recipient
+        FROM = :f
+        TO = :t
+        CC = :c
+        BCC = :b
+
+        attr_accessor :field, :email
+        attr_writer :display_name
+
+        def initialize(field, email, display_name = nil)
+          @email = email
+          @field = field.to_sym
+          @display_name = display_name
+        end
+
+        def display_name
+          @display_name || "#{@email} (#{@display_name})"
+        end
+      end
+    end
+  end
+end

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

@@ -4,28 +4,17 @@ module Zm
   module Client
     # class factory [messages]
     class MessagesBuilder < Base::ObjectsBuilder
-      def initialize(account, json)
-        @account = account
-        @json = json
+      def initialize(parent, json)
+        super(parent, json)
+        @json_item_key = :m
       end
 
       def make
-        root.map do |s|
-          Message.new(@account, s)
-        end
-      end
-
-      def ids
-        hits = @json.dig(:Body, :SearchResponse, :hit) || []
-        hits.map { |s| s[:id] }
-      end
-
-      def root
-        root = @json[:Body][:SearchResponse][:m]
-        return [] if root.nil?
+        return [] if json_items.nil?
 
-        root = [root] unless root.is_a?(Array)
-        root
+        json_items.map do |entry|
+          MessageJsnsInitializer.create(@parent, entry)
+        end
       end
     end
   end