ext_ooor 2.3.0.1

data/lib/generators/ooor/ooor.yml

@@ -0,0 +1,49 @@
+# Odoo. Versions 7 and up are supported.
+#
+default: &default
+  global_context:
+    'lang': fr_FR
+  bootstrap: true
+
+
+development:
+  <<: *default
+  database: db
+  username: admin
+  password: admin
+  url: http://localhost:8069
+
+
+# database to use when you run tests with "rake".
+test:
+  <<: *default
+  username: admin
+  password: admin
+  url: http://localhost:8069
+
+
+# As with config/secrets.yml, you never want to store sensitive information,
+# like your Odoo portal password, in your source code. If your source code is
+# ever seen by anyone, they now have access to your ERP with the portal user.
+#
+# Instead, provide the password as a unix environment variable when you boot
+# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
+# for a full rundown on how to provide these environment variables in a
+# production deployment.
+#
+# On Heroku and other platform providers, you may have a full connection URL
+# available as an environment variable. For example:
+#
+#   OOOR_URL="ooor://myuser:mypass@localhost:port/somedatabase"
+#
+# You can use this database configuration with:
+#
+#   production:
+#     url: <%%= ENV['OOOR_URL'] %>
+#
+production:
+  <<: *default
+  database: prod_db
+  username: portal_user
+  password: <%%= ENV['OOOR_PASSWORD'] %>
+  url: https://prod_host

data/lib/ooor.rb

@@ -0,0 +1,230 @@
+#    OOOR: OpenObject On Ruby
+#    Copyright (C) 2009-2013 Akretion LTDA (<http://www.akretion.com>).
+#    Author: Raphaël Valyi
+#    Licensed under the MIT license, see MIT-LICENSE file
+
+require 'active_support/dependencies/autoload'
+require 'active_support/concern'
+require 'active_support/cache'
+require 'logger'
+
+
+module Ooor
+  extend ActiveSupport::Autoload
+  autoload :Base
+  autoload :ModelSchema
+  autoload :Persistence
+  autoload :AutosaveAssociation
+  autoload :NestedAttributes
+  autoload :Callbacks
+  autoload :Cache, 'active_support/cache'
+  autoload :Serialization
+  autoload :Relation
+  autoload :TypeCasting
+  autoload :Naming
+  autoload :Associations
+  autoload :FieldMethods
+  autoload :Report
+  autoload :Locale
+  autoload :Transport
+  autoload :Block
+  autoload :MiniActiveResource
+  autoload :SessionHandler
+  autoload :ModelRegistry
+  autoload :UnknownAttributeOrAssociationError, 'ooor/errors'
+  autoload :OpenERPServerError, 'ooor/errors'
+  autoload :HashWithIndifferentAccess, 'active_support/core_ext/hash/indifferent_access'
+
+  autoload_under 'relation' do
+    autoload :FinderMethods
+  end
+
+  module OoorBehavior
+    extend ActiveSupport::Concern
+    module ClassMethods
+
+      attr_accessor :default_config, :default_session, :cache_store
+
+      IRREGULAR_CONTEXT_POSITIONS = {
+        import_data: 5,
+        fields_view_get: 2,
+        search: 4,
+        name_search:  3,
+        read_group: 5,
+        fields_get: 1,
+        read: 2,
+        perm_read: 1,
+        check_recursion: 1
+      }
+
+      def new(config={})
+        defaults = HashWithIndifferentAccess.new({generate_constants: true})
+        formated_config = format_config(config)
+        self.default_config = defaults.merge(formated_config)
+        session = session_handler.retrieve_session(default_config, :noweb)
+        if default_config[:database] && default_config[:password] && default_config[:bootstrap] != false
+          session.global_login()
+        end
+        Ooor.default_session = session
+      end
+
+      def cache(store=nil)
+        @cache_store ||= ActiveSupport::Cache.lookup_store(store)
+      end
+
+      def xtend(model_name, &block)
+        @extensions ||= {}
+        @extensions[model_name] ||= []
+        @extensions[model_name] << block
+        @extensions
+      end
+
+      def extensions
+        @extensions ||= {}
+      end
+
+      def session_handler() @session_handler ||= SessionHandler.new; end
+      def model_registry() @model_registry ||= ModelRegistry.new; end
+
+      def logger
+        @logger ||= Logger.new($stdout)
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      def irregular_context_position(method)
+        IRREGULAR_CONTEXT_POSITIONS.merge(default_config[:irregular_context_positions] || {})[method.to_sym]
+      end
+
+      # gives a hash config from a connection string or a yaml file, injects default values
+      def format_config(config)
+        if config.is_a?(String) && config.end_with?('.yml')
+          env = defined?(Rails.env) ? Rails.env : nil
+          config = load_config_file(config, env)
+        end
+        if config.is_a?(String)
+          cs = config
+          config = HashWithIndifferentAccess.new()
+        elsif config[:ooor_url]
+          cs = config[:ooor_url]
+        elsif ENV['OOOR_URL']
+          cs = ENV['OOOR_URL'].dup()
+        end
+        config.merge!(parse_connection_string(cs)) if cs
+        defaults = HashWithIndifferentAccess.new({
+          url: 'http://localhost:8069',
+          username: 'admin'
+        })
+        defaults[:password] = ENV['OOOR_PASSWORD'] if ENV['OOOR_PASSWORD']
+        defaults[:username] = ENV['OOOR_USERNAME'] if ENV['OOOR_USERNAME']
+        defaults[:database] = ENV['OOOR_DATABASE'] if ENV['OOOR_DATABASE']
+        defaults.merge(config)
+      end
+
+
+      private
+
+      def load_config_file(config_file=nil, env=nil)
+        config_file ||= defined?(Rails.root) && "#{Rails.root}/config/ooor.yml" || 'ooor.yml'
+        config_parsed = ::YAML.load(ERB.new(File.new(config_file).read).result)
+        HashWithIndifferentAccess.new(config_parsed)[env || 'development']
+      rescue SystemCallError
+        Ooor.logger.error """failed to load OOOR yaml configuration file.
+           make sure your app has a #{config_file} file correctly set up
+           if not, just copy/paste the default ooor.yml file from the OOOR Gem
+           to #{Rails.root}/config/ooor.yml and customize it properly\n\n"""
+        {}
+      end
+
+      def parse_connection_string(cs)
+        if cs.start_with?('ooor://') && ! cs.index('@')
+          cs.sub!(/^ooor:\/\//, '@')
+        end
+
+        cs.sub!(/^http:\/\//, '')
+        cs.sub!(/^ooor:/, '')
+        cs.sub!(/^ooor:/, '')
+        cs.sub!('//', '')
+        if cs.index('ssl=true')
+          ssl = true
+          cs.gsub!('?ssl=true', '').gsub!('ssl=true', '')
+        end
+        if cs.index(' -s')
+          ssl = true
+          cs.gsub!(' -s', '')
+        end
+
+        if cs.index('@')
+          parts = cs.split('@')
+          right = parts[1]
+          left = parts[0]
+          if right.index('/')
+            parts = right.split('/')
+            database = parts[1]
+            host, port = parse_host_port(parts[0])
+          else
+            host, port = parse_host_port(right)
+          end
+
+          if left.index(':')
+            user_pwd = left.split(':')
+            username = user_pwd[0]
+            password = user_pwd[1]
+          else
+            if left.index('.') && !database
+              username = left.split('.')[0]
+              database = left.split('.')[1]
+            else
+              username = left
+            end
+          end
+        else
+          host, port = parse_host_port(cs)
+        end
+
+        host ||= 'localhost'
+        port ||= 8069
+        ssl = true if port == 443
+        username = 'admin' if username.blank?
+        {
+          url: "#{ssl ? 'https' : 'http'}://#{host}:#{port}",
+          username: username,
+          database: database,
+          password: password,
+        }.select { |_, value| !value.nil? } # .compact() on Rails > 4
+      end
+
+      def parse_host_port(host_port)
+        if host_port.index(':')
+          host_port = host_port.split(':')
+          host = host_port[0]
+          port = host_port[1].to_i
+        else
+          host = host_port
+          port = 80
+        end
+        return host, port
+      end
+
+    end
+
+    def with_ooor_session(config={}, id=:noweb)
+      session = Ooor.session_handler.retrieve_session(config, id)
+      yield session
+    end
+
+    def with_ooor_default_session(config={})
+      if config
+        Ooor.new(config)
+      else
+        Ooor.default_session
+      end
+    end
+  end
+
+  include OoorBehavior
+end
+
+require 'ooor/railtie' if defined?(Rails)

data/lib/ooor/associations.rb

@@ -0,0 +1,78 @@
+module Ooor
+  module Associations
+
+    # similar to ActiveRecord CollectionProxy but without lazy loading work yet
+    class CollectionProxy < Relation
+
+      def to_ary
+        to_a.dup
+      end
+#      alias_method :to_a, :to_ary
+
+      def class
+        Array
+      end
+
+      def is_a?(*args)
+        @records.is_a?(*args)
+      end
+
+      def kind_of?(*args)
+        @records.kind_of?(*args)
+      end
+
+    end
+
+
+    # fakes associations like much like ActiveRecord according to the cached OpenERP data model
+    def relationnal_result(method_name, *arguments)
+      self.class.reload_fields_definition(false)
+      if self.class.many2one_associations.has_key?(method_name)
+        load_m2o_association(method_name, *arguments)
+      elsif self.class.polymorphic_m2o_associations.has_key?(method_name)# && @associations[method_name]
+        load_polymorphic_m2o_association(method_name, *arguments)
+#        values = @associations[method_name].split(',')
+#        self.class.const_get(values[0]).find(values[1], arguments.extract_options!)
+      else # o2m or m2m
+        load_x2m_association(method_name, *arguments)
+      end
+    end
+
+    private
+
+    def load_polymorphic_m2o_association(method_name, *arguments)
+      if @associations[method_name]
+        values = @associations[method_name].split(',')
+        self.class.const_get(values[0]).find(values[1], arguments.extract_options!)
+      else
+        false
+      end
+    end
+
+    def load_m2o_association(method_name, *arguments)
+      if !@associations[method_name]
+        nil
+      else
+        if @associations[method_name].is_a?(Integer)
+          id = @associations[method_name]
+          display_name = nil
+        else
+          id = @associations[method_name][0]
+          display_name = @associations[method_name][1]
+        end
+        rel = self.class.many2one_associations[method_name]['relation']
+        self.class.const_get(rel).new({id: id, _display_name: display_name}, [], true, false, true)
+#        self.class.const_get(rel).find(id, arguments.extract_options!)
+      end
+    end
+
+    def load_x2m_association(method_name, *arguments)
+      model_key = self.class.all_fields[method_name]['relation']
+      ids = @associations[method_name] || []
+      options = arguments.extract_options!
+      related_class = self.class.const_get(model_key)
+      CollectionProxy.new(related_class, {}).apply_finder_options(options.merge(ids: ids))      
+    end
+
+  end
+end

data/lib/ooor/autosave_association.rb

@@ -0,0 +1,197 @@
+require 'ostruct'
+require 'active_support/concern'
+
+module Ooor
+  # = Ooor Autosave Association, adapted from ActiveRecord 4.1
+  #
+  # +AutosaveAssociation+ is a module that takes care of automatically saving
+  # associated records when their parent is saved. In addition to saving, it
+  # also destroys any associated records that were marked for destruction.
+  # (See +mark_for_destruction+ and <tt>marked_for_destruction?</tt>).
+  #
+  # Saving of the parent, its associations, and the destruction of marked
+  # associations, all happen inside a transaction. This should never leave the
+  # database in an inconsistent state.
+  #
+  # If validations for any of the associations fail, their error messages will
+  # be applied to the parent (TODO)
+  module AutosaveAssociation
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      private
+
+        # same as ActiveRecord
+        def define_non_cyclic_method(name, &block)
+          define_method(name) do |*args|
+            result = true; @_already_called ||= {}
+            # Loop prevention for validation of associations
+            unless @_already_called[name]
+              begin
+                @_already_called[name]=true
+                result = instance_eval(&block)
+              ensure
+                @_already_called[name]=false
+              end
+            end
+
+            result
+          end
+        end
+
+        # Adds validation and save callbacks for the association as specified by
+        # the +reflection+.
+        #
+        # For performance reasons, we don't check whether to validate at runtime.
+        # However the validation and callback methods are lazy and those methods
+        # get created when they are invoked for the very first time. However,
+        # this can change, for instance, when using nested attributes, which is
+        # called _after_ the association has been defined. Since we don't want
+        # the callbacks to get defined multiple times, there are guards that
+        # check if the save or validation methods have already been defined
+        # before actually defining them.
+        def add_autosave_association_callbacks(reflection) # TODO add support for m2o
+          save_method = :"autosave_associated_records_for_#{reflection.name}"
+          validation_method = :"validate_associated_records_for_#{reflection.name}"
+          collection = true #reflection.collection?
+          unless method_defined?(save_method)
+            if collection
+              before_save :before_save_collection_association
+              define_non_cyclic_method(save_method) { save_collection_association(reflection) }
+              before_save save_method
+              # NOTE Ooor is different from ActiveRecord here: we run the nested callbacks before saving
+              # the whole hash of values including the nested records
+              # Doesn't use after_save as that would save associations added in after_create/after_update twice
+#              after_create save_method
+#              after_update save_method
+            else
+              raise raise ArgumentError, "Not implemented in Ooor; seems OpenERP won't support such nested attribute in the same transaction anyhow"
+            end
+          end
+
+          if reflection.validate? && !method_defined?(validation_method)
+            method = (collection ? :validate_collection_association : :validate_single_association)
+            define_non_cyclic_method(validation_method) { send(method, reflection) }
+            validate validation_method
+          end
+        end
+    end
+
+    # Reloads the attributes of the object as usual and clears <tt>marked_for_destruction</tt> flag.
+    def reload(options = nil)
+      @marked_for_destruction = false
+      @destroyed_by_association = nil
+      super
+    end
+
+    # Marks this record to be destroyed as part of the parents save transaction.
+    # This does _not_ actually destroy the record instantly, rather child record will be destroyed
+    # when <tt>parent.save</tt> is called.
+    #
+    # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
+    def mark_for_destruction
+      @marked_for_destruction = true
+    end
+
+    # Returns whether or not this record will be destroyed as part of the parents save transaction.
+    #
+    # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
+    def marked_for_destruction?
+      @marked_for_destruction
+    end
+
+    # Records the association that is being destroyed and destroying this
+    # record in the process.
+    def destroyed_by_association=(reflection)
+      @destroyed_by_association = reflection
+    end
+
+    # Returns the association for the parent being destroyed.
+    #
+    # Used to avoid updating the counter cache unnecessarily.
+    def destroyed_by_association
+      @destroyed_by_association
+    end
+
+    # Returns whether or not this record has been changed in any way (including whether
+    # any of its nested autosave associations are likewise changed)
+    def changed_for_autosave?
+      new_record? || changed? || marked_for_destruction? # TODO || nested_records_changed_for_autosave?
+    end
+
+    private
+
+      # Returns the record for an association collection that should be validated
+      # or saved. If +autosave+ is +false+ only new records will be returned,
+      # unless the parent is/was a new record itself.
+      def associated_records_to_validate_or_save(association, new_record, autosave)
+        if new_record
+          association && association.target
+        elsif autosave
+          association.target.find_all { |record| record.changed_for_autosave? }
+        else
+          association.target.find_all { |record| record.new_record? }
+        end
+      end
+
+      # go through nested autosave associations that are loaded in memory (without loading
+      # any new ones), and return true if is changed for autosave
+#      def nested_records_changed_for_autosave?
+#        self.class.reflect_on_all_autosave_associations.any? do |reflection|
+#          association = association_instance_get(reflection.name)
+#          association && Array.wrap(association.target).any? { |a| a.changed_for_autosave? }
+#        end
+#      end
+
+      # Is used as a before_save callback to check while saving a collection
+      # association whether or not the parent was a new record before saving.
+      def before_save_collection_association
+        @new_record_before_save = new_record?
+        true
+      end
+
+      # Saves any new associated records, or all loaded autosave associations if
+      # <tt>:autosave</tt> is enabled on the association.
+      #
+      # In addition, it destroys all children that were marked for destruction
+      # with mark_for_destruction.
+      #
+      # This all happens inside a transaction, _if_ the Transactions module is included into
+      # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
+      def save_collection_association(reflection)
+#        if association = association_instance_get(reflection.name)
+        if target = @loaded_associations[reflection.name] #TODO use a real Association wrapper
+          association = OpenStruct.new(target: target)
+          autosave = reflection.options[:autosave]
+
+          if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+             # NOTE saving the object with its nested associations will properly destroy records in OpenERP
+             # no need to do it now like in ActiveRecord
+            records.each do |record|
+              next if record.destroyed?
+
+              saved = true
+
+              if autosave != false && (@new_record_before_save || record.new_record?)
+                if autosave
+#                  saved = association.insert_record(record, false)
+                  record.run_callbacks(:save) { false }
+                  record.run_callbacks(:create) { false }
+#                else
+#                  association.insert_record(record) unless reflection.nested?
+                end
+              elsif autosave
+                record.run_callbacks(:save) {false}
+                record.run_callbacks(:update) {false}
+#                saved = record.save(:validate => false)
+              end
+
+            end
+          end
+          # reconstruct the scope now that we know the owner's id
+#          association.reset_scope if association.respond_to?(:reset_scope)
+        end
+      end
+
+  end
+end