viewpoint 1.1.1 → 2.0.0

data/lib/ews/types/item.rb

@@ -1,447 +1,451 @@
-module Viewpoint::EWS::Types
-  module Item
-    include Viewpoint::EWS
-    include Viewpoint::EWS::Types
-    include ItemFieldUriMap
-
-    def self.included(klass)
-      klass.extend ClassMethods
-    end
+# frozen_string_literal: true
+
+module Viewpoint
+  module EWS
+    module Types
+      # Item EWS data type.
+      module Item
+        include Viewpoint::EWS
+        include Viewpoint::EWS::Types
+        include ItemFieldUriMap
+
+        def self.included(klass)
+          klass.extend ClassMethods
+        end
 
-    module ClassMethods
-      def init_simple_item(ews, id, change_key = nil, parent = nil)
-        ews_item = {item_id: {attribs: {id: id, change_key: change_key}}}
-        self.new ews, ews_item, parent
-      end
-    end
+        # Class-level helpers for EWS item types.
+        module ClassMethods
+          def init_simple_item(ews, id, change_key = nil, parent = nil)
+            ews_item = { item_id: { attribs: { id: id, change_key: change_key } } }
+            new ews, ews_item, parent
+          end
+        end
 
-    ITEM_KEY_PATHS = {
-      item_id:        [:item_id, :attribs],
-      id:             [:item_id, :attribs, :id],
-      change_key:     [:item_id, :attribs, :change_key],
-      subject:        [:subject, :text],
-      sensitivity:    [:sensitivity, :text],
-      size:           [:size, :text],
-      date_time_sent: [:date_time_sent, :text],
-      date_time_created: [:date_time_created, :text],
-      last_modified_time: [:last_modified_time, :text],
-      mime_content: [:mime_content, :text],
-      has_attachments?:[:has_attachments, :text],
-      is_associated?: [:is_associated, :text],
-      is_read?:       [:is_read, :text],
-      is_draft?:      [:is_draft, :text],
-      is_submitted?:  [:is_submitted, :text],
-      conversation_id:[:conversation_id, :attribs, :id],
-      categories:     [:categories, :elems],
-      internet_message_id:[:internet_message_id, :text],
-      internet_message_headers:[:internet_message_headers, :elems],
-      sender:         [:sender, :elems, 0, :mailbox, :elems],
-      from:           [:from, :elems, 0, :mailbox, :elems],
-      to_recipients:  [:to_recipients, :elems],
-      cc_recipients:  [:cc_recipients, :elems],
-      attachments:    [:attachments, :elems],
-      importance:     [:importance, :text],
-      conversation_index:     [:conversation_index, :text],
-      conversation_topic:     [:conversation_topic, :text],
-      body_type: [:body, :attribs, :body_type],
-      body: [:body, :text]
-    }
-
-    ITEM_KEY_TYPES = {
-      size:               ->(str){str.to_i},
-      date_time_sent:     ->(str){DateTime.parse(str)},
-      date_time_created:  ->(str){DateTime.parse(str)},
-      last_modified_time: ->(str){DateTime.parse(str)},
-      has_attachments?:   ->(str){str.downcase == 'true'},
-      is_associated?:     ->(str){str.downcase == 'true'},
-      is_read?:           ->(str){str.downcase == 'true'},
-      is_draft?:          ->(str){str.downcase == 'true'},
-      is_submitted?:      ->(str){str.downcase == 'true'},
-      categories:         ->(obj){obj.collect{|s| s[:string][:text]}},
-      internet_message_headers: ->(obj){obj.collect{|h|
-          {h[:internet_message_header][:attribs][:header_name] =>
-            h[:internet_message_header][:text]} } },
-      sender: :build_mailbox_user,
-      from:   :build_mailbox_user,
-      to_recipients:   :build_mailbox_users,
-      cc_recipients:   :build_mailbox_users,
-      attachments: :build_attachments,
-    }
-
-    ITEM_KEY_ALIAS = {
-      :read?        => :is_read?,
-      :draft?       => :is_draft?,
-      :submitted?   => :is_submitted?,
-      :associated?  => :is_associated?,
-    }
-
-    attr_reader :ews_item, :parent
-
-    # @param ews [SOAP::ExchangeWebService] the EWS reference
-    # @param ews_item [Hash] the EWS parsed response document
-    # @param parent [GenericFolder] an optional parent object
-    def initialize(ews, ews_item, parent = nil)
-      super(ews, ews_item)
-      @parent = parent
-      @body_type = false
-      simplify!
-      @new_file_attachments = []
-      @new_item_attachments = []
-      @new_inline_attachments = []
-    end
+        ITEM_KEY_PATHS = {
+          item_id: %i[item_id attribs],
+          id: %i[item_id attribs id],
+          change_key: %i[item_id attribs change_key],
+          subject: %i[subject text],
+          sensitivity: %i[sensitivity text],
+          size: %i[size text],
+          date_time_sent: %i[date_time_sent text],
+          date_time_created: %i[date_time_created text],
+          last_modified_time: %i[last_modified_time text],
+          mime_content: %i[mime_content text],
+          has_attachments?: %i[has_attachments text],
+          is_associated?: %i[is_associated text],
+          is_read?: %i[is_read text],
+          is_draft?: %i[is_draft text],
+          is_submitted?: %i[is_submitted text],
+          conversation_id: %i[conversation_id attribs id],
+          categories: %i[categories elems],
+          internet_message_id: %i[internet_message_id text],
+          internet_message_headers: %i[internet_message_headers elems],
+          sender: [:sender, :elems, 0, :mailbox, :elems],
+          from: [:from, :elems, 0, :mailbox, :elems],
+          to_recipients: %i[to_recipients elems],
+          cc_recipients: %i[cc_recipients elems],
+          attachments: %i[attachments elems],
+          importance: %i[importance text],
+          conversation_index: %i[conversation_index text],
+          conversation_topic: %i[conversation_topic text],
+          body_type: %i[body attribs body_type],
+          body: %i[body text]
+        }.freeze
+
+        ITEM_KEY_TYPES = {
+          size: lambda(&:to_i),
+          date_time_sent: ->(str) { DateTime.parse(str) },
+          date_time_created: ->(str) { DateTime.parse(str) },
+          last_modified_time: ->(str) { DateTime.parse(str) },
+          has_attachments?: ->(str) { str.downcase == 'true' },
+          is_associated?: ->(str) { str.downcase == 'true' },
+          is_read?: ->(str) { str.downcase == 'true' },
+          is_draft?: ->(str) { str.downcase == 'true' },
+          is_submitted?: ->(str) { str.downcase == 'true' },
+          categories: ->(obj) { obj.collect { |s| s[:string][:text] } },
+          internet_message_headers: lambda { |obj|
+            obj.collect { |h|
+              { h[:internet_message_header][:attribs][:header_name] =>
+                h[:internet_message_header][:text] }
+            }
+          },
+          sender: :build_mailbox_user,
+          from: :build_mailbox_user,
+          to_recipients: :build_mailbox_users,
+          cc_recipients: :build_mailbox_users,
+          attachments: :build_attachments
+        }.freeze
+
+        ITEM_KEY_ALIAS = {
+          read?: :is_read?,
+          draft?: :is_draft?,
+          submitted?: :is_submitted?,
+          associated?: :is_associated?
+        }.freeze
+
+        attr_reader :ews_item, :parent
+
+        # @param ews [SOAP::ExchangeWebService] the EWS reference
+        # @param ews_item [Hash] the EWS parsed response document
+        # @param parent [GenericFolder] an optional parent object
+        def initialize(ews, ews_item, parent = nil)
+          super(ews, ews_item)
+          @parent = parent
+          @body_type = false
+          simplify!
+          @new_file_attachments = []
+          @new_item_attachments = []
+          @new_inline_attachments = []
+        end
 
-    # Specify a body_type to fetch this item with if it hasn't already been fetched.
-    # @param body_type [String, Symbol, FalseClass] must be :best, :text, or
-    #   :html. You can also set it to false to make it use the default.
-    def default_body_type=(body_type)
-      @body_type = body_type
-    end
+        # Specify a body_type to fetch this item with if it hasn't already been fetched.
+        # @param body_type [String, Symbol, FalseClass] must be :best, :text, or
+        #   :html. You can also set it to false to make it use the default.
+        def default_body_type=(body_type)
+          @body_type = body_type
+        end
 
-    def delete!(deltype = :hard, opts = {})
-      opts = {
-        :delete_type => delete_type(deltype),
-        :item_ids => [{:item_id => {:id => id}}]
-      }.merge(opts)
+        def delete!(deltype = :hard, opts = {})
+          opts = {
+            delete_type: delete_type(deltype),
+            item_ids: [{ item_id: { id: id } }]
+          }.merge(opts)
+
+          resp = @ews.delete_item(opts)
+          rmsg = resp.response_messages[0]
+          unless rmsg.success?
+            raise EwsError,
+                  "Could not delete #{self.class}. #{rmsg.response_code}: #{rmsg.message_text}"
+          end
 
-      resp = @ews.delete_item(opts)
-      rmsg = resp.response_messages[0]
-      unless rmsg.success?
-        raise EwsError, "Could not delete #{self.class}. #{rmsg.response_code}: #{rmsg.message_text}"
-      end
-      true
-    end
+          true
+        end
 
-    def recycle!
-      delete! :recycle
-    end
+        def recycle!
+          delete! :recycle
+        end
 
-    def get_all_properties!
-      @ews_item = get_item(base_shape: 'AllProperties')
-      simplify!
-    end
+        def get_all_properties!
+          @ews_item = get_item(base_shape: 'AllProperties')
+          simplify!
+        end
 
-    # Mark an item as read
-    def mark_read!
-      update_is_read_status true
-    end
+        # Mark an item as read
+        def mark_read!
+          update_is_read_status true
+        end
 
-    # Mark an item as unread
-    def mark_unread!
-      update_is_read_status false
-    end
+        # Mark an item as unread
+        def mark_unread!
+          update_is_read_status false
+        end
 
-    # Move this item to a new folder
-    # @param [String,Symbol,GenericFolder] new_folder The new folder to move it to. This should
-    #   be a subclass of GenericFolder, a DistinguishedFolderId (must me a Symbol) or a FolderId (String)
-    # @return [String] the new Id of the moved item
-    def move!(new_folder)
-      new_folder = new_folder.id if new_folder.kind_of?(GenericFolder)
-      move_opts = {
-        :to_folder_id => {:id => new_folder},
-        :item_ids => [{:item_id => {:id => self.id}}]
-      }
-      resp = @ews.move_item(move_opts)
-      rmsg = resp.response_messages[0]
-
-      if rmsg.success?
-        obj = rmsg.items.first
-        itype = obj.keys.first
-        obj[itype][:elems][0][:item_id][:attribs][:id]
-      else
-        raise EwsError, "Could not move item. #{resp.code}: #{resp.message}"
-      end
-    end
+        # Move this item to a new folder
+        # @param [String,Symbol,GenericFolder] new_folder The new folder to move it to. This should
+        #   be a subclass of GenericFolder, a DistinguishedFolderId (must me a Symbol) or a FolderId (String)
+        # @return [String] the new Id of the moved item
+        def move!(new_folder)
+          new_folder = new_folder.id if new_folder.is_a?(GenericFolder)
+          move_opts = {
+            to_folder_id: { id: new_folder },
+            item_ids: [{ item_id: { id: id } }]
+          }
+          resp = @ews.move_item(move_opts)
+          rmsg = resp.response_messages[0]
 
-    # Copy this item to a new folder
-    # @param [String,Symbol,GenericFolder] new_folder The new folder to move it to. This should
-    #   be a subclass of GenericFolder, a DistinguishedFolderId (must me a Symbol) or a FolderId (String)
-    # @return [String] the new Id of the copied item
-    def copy(new_folder)
-      new_folder = new_folder.id if new_folder.kind_of?(GenericFolder)
-      copy_opts = {
-        :to_folder_id => {:id => new_folder},
-        :item_ids => [{:item_id => {:id => self.id}}]
-      }
-      resp = @ews.copy_item(copy_opts)
-      rmsg = resp.response_messages[0]
-
-      if rmsg.success?
-        obj = rmsg.items.first
-        itype = obj.keys.first
-        obj[itype][:elems][0][:item_id][:attribs][:id]
-      else
-        raise EwsError, "Could not copy item. #{rmsg.response_code}: #{rmsg.message_text}"
-      end
-    end
+          raise EwsError, "Could not move item. #{resp.code}: #{resp.message}" unless rmsg.success?
 
-    def add_file_attachment(file)
-      fa = OpenStruct.new
-      fa.name     = File.basename(file.path)
-      fa.content  = Base64.encode64(file.read)
-      @new_file_attachments << fa
-    end
+          obj = rmsg.items.first
+          itype = obj.keys.first
+          obj[itype][:elems][0][:item_id][:attribs][:id]
+        end
 
-    def add_item_attachment(other_item, name = nil)
-      ia = OpenStruct.new
-      ia.name = (name ? name : other_item.subject)
-      ia.item = {id: other_item.id, change_key: other_item.change_key}
-      @new_item_attachments << ia
-    end
+        # Copy this item to a new folder
+        # @param [String,Symbol,GenericFolder] new_folder The new folder to move it to. This should
+        #   be a subclass of GenericFolder, a DistinguishedFolderId (must me a Symbol) or a FolderId (String)
+        # @return [String] the new Id of the copied item
+        def copy(new_folder)
+          new_folder = new_folder.id if new_folder.is_a?(GenericFolder)
+          copy_opts = {
+            to_folder_id: { id: new_folder },
+            item_ids: [{ item_id: { id: id } }]
+          }
+          resp = @ews.copy_item(copy_opts)
+          rmsg = resp.response_messages[0]
 
-    def add_inline_attachment(file)
-      fi = OpenStruct.new
-      fi.name     = File.basename(file.path)
-      fi.content  = Base64.encode64(file.read)
-      @new_inline_attachments << fi
-    end
+          raise EwsError, "Could not copy item. #{rmsg.response_code}: #{rmsg.message_text}" unless rmsg.success?
 
-    def submit!
-      if draft?
-        submit_attachments!
-        resp = ews.send_item(item_ids: [{item_id: {id: self.id, change_key: self.change_key}}])
-        rm = resp.response_messages[0]
-        if rm.success?
-          true
-        else
-          raise EwsSendItemError, "#{rm.code}: #{rm.message_text}"
+          obj = rmsg.items.first
+          itype = obj.keys.first
+          obj[itype][:elems][0][:item_id][:attribs][:id]
         end
-      else
-        false
-      end
-    end
 
-    def submit_attachments!
-      return false unless draft? && !(@new_file_attachments.empty? && @new_item_attachments.empty? && @new_inline_attachments.empty?)
-
-      opts = {
-        parent_id: {id: self.id, change_key: self.change_key},
-        files: @new_file_attachments,
-        items: @new_item_attachments,
-        inline_files: @new_inline_attachments
-      }
-      resp = ews.create_attachment(opts)
-      set_change_key resp.response_messages[0].attachments[0].parent_change_key
-      @new_file_attachments = []
-      @new_item_attachments = []
-      @new_inline_attachments = []
-    end
+        def add_file_attachment(file)
+          fa = OpenStruct.new
+          fa.name     = File.basename(file.path)
+          fa.content  = Base64.encode64(file.read)
+          @new_file_attachments << fa
+        end
 
-    # If you want to add to the body set #new_body_content. If you set #body
-    # it will override the body that is there.
-    # @see MessageAccessors#send_message for options
-    #   additional options:
-    #     :new_body_content, :new_body_type
-    # @example
-    #   item.forward do |i|
-    #     i.new_body_content = "Add this to the top"
-    #     i.to_recipients << 'test@example.com'
-    #   end
-    def forward(opts = {})
-      msg = Template::ForwardItem.new opts.clone
-      yield msg if block_given?
-      msg.reference_item_id = {id: self.id, change_key: self.change_key}
-      dispatch_create_item! msg
-    end
+        def add_item_attachment(other_item, name = nil)
+          ia = OpenStruct.new
+          ia.name = (name || other_item.subject)
+          ia.item = { id: other_item.id, change_key: other_item.change_key }
+          @new_item_attachments << ia
+        end
 
-    def reply_to(opts = {})
-      msg = Template::ReplyToItem.new opts.clone
-      yield msg if block_given?
-      msg.reference_item_id = {id: self.id, change_key: self.change_key}
-      dispatch_create_item! msg
-    end
+        def add_inline_attachment(file)
+          fi = OpenStruct.new
+          fi.name     = File.basename(file.path)
+          fi.content  = Base64.encode64(file.read)
+          @new_inline_attachments << fi
+        end
 
-    def reply_to_all(opts = {})
-      msg = Template::ReplyToItem.new opts.clone
-      yield msg if block_given?
-      msg.reference_item_id = {id: self.id, change_key: self.change_key}
-      msg.ews_type = :reply_all_to_item
-      dispatch_create_item! msg
-    end
+        def submit!
+          if draft?
+            submit_attachments!
+            resp = ews.send_item(item_ids: [{ item_id: { id: id, change_key: change_key } }])
+            rm = resp.response_messages[0]
+            rm.success? || raise(EwsSendItemError, "#{rm.code}: #{rm.message_text}")
+          else
+            false
+          end
+        end
 
+        def submit_attachments!
+          new_attachments = @new_file_attachments + @new_item_attachments + @new_inline_attachments
+          return false unless draft? && !new_attachments.empty?
 
-    private
+          opts = {
+            parent_id: { id: id, change_key: change_key },
+            files: @new_file_attachments,
+            items: @new_item_attachments,
+            inline_files: @new_inline_attachments
+          }
+          resp = ews.create_attachment(opts)
+          set_change_key resp.response_messages[0].attachments[0].parent_change_key
+          @new_file_attachments = []
+          @new_item_attachments = []
+          @new_inline_attachments = []
+        end
 
-    def key_paths
-      super.merge(ITEM_KEY_PATHS)
-    end
+        # If you want to add to the body set #new_body_content. If you set #body
+        # it will override the body that is there.
+        # @see MessageAccessors#send_message for options
+        #   additional options:
+        #     :new_body_content, :new_body_type
+        # @example
+        #   item.forward do |i|
+        #     i.new_body_content = "Add this to the top"
+        #     i.to_recipients << 'test@example.com'
+        #   end
+        def forward(opts = {})
+          msg = Template::ForwardItem.new opts.clone
+          yield msg if block_given?
+          msg.reference_item_id = { id: id, change_key: change_key }
+          dispatch_create_item! msg
+        end
 
-    def key_types
-      super.merge(ITEM_KEY_TYPES)
-    end
+        def reply_to(opts = {})
+          msg = Template::ReplyToItem.new opts.clone
+          yield msg if block_given?
+          msg.reference_item_id = { id: id, change_key: change_key }
+          dispatch_create_item! msg
+        end
 
-    def key_alias
-      super.merge(ITEM_KEY_ALIAS)
-    end
+        def reply_to_all(opts = {})
+          msg = Template::ReplyToItem.new opts.clone
+          yield msg if block_given?
+          msg.reference_item_id = { id: id, change_key: change_key }
+          msg.ews_type = :reply_all_to_item
+          dispatch_create_item! msg
+        end
+
+        private
 
-    def update_is_read_status(read)
-      field = :is_read
-      opts = {item_changes:
-        [
-          { item_id: {id: id, change_key: change_key},
-            updates: [
-              {set_item_field: {field_uRI: {field_uRI: FIELD_URIS[field][:text]},
-                message: {sub_elements: [{field => {text: read}}]}}}
-            ]
+        def key_paths
+          super.merge(ITEM_KEY_PATHS)
+        end
+
+        def key_types
+          super.merge(ITEM_KEY_TYPES)
+        end
+
+        def key_alias
+          super.merge(ITEM_KEY_ALIAS)
+        end
+
+        def update_is_read_status(read)
+          field = :is_read
+          opts = { item_changes:
+            [
+              { item_id: { id: id, change_key: change_key },
+                updates: [
+                  { set_item_field: { field_uRI: { field_uRI: FIELD_URIS[field][:text] },
+                                      message: { sub_elements: [{ field => { text: read } }] } } }
+                ] }
+            ] }
+          resp = ews.update_item({ conflict_resolution: 'AutoResolve' }.merge(opts))
+          rmsg = resp.response_messages[0]
+          raise EwsError, "#{rmsg.response_code}: #{rmsg.message_text}" unless rmsg.success?
+
+          true
+        end
+
+        def simplify!
+          return unless @ews_item.key?(:elems)
+
+          @ews_item = @ews_item[:elems].each_with_object({}) do |i, o|
+            key = i.keys.first
+            if o.key?(key)
+              if o[key].is_a?(Array)
+                o[key] << i[key]
+              else
+                o[key] = [o.delete(key), i[key]]
+              end
+            else
+              o[key] = i[key]
+            end
+          end
+        end
+
+        # Get a specific item by its ID.
+        # @param [Hash] opts Misc options to control request
+        # @option opts [String] :base_shape IdOnly/Default/AllProperties
+        # @raise [EwsError] raised when the backend SOAP method returns an error.
+        def get_item(opts = {})
+          args = get_item_args(opts)
+          resp = ews.get_item(args)
+          get_item_parser(resp)
+        end
+
+        # Build up the arguements for #get_item
+        # @todo: should we really pass the ChangeKey or do we want the freshest obj?
+        def get_item_args(opts)
+          opts[:base_shape] ||= 'Default'
+          default_args = {
+            item_shape: { base_shape: opts[:base_shape] },
+            item_ids: [{ item_id: { id: id, change_key: change_key } }]
           }
-        ]
-      }
-      resp = ews.update_item({conflict_resolution: 'AutoResolve'}.merge(opts))
-      rmsg = resp.response_messages[0]
-      unless rmsg.success?
-        raise EwsError, "#{rmsg.response_code}: #{rmsg.message_text}"
-      end
-      true
-    end
+          default_args[:item_shape][:body_type] = @body_type if @body_type
+          default_args
+        end
 
-    def simplify!
-      return unless @ews_item.has_key?(:elems)
-      @ews_item = @ews_item[:elems].inject({}) do |o,i|
-        key = i.keys.first
-        if o.has_key?(key)
-          if o[key].is_a?(Array)
-            o[key] << i[key]
-          else
-            o[key] = [o.delete(key), i[key]]
+        def get_item_parser(resp)
+          rm = resp.response_messages[0]
+          unless rm.status == 'Success'
+            raise EwsError,
+                  "Could not retrieve #{self.class}. #{rm.code}: #{rm.message_text}"
           end
-        else
-          o[key] = i[key]
+
+          rm.items[0].values.first
         end
-        o
-      end
-    end
 
-    # Get a specific item by its ID.
-    # @param [Hash] opts Misc options to control request
-    # @option opts [String] :base_shape IdOnly/Default/AllProperties
-    # @raise [EwsError] raised when the backend SOAP method returns an error.
-    def get_item(opts = {})
-      args = get_item_args(opts)
-      resp = ews.get_item(args)
-      get_item_parser(resp)
-    end
+        # Map a delete type to what EWS expects
+        # @param [Symbol] type. Must be :hard, :soft, or :recycle
+        def delete_type(type)
+          case type
+          when :hard then 'HardDelete'
+          when :soft then 'SoftDelete'
+          when :recycle then 'MoveToDeletedItems'
+          else 'MoveToDeletedItems'
+          end
+        end
 
-    # Build up the arguements for #get_item
-    # @todo: should we really pass the ChangeKey or do we want the freshest obj?
-    def get_item_args(opts)
-      opts[:base_shape] ||= 'Default'
-      default_args = {
-        item_shape: {base_shape: opts[:base_shape]},
-        item_ids:   [{item_id:{id: id, change_key: change_key}}]
-      }
-      default_args[:item_shape][:body_type] = @body_type if @body_type
-      default_args
-    end
+        def build_deleted_occurrences(occurrences)
+          occurrences.collect { |a| DateTime.parse a[:deleted_occurrence][:elems][0][:start][:text] }
+        end
 
-    def get_item_parser(resp)
-      rm = resp.response_messages[0]
-      if(rm.status == 'Success')
-        rm.items[0].values.first
-      else
-        raise EwsError, "Could not retrieve #{self.class}. #{rm.code}: #{rm.message_text}"
-      end
-    end
+        def build_modified_occurrences(occurrences)
+          {}.tap do |h|
+            occurrences.collect do |a|
+              elems = a[:occurrence][:elems]
 
-    # Map a delete type to what EWS expects
-    # @param [Symbol] type. Must be :hard, :soft, or :recycle
-    def delete_type(type)
-      case type
-      when :hard then 'HardDelete'
-      when :soft then 'SoftDelete'
-      when :recycle then 'MoveToDeletedItems'
-      else 'MoveToDeletedItems'
-      end
-    end
+              h[DateTime.parse(elems.find { |e| e[:original_start] }[:original_start][:text])] = {
+                start: elems.find { |e| e[:start] }[:start][:text],
+                end: elems.find { |e| e[:end] }[:end][:text]
+              }
+            end
+          end
+        end
 
-    def build_deleted_occurrences(occurrences)
-      occurrences.collect{|a| DateTime.parse a[:deleted_occurrence][:elems][0][:start][:text]}
-    end
+        def build_mailbox_user(mbox_ews)
+          MailboxUser.new(ews, mbox_ews)
+        end
 
-    def build_modified_occurrences(occurrences)
-      {}.tap do |h|
-        occurrences.collect do |a|
-          elems = a[:occurrence][:elems]
+        def build_mailbox_users(users)
+          return [] if users.nil?
 
-          h[DateTime.parse(elems.find{|e| e[:original_start]}[:original_start][:text])] = {
-            start: elems.find{|e| e[:start]}[:start][:text],
-            end: elems.find{|e| e[:end]}[:end][:text]
-          }
+          users.collect { |u| build_mailbox_user(u[:mailbox][:elems]) }
         end
-      end
-    end
 
-    def build_mailbox_user(mbox_ews)
-      MailboxUser.new(ews, mbox_ews)
-    end
+        def build_attendees_users(users)
+          return [] if users.nil?
 
-    def build_mailbox_users(users)
-      return [] if users.nil?
-      users.collect{|u| build_mailbox_user(u[:mailbox][:elems])}
-    end
+          users.collect { |u|
+            u[:attendee][:elems].collect do |a|
+              build_mailbox_user(a[:mailbox][:elems]) if a[:mailbox]
+            end
+          }.flatten.compact
+        end
 
-    def build_attendees_users(users)
-      return [] if users.nil?
-      users.collect do |u|
-        u[:attendee][:elems].collect do |a|
-          build_mailbox_user(a[:mailbox][:elems]) if a[:mailbox]
+        def build_attachments(attachments)
+          return [] if attachments.nil?
+
+          attachments.collect do |att|
+            key = att.keys.first
+            class_by_name(key).new(self, att[key])
+          end
         end
-      end.flatten.compact
-    end
 
-    def build_attachments(attachments)
-      return [] if attachments.nil?
-      attachments.collect do |att|
-        key = att.keys.first
-        class_by_name(key).new(self, att[key])
-      end
-    end
+        def set_change_key(change_key) # rubocop:disable Naming/AccessorMethodName -- public API name
+          p = resolve_key_path(ews_item, key_paths[:change_key][0..-2])
+          p[:change_key] = change_key
+        end
 
-    def set_change_key(ck)
-      p = resolve_key_path(ews_item, key_paths[:change_key][0..-2])
-      p[:change_key] = ck
-    end
+        # Handles the CreateItem call for Forward, ReplyTo, and ReplyAllTo
+        # It will handle the neccessary actions for adding attachments.
+        def dispatch_create_item!(msg)
+          if msg.has_attachments?
+            draft = msg.draft
+            msg.draft = true
+            resp = validate_created_item(ews.create_item(msg.to_ews))
+            msg.file_attachments.each do |f|
+              next unless f.is_a?(File)
+
+              resp.add_file_attachment(f)
+            end
+            if draft
+              resp.submit_attachments!
+              resp
+            else
+              resp.submit!
+            end
+          else
+            resp = ews.create_item(msg.to_ews)
+            validate_created_item resp
+          end
+        end
 
-    # Handles the CreateItem call for Forward, ReplyTo, and ReplyAllTo
-    # It will handle the neccessary actions for adding attachments.
-    def dispatch_create_item!(msg)
-      if msg.has_attachments?
-        draft = msg.draft
-        msg.draft = true
-        resp = validate_created_item(ews.create_item(msg.to_ews))
-        msg.file_attachments.each do |f|
-          next unless f.kind_of?(File)
-          resp.add_file_attachment(f)
-        end
-        if draft
-          resp.submit_attachments!
-          resp
-        else
-          resp.submit!
-        end
-      else
-        resp = ews.create_item(msg.to_ews)
-        validate_created_item resp
-      end
-    end
+        # validate the CreateItem response.
+        # @return [Boolean, Item] returns true if items is empty and status is
+        #   "Success" if items is not empty it will return the first Item since
+        #   we are only dealing with single items here.
+        # @raise EwsCreateItemError on failure
+        def validate_created_item(response)
+          msg = response.response_messages[0]
 
-    # validate the CreateItem response.
-    # @return [Boolean, Item] returns true if items is empty and status is
-    #   "Success" if items is not empty it will return the first Item since
-    #   we are only dealing with single items here.
-    # @raise EwsCreateItemError on failure
-    def validate_created_item(response)
-      msg = response.response_messages[0]
-
-      if(msg.status == 'Success')
-        msg.items.empty? ? true : parse_created_item(msg.items.first)
-      else
-        raise EwsCreateItemError, "#{msg.code}: #{msg.message_text}"
-      end
-    end
+          raise EwsCreateItemError, "#{msg.code}: #{msg.message_text}" unless msg.status == 'Success'
 
-    def parse_created_item(msg)
-      mtype = msg.keys.first
-      message = class_by_name(mtype).new(ews, msg[mtype])
-    end
+          msg.items.empty? || parse_created_item(msg.items.first)
+        end
 
+        def parse_created_item(msg)
+          mtype = msg.keys.first
+          class_by_name(mtype).new(ews, msg[mtype])
+        end
+      end
+    end
   end
 end