rodoo 0.1.0

data/lib/rodoo/model.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Base class for Odoo models. Provides both class-level query methods and instance-level persistence.
+  #
+  # @example Defining a model
+  #   class Contact < Rodoo::Model
+  #     model_name "res.partner"
+  #   end
+  #
+  # @example Querying
+  #   contact = Rodoo::Contact.find(42)
+  #   contacts = Rodoo::Contact.where([["is_company", "=", true]])
+  #   all = Rodoo::Contact.all(limit: 10)
+  #
+  # @example Creating
+  #   contact = Rodoo::Contact.create(name: "Acme Corp")
+  #
+  # @example Building and saving
+  #   contact = Rodoo::Contact.new(name: "Draft")
+  #   contact.email = "draft@example.com"
+  #   contact.save
+  #
+  class Model
+    # ============================================
+    # Class-level configuration and query methods
+    # ============================================
+
+    # Sets or gets the Odoo model name for this model
+    #
+    # @param name [String, nil] The Odoo model name (e.g., "res.partner")
+    # @return [String] The model name
+    def self.model_name(name = nil)
+      if name
+        @odoo_model_name = name
+      else
+        @odoo_model_name || (superclass.respond_to?(:model_name) ? superclass.model_name : nil)
+      end
+    end
+
+    # Find a single record by ID
+    #
+    # @param id [Integer] The record ID
+    # @return [Model] The found record
+    # @raise [Rodoo::NotFoundError] If the record doesn't exist
+    #
+    # @example
+    #   contact = Rodoo::Contact.find(42)
+    #   contact.name  # => "Acme Corp"
+    #
+    def self.find(id)
+      result = execute("read", ids: [id])
+      raise NotFoundError, "#{model_name} with id=#{id} not found" if result.nil? || result.empty?
+
+      new(result.first)
+    end
+
+    # Search for records with flexible query syntax
+    #
+    # @param conditions [Array, Hash, String, nil] Query conditions
+    # @param fields [Array<String>, nil] Fields to retrieve
+    # @param limit [Integer, nil] Maximum records to return
+    # @param offset [Integer, nil] Number of records to skip
+    # @return [Array<Model>] Array of matching records
+    #
+    # @example Keyword arguments (equality)
+    #   Rodoo::Contact.where(name: "Acme", is_company: true)
+    #
+    # @example String condition
+    #   Rodoo::Contact.where("credit_limit > 1000")
+    #
+    # @example Array of strings
+    #   Rodoo::Contact.where(["credit_limit > 1000", "active = true"])
+    #
+    # @example Raw Odoo domain (array of arrays)
+    #   Rodoo::Contact.where([["is_company", "=", true]], limit: 10)
+    #
+    def self.where(conditions = nil, fields: nil, limit: nil, offset: nil, **attrs)
+      domain = DomainBuilder.build(conditions, attrs)
+
+      params = { domain: domain }
+      params[:fields] = fields if fields
+      params[:limit] = limit if limit
+      params[:offset] = offset if offset
+
+      execute("search_read", params).map { |record| new(record) }
+    end
+
+    # Fetch all records (optionally limited)
+    #
+    # @param fields [Array<String>, nil] Fields to retrieve
+    # @param limit [Integer, nil] Maximum records to return
+    # @return [Array<Model>] Array of records
+    #
+    # @example
+    #   all_contacts = Rodoo::Contact.all(limit: 100)
+    #
+    def self.all(fields: nil, limit: nil)
+      where([], fields: fields, limit: limit)
+    end
+
+    # Find a single record by attribute conditions
+    #
+    # @param conditions [Array, Hash, String, nil] Query conditions (same as where)
+    # @return [Model, nil] The first matching record or nil if not found
+    #
+    # @example Find by keyword arguments
+    #   contact = Rodoo::Contact.find_by(email: "john@example.com")
+    #
+    # @example Find by multiple conditions
+    #   contact = Rodoo::Contact.find_by(name: "Acme Corp", is_company: true)
+    #
+    # @example Find by string condition
+    #   contact = Rodoo::Contact.find_by("credit_limit > 1000")
+    #
+    # @example Find by raw domain
+    #   contact = Rodoo::Contact.find_by([["name", "ilike", "%acme%"]])
+    #
+    def self.find_by(conditions = nil, **attrs)
+      where(conditions, limit: 1, **attrs).first
+    end
+
+    # Find a single record by attribute conditions, raising if not found
+    #
+    # @param conditions [Array, Hash, String, nil] Query conditions (same as where)
+    # @return [Model] The first matching record
+    # @raise [Rodoo::NotFoundError] If no matching record is found
+    #
+    # @example Find by email (raises if not found)
+    #   contact = Rodoo::Contact.find_by!(email: "john@example.com")
+    #
+    def self.find_by!(conditions = nil, **attrs)
+      record = find_by(conditions, **attrs)
+      return record if record
+
+      raise NotFoundError, "#{model_name} matching #{conditions.inspect} #{attrs.inspect} not found"
+    end
+
+    # Create a new record in Odoo
+    #
+    # @param attrs [Hash] Attributes for the new record
+    # @return [Model] The created record with its ID
+    #
+    # @example
+    #   contact = Rodoo::Contact.create(name: "New Contact", email: "new@example.com")
+    #   contact.id  # => 123
+    #
+    def self.create(attrs)
+      ids = execute("create", vals_list: [attrs])
+      find(ids.first)
+    end
+
+    # Execute an Odoo method via the JSON-2 API
+    #
+    # @param method [String] The method to call (e.g., "search_read")
+    # @param params [Hash] The method parameters
+    # @return [Object] The response data
+    def self.execute(method, params = {})
+      Rodoo.connection.execute(model_name, method, params)
+    end
+
+    # ============================================
+    # Instance attributes and lifecycle
+    # ============================================
+
+    def initialize(attributes = {})
+      @attributes = (attributes || {}).transform_keys(&:to_sym)
+    end
+
+    def [](key)
+      @attributes[key.to_sym]
+    end
+
+    def []=(key, value)
+      @attributes[key.to_sym] = value
+    end
+
+    def to_h
+      @attributes.dup
+    end
+
+    def persisted?
+      !id.nil?
+    end
+
+    # Save the record to Odoo
+    #
+    # Creates a new record if unpersisted, updates if persisted.
+    #
+    # @return [self]
+    def save
+      if persisted?
+        update(to_h.except(:id))
+      else
+        result = self.class.create(to_h)
+        self.id = result.id
+      end
+      self
+    end
+
+    # Update specific attributes on a persisted record
+    #
+    # @param attrs [Hash] Attributes to update
+    # @return [self]
+    # @raise [Rodoo::Error] If the record hasn't been persisted
+    def update(attrs)
+      raise Error, "Cannot update a record that hasn't been persisted" unless persisted?
+
+      normalized = attrs.transform_keys(&:to_sym)
+      self.class.execute("write", ids: [id], vals: normalized)
+      normalized.each { |key, value| self[key] = value }
+      self
+    end
+
+    # Reload the record from Odoo
+    #
+    # @return [self]
+    # @raise [Rodoo::Error] If the record hasn't been persisted
+    def reload
+      raise Error, "Cannot reload a record that hasn't been persisted" unless persisted?
+
+      fresh = self.class.find(id)
+      fresh.to_h.each { |key, value| self[key] = value }
+      self
+    end
+
+    # Permanently delete the record from Odoo
+    #
+    # @return [self] The deleted record (frozen)
+    # @raise [Rodoo::Error] If the record hasn't been persisted
+    #
+    # @example
+    #   contact = Rodoo::Contact.find(42)
+    #   contact.destroy
+    #   contact.destroyed?  # => true
+    #
+    def destroy
+      raise Error, "Cannot destroy a record that hasn't been persisted" unless persisted?
+
+      self.class.execute("unlink", ids: [id])
+      @destroyed = true
+      freeze
+    end
+
+    # Check if this record has been destroyed
+    #
+    # @return [Boolean]
+    def destroyed?
+      @destroyed == true
+    end
+
+    def inspect
+      "#<#{self.class.name} id=#{id.inspect} #{inspectable_attributes}>"
+    end
+
+    private
+
+    def respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+
+    def method_missing(method_name, *args, &)
+      attr_name = method_name.to_s
+
+      if attr_name.end_with?("=")
+        @attributes[attr_name.delete_suffix("=").to_sym] = args.first
+      else
+        @attributes[method_name]
+      end
+    end
+
+    def inspectable_attributes
+      to_h.except(:id).map { |k, v| "#{k}=#{v.inspect}" }.join(" ")
+    end
+  end
+end

data/lib/rodoo/models/accounting_entry.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Base class for Odoo accounting entries (account.move).
+  #
+  # In Odoo, customer invoices, provider invoices, credit notes, and journal entries
+  # are all stored in the same model (account.move) and differentiated by the move_type field.
+  #
+  # This class provides the base functionality, while subclasses automatically filter
+  # and set the appropriate move_type.
+  #
+  # @example Using a specific subclass
+  #   invoice = Rodoo::CustomerInvoice.create(partner_id: 42)
+  #   bills = Rodoo::ProviderInvoice.where([["state", "=", "posted"]])
+  #
+  # @example Using the base class to query all types
+  #   all_entries = Rodoo::AccountingEntry.where([["date", ">", "2025-01-01"]])
+  #
+  class AccountingEntry < Model
+    model_name "account.move"
+
+    # Subclasses override this to specify their move_type
+    #
+    # @return [String, nil] The move_type value for this class
+    def self.default_move_type
+      nil
+    end
+
+    # Search for records, automatically scoped to the move_type
+    #
+    # @param conditions [Array, Hash, String, nil] Query conditions
+    # @param options [Hash] Additional options (fields, limit, offset)
+    # @return [Array<AccountingEntry>] Array of matching records
+    def self.where(conditions = nil, **options)
+      domain = DomainBuilder.build(conditions, options.except(:fields, :limit, :offset))
+      domain = [["move_type", "=", default_move_type]] + domain if default_move_type
+      super(domain, **options.slice(:fields, :limit, :offset))
+    end
+
+    # Create a new record, automatically setting the move_type
+    #
+    # @param attrs [Hash] Attributes for the new record
+    # @return [AccountingEntry] The created record
+    def self.create(attrs)
+      scoped_attrs = if default_move_type
+                       { move_type: default_move_type }.merge(attrs)
+                     else
+                       attrs
+                     end
+      super(scoped_attrs)
+    end
+  end
+end

data/lib/rodoo/models/accounting_entry_line.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Accounting entry line (account.move.line) - individual debit/credit lines within an accounting entry.
+  #
+  # Every accounting entry (invoice, bill, journal entry) has at least two lines:
+  # one for the debit side and one for the credit side.
+  #
+  # @example Find lines for a specific entry
+  #   lines = Rodoo::AccountingEntryLine.where([["move_id", "=", 42]])
+  #
+  # @example Find all receivable lines
+  #   receivables = Rodoo::AccountingEntryLine.where([["account_type", "=", "asset_receivable"]])
+  #
+  # @example Get line details
+  #   line = Rodoo::AccountingEntryLine.find(123)
+  #   line.debit    # => 1000.0
+  #   line.credit   # => 0.0
+  #   line.balance  # => 1000.0
+  #
+  class AccountingEntryLine < Model
+    model_name "account.move.line"
+  end
+end

data/lib/rodoo/models/analytic_account.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rodoo
+  class AnalyticAccount < Model
+    model_name "account.analytic.account"
+  end
+end

data/lib/rodoo/models/analytic_plan.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rodoo
+  class AnalyticPlan < Model
+    model_name "account.analytic.plan"
+  end
+end

data/lib/rodoo/models/contact.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Contact model for Odoo's res.partner (contacts/companies)
+  #
+  # @example Find a contact
+  #   contact = Rodoo::Contact.find(42)
+  #
+  # @example Search for companies
+  #   companies = Rodoo::Contact.where([["is_company", "=", true]])
+  #
+  # @example Create a contact
+  #   contact = Rodoo::Contact.create(name: "Acme Corp", is_company: true)
+  #
+  class Contact < Model
+    model_name "res.partner"
+  end
+end

data/lib/rodoo/models/customer_credit_note.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Customer credit note / refund (move_type: out_refund)
+  #
+  # @example
+  #   credit_note = Rodoo::CustomerCreditNote.create(partner_id: 42)
+  #   credit_notes = Rodoo::CustomerCreditNote.where([["state", "=", "posted"]])
+  #
+  class CustomerCreditNote < AccountingEntry
+    def self.default_move_type
+      "out_refund"
+    end
+  end
+end

data/lib/rodoo/models/customer_invoice.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Customer invoice (move_type: out_invoice)
+  #
+  # @example
+  #   invoice = Rodoo::CustomerInvoice.create(partner_id: 42)
+  #   invoices = Rodoo::CustomerInvoice.where([["state", "=", "posted"]])
+  #
+  class CustomerInvoice < AccountingEntry
+    def self.default_move_type
+      "out_invoice"
+    end
+  end
+end

data/lib/rodoo/models/journal_entry.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Journal entry (move_type: entry)
+  #
+  # @example
+  #   entry = Rodoo::JournalEntry.create(journal_id: 1)
+  #   entries = Rodoo::JournalEntry.where([["state", "=", "posted"]])
+  #
+  class JournalEntry < AccountingEntry
+    def self.default_move_type
+      "entry"
+    end
+  end
+end

data/lib/rodoo/models/product.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Product model for Odoo's product.product (product variants)
+  #
+  # @example Find a product
+  #   product = Rodoo::Product.find(42)
+  #
+  # @example Search for active products
+  #   products = Rodoo::Product.where([["active", "=", true]])
+  #
+  # @example Create a product
+  #   product = Rodoo::Product.create(name: "Widget", list_price: 9.99)
+  #
+  class Product < Model
+    model_name "product.product"
+  end
+end

data/lib/rodoo/models/project.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Project model for Odoo's project.project table.
+  #
+  # @example Find a project by ID
+  #   project = Rodoo::Project.find(42)
+  #
+  # @example Search for projects
+  #   project = Rodoo::Project.where([["is_company", "=", true]])
+  #
+  # @example Create a project
+  #   project = Rodoo::Project.create(name: "my_project", account_id: analytic_account_id, allow_billable: true)
+  #
+  class Project < Model
+    model_name "project.project"
+  end
+end

data/lib/rodoo/models/provider_credit_note.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Provider/vendor credit note / refund (move_type: in_refund)
+  #
+  # @example
+  #   refund = Rodoo::ProviderCreditNote.create(partner_id: 42)
+  #   refunds = Rodoo::ProviderCreditNote.where([["state", "=", "posted"]])
+  #
+  class ProviderCreditNote < AccountingEntry
+    def self.default_move_type
+      "in_refund"
+    end
+  end
+end

data/lib/rodoo/models/provider_invoice.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Provider/vendor invoice (move_type: in_invoice)
+  #
+  # @example
+  #   bill = Rodoo::ProviderInvoice.create(partner_id: 42)
+  #   bills = Rodoo::ProviderInvoice.where([["state", "=", "posted"]])
+  #
+  class ProviderInvoice < AccountingEntry
+    def self.default_move_type
+      "in_invoice"
+    end
+  end
+end

data/lib/rodoo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rodoo
+  VERSION = "0.1.0"
+end

data/lib/rodoo.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "rodoo/version"
+require_relative "rodoo/configuration"
+require_relative "rodoo/connection"
+require_relative "rodoo/errors"
+require_relative "rodoo/domain_builder"
+require_relative "rodoo/model"
+
+module Rodoo
+  autoload :AccountingEntry, "rodoo/models/accounting_entry"
+  autoload :AccountingEntryLine, "rodoo/models/accounting_entry_line"
+  autoload :AnalyticAccount, "rodoo/models/analytic_account"
+  autoload :AnalyticPlan, "rodoo/models/analytic_plan"
+  autoload :CustomerCreditNote, "rodoo/models/customer_credit_note"
+  autoload :CustomerInvoice, "rodoo/models/customer_invoice"
+  autoload :JournalEntry, "rodoo/models/journal_entry"
+  autoload :Contact, "rodoo/models/contact"
+  autoload :Product, "rodoo/models/product"
+  autoload :Project, "rodoo/models/project"
+  autoload :ProviderCreditNote, "rodoo/models/provider_credit_note"
+  autoload :ProviderInvoice, "rodoo/models/provider_invoice"
+
+  @configuration = nil
+  @connection = nil
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+    @connection = nil # Reset connection when configuration changes
+  end
+
+  def self.reset!
+    @configuration = Configuration.new
+    @connection = nil
+  end
+
+  def self.connection
+    configuration.validate!
+    @connection ||= Connection.new(configuration)
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: rodoo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rodrigo Serrano
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: This gem implements a wrapper to interact with Odoo's API in Ruby. The
+  API used is Odoo's 'external JSON-2 API' introduced in Odoo v19.
+email:
+- rodrigo.serrano@dekuple.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".env.example"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- LICENSE.txt
+- Odoo_API.md
+- README.md
+- Rakefile
+- lib/rodoo.rb
+- lib/rodoo/configuration.rb
+- lib/rodoo/connection.rb
+- lib/rodoo/domain_builder.rb
+- lib/rodoo/errors.rb
+- lib/rodoo/model.rb
+- lib/rodoo/models/accounting_entry.rb
+- lib/rodoo/models/accounting_entry_line.rb
+- lib/rodoo/models/analytic_account.rb
+- lib/rodoo/models/analytic_plan.rb
+- lib/rodoo/models/contact.rb
+- lib/rodoo/models/customer_credit_note.rb
+- lib/rodoo/models/customer_invoice.rb
+- lib/rodoo/models/journal_entry.rb
+- lib/rodoo/models/product.rb
+- lib/rodoo/models/project.rb
+- lib/rodoo/models/provider_credit_note.rb
+- lib/rodoo/models/provider_invoice.rb
+- lib/rodoo/version.rb
+homepage: https://github.com/dekuple/rodoo
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dekuple/rodoo
+  source_code_uri: https://github.com/dekuple/rodoo
+  changelog_uri: https://github.com/dekuple/rodoo/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Odoo API wrapper (using the modern JSON-2 API)
+test_files: []