acts_as_sdata 1.0.0

data/lib/s_data/payload_map/payload_map.rb

@@ -0,0 +1,136 @@
+
+
+module SData
+  module PayloadMap
+    def define_payload_map(map)
+      include InstanceMethods
+      cattr_accessor :payload_map
+      self.payload_map = PayloadMapHash.new(map)
+      self.payload_map.each do |name, opts|
+        has_sdata_attr(name, opts)
+      end
+    end
+
+    def has_sdata_attr(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {:static_value => nil, :precedence => 50}
+      args.each do | name |
+        options[:method_name] ||= name
+        options[:method_name_with_deleted] = options[:method_name]
+        
+        method_name = options[:method_name]
+        payload_map[name] ||= options
+        
+        case field_type(options)
+        when :static_value
+          define_static_value_reader method_name, options[:static_value]
+
+        when :baze_field
+          define_baze_field_reference method_name, options[:baze_field]
+
+        when :method
+
+        when :proc
+          define_proc_caller method_name, options[:proc]
+
+          if options.has_key?(:proc_with_deleted)
+            method_name_with_deleted = options[:method_name_with_deleted] = "#{method_name.to_s}_with_deleted"
+            define_proc_with_deleted_caller method_name_with_deleted, options[:proc_with_deleted]
+          end
+
+        else
+          raise SData::Exceptions::VirtualBase::InvalidSDataAttribute.new(
+              "#{args.join(", ")}: must supply a static_value, baze_field, method or proc")
+        end
+      end
+    end
+
+    def has_sdata_association(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {:precedence => 50, :type => :association}
+      options[:type] ||= :association
+      raise SData::Exceptions::VirtualBase::InvalidSDataAssociation.new(
+          "#{args.join(", ")}: must supply a proc or method") unless [:proc, :method].any?{|k|options.has_key?(k)}
+      raise SData::Exceptions::VirtualBase::InvalidSDataAssociation.new(
+          "#{args.join(", ")}: invalid association type '#{options[:type]}") unless [:association, :child].include?(options[:type])
+      args.push options
+      has_sdata_attr(*args)
+    end
+    
+    module InstanceMethods
+      def payload
+        self
+      end
+      
+      
+      # Walks the payload, loading each association, descending into children, and yielding the tuple
+      # [payload_map_definition, node_object(s)] for each node. Can use without a block
+      # to fire all faults -- sync uses this when caching changed objects.
+      def associations_with_deleted(expand=:all_children)
+        return if expand == :none
+        payload_map.each_pair do |child_node_name, child_node_data|
+          if child_node_data[:type] == :association
+            expand = :none
+          elsif child_node_data[:type] == :child
+            expand = :all_children
+          else
+            next
+          end
+          child = __send__(child_node_data[:method_name_with_deleted])
+          yield child_node_data.merge(:name => child_node_name), child if block_given?
+          case child
+          when Array
+            child.each{ |grandchild| grandchild.associations_with_deleted(expand) if child.is_a?(SData::VirtualBase)}
+          when SData::VirtualBase
+            associations_with_deleted(expand)
+          end
+        end
+      end      
+    end
+
+  protected
+
+    def field_type(options)
+      [:static_value, :baze_field, :method, :proc].each do |type|
+        if options.has_key?(type)
+          return type
+        end
+      end
+      nil
+    end
+
+    def define_static_value_reader(method_name, value)
+      class_eval do
+        define_method method_name do
+          value
+        end
+      end
+    end
+
+    def define_baze_field_reference(method_name, baze_field)
+      class_eval do
+        define_method method_name do
+          self.baze.__send__ baze_field
+        end
+      end
+    end
+
+    def define_proc_caller(method_name, block)
+      class_eval do
+        define_method method_name, block
+      end
+    end
+
+    def define_proc_with_deleted_caller(method_name, block)
+      cache_var = "@#{method_name.to_s}_cached"
+      class_eval do
+        define_method(method_name) do
+          unless instance_variable_get(cache_var)
+            instance_variable_set(cache_var, instance_eval(&block))
+          end
+          instance_variable_get(cache_var)
+        end
+      end
+    end
+  end
+end
+
+SData::VirtualBase.extend SData::PayloadMap

data/lib/s_data/payload_map/payload_map_hash.rb

@@ -0,0 +1,39 @@
+module SData
+  module PayloadMap
+    class PayloadMapHash < Hash
+      def initialize(hash)
+        merge!(hash)
+      end
+
+      def attrs
+        reject{|k,v| ! [:static_value, :baze_field].any?{|type| v.has_key?(type)} }
+      end
+      
+      def static_values
+        subset :static_value
+      end
+
+      def baze_fields
+        subset :baze_field
+      end
+
+      def procs
+        subset :proc
+      end
+
+      def procs_with_deleted
+        subset :proc_with_deleted, :proc
+      end
+
+    protected
+
+      def subset(*mapping_type)
+        mapping_type = [mapping_type].flatten
+        raw_subset = select { |key, value| mapping_type.any?{|type| value.has_key?(type) }}
+        hash = Hash[raw_subset]
+        hash.merge(hash){ |key, value| value[mapping_type.detect{|type| value.include?(type)}] }
+      end
+      
+    end
+  end
+end

data/lib/s_data/predicate.rb

@@ -0,0 +1,31 @@
+module SData
+  class Predicate < Struct.new(:field, :relation, :value)
+    def self.parse(fields_map, predicate_string)
+      # Gotcha on Rightscale that escaped + before it hits controller, but doesn't escape other special chars!
+      escaped_predicate_string = CGI::unescape(predicate_string.gsub('+', '%2B')) 
+      match_data = escaped_predicate_string.match(/(\w+)\s(gt|lt|eq|ne|lteq|gteq)\s('?.+'?|'')/) || []
+
+      canonical_field_name = match_data[1].underscore.to_sym unless match_data[1].nil?
+      self.new fields_map[canonical_field_name], match_data[2], strip_quotes(match_data[3])
+    end
+
+    def self.strip_quotes(value)
+      return value unless value.is_a?(String)
+      value = value.gsub("%27", "'")
+      return value unless value =~ /'.*?'/
+      return value[1,value.length-2]
+    end
+
+    def to_conditions      
+      if valid?
+        ConditionsBuilder.build_conditions field, relation.to_sym, value
+      else
+        raise Sage::BusinessLogic::Exception::IncompatibleDataException, "Invalid predicate string"
+      end
+    end
+
+    def valid?
+      field && relation && value
+    end
+  end
+end

data/lib/s_data/route_mapper.rb

@@ -0,0 +1,143 @@
+module SData
+  class RouteMapper < Struct.new(:router, :resource_name, :options)
+    def map_sdata_routes!
+      #RADAR: the order of the below statements makes a difference
+
+      map_sdata_show_instance
+      map_sdata_show_instance_with_condition_and_predicate
+      map_sdata_show_instance_with_condition
+      map_sdata_show_instance_with_predicate
+
+      map_sdata_create_link
+      map_sdata_create_instance
+      map_sdata_update_instance
+      
+      map_sdata_sync_source
+      map_sdata_sync_source_status
+      map_sdata_sync_source_delete
+      map_sdata_receive_sync_results
+
+      map_sdata_collection_with_condition
+      map_sdata_collection
+    end
+
+    def self.urlize(string)
+      string.gsub("'", "(%27|')").gsub("\s", "(%20|\s)")
+    end
+
+    protected
+    
+    CONDITION = urlize("{:condition,([$](linked))}")
+    PREDICATE = urlize("{:predicate,[A-z]+\s[A-z]+\s'?[^']*'?}")
+
+    TRACKING_ID = urlize("{:trackingID,'[^']+'}")
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts
+    def map_sdata_collection
+      map_route "#{name_in_path}", 'sdata_collection', :get
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts/$syncSource('someid')
+    def map_sdata_sync_source_status
+      map_route "#{name_in_path}\/$syncSource\\(:trackingID\\)", 'sdata_collection_sync_feed_status', :get
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts/$syncSource
+    def map_sdata_sync_source_delete
+      map_route "#{name_in_path}\/$syncSource\\(:trackingID\\)", 'sdata_collection_sync_feed_delete', :delete
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts/$linked 
+    def map_sdata_collection_with_condition
+      map_route "#{name_in_path}\/#{CONDITION}", 'sdata_collection', :get
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts('1')    
+    def map_sdata_show_instance
+      map_route "#{name_in_path}\\(:instance_id\\)", 'sdata_show_instance', :get
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts/$linked('1')    
+    def map_sdata_show_instance_with_condition
+      map_route "#{name_in_path}/#{CONDITION}\\(:instance_id\\)", 'sdata_show_instance', :get
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts(name eq 'asdf')
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts(name eq asdf)
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts(name eq '')
+    def map_sdata_show_instance_with_predicate
+      map_route "#{name_in_path}\\(#{PREDICATE}\\)", 'sdata_show_instance', :get
+    end
+
+    # /$linked(name eq 'Second')
+    def map_sdata_show_instance_with_condition_and_predicate
+      map_route "#{name_in_path}/#{CONDITION}\\(#{PREDICATE}\\)", 'sdata_show_instance', :get
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts
+    def map_sdata_create_instance
+      map_route "#{name_in_path}", 'sdata_create_instance', :post
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts/$linked
+    def map_sdata_create_link
+      map_route "#{name_in_path}/#{CONDITION}", 'sdata_create_link', :post
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts('1')
+    def map_sdata_update_instance
+      map_route "#{name_in_path}\\(:instance_id\\)", 'sdata_update_instance', :put
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts/$syncSource
+    def map_sdata_sync_source
+      map_route "#{name_in_path}/$syncSource", 'sdata_collection_sync_feed', :post
+    end
+
+    # http://localhost:3000/sdata/billingboss/crmErp/-/tradingAccounts/$syncResults
+    def map_sdata_receive_sync_results
+      map_route "#{name_in_path}/$syncResults\\(:trackingID\\)", 'sdata_collection_sync_results', :post
+    end
+
+
+    def map_route(path, action, method)
+      path = prefix.chomp('/') + '/' + path if prefix?
+      path = path + ".sdata" if formatted_paths?
+
+      router.connect path, :controller => controller_with_namespace, :action => action, :conditions => { :method => method }, :priority => 99
+    end
+
+    def controller_with_namespace
+      @controller_with_namespace ||= "#{namespace}#{controller}"
+    end
+
+    def namespace
+      @namespace ||= (options[:namespace] ? "#{options[:namespace]}/" : "")
+    end
+
+    def controller
+      @controller ||= resource_name.to_s.pluralize
+    end
+
+    def name_in_path
+      @name_in_path ||= resource_name.to_s.camelize(:lower).pluralize
+    end
+
+    def formatted_paths?
+      @formatted_paths ||= options[:formatted_paths]
+    end
+
+    def prefix
+      if options[:prefix]
+        @prefix = options[:prefix] + '/{:dataset,([^\/]+)}'   
+      else
+        @prefix = '/'
+      end
+    end
+
+    def prefix?
+      !! prefix
+    end
+
+  end
+end

data/lib/s_data/router_mixin.rb

@@ -0,0 +1,10 @@
+module SData
+  module RouterMixin
+    def sdata_resource(name, options={})
+      route_creator = SData::RouteMapper.new(self, name, options)
+      route_creator.map_sdata_routes!
+    end
+  end
+end
+
+ActionController::Routing::RouteSet::Mapper.__send__ :include, SData::RouterMixin

data/lib/s_data/sync/controller_mixin.rb

@@ -0,0 +1,122 @@
+module SData
+  module Sync
+    module ControllerMixin
+      def syncs_sdata(options={})
+        raise "cannot sync sdata unless controller first acts_as_sdata" if self.sdata_options.nil? 
+        cattr_accessor :sdata_sync_options
+        self.sdata_sync_options = options
+
+        include InstanceMethods
+      end
+
+      module InstanceMethods
+        module Actions
+          # TODO: error handling
+          def sdata_collection_sync_feed
+            # get the target digest
+            payload = params[:entry].sdata_payload
+            
+            raise "no payload!" if payload.blank?
+
+            sd_sync_run = SData::SdSyncRun.find_by_tracking_id(tracking_id)
+            raise Sage::BusinessLogic::Exception::AccessDeniedException, "Access denied" unless sd_sync_run.nil?
+            
+            # prepare a sync run to hold our state
+            sd_sync_run = SData::SdSyncRun.new(   :tracking_id => tracking_id, 
+                                                  :run_name => params[:runName], 
+                                                  # :created_at => params[:runStamp],
+                                                  :sd_class => model_class.sdata_name,
+                                                  :created_by => target_user)
+            sd_sync_run.target_digest = payload.sync_digest
+            
+            sd_sync_run.start!
+            sd_sync_run.process!
+            xml = sd_sync_run.to_xml.to_s
+            render :xml => xml, :content_type => "application/xml", :location => sync_source_url(sd_sync_run.tracking_id), :status => 202
+          end
+          
+          def sdata_collection_sync_feed_status
+            sd_sync_run = SData::SdSyncRun.find_by_tracking_id(tracking_id)
+            raise Sage::BusinessLogic::Exception::AccessDeniedException, "Access denied" if sd_sync_run.nil?
+            assert_access_to sd_sync_run
+            if sd_sync_run.finished?
+              @total_results = sd_sync_run.total_results
+              feed =  build_sdata_feed(:feed => {:title => "#{model_class.sdata_name} synchronization feed #{params[:trackingID]}"})
+              feed[SData.config[:schemas]['sync'], 'syncMode'] << "catchUp"
+
+              feed.sync_digest = sd_sync_run.source_digest
+
+              atom_entries = []
+              errors = []
+              sd_sync_run.objects[zero_based_start_index,records_to_return].each do |obj|
+                begin
+                  # RADAR: this (the (params) part) will allow user to insert a different dataset (and possibly
+                  # other data) than that which was synchronized during the run. If this is somehow a security
+                  # problem, need to freeze that data during synctime. an be also solved by freezing username 
+                  # in feed and matching dataset against it at accestime.
+                  # RADAR: children (e.g. line items) will be embedded in parent (e.g. invoice) during this
+                  # request, but from live data rather than syncronized one, is this a potential problem?
+                  feed.entries << obj.to_atom(params.merge(:sync => true)){|entry| entry.sync_syncState = obj.sd_sync_state }
+                rescue Exception => e
+                  errors << ApplicationDiagnosis.new(:exception => e).to_xml(:feed)
+                end
+              end
+              #TODO: syntactic sugar if possible (such as diagnosing_errors(&block) which does the dirty work)
+              errors.each do |error|
+                feed[SData.config[:schemas]['sdata'], 'diagnosis'] << error
+              end
+              populate_open_search_for(feed)
+              build_feed_links_for(feed)
+              render :xml => feed, :content_type => "application/atom+xml; type=feed"
+            else
+              render :xml => sd_sync_run.to_xml.to_s, 
+                  :content_type => "application/atom+xml; type=feed", 
+                  :location => sync_source_url(sd_sync_run.tracking_id),
+                  :status => 202
+            end
+          end
+          
+          def sdata_collection_sync_feed_delete
+            sd_sync_run = SData::SdSyncRun.find_by_tracking_id(tracking_id)
+            sd_sync_run.destroy
+            render :text => "OK"
+          end
+          
+          def sdata_collection_sync_results
+            render :text => "Not implemented!"
+          end
+        end
+        module AuxiliaryMethods
+          protected
+          
+          # TODO: sort out profusion of urls endpoints and config classes!
+          def resource_url
+            case self.action_name
+            when 'sdata_collection_sync_feed_status',
+              'sdata_collection_sync_feed_status',
+              'sdata_collection_sync_feed_delete'
+              super + "/$syncSource('#{tracking_id}')"
+            else
+              super
+            end
+          end
+
+          def sync_source_url(track)
+            endpoint  = target_user.endpoint
+            "#{endpoint}/#{SData.sdata_collection_url_component(model_class)}/$syncSource('#{track}')"
+          end
+          
+          def tracking_id
+            CGI::unescape(params[:trackingID]).gsub(/^'/,'').gsub(/'$/,'')
+          end
+          
+          
+        end
+        include Actions
+        include AuxiliaryMethods
+      end
+    end
+  end
+end
+ActionController::Base.extend SData::Sync::ControllerMixin
+# Atom::Entry.elements "sync:digest", :class => SData::SdDigest::AtomWrapper