acts_as_sdata 1.0.0

data/lib/s_data/controller_mixin/collection_scope.rb

@@ -0,0 +1,57 @@
+module SData
+  module ControllerMixin
+    module CollectionScope
+
+    protected
+
+      def where_clause?
+        !! where_clause
+      end
+
+      def where_clause
+        expression = params.to_a.select{ |pair| pair[1].nil? }.flatten.compact.first
+        expression.nil? ? nil : expression.match(/where\s(.*)/)[0]
+      end
+
+      #(name eq 'asdf') -> options[:conditions] = ['"name" eq ?', 'asdf']
+      def sdata_scope
+        options = {}
+
+        if where_clause?
+          predicate = SData::Predicate.parse(model_class.payload_map.baze_fields, where_clause)
+          options[:conditions] = predicate.to_conditions
+        end
+
+        if sdata_options[:scoping]
+          options[:conditions] ||= []
+          sdata_options[:scoping].each do |scope|
+            options[:conditions][0] = [options[:conditions].to_a[0], scope].compact.join(' and ')
+            1.upto(sdata_options[:scope_param_size] || 1) do
+              options[:conditions] << target_user.id.to_s
+            end
+          end
+        end
+
+        if params.key? :condition
+          options[:conditions] ||= []
+          if params[:condition] == "$linked"
+            virtual_class = sdata_options[:model].to_s.demodulize
+            baze_class = sdata_options[:model].baze_class.name.demodulize
+            condition = "id IN (SELECT bb_model_id FROM sd_uuids WHERE bb_model_type = '#{baze_class}' and sd_class = '#{virtual_class}')"
+            options[:conditions][0] = [options[:conditions].to_a[0], condition].compact.join(' and ')
+          end
+        end
+
+        #FIXME: this is an unoptimized solution that may be a bottleneck for large number of matches
+        #if user has hundreds of records but requests first 10, we shouldnt load them all into memory
+        #but use sql query to count how many exist in total, and then load the first 10 only
+
+        #FIXME: do not return records deleted through acts_as_paranoid!
+        results = sdata_options[:model].all(options)
+        @total_results = results.count
+        paginated_results = results[zero_based_start_index, records_to_return]
+        paginated_results.to_a
+      end
+    end
+  end
+end

data/lib/s_data/controller_mixin/s_data_feed.rb

@@ -0,0 +1,87 @@
+module SData
+  module ControllerMixin
+    module SDataFeed
+
+    protected
+
+      def resource_url
+        sdata_options[:model].sdata_resource_kind_url(params[:dataset])
+      end
+
+      def build_feed_links_for(feed)
+        feed.links << Atom::Link.new(
+          :rel => 'self',
+          :href => (resource_url + "?#{request.query_parameters.to_param}".chomp('?')),
+          :type => 'application/atom+xml; type=feed',
+          :title => 'Refresh')
+        if (records_to_return > 0) && (@total_results > records_to_return)
+          feed.links << Atom::Link.new(
+            :rel => 'first',
+            :href => (resource_url + "?#{request.query_parameters.merge(:startIndex => '1').to_param}"),
+            :type => 'application/atom+xml; type=feed',
+            :title => 'First Page')
+          feed.links << Atom::Link.new(
+            :rel => 'last',
+            :href => (resource_url + "?#{request.query_parameters.merge(:startIndex => [1,(@last=(((@total_results-zero_based_start_index - 1) / records_to_return * records_to_return) + zero_based_start_index + 1))].max).to_param}"),
+            :type => 'application/atom+xml; type=feed',
+            :title => 'Last Page')
+          if (one_based_start_index+records_to_return) <= @total_results
+            feed.links << Atom::Link.new(
+              :rel => 'next',
+              :href => (resource_url + "?#{request.query_parameters.merge(:startIndex => [1,[@last, (one_based_start_index+records_to_return)].min].max.to_s).to_param}"),
+              :type => 'application/atom+xml; type=feed',
+              :title => 'Next Page')
+          end
+          if (one_based_start_index > 1)
+            feed.links << Atom::Link.new(
+              :rel => 'previous',
+              :href => (resource_url + "?#{request.query_parameters.merge(:startIndex => [1,[@last, (one_based_start_index-records_to_return)].min].max.to_s).to_param}"),
+              :type => 'application/atom+xml; type=feed',
+              :title => 'Previous Page')
+          end
+        end
+      end
+
+      def build_sdata_feed(opts={})
+        opts = sdata_options.deep_merge(opts)
+        Atom::Feed.new do |f|
+          f.title = opts[:feed][:title]
+          f.updated = Time.now
+          f.authors << Atom::Person.new(:name => opts[:feed][:author])
+          f.id = resource_url
+          f.categories << Atom::Category.new(:scheme => 'http://schemas.sage.com/sdata/categories',
+                                             :term   => self.category_term,
+                                             :label  => self.category_term.underscore.humanize.titleize)
+        end
+      end
+
+      def records_to_return
+        default_items_per_page = sdata_options[:feed][:default_items_per_page] || 10
+        maximum_items_per_page = sdata_options[:feed][:maximum_items_per_page] || 100
+        #check whether the count param is castable into integer
+        return default_items_per_page if params[:count].blank? or (params[:count].to_i.to_s != params[:count])
+        items_per_page = [params[:count].to_i, maximum_items_per_page].min
+        items_per_page = default_items_per_page if (items_per_page < 0)
+        items_per_page
+      end
+
+      def one_based_start_index
+        [(params[:startIndex].to_i), 1].max
+      end
+
+      def zero_based_start_index
+        [(one_based_start_index - 1), 0].max
+      end
+
+      def populate_open_search_for(feed)
+        feed[SData.config[:schemas]['opensearch'], 'totalResults'] << @total_results
+        feed[SData.config[:schemas]['opensearch'], 'startIndex'] << one_based_start_index
+        feed[SData.config[:schemas]['opensearch'], 'itemsPerPage'] << records_to_return
+      end
+
+      def category_term
+        self.sdata_options[:model].name.demodulize.camelize(:lower).pluralize
+      end
+    end
+  end
+end

data/lib/s_data/controller_mixin/s_data_instance.rb

@@ -0,0 +1,35 @@
+module SData
+  module ControllerMixin
+    module SDataInstance
+
+    protected
+
+      def sdata_instance
+        if params[:condition] == "$linked"
+          linked_sdata_instance
+        elsif params.key?(:predicate)
+          sdata_instance_by_predicate
+        else
+          non_linked_sdata_instance
+        end
+      end
+
+      def sdata_instance_by_predicate
+        predicate = SData::Predicate.parse(model_class.payload_map.baze_fields, params[:predicate])
+        scope = model_class.all(:conditions => predicate.to_conditions)
+        if scope.count != 1
+          raise Sage::BusinessLogic::Exception::IncompatibleDataException, "Conditions scope must contain exactly one entry"
+        end
+        scope.first
+      end
+
+      def linked_sdata_instance
+        SData::SdUuid.find_by_virtual_model_and_uuid(model_class, Predicate.strip_quotes(params[:instance_id]))
+      end
+
+      def non_linked_sdata_instance
+        model_class.find_by_sdata_instance_id(Predicate.strip_quotes(params[:instance_id]))
+      end
+    end
+  end
+end

data/lib/s_data/diagnosis/application_controller_mixin.rb

@@ -0,0 +1,16 @@
+module SData
+  module ApplicationControllerMixin
+    def sdata_rescue_support
+      self.__send__ :include, SDataRescue
+    end
+    
+    module SDataRescue
+      def sdata_global_rescue(exception, request_path)
+        RAILS_DEFAULT_LOGGER.debug("sdata_global_rescue. exception: #{exception.inspect} request_path: #{request_path.inspect}")
+        error_payload = SData::Diagnosis::DiagnosisMapper.map(exception, request_path)
+        render :xml => error_payload.to_xml(:root), :status => (error_payload.send('http_status_code') || '500')
+      end
+    end
+  end
+end
+ActionController::Base.extend SData::ApplicationControllerMixin

data/lib/s_data/diagnosis/diagnosis.rb

@@ -0,0 +1,130 @@
+module SData
+  class Diagnosis
+
+    @@sdata_attributes = [:severity, :sdata_code, :application_code, :message, :stack_trace, :payload_path, :exception, :http_status_code]
+    @@sdata_attributes.each {|attr| attr_accessor attr}
+
+    def initialize(params={})
+      raise "SData::Diagnosis is an abstract class; instantiate a subclass instead" if self.class == SData::Diagnosis
+      params.each_pair do |key,value|
+        if @@sdata_attributes.include?(key)
+          self.send("#{key}=", value)
+        end
+      end
+      if self.exception && !self.message
+        self.message = self.exception.message 
+      end
+      self.sdata_code ||= self.class.name.demodulize
+      self.severity ||= "error"
+    end
+
+    def to_xml(mode=:root)
+      case mode
+      when :root
+        return Diagnosis.construct_header_for(self.diagnosis_payload)
+      when :feed
+        return self.diagnosis_payload[0]
+      when :entry
+        return self.diagnosis_payload
+      end
+    end
+    
+    #Can be called from outside to build a single header for multiple diagnoses, each of which has been
+    #constructed with (header=false) option. Useful when generating multiple diagnoses inside a single Feed.
+    #Currently won't work inside a signle Entry due to parsing problems in rAtom.
+    #Solving this problem is complex, so won't try to implement unless we confirm it's required. -Eugene
+    def self.construct_header_for(diagnosis_payloads)
+      document = XML::Document.new
+      root_node = XML::Node.new("sdata:diagnoses")
+      #TODO FIXME: SData spec says root node must be just 'xmlns=' and not 'xmlns:sdata', but this fails W3
+      #XML validation. Confirm which way is correct -- if former, change below line to root_node['xmlns']...
+      root_node['xmlns:sdata'] = "#{SData.config[:schemas]['sdata']}"
+      diagnosis_payloads.each do |diagnosis_payload|
+        root_node << diagnosis_payload
+      end
+      document.root = root_node
+      document
+    end
+
+    protected
+    
+    def diagnosis_payload
+      node = XML::Node.new("sdata:diagnosis")
+      @@sdata_attributes.each do |attribute|
+        value = self.send(attribute) unless [:http_status_code].include?(attribute)
+        if value
+          if value.is_a?(Exception)
+            node << (XML::Node.new("sdata:stackTrace") << value.backtrace.join("\n") ) if SData.config[:show_stack_trace]
+          else
+            node << (XML::Node.new("sdata:#{attribute.to_s.camelize(:lower)}") << value)
+          end
+        end
+      end
+      #nesting node in [] because of strange quirk in Atom::Content's mixin in AtomExtensions::ContentMixin,
+      #in which .self becomes the return value of this method, but doesn't escape properly in the Atom Entry
+      #making .self be [node] and then calling self[0] works fine.
+      [node]
+    end
+    
+  end
+
+  #potential TODO: write a static class-generating method which diagnoses exception and decides what kind of
+  #error payload class to return (caller will then instantiate it)
+
+  #customize as needed
+  class BadUrlSyntax < Diagnosis
+    def initialize(params={})
+      self.http_status_code = '400'
+      super(params)
+    end
+  end
+  class BadQueryParameter < Diagnosis
+    def initialize(params={})
+      self.http_status_code = '400'
+      super(params)
+    end    
+  end
+  class ApplicationNotFound < Diagnosis
+    def initialize(params={})
+      self.http_status_code = '404'
+      super(params)
+    end    
+  end
+  class ApplicationUnavailable < Diagnosis
+    def initialize(params={})
+      self.http_status_code = '503'
+      super(params)
+    end    
+  end
+  class DatasetNotFound < Diagnosis
+    def initialize(params={})
+      self.http_status_code = '404'
+      super(params)
+    end    
+  end
+  class ContractNotFound < Diagnosis
+    def initialize(params={})
+      self.http_status_code = '404'
+      super(params)
+    end    
+  end
+  class ResourceKindNotFound < Diagnosis
+    def initialize(params={})
+      self.http_status_code = '404'
+      super(params)
+    end    
+  end
+  class BadWhereSyntax < Diagnosis
+    def initialize(params={})
+      self.http_status_code = '400'
+      super(params)
+    end    
+  end
+  class ApplicationDiagnosis < Diagnosis
+    def initialize(params={})
+      self.http_status_code = '500'
+      super(params)
+    end    
+  end
+  
+end

data/lib/s_data/diagnosis/diagnosis_mapper.rb

@@ -0,0 +1,39 @@
+module SData
+  class Diagnosis
+    class DiagnosisMapper
+      def self.map(exception, request_path='')
+        error_payload = case exception.class.name.demodulize
+        when 'NoMethodError'
+          if request_path.match /^\/#{SData.store_path}\/[^\/]+\/[A-z]+\/.*/ 
+            SData::ApplicationDiagnosis.new(:exception => exception, :http_status_code => '500')          
+          elsif request_path.match /^\/#{SData.store_path}\/[^\/]+\/[A-z]+/ 
+            SData::ResourceKindNotFound.new(:exception => exception, :http_status_code => '404')
+          elsif request_path.match /^\/#{SData.store_path}\/[^\/]+$/
+            SData::ApplicationDiagnosis.new(:exception => exception, :http_status_code => '501')
+          elsif request_path.match /^\/#{SData.store_path}.+/
+            SData::DatasetNotFound.new(:exception => exception, :http_status_code => '404')
+          elsif request_path.match /^\/#{SData.store_path}$/
+            SData::ApplicationDiagnosis.new(:exception => exception, :http_status_code => '501')
+          elsif request_path.match /^\/sdata\/#{SData.config[:application]}.+/  
+            SData::ContractNotFound.new(:exception => exception, :http_status_code => '404')
+          elsif request_path.match /^\/sdata\/#{SData.config[:application]}$/  
+            SData::ApplicationDiagnosis.new(:exception => exception, :http_status_code => '501')
+          else
+            SData::ApplicationNotFound.new(:exception => exception, :http_status_code => '404')
+          end
+        when 'AccessDeniedException'
+          SData::ApplicationDiagnosis.new(:exception => exception, :http_status_code => '403')
+        when 'ExpiredSubscriptionException'
+          SData::ApplicationDiagnosis.new(:exception => exception, :http_status_code => '402')
+        when 'UnauthenticatedException'
+          SData::ApplicationDiagnosis.new(:exception => exception, :http_status_code => '401')
+        when 'IncompatibleDataException'
+          SData::BadWhereSyntax.new(:exception => exception, :http_status_code => '409')
+        else
+          SData::ApplicationDiagnosis.new(:exception => exception, :http_status_code => '500')
+        end
+        error_payload
+      end
+    end
+  end
+end

data/lib/s_data/exceptions.rb

@@ -0,0 +1,10 @@
+module SData
+  module Exceptions
+    module VirtualBase
+      class InvalidSDataAttribute < ArgumentError
+      end
+      class InvalidSDataAssociation < InvalidSDataAttribute
+      end
+    end
+  end
+end

data/lib/s_data/formatting.rb

@@ -0,0 +1,13 @@
+module SData
+  class Formatting
+    def self.format_date_time(date_time)
+      return date_time unless date_time
+      case date_time.class.name
+      when 'ActiveSupport::TimeWithZone', 'Time'
+        date_time.strftime("%Y-%m-%dT%H:%M:%S%z").insert(-3,':')
+      when 'Date'
+        date_time.strftime("%Y-%m-%d")
+      end
+    end
+  end
+end

data/lib/s_data/namespace_definitions.rb

@@ -0,0 +1,19 @@
+# The following pre-sets the namespace prefix for simple extensions. It is done this way because
+# the namespace map is lazily created in the Atom::Feed.to_xml method. Could also alias to_xml,
+# and add all the namespaces in extensions_namespaces to this map
+module SData
+  module NamespaceMapMixin
+    def self.included(base) 
+      base.class_eval do 
+        alias_method :initialize, :initialize_with_map
+      end
+    end
+
+    def initialize_with_map(default=Atom::NAMESPACE)
+        @default = default
+        @i = 0
+        @map = SData.config[:schemas].invert
+    end
+  end
+end
+Atom::Xml::NamespaceMap.__send__ :include, SData::NamespaceMapMixin

data/lib/s_data/payload.rb

@@ -0,0 +1,158 @@
+module SData
+  class Payload
+    
+    attr_accessor :builder, :root_node_name, :included, :selected, :maximum_precedence, :sync, :contract
+    attr_accessor :xml_node, :entity, :expand, :dataset
+    
+    def initialize(params)
+      self.builder = Builder::XmlMarkup.new
+      self.included = params[:included]
+      self.selected = params[:selected]
+      self.maximum_precedence = params[:maximum_precedence]
+      self.sync = params[:sync]
+      self.contract = params[:contract]
+      self.expand = params[:expand]
+      self.entity = params[:entity]
+      self.dataset = params[:dataset]
+    end
+
+    def ==(other)
+      return false unless other.is_a?(SData::Payload)
+      [:root_node_name, :included, :selected, :maximum_precedence, :sync, :contract, :entity, :expand].all?{|attr| self.send(attr) == other.send(attr)}
+    end
+
+    def self.is_sync?
+      false
+    end
+
+    def is_sync?
+      !sync.nil? ? sync : Payload.is_sync?
+    end
+    
+    def self.parse(xml)
+      returning new do |payload|
+        payload.xml_node = xml
+      end
+    end
+
+    def to_xml(*params)
+      node = XML::Node.new("sdata:payload")
+      generate! if @xml_node.nil?
+      node << @xml_node
+      return node
+    end
+    
+    def generate!
+      @xml_node = generate(entity.sdata_node_name, entity, expand, 1, nil)
+    end
+    
+    def generate(node_name, node_value, expand, element_precedence, resource_collection)
+      self.root_node_name ||= node_name
+      return "" if element_precedence > maximum_precedence
+      return "" if excluded_in_select?(node_name)
+      if node_value.respond_to?(:sdata_options)
+        construct_from_sdata_model(node_name, node_value, expand, element_precedence, resource_collection)
+      elsif node_value.is_a?(Array)
+        construct_from_array(node_name, node_value, expand, element_precedence, resource_collection)
+      elsif node_value.is_a?(Hash)
+        construct_from_hash(node_name, node_value, expand, element_precedence, resource_collection)
+      else
+        construct_from_string(node_name, node_value, expand, element_precedence, resource_collection)
+      end
+    end
+  
+    def construct_from_sdata_model(node_name, node_value, expand, element_precedence, resource_collection)
+      node = XML::Node.new(qualified(node_name))
+      attributes = node_value.resource_header_attributes(dataset, included)
+      attributes.each_pair do |key,value|
+        node[key] = value.to_s
+      end
+      if (node_name == self.root_node_name) || (expand != :none) || included.include?(formatted(node_name))
+        expand = :none if (expand == :immediate_children) 
+        node_value.payload_map.each_pair do |child_node_name, child_node_data|
+          if child_node_data[:type] == :association
+            child_expand = :none
+          else
+            child_expand = (is_sync? ? :all_children : expand)
+          end
+          collection = ({:parent => node_value, :url => formatted(child_node_name), :type => node_value.payload_map[child_node_name][:type]})
+          attribute_method_name = sdata_attribute_method(child_node_data)
+          node << generate(formatted(child_node_name), node_value.send(attribute_method_name), child_expand, child_node_data[:precedence], collection)
+        end
+      end
+      node
+    end
+    
+    # this doesn't belong here. sdata attribute definitions should be real objects not hashes, so they can figure this stuff out themselves
+    def sdata_attribute_method(attribute_definition)
+      is_sync? ? attribute_definition[:method_name_with_deleted] : attribute_definition[:method_name]
+    end
+    
+    def construct_from_array(node_name, node_value, expand, element_precedence, resource_collection)
+      if resource_collection && resource_collection[:type]
+        construct_from_sdata_array(node_name, node_value, expand, element_precedence, resource_collection)
+      else
+        construct_from_non_sdata_array(node_name, node_value, expand, element_precedence, resource_collection)
+      end
+    end
+  
+    def construct_from_sdata_array(node_name, node_value, expand, element_precedence, resource_collection)
+      expand = :none if (expand == :immediate_children)
+      node = XML::Node.new(qualified(node_name))
+      scoped_children_collection = sdata_collection_url(resource_collection[:parent], resource_collection[:url])
+      node['sdata:url'] = scoped_children_collection
+      node_value.each do |item|
+        node << generate(item.sdata_node_name, item, expand, element_precedence, nil)
+      end
+      node
+    end
+      
+    def construct_from_non_sdata_array(node_name, node_value, expand, element_precedence, resource_collection)
+      expand = :none if (expand == :immediate_children) 
+      node = XML::Node.new(qualified(node_name))
+      node_value.each do |item|
+        node << generate(formatted(node_name).singularize, item, expand, element_precedence, (item.is_a?(Hash) ? item[:resource_collection] : nil))
+      end
+      node      
+    end
+      
+    def construct_from_hash(node_name, node_value, expand, element_precedence, resource_collection)
+      expand = :none if (expand == :immediate_children) 
+      node = XML::Node.new(qualified(node_name))
+      node_value.each_pair do |child_node_name, child_node_data|
+        node << generate(formatted(child_node_name), child_node_data, expand, element_precedence, (child_node_data.is_a?(Hash) ? child_node_data[:resource_collection] : nil))
+      end
+      node
+    end
+
+    def construct_from_string(node_name, node_value, expand, element_precedence, resource_collection)
+      node = XML::Node.new(qualified(node_name))
+      if !node_value.to_s.blank?
+        node << node_value
+      else
+        node['xsi:nil'] = 'true'
+      end
+      node
+    end
+
+    def qualified(node_name)
+      "#{contract}:#{(formatted(node_name))}"
+    end
+
+    def formatted(node_name)
+      node_name.to_s.camelize(:lower)
+    end
+
+    def sdata_collection_url(parent, child)
+      #FIXME: adjust for bookkeeper support
+      SData.endpoint + "/#{dataset}/" + parent.sdata_node_name + "('#{parent.id}')/" + child
+    end
+
+    def excluded_in_select?(node_name)
+      return false if selected.empty?
+      return false if node_name == self.root_node_name
+      return !selected.include?(node_name.to_s.camelize(:lower))
+    end
+
+  end
+end