term.rb in osm-0.2.0

- old
+ new

@@ -34,84 +34,89 @@
     # @return [Array<Osm::Term>]
     def self.get_all(api, options={})
       cache_key = ['terms', api.user_id]
 
       if !options[:no_cache] && cache_exist?(api, cache_key)
-        return cache_read(api, cache_key)
+        ids = cache_read(api, cache_key)
+        return get_from_ids(api, ids, 'term', options, :get_all)
       end
 
       data = api.perform_query('api.php?action=getTerms')
 
-      result = Array.new
+      terms = Array.new
+      ids = Array.new
       data.each_key do |key|
         data[key].each do |term_data|
           term = Osm::Term.new(
             :id => Osm::to_i_or_nil(term_data['termid']),
             :section_id => Osm::to_i_or_nil(term_data['sectionid']),
             :name => term_data['name'],
             :start => Osm::parse_date(term_data['startdate']),
             :finish => Osm::parse_date(term_data['enddate']),
           )
-          result.push term
+          terms.push term
+          ids.push term.id
           cache_write(api, ['term', term.id], term)
         end
       end
 
-      cache_write(api, cache_key, result)
-      return result
+      cache_write(api, cache_key, ids)
+      return terms
     end
 
     # Get the terms that the OSM user can access for a given section
     # @param [Osm::Api] api The api to use to make the request
-    # @param [Fixnum] section the section (or its ID) of the section to get terms for
+    # @param [Fixnum] section The section (or its ID) of the section to get terms for
     # @!macro options_get
     # @return [Array<Osm::Term>, nil] An array of terms or nil if the user can not access that section
     def self.get_for_section(api, section, options={})
+      require_access_to_section(api, section, options)
       section_id = section.to_i
-      return nil unless get_user_permissions(api).keys.include?(section_id)
       return get_all(api, options).select{ |term| term.section_id == section_id }
     end
 
     # Get a term
-    # @param [Osm::Api] The api to use to make the request
-    # @param [Fixnum] term_id the id of the required term
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Fixnum] term_id The id of the required term
     # @!macro options_get
     # @return nil if an error occured or the user does not have access to that term
-    # @return [Osm::Section]
+    # @return [Osm::Term]
     def self.get(api, term_id, options={})
       cache_key = ['term', term_id]
 
       if !options[:no_cache] && cache_exist?(api, cache_key)
-        return cache_read(api, cache_key)
+        term = cache_read(api, cache_key)
+        return term if can_access_section?(api, term.section_id, options)
       end
 
       terms = get_all(api, options)
       return nil unless terms.is_a? Array
 
       terms.each do |term|
         if term.id == term_id
-          return (get_user_permissions(api).keys.include?(term.section_id) ? term : nil)
+          return (can_access_section?(api, term.section_id, options) ? term : nil)
         end
       end
       return nil
     end
 
     # Get the current term for a given section
     # @param [Osm::Api] api The api to use to make the request
-    # @param [Osm::Section, Fixnum] section The section (or its ID)  to get terms for
-    # @!macro options_get
+    # @param [Osm::Section, Fixnum, #to_i] section The section (or its ID)  to get terms for
+    # @!macro options_get 
     # @return [Osm::Term, nil] The current term or nil if the user can not access that section
+    # @raise [Osm::Error] If the term doesn't have a Term which is current
     def self.get_current_term_for_section(api, section, options={})
       section_id = section.to_i
       terms = get_for_section(api, section_id, options)
 
       return nil if terms.nil?
       terms.each do |term|
         return term if term.current?
       end
 
-      raise Error, 'There is no current term for the section.'
+      raise Osm::Error, 'There is no current term for the section.'
     end
 
     # Create a term in OSM
     # @param [Osm::Api] api The api to use to make the request
     # @param [Hash] options - the configuration of the new term
@@ -123,10 +128,11 @@
     def self.create(api, options={})
       raise ArgumentError, ":section can't be nil" if options[:section].nil?
       raise ArgumentError, ":name can't be nil" if options[:name].nil?
       raise ArgumentError, ":start can't be nil" if options[:start].nil?
       raise ArgumentError, ":finish can't be nil" if options[:finish].nil?
+      require_access_to_section(api, options[:section])
 
       api_data = {
         'term' => options[:name],
         'start' => options[:start].strftime(Osm::OSM_DATE_FORMAT),
         'end' => options[:finish].strftime(Osm::OSM_DATE_FORMAT),
@@ -144,34 +150,39 @@
       return data.is_a?(Hash) && data['terms'].is_a?(Hash)
     end
 
 
     # Update a term in OSM
-    # @param [Osm::Api] The api to use to make the request
+    # @param [Osm::Api] api The api to use to make the request
     # @return [Boolean] if the operation suceeded or not
+    # @raise [Osm::ObjectIsInvalid] If the Term is invalid
     def update(api)
-      raise ObjectIsInvalid, 'term is invalid' unless valid?
+      raise Osm::ObjectIsInvalid, 'term is invalid' unless valid?
+      require_access_to_section(api, section_id)
 
       data = api.perform_query("users.php?action=addTerm&sectionid=#{section_id}", {
         'term' => name,
         'start' => start.strftime(Osm::OSM_DATE_FORMAT),
         'end' => finish.strftime(Osm::OSM_DATE_FORMAT),
         'termid' => id
       })
 
-      # The cached terms for the section will be out of date - remove them
-      cache_delete(api, ['term', id])
-      cache_delete(api, ['terms', api.user_id])
-
-      return data.is_a?(Hash) && data['terms'].is_a?(Hash)
+      if data.is_a?(Hash) && data['terms'].is_a?(Hash)
+        reset_changed_attributes
+        # The cached term will be out of date - remove it
+        cache_delete(api, ['term', id])
+        return true
+      else
+        return false
+      end
     end
 
 
 
     # @!method initialize
     #   Initialize a new Term
-    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+    #   @param [Hash] attributes The hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
 
     # Determine if the term is completly before the passed date
     # @param [Date] date
     # @return [Boolean] if the term is completly before the passed date
@@ -203,10 +214,10 @@
     def current?
       return (start <= Date.today) && (finish >= Date.today)
     end
 
     # Determine if the provided date is within the term
-    # @param [Date] date the date to test
+    # @param [Date] date The date to test
     # @return [Boolean] if the term started before the date and finishes after the date
     def contains_date?(date)
       return (start <= date) && (finish >= date)
     end
 