acts_as_sdata 1.0.0

data/lib/s_data/active_record_extensions/sdata_uuid_mixin.rb

@@ -0,0 +1,133 @@
+module SData
+  module ActiveRecordExtensions
+    module SdataUuidMixin
+    
+      def acts_as_sdata_uuid
+        self.__send__ :extend, UuidClassMethods
+      end
+    
+      module UuidClassMethods
+
+     
+        def find_by_virtual_model_and_uuid(virtual_model, uuid)
+          sd_uuids = SData::SdUuid.find(:all, :conditions => {:sd_class => virtual_model.sdata_name, :bb_model_type => virtual_model.baze_class_name, :uuid => uuid})
+        
+          sd_uuid = enforce_uniqueness(sd_uuids, virtual_model.sdata_name, virtual_model.baze_class_name)
+          
+          raise "#{virtual_model.sdata_name} with UUID '#{uuid}' not found" unless sd_uuid
+          virtual_model.build_for(sd_uuid.bb_model)    
+        end
+      
+        # Handling multiple uuids: when linking and the resource already had a uuid on both sides, one provider wins and
+        # stores it's uuid for the resource on the other provider (http://interop.sage.com/daisy/sdataSync/Link/525-DSY.html)
+        # At a later date sdata will provide an algorithm for uuid propagation; for the time being we assume the last stored
+        # is the correct one.
+        def find_for_virtual_instance(virtual_instance, baze=nil)
+          baze ||= virtual_instance.baze
+          SData::SdUuid.first(:conditions => {:sd_class => virtual_instance.sdata_name, 
+                                                       :bb_model_type => baze.class.name.demodulize, 
+                                                       :bb_model_id => baze.id},
+                                                       :order => "updated_at DESC" )
+        end
+      
+        def enforce_uniqueness(sd_uuids, sd_class, baze_class_name)
+          return nil if sd_uuids.nil? || sd_uuids.empty?
+          if sd_uuids.count > 1
+            RAILS_DEFAULT_LOGGER.fatal("SdUuid uniqueness violation for #{sd_class} - #{baze_class_name} - #{uuid}. Using first created")
+            sd_uuids.sort_by!{|sid| sid.updated_at}
+          end
+          sd_uuids.first
+        end
+      
+        # This method is used to respond to a PUT to $linked('uuid'), to change what bb_model instance a uuid points to
+        # TODO this method makes no attempt to handle multiple baze_classes
+        # RADAR this method also has a RACE, but which should only happen when the provider/linking engine 
+        # is doing something fubarred
+        def reassign_uuid!(uuid, virtual_model, new_id)
+          raise "Cannot edit uuid for virtual_model (#{virtual_model.name}) with no fixed baze_class." if virtual_model.baze_class.nil?
+          sd_uuids = SData::SdUuid.find(:all, :conditions => {:sd_class => virtual_model.sdata_name, :bb_model_type => virtual_model.baze_class_name, :uuid => uuid})
+          sd_uuid = enforce_uniqueness(sd_uuids, virtual_model.sdata_name, virtual_model.baze_class_name)
+          sd_uuid.update_attributes!({:bb_model_id => new_id})
+        end
+      
+        # TODO: handle case where virtual model depends on multiple models whose updated_at matter. 
+        # This method can change the uuid of a given underlying BB model. It CANNOT set a uuid for the tuple [sd_class,
+        # bb_model_type] for a given bb_model_id if an instance of the tuple [sd_class, bb_model_type] with a different
+        # bb_model_id exists. To swap which bb_model_id of a [sd_class, bb_model_type] a uuid points to, use reassign_uuid!.
+        # Move the delete case to a separate method, and the controller should determine whether the request is deleting
+        # or not (does spec actually say you can delete a uuid by POST ing empty uuid to it? don't you have to do a DELETE?).
+        # Because of unique index on [sd_class, bb_model, uuid] this has a race condition and can theoretically throw, but
+        # only if a linking engine is mistakenly sending multiple requests rapidly. The controller can just report a 
+        # generic error.
+        def create_or_update_uuid_for(virtual_instance, uuid)
+          raise "Cannot create_or_update_uuid_for virtual_model (#{virtual_model.name}) with no fixed baze_class." if virtual_instance.class.baze_class.nil?
+          raise "virtual_instance #{virtual_instance.inspect} has no baze" unless virtual_instance.baze
+          return if uuid.blank?
+
+          sd_uuid = SData::SdUuid.find_for_virtual_instance(virtual_instance)
+          params = {:sd_class => virtual_instance.sdata_name,
+                                  :bb_model_type => virtual_instance.baze_class_name,
+                                  :bb_model_id => virtual_instance.baze.id,
+                                  :uuid => uuid}
+          if sd_uuid
+            sd_uuid.update_attributes!(params)
+          else
+            begin
+              SData::SdUuid.create(params)
+            rescue ::ActiveRecord::StatementInvalid
+              raise Sage::BusinessLogic::Exception::IncompatibleDataException, "UUID already exists for another resource"
+            end
+          end
+        end
+            
+        # return all the bb_records which form the basis of this resource and which have been linked
+        # MJ TODO -- check if there is a way to use the bb_model polymorphic assoc to autmatically create this query
+        def linked_bb_records(endpoint=nil)
+          klasses = baze_classes || [self]
+          records = {}
+          klasses.each do |klass|
+            klassname = klass.name.demodulize
+            tablename = klassname.tableize
+            conditions = { :bb_model_type => klassname }
+            # conditions[:endpoint] = endpoint  # we don't need this now
+            records[klassname.to_sym] = klass.all(:joins => "INNER JOIN sd_uuids ON sd_uuids.bb_model_id = #{tablename}.id", 
+                :conditions => {:sd_uuids => conditions})
+          end
+          records
+        end
+      end
+    end
+  
+    module SdataUuidableMixin
+      def has_sdata_uuid
+        self.__send__ :include, UuidableInstanceMethods
+      end
+    
+      module UuidableInstanceMethods
+            
+        def uuid
+          record = sd_uuid
+          record ? record.uuid : nil
+        end
+      
+        # WARN: don't cache this, it will potentially break things
+        # RADAR: This finds the most recently updated of potentially many sd_uuids -- see
+        # http://interop.sage.com/daisy/sdataSync/Link/525-DSY.html, linking scenario 3
+        def sd_uuid
+          SData::SdUuid.find_for_virtual_instance(self)
+        end
+
+        def create_or_update_uuid!(value)
+          SData::SdUuid.create_or_update_uuid_for(self, value)
+        end
+      
+        def linked?
+          !sd_uuid.nil?
+        end
+      
+      end
+    end
+  
+    ::ActiveRecord::Base.extend SdataUuidMixin
+  end
+end

data/lib/s_data/atom_extensions/content_mixin.rb

@@ -0,0 +1,14 @@
+module SData
+  module AtomExtensions
+    module  ContentMixin
+      class Diagnosis < Atom::Content::Base
+        attribute :type, :'xml:lang'
+        def to_xml(*params)
+          self[0] #magic done in diagnosis.rb
+        end
+      end
+      
+    end
+  end
+end
+Atom::Content.__send__ :include, SData::AtomExtensions::ContentMixin

data/lib/s_data/atom_extensions/entry_mixin.rb

@@ -0,0 +1,41 @@
+# the following should stay together, to ensure that when adding custom nodes, the namespcaes
+# they are in are available to ratom, or it will silently decide to make the node an Atom::Content
+SData.config[:schemas].each do |prefix, namespace|
+  Atom::Feed.add_extension_namespace(prefix.to_s, namespace)
+  Atom::Entry.add_extension_namespace(prefix.to_s, namespace)
+end
+
+
+Atom::Entry.element "sdata:payload", 
+                    :class => SData::AtomExtensions::Nodes::Payload,
+                    :namespace => SData.config[:schemas][:sdata]
+
+#TODO the rest should be done like payload
+Atom::Entry.element :diagnosis, :class => Atom::Content
+
+Atom::Entry.element "sync:syncState",
+                    :class => SData::AtomExtensions::Nodes::SyncState,
+                    :namespace => SData.config[:schemas][:sync]
+Atom::Feed.element  "sync:digest", 
+                    :class => SData::AtomExtensions::Nodes::Digest, 
+                    :namespace => SData.config[:schemas][:sync]
+
+module Atom
+  class Entry
+    def extended_element(element_with_namespace)
+      namespace, element = element_with_namespace.split(':')
+      self.simple_extensions.keys.each do |key|
+        return self.simple_extensions[key][0] if key == "{#{SData.config[:schemas][namespace]},#{element}}"
+      end
+      nil
+    end
+
+    def to_attributes
+      attributes = {}
+      self['http://sdata.sage.com/schemes/attributes'].each_pair do |name, values|
+        attributes[name] = values.first
+      end
+      attributes
+    end
+  end
+end

data/lib/s_data/atom_extensions/nodes/digest.rb

@@ -0,0 +1,48 @@
+module SData
+  module AtomExtensions
+    module Nodes
+
+      class DigestEntry
+        include Atom::Xml::Parseable
+        add_extension_namespace "sdata", SData.config[:schemas][:sdata]
+        add_extension_namespace 'sync', SData.config[:schemas][:sync]
+        element "sync:endpoint", :namespace => SData.config[:schemas][:sync]
+        element "sync:tick", :namespace => SData.config[:schemas][:sync]
+        element "sync:stamp", :namespace => SData.config[:schemas][:sync]
+        element "sync:conflictPriority", :namespace => SData.config[:schemas][:sync]
+        
+        def initialize(xml=nil)
+          if xml
+            # puts "DigestEntry call xml.read"
+            xml.read
+            parse(xml)
+          end
+        end
+        
+        def self.parse(xml)
+          new(xml)
+        end
+      end
+
+      class Digest
+        include Atom::Xml::Parseable
+        add_extension_namespace "sdata", SData.config[:schemas][:sdata]
+        add_extension_namespace 'sync', SData.config[:schemas][:sync]
+        elements "sync:digestEntry", :class => SData::AtomExtensions::Nodes::DigestEntry, :namespace => SData.config[:schemas][:sync]
+        uri_attribute "sdata:url"
+        element "sync:origin", :namespace => SData.config[:schemas][:sync]
+        
+        def initialize(xml=nil)
+          xml.read
+          parse(xml)
+        end
+        
+        def self.parse(xml)
+          new(xml)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/s_data/atom_extensions/nodes/payload.rb

@@ -0,0 +1,34 @@
+
+module SData
+  module AtomExtensions
+    module Nodes
+      class Payload
+        attr_accessor :raw_xml
+        include Atom::Xml::Parseable
+        add_extension_namespace "sdata", SData.config[:schemas][:sdata]
+        add_extension_namespace 'sync', SData.config[:schemas][:sync]
+
+        element 'sync:digest', :class => SData::AtomExtensions::Nodes::Digest, :namespace => SData.config[:schemas][:sync]
+      
+        def initialize(xml=nil)
+          # temporary, until have time to add Linking atom extension
+          @raw_xml = xml.read_inner_xml
+          xml.read
+          parse(xml)
+        end
+        
+        def self.parse(xml)
+          new(xml)
+        end
+
+        def to_xml(*params)
+          node = XML::Node.new("sdata:payload")
+          node << content
+          return node
+        end
+        
+      end
+    end
+  end
+end
+

data/lib/s_data/atom_extensions/nodes/sync_state.rb

@@ -0,0 +1,14 @@
+module SData
+  module AtomExtensions
+    module Nodes # the reason I didn't name this Atom is that I didn't feel like adding :: in a gawdjillion places ATM   
+      class SyncState
+        def initialize(xml=nil)
+        end
+        
+        def self.parse(xml)
+          # no need to parse sync states at this time
+        end
+      end
+    end
+  end
+end

data/lib/s_data/conditions_builder.rb

@@ -0,0 +1,59 @@
+module SData
+  class ConditionsBuilder
+    SQL_RELATIONS_MAP = {
+        :binary => {                              
+            :eq => '%s = ?',
+            :ne => '%s <> ?',
+            :lt => '%s < ?',
+            :lteq => '%s <= ?',
+            :gt => '%s > ?',
+            :gteq => '%s >= ?'
+        },
+        
+        :ternary => {
+            :between => '%s BETWEEN ? AND ?'
+        }
+    }
+
+    attr_accessor :field, :relation, :values
+    
+    def self.build_conditions(field, relation, *values)
+      self.new(field, relation, *values).conditions
+    end
+    
+    def initialize(field, relation, *values)
+      @field = field
+      @relation = relation
+      @values = values
+    end
+
+    def conditions
+      arguments_invalid? ?
+        [] :
+        [template_with_field_name] + values
+    end
+
+  protected    
+
+    def arguments_invalid?
+      field.nil? or relation.nil? or values.nil? or template.nil?
+    end
+
+    def template_with_field_name
+      template % quoted_field_name
+    end
+    
+    def quoted_field_name
+      ActiveRecord::Base.connection.quote_column_name(@field)
+    end
+
+    def template
+      case values.size
+        when 1:
+          SQL_RELATIONS_MAP[:binary][relation]
+        when 2:
+          SQL_RELATIONS_MAP[:ternary][relation]
+      end
+    end
+  end
+end

data/lib/s_data/controller_mixin.rb

@@ -0,0 +1,11 @@
+module SData
+  module ControllerMixin
+    def acts_as_sdata(options)
+      cattr_accessor :sdata_options
+      self.sdata_options = options
+      include Actions
+    end
+  end
+end
+
+ActionController::Base.extend SData::ControllerMixin

data/lib/s_data/controller_mixin/actions.rb

@@ -0,0 +1,87 @@
+require 'nokogiri'
+
+module SData
+  module ControllerMixin
+    module Actions
+      def sdata_collection
+        begin
+          errors = []
+          collection = build_sdata_feed
+          sdata_scope.each do |entry|
+            begin
+              collection.entries << entry.to_atom(params)
+            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|
+            collection[SData.config[:schemas]['sdata'], 'diagnosis'] << error
+          end
+          populate_open_search_for(collection)
+          build_feed_links_for(collection)
+          render :xml => collection, :content_type => "application/atom+xml; type=feed"
+        rescue Exception => e
+          handle_exception(e)
+        end
+      end
+
+      def sdata_show_instance
+        begin
+          instance = sdata_instance
+          assert_access_to instance
+          render :xml => instance.to_atom(params), :content_type => "application/atom+xml; type=entry"
+        rescue Exception => e
+          handle_exception(e)
+        end
+      end
+
+      def sdata_create_instance
+        raise "not currently supported"
+      end
+
+      def sdata_update_instance
+        raise "not currently supported"
+      end
+
+      def sdata_create_link
+        begin
+          payload_xml = params['entry'].sdata_payload.raw_xml
+          payload = Nokogiri::XML(payload_xml).root
+          id = payload.attributes['key'].value.to_i
+          uuid = payload.attributes['uuid'].value
+          instance = model_class.find(id)
+          assert_access_to instance
+          instance.create_or_update_uuid! uuid
+          render :xml => instance.to_atom(params), :content_type => "application/atom+xml; type=entry", :status => "201"
+        rescue Exception => e
+          handle_exception(e)
+        end
+      end
+
+    protected
+
+      def model_class
+        self.class.sdata_options[:model]
+      end
+
+      def assert_access_to(instance)
+        raise "Unauthenticated" unless logged_in?
+        # Not returning Access Denied on purpose so that users cannot fish for existence of emails or other data.
+        # As far as user should be concerned, all requests are scoped to his/her own data.
+        # Data which is found but which belongs to someone else should be as good as data that doesn't exist.
+        raise Sage::BusinessLogic::Exception::IncompatibleDataException, "Conditions scope must contain exactly one entry" if (instance.owner != target_user)
+      end
+
+      
+      def handle_exception(exception)
+        diagnosis = SData::Diagnosis::DiagnosisMapper.map(exception)
+        render :xml => diagnosis.to_xml(:root), :status => diagnosis.http_status_code || 500
+      end
+
+      include SDataInstance
+      include SDataFeed
+      include CollectionScope
+    end
+  end
+end