viewpoint 1.0.0.beta.1 → 1.0.0

data/lib/ews/types/calendar_folder.rb

@@ -4,5 +4,47 @@ module Viewpoint::EWS::Types
     include Viewpoint::EWS::Types
     include Viewpoint::EWS::Types::GenericFolder
 
+    # Fetch items between a given time period
+    # @param [DateTime] start_date the time to start fetching Items from
+    # @param [DateTime] end_date the time to stop fetching Items from
+    def items_between(start_date, end_date, opts={})
+      items do |obj|
+        obj.restriction = { :and =>
+          [
+            {:is_greater_than_or_equal_to =>
+              [
+                {:field_uRI => {:field_uRI=>'calendar:Start'}},
+                {:field_uRI_or_constant=>{:constant => {:value =>start_date}}}
+              ]
+            },
+            {:is_less_than_or_equal_to =>
+              [
+                {:field_uRI => {:field_uRI=>'calendar:End'}},
+                {:field_uRI_or_constant=>{:constant => {:value =>end_date}}}
+              ]
+            }
+          ]
+        }
+      end
+    end
+
+    # Creates a new appointment
+    # @param attributes [Hash] Parameters of the calendar item. Some example attributes are listed below.
+    # @option attributes :subject [String]
+    # @option attributes :start [Time]
+    # @option attributes :end [Time]
+    # @return [CalendarItem]
+    # @see Template::CalendarItem
+    def create_item(attributes)
+      template = Viewpoint::EWS::Template::CalendarItem.new attributes
+      template.saved_item_folder_id = {id: self.id, change_key: self.change_key}
+      rm = ews.create_item(template.to_ews_create).response_messages.first
+      if rm && rm.success?
+        CalendarItem.new ews, rm.items.first[:calendar_item][:elems].first
+      else
+        raise EwsCreateItemError, "Could not create item in folder. #{rm.code}: #{rm.message_text}" unless rm
+      end
+    end
+
   end
 end

data/lib/ews/types/calendar_item.rb

@@ -3,23 +3,115 @@ module Viewpoint::EWS::Types
     include Viewpoint::EWS
     include Viewpoint::EWS::Types
     include Viewpoint::EWS::Types::Item
+    include Viewpoint::StringUtils
 
     CALENDAR_ITEM_KEY_PATHS = {
       recurring?:   [:is_recurring, :text],
       meeting?:     [:is_meeting, :text],
       cancelled?:   [:is_cancelled, :text],
-    }
+      duration:     [:duration, :text],
+      time_zone:    [:time_zone, :text],
+      start:        [:start, :text],
+      end:          [:end, :text],
+      location:     [:location, :text],
+      all_day?:     [:is_all_day_event, :text],
+      my_response_type:   [:my_response_type, :text],
+      organizer: [:organizer, :elems, 0, :mailbox, :elems],
+      optional_attendees: [:optional_attendees, :elems ],
+      required_attendees: [:required_attendees, :elems ],
+      recurrence: [:recurrence, :elems ],
+      deleted_occurrences: [:deleted_occurrences, :elems ],
+      modified_occurrences: [:modified_occurrences, :elems ]
+   }
 
     CALENDAR_ITEM_KEY_TYPES = {
+      start:        ->(str){DateTime.parse(str)},
+      end:          ->(str){DateTime.parse(str)},
       recurring?:   ->(str){str.downcase == 'true'},
       meeting?:     ->(str){str.downcase == 'true'},
       cancelled?:   ->(str){str.downcase == 'true'},
+      all_day?:     ->(str){str.downcase == 'true'},
+      organizer: :build_mailbox_user,
+      optional_attendees: :build_attendees_users,
+      required_attendees: :build_attendees_users,
+      deleted_occurrences: :build_deleted_occurrences,
+      modified_occurrences: :build_modified_occurrences
     }
     CALENDAR_ITEM_KEY_ALIAS = {}
 
+    # Updates the specified item attributes
+    #
+    # Uses `SetItemField` if value is present and `DeleteItemField` if value is nil
+    # @param updates [Hash] with (:attribute => value)
+    # @param options [Hash]
+    # @option options :conflict_resolution [String] one of 'NeverOverwrite', 'AutoResolve' (default) or 'AlwaysOverwrite'
+    # @option options :send_meeting_invitations_or_cancellations [String] one of 'SendToNone' (default), 'SendOnlyToAll',
+    #   'SendOnlyToChanged', 'SendToAllAndSaveCopy' or 'SendToChangedAndSaveCopy'
+    # @return [CalendarItem, false]
+    # @example Update Subject and Body
+    #   item = #...
+    #   item.update_item!(subject: 'New subject', body: 'New Body')
+    # @see http://msdn.microsoft.com/en-us/library/exchange/aa580254.aspx
+    # @todo AppendToItemField updates not implemented
+    def update_item!(updates, options = {})
+      item_updates = []
+      updates.each do |attribute, value|
+        item_field = FIELD_URIS[attribute][:text] if FIELD_URIS.include? attribute
+        field = {field_uRI: {field_uRI: item_field}}
+
+        if value.nil? && item_field
+          # Build DeleteItemField Change
+          item_updates << {delete_item_field: field}
+        elsif item_field
+          # Build SetItemField Change
+          item = Viewpoint::EWS::Template::CalendarItem.new(attribute => value)
+
+          # Remap attributes because ews_builder #dispatch_field_item! uses #build_xml!
+          item_attributes = item.to_ews_item.map do |name, value|
+            if value.is_a? String
+              {name => {text: value}}
+            elsif value.is_a? Hash
+              node = {name => {}}
+              value.each do |attrib_key, attrib_value|
+                attrib_key = camel_case(attrib_key) unless attrib_key == :text
+                node[name][attrib_key] = attrib_value
+              end
+              node
+            else
+              {name => value}
+            end
+          end
+
+          item_updates << {set_item_field: field.merge(calendar_item: {sub_elements: item_attributes})}
+        else
+          # Ignore unknown attribute
+        end
+      end
+
+      if item_updates.any?
+        data = {}
+        data[:conflict_resolution] = options[:conflict_resolution] || 'AutoResolve'
+        data[:send_meeting_invitations_or_cancellations] = options[:send_meeting_invitations_or_cancellations] || 'SendToNone'
+        data[:item_changes] = [{item_id: self.item_id, updates: item_updates}]
+        rm = ews.update_item(data).response_messages.first
+        if rm && rm.success?
+          self.get_all_properties!
+          self
+        else
+          raise EwsCreateItemError, "Could not update calendar item. #{rm.code}: #{rm.message_text}" unless rm
+        end
+      end
+
+    end
+
+    def duration_in_seconds
+      iso8601_duration_to_seconds(duration)
+    end
+
 
     private
 
+
     def key_paths
       super.merge(CALENDAR_ITEM_KEY_PATHS)
     end

data/lib/ews/types/export_items_response_message.rb

@@ -0,0 +1,52 @@
+module Viewpoint::EWS::Types
+  
+  class ExportItemsResponseMessage
+    include Viewpoint::EWS
+    include Viewpoint::EWS::Types
+    include Viewpoint::EWS::Types::Item
+
+    BULK_KEY_PATHS = {
+      :id          => [:item_id, :attribs, :id],
+      :change_key  => [:item_id, :attribs, :change_key],
+      :data        => [:data, :text]
+    }
+
+    BULK_KEY_TYPES = { }
+
+    BULK_KEY_ALIAS = { }
+
+    def initialize(ews, bulk_item)
+      super(ews, bulk_item)
+      @item = bulk_item
+      @ews = ews
+    end
+
+    def id
+      @item[:item_id][:attribs][:id]
+    end
+
+    def change_key
+      @item[:item_id][:attribs][:change_key]
+    end
+
+    def data
+      @item[:data][:text]
+    end
+
+
+    private
+
+    def key_paths
+      @key_paths ||= BULK_KEY_PATHS
+    end
+
+    def key_types
+      @key_types ||= BULK_KEY_TYPES
+    end
+
+    def key_alias
+      @key_alias ||= BULK_KEY_ALIAS
+    end
+
+  end
+end

data/lib/ews/types/generic_folder.rb

@@ -1,11 +1,32 @@
+=begin
+  This file is part of Viewpoint; the Ruby library for Microsoft Exchange Web Services.
+
+  Copyright © 2011 Dan Wanek <dan.wanek@gmail.com>
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+=end
+
 require 'ews/item_accessors'
+
 module Viewpoint::EWS::Types
   module GenericFolder
     include Viewpoint::EWS
     include Viewpoint::EWS::Types
     include Viewpoint::EWS::ItemAccessors
+    include Viewpoint::StringUtils
 
     GFOLDER_KEY_PATHS = {
+      :folder_id        => [:folder_id, :attribs],
       :id               => [:folder_id, :attribs, :id],
       :change_key       => [:folder_id, :attribs, :change_key],
       :parent_folder_id => [:parent_folder_id, :attribs, :id],
@@ -26,13 +47,15 @@ module Viewpoint::EWS::Types
       :ckey   => :change_key,
     }
 
-    attr_accessor :subscription_id, :watermark
+    attr_accessor :subscription_id, :watermark, :sync_state
 
     # @param [SOAP::ExchangeWebService] ews the EWS reference
     # @param [Hash] ews_item the EWS parsed response document
     def initialize(ews, ews_item)
       super
       simplify!
+      @sync_state = nil
+      @synced = false
     end
 
     def delete!
@@ -148,6 +171,51 @@ module Viewpoint::EWS::Types
       #Base64.decode64 txt
     end
 
+    # Syncronize Items in this folder. If this method is issued multiple
+    # times it will continue where the last sync completed.
+    # @param [Integer] sync_amount The number of items to synchronize per sync
+    # @param [Boolean] sync_all Whether to sync all the data by looping through.
+    #   The default is to just sync the first set.  You can manually loop through
+    #   with multiple calls to #sync_items!
+    # @return [Hash] Returns a hash with keys for each change type that ocurred.
+    #   Possible key values are:
+    #     (:create/:udpate/:delete/:read_flag_change).
+    #   For :deleted and :read_flag_change items a simple hash with :id and
+    #   :change_key is returned.
+    #   See: http://msdn.microsoft.com/en-us/library/aa565609.aspx
+    def sync_items!(sync_state = nil, sync_amount = 256, sync_all = false, opts = {})
+      item_shape = opts.has_key?(:item_shape) ? opts.delete(:item_shape) : {:base_shape => :default}
+      sync_state ||= @sync_state
+
+      resp = ews.sync_folder_items item_shape: item_shape,
+        sync_folder_id: self.folder_id, max_changes_returned: sync_amount, sync_state: sync_state
+      rmsg = resp.response_messages[0]
+
+      if rmsg.success?
+        @synced = rmsg.includes_last_item_in_range?
+        @sync_state = rmsg.sync_state
+        rhash = {}
+        rmsg.changes.each do |c|
+          ctype = c.keys.first
+          rhash[ctype] = [] unless rhash.has_key?(ctype)
+          if ctype == :delete || ctype == :read_flag_change
+            rhash[ctype] << c[ctype][:elems][0][:item_id][:attribs]
+          else
+            type = c[ctype][:elems][0].keys.first
+            item = class_by_name(type).new(ews, c[ctype][:elems][0][type])
+            rhash[ctype] << item
+          end
+        end
+        rhash
+      else
+        raise EwsError, "Could not synchronize: #{rmsg.code}: #{rmsg.message_text}"
+      end
+    end
+
+    def synced?
+      @synced
+    end
+
     # Subscribe this folder to events.  This method initiates an Exchange pull
     # type subscription.
     #
@@ -339,7 +407,7 @@ module Viewpoint::EWS::Types
       end
 
       events.collect do |ev|
-        nev = ev.to_s.ruby_case
+        nev = ruby_case(ev)
         if nev.end_with?('_event')
           nev.to_sym
         else

data/lib/ews/types/item.rb

@@ -4,7 +4,19 @@ module Viewpoint::EWS::Types
     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
+
     ITEM_KEY_PATHS = {
+      item_id:        [:item_id, :attribs],
       id:             [:item_id, :attribs, :id],
       change_key:     [:item_id, :attribs, :change_key],
       subject:        [:subject, :text],
@@ -12,6 +24,7 @@ module Viewpoint::EWS::Types
       size:           [:size, :text],
       date_time_sent: [:date_time_sent, :text],
       date_time_created: [:date_time_created, :text],
+      mime_content: [:mime_content, :text],
       has_attachments?:[:has_attachments, :text],
       is_associated?: [:is_associated, :text],
       is_read?:       [:is_read, :text],
@@ -24,6 +37,7 @@ module Viewpoint::EWS::Types
       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],
@@ -47,6 +61,8 @@ module Viewpoint::EWS::Types
             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,
     }
 
@@ -69,6 +85,7 @@ module Viewpoint::EWS::Types
       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.
@@ -78,11 +95,12 @@ module Viewpoint::EWS::Types
       @body_type = body_type
     end
 
-    def delete!(deltype = :hard)
+    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?
@@ -164,6 +182,13 @@ module Viewpoint::EWS::Types
       @new_item_attachments << ia
     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 submit!
       if draft?
         submit_attachments!
@@ -180,17 +205,19 @@ module Viewpoint::EWS::Types
     end
 
     def submit_attachments!
-      return false unless draft? && !(@new_file_attachments.empty? && @new_item_attachments.empty?)
+      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
+        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
 
     # If you want to add to the body set #new_body_content. If you set #body
@@ -261,6 +288,7 @@ module Viewpoint::EWS::Types
     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)
@@ -318,11 +346,43 @@ module Viewpoint::EWS::Types
       end
     end
 
+    def build_deleted_occurrences(occurrences)
+      occurrences.collect{|a| DateTime.parse a[:deleted_occurrence][:elems][0][:start][:text]}
+    end
+
+    def build_modified_occurrences(occurrences)
+      {}.tap do |h|
+        occurrences.collect do |a|
+          elems = a[:occurrence][:elems]
+
+          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_mailbox_user(mbox_ews)
       MailboxUser.new(ews, mbox_ews)
     end
 
+    def build_mailbox_users(users)
+      return [] if users.nil?
+      users.collect{|u| build_mailbox_user(u[:mailbox][:elems])}
+    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]
+        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])