nexo 0.1.0

data/app/lib/nexo/event_receiver.rb

@@ -0,0 +1,45 @@
+module Nexo
+  # This callbacks must be called when synchronizables change locally, must not
+  # be called when the system is notified of an external element change
+  class EventReceiver
+    def synchronizable_created(synchronizable)
+      validate_synchronizable_state!(synchronizable)
+
+      synchronizable.initialize_values!
+
+      SynchronizableChangedJob.perform_later(synchronizable)
+    end
+
+    def synchronizable_updated(synchronizable)
+      if synchronizable.change_is_significative_to_sequence?
+        synchronizable.increment_sequence!
+      end
+
+      # Even if sequence remains the same the synchronizable may be removed
+      # from some Folder, so we have to always enqueue the job
+      SynchronizableChangedJob.perform_later(synchronizable)
+    end
+
+    def synchronizable_destroyed(synchronizable)
+      folder_service.destroy_elements(synchronizable, :synchronizable_destroyed)
+    end
+
+    def folder_policy_changed(folder_policy)
+      FolderSyncJob.perform_later(folder_policy.folder)
+    end
+
+    private
+
+    # :nocov: mocked
+    def folder_service
+      @folder_service ||= FolderService.new
+    end
+    # :nocov:
+
+    def validate_synchronizable_state!(synchronizable)
+      unless synchronizable.sequence.nil?
+        raise Errors::InvalidSynchronizableState, "sequence is present: #{synchronizable.sequence}"
+      end
+    end
+  end
+end

data/app/lib/nexo/folder_service.rb

@@ -0,0 +1,67 @@
+module Nexo
+  # Handles the composition of folders
+  #
+  # Responsabilities:
+  # - Creation of Element's
+  # - Flagging Element's for deletion
+  # - Triggering the SyncElementJob
+  class FolderService
+    def find_element_and_sync(folder, synchronizable)
+      # TODO: handle conflicted synchronizable
+      element = find_element(folder, synchronizable)
+
+      if element.present?
+        sync_element(element)
+      else
+        create_and_sync_element(folder, synchronizable)
+      end
+    end
+
+    def destroy_elements(synchronizable, reason)
+      synchronizable.nexo_elements.each do |element|
+        element.flag_for_deletion!(reason)
+
+        SyncElementJob.perform_later(element)
+      end
+    end
+
+    private
+
+    def find_element(folder, synchronizable)
+      folder.find_element(synchronizable:)
+    end
+
+    def create_and_sync_element(folder, synchronizable)
+      must_be_included = folder.policy_match?(synchronizable)
+
+      if must_be_included
+        element = Element.create!(
+          synchronizable:,
+          folder:
+        )
+
+        if synchronizable.sequence.nil?
+          # TODO: whats the use of having this and also in EventReceiver?
+          synchronizable.initialize_values!
+        end
+
+        SyncElementJob.perform_later(element)
+      end
+    end
+
+    def sync_element(element)
+      synchronizable = element.synchronizable
+
+      if synchronizable.conflicted?
+        raise Nexo::Errors::ElementConflicted, element
+      end
+
+      # Check if Synchronizable still must be included in folder
+      if !element.policy_still_match?
+        element.flag_for_deletion!(:no_longer_included_in_folder)
+      end
+
+      SyncElementJob.perform_later(element)
+    end
+  end
+end

data/app/lib/nexo/policy_service.rb

@@ -0,0 +1,40 @@
+module Nexo
+  class PolicyService
+    def initialize
+      @finders = []
+    end
+
+    @instance = new
+
+    private_class_method :new
+
+    def self.instance
+      @instance
+    end
+
+    def register_folder_policy_finder(&block)
+      @finders << block
+    end
+
+    attr_reader :finders
+
+    def match?(folder, synchronizable)
+      policies = policies_for(folder)
+      matching_policies = policies.select { |policy| policy.match?(synchronizable) }
+      if matching_policies.any?
+        aplicable_policy = matching_policies.sort_by { |policy| policy.priority }.last
+        aplicable_policy.sync_policy == :include
+      else
+        false
+      end
+    end
+
+    def policies_for(folder)
+      aux = @finders.map do |finder|
+        finder.call(folder)
+      end
+
+      aux.flatten.compact
+    end
+  end
+end

data/app/lib/nexo/service_builder.rb

@@ -0,0 +1,30 @@
+module Nexo
+  # Centralizes the creation of API service objects
+  class ServiceBuilder
+    @instance = new
+
+    private_class_method :new
+
+    def self.instance
+      @instance
+    end
+
+    def build_protocol_service(folder)
+      service_klass_name = "#{folder.integration.client.service}_#{folder.protocol}_service".camelcase
+      build_service(service_klass_name, folder.integration)
+    end
+
+    def build_auth_service(integration)
+      service_klass_name = "#{integration.client.service}_auth_service".camelcase
+      build_service(service_klass_name, integration)
+    end
+
+    private
+
+    def build_service(klass_name, integration)
+      service_klass = Nexo.const_get(klass_name)
+
+      service_klass.new(integration)
+    end
+  end
+end

data/app/models/concerns/nexo/calendar_event.rb

@@ -0,0 +1,56 @@
+module Nexo
+  module CalendarEvent
+    include Synchronizable
+
+    extend ActiveSupport::Concern
+
+    define_protocol(:nexo_calendar_event, %i[
+      date_from
+      date_to
+      time_from
+      time_to
+      summary
+      description
+    ])
+
+    def change_is_significative_to_sequence?
+      previous_changes.keys.map(&:to_sym).intersection(protocol_methods).any?
+    end
+
+    def datetime_from
+      build_date_time(date_from, time_from)
+    end
+
+    def datetime_to
+      build_date_time(date_to, time_to)
+    end
+
+    private
+
+    # @param [Date] date
+    # @param [Time] time
+    #
+    # @return [Date, DateTime]
+    def build_date_time(date, time = nil)
+      if time.present?
+        DateTime.new(
+          date.year,
+          date.month,
+          date.day,
+          time.hour,
+          time.min,
+          time.sec,
+          time.zone
+        )
+      else
+        date
+      end
+    end
+
+
+    # TODO: refactor https://api.rubyonrails.org/classes/ActiveSupport/Concern.html
+    included do
+      include Nexo::Synchronizable::Associations
+    end
+  end
+end

data/app/models/concerns/nexo/folder_policy.rb

@@ -0,0 +1,24 @@
+module Nexo
+  module FolderPolicy
+    extend ActiveSupport::Concern
+    # include ActiveModel::Model
+    include ActiveModel::Validations
+
+    # TODO: add belongs_to :folder ?
+
+    # validates_inclusion_of :sync_policy, in: %w( include exclude )
+    # TODO!: check if this is being used
+    included do
+      validates :sync_policy, inclusion: { in: %w[ bla ] }
+      validates :priority, numericality: true
+    end
+
+    def match?(synchronizable)
+      # :nocov: borderline
+      raise "must be implemented in subclass"
+      # :nocov:
+    end
+
+    attr_reader :priority, :sync_policy
+  end
+end

data/app/models/concerns/nexo/synchronizable.rb

@@ -0,0 +1,88 @@
+module Nexo
+  module Synchronizable
+    extend ActiveSupport::Concern
+
+    def protocol_methods
+      # uuid (deprecated)
+      #   hay un problema con generar un uuid por synchronizable y es que si se
+      #   inserta en un google calendar y luego se elimina, luego ya no se
+      #   puede volver a insertar con el mismo uuid, sería mejor que el id se
+      #   genere automáticamente por google y guardarlo en Element
+      %i[
+        sequence
+      ]
+    end
+
+    module ClassMethods
+      def define_protocol(name, methods)
+        define_method(:protocols) do
+          if defined? super
+            # :nocov: TODO, not yet implemented
+            super << name
+            # :nocov:
+          else
+            [ name ]
+          end
+        end
+
+        define_method(:protocol_methods) do
+          if defined? super
+            [ super(), methods ].flatten
+          else
+            # :nocov: borderline
+            raise "protocol_methods should be defined"
+            # :nocov:
+          end
+        end
+      end
+    end
+
+    def method_missing(method_name, *, &)
+      if method_name.in?(protocol_methods)
+        raise Errors::InterfaceMethodNotImplemented, method_name
+      end
+
+      super
+    end
+
+    # ----------------------------------------------------
+
+    module Associations
+      extend ActiveSupport::Concern
+      included do
+        has_many :nexo_elements, class_name: "Nexo::Element", as: :synchronizable
+      end
+    end
+
+    def conflicted?
+      nexo_elements.conflicted.any?
+    end
+
+    # :nocov: TODO, not yet implemented
+    def update_from!(element_version)
+      transaction do
+        # TODO: parse the element_version.payload
+        # and set the Synchronizable fields according to the Folder#protocol
+
+        new_sequence = increment_sequence!
+        element_version.update_sequence!(new_sequence)
+      end
+    end
+    # :nocov:
+
+    def initialize_values!
+      update!(sequence: 0)
+    end
+
+    def increment_sequence!
+      # This operation is performed directly in the database without the need
+      # to read the current value first. So, it is atomic at a database level,
+      # though the in-memory object consitency is subject to race conditions.
+      #
+      # increment(:sequence), without the bang, is not atomic
+      #
+      # https://api.rubyonrails.org/v7.2/classes/ActiveRecord/Persistence.html#method-i-increment-21
+      increment!(:sequence)
+    end
+  end
+end

data/app/models/nexo/application_record.rb

@@ -0,0 +1,5 @@
+module Nexo
+  class ApplicationRecord < ::ApplicationRecord
+    self.abstract_class = true
+  end
+end

data/app/models/nexo/client.rb

@@ -0,0 +1,49 @@
+# == Schema Information
+#
+# Table name: nexo_clients
+#
+#  id                        :integer          not null, primary key
+#  service                   :integer
+#  secret                    :string
+#  tcp_status                :integer
+#  brand_name                :integer
+#  user_integrations_allowed :boolean
+#  created_at                :datetime         not null
+#  updated_at                :datetime         not null
+#
+require "google-apis-calendar_v3"
+require "google-apis-oauth2_v2"
+
+module Nexo
+  AVAILABLE_SCOPES = {
+    google: {
+      auth_email: Google::Apis::Oauth2V2::AUTH_USERINFO_EMAIL,
+      auth_calendar_app_created: Google::Apis::CalendarV3::AUTH_CALENDAR_APP_CREATED,
+      auth_calendar_calendarlist: Google::Apis::CalendarV3::AUTH_CALENDAR_CALENDARLIST
+    }
+  }
+
+  class Client < ApplicationRecord
+    encrypts :secret
+
+    enum :service, google: 0
+    enum :tcp_status, authorized: 0, disabled: 1, expired: 2
+
+    validates :service, :user_integrations_allowed,
+              :tcp_status, :secret, presence: true
+
+    serialize :secret, coder: JSON
+
+    def to_s
+      service.titleize
+    end
+
+    def available_scopes_for_select
+      service_scopes.keys
+    end
+
+    def service_scopes
+      AVAILABLE_SCOPES[service.to_sym]
+    end
+  end
+end

data/app/models/nexo/element.rb

@@ -0,0 +1,74 @@
+# == Schema Information
+#
+# Table name: nexo_elements
+#
+#  id                  :integer          not null, primary key
+#  folder_id           :integer          not null
+#  synchronizable_id   :integer          not null
+#  synchronizable_type :string           not null
+#  uuid                :string
+#  flag_deletion       :boolean          not null
+#  deletion_reason     :integer
+#  conflicted          :boolean          default(FALSE), not null
+#  discarded_at        :datetime
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#
+module Nexo
+  class Element < ApplicationRecord
+    belongs_to :folder, class_name: "Nexo::Folder"
+    belongs_to :synchronizable, polymorphic: true
+    has_many :element_versions, dependent: :destroy, class_name: "Nexo::ElementVersion"
+
+    after_initialize do
+      # TODO: https://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html#method-i-attribute
+      self.flag_deletion = false if flag_deletion.nil?
+    end
+
+    scope :kept, -> { where(discarded_at: nil) }
+
+    enum :deletion_reason, no_longer_included_in_folder: 0, synchronizable_destroyed: 1
+
+    scope :conflicted, -> { where(conflicted: true) }
+
+    def policy_still_match?
+      folder.policy_match?(synchronizable)
+    end
+
+    def last_synced_sequence
+      element_versions.pluck(:sequence).max || -1
+    end
+
+    def external_unsynced_change?
+      last_external_unsynced_version.present?
+    end
+
+    def last_external_unsynced_version
+      element_versions.where(sequence: nil).order(created_at: :desc).first
+    end
+
+    def flag_for_deletion!(deletion_reason)
+      update!(flag_deletion: true, deletion_reason:)
+    end
+
+    def flagged_for_deletion?
+      flag_deletion?
+    end
+
+    # :nocov: TODO, not yet being called
+    def flag_as_conflicted!
+      update!(conflicted: true)
+
+      # TODO: log "Conflicted Element: #{element.to_gid}"
+    end
+    # :nocov:
+
+    def discarded?
+      discarded_at.present?
+    end
+
+    def discard!
+      update!(discarded_at: Time.current)
+    end
+  end
+end

data/app/models/nexo/element_version.rb

@@ -0,0 +1,38 @@
+# == Schema Information
+#
+# Table name: nexo_element_versions
+#
+#  id         :integer          not null, primary key
+#  element_id :integer          not null
+#  payload    :string
+#  etag       :string
+#  sequence   :integer
+#  origin     :integer          not null
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+module Nexo
+  # sequence
+  #
+  #   cuando es null significa que el origin es external que debe ser
+  #   sincronizado. si está presente, significa que fue sinzronizado
+  #
+  # etag
+  #
+  #   id de versión remota, para evitar pisar datos remotos aún no fetcheados y
+  #   para no volver a traer datos si no hubo ningún cambio desde la última vez
+  #   que se fetchearon
+  #
+  # payload
+  #
+  #   raw data from API
+  class ElementVersion < ApplicationRecord
+    belongs_to :element, class_name: "Nexo::Element"
+
+    enum :origin, internal: 0, external: 1
+
+    serialize :payload, coder: JSON
+
+    validates :payload, :etag, :origin, presence: true
+  end
+end

data/app/models/nexo/folder.rb

@@ -0,0 +1,43 @@
+# == Schema Information
+#
+# Table name: nexo_folders
+#
+#  id                  :integer          not null, primary key
+#  integration_id      :integer          not null
+#  protocol            :integer          not null
+#  external_identifier :string
+#  name                :string
+#  description         :string
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#
+module Nexo
+  class Folder < ApplicationRecord
+    belongs_to :integration, class_name: "Nexo::Integration"
+    has_many :elements, class_name: "Nexo::Element"
+
+    enum :protocol, calendar: 0, dummy_calendar: 1
+
+    validates :protocol, :name, presence: true
+
+    # TODO!: find better name
+    # maybe policy_applies?
+    def policy_match?(synchronizable)
+      PolicyService.instance.match?(self, synchronizable)
+    end
+
+    def find_element(synchronizable:)
+      ary = elements.where(synchronizable:, discarded_at: nil).to_a
+
+      if ary.count > 1
+        raise Errors::MoreThanOneElementInFolderForSynchronizable
+      end
+
+      ary.first
+    end
+
+    def time_zone
+      Rails.application.config.time_zone
+    end
+  end
+end

data/app/models/nexo/integration.rb

@@ -0,0 +1,60 @@
+# == Schema Information
+#
+# Table name: nexo_integrations
+#
+#  id           :integer          not null, primary key
+#  user_id      :integer          not null
+#  client_id    :integer          not null
+#  name         :string
+#  scope        :string
+#  expires_at   :datetime
+#  discarded_at :datetime
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#
+module Nexo
+  class Integration < ApplicationRecord
+    include Discard::Model if defined? Discard::Model
+    include Hashid::Rails if defined? Hashid::Rails
+
+    serialize :scope, coder: JSON
+    belongs_to :user
+    belongs_to :client, class_name: "Nexo::Client"
+    has_many :tokens, class_name: "Nexo::Token"
+
+    validates :scope, presence: true
+
+    def external_api_scope
+      if scope.blank?
+        # :nocov: borderline
+        raise "scope must be present"
+        # :nocov:
+      end
+
+      scope.map { |permission| client.service_scopes[permission.to_sym] }
+    end
+
+    def expires_in
+      return unless credentials.present?
+
+      (credentials.expires_at - Time.current).to_i
+    end
+
+    def token_status
+      if credentials.present?
+        if credentials.expires_at > Time.current
+          :active_token
+        else
+          :expired_token
+        end
+      else
+        :no_token
+      end
+    end
+
+    def credentials
+      service = ServiceBuilder.instance.build_auth_service(self)
+      @credentials ||= service.get_credentials
+    end
+  end
+end

data/app/models/nexo/token.rb

@@ -0,0 +1,29 @@
+# == Schema Information
+#
+# Table name: nexo_tokens
+#
+#  id             :integer          not null, primary key
+#  integration_id :integer          not null
+#  secret         :string
+#  tpt_status     :integer          not null
+#  environment    :string           not null
+#  created_at     :datetime         not null
+#  updated_at     :datetime         not null
+#
+module Nexo
+  class Token < ApplicationRecord
+    belongs_to :integration, class_name: "Nexo::Integration"
+
+    after_initialize do
+      # TODO: https://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html#method-i-attribute
+      self.tpt_status = :active if tpt_status.nil?
+      self.environment = Rails.env if environment.nil?
+    end
+
+    encrypts :secret
+
+    enum :tpt_status, active: 0, revoked: 1, expired: 2
+
+    validates :secret, :tpt_status, :environment, presence: true
+  end
+end

data/config/routes.rb

@@ -0,0 +1,2 @@
+Nexo::Engine.routes.draw do
+end

data/db/migrate/20250505192315_create_nexo_clients.rb

@@ -0,0 +1,13 @@
+class CreateNexoClients < ActiveRecord::Migration[7.2]
+  def change
+    create_table :nexo_clients do |t|
+      t.integer :service
+      t.string :secret
+      t.integer :tcp_status
+      t.integer :brand_name
+      t.boolean :user_integrations_allowed
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20250505195429_create_nexo_integrations.rb

@@ -0,0 +1,15 @@
+class CreateNexoIntegrations < ActiveRecord::Migration[7.2]
+  def change
+    create_table :nexo_integrations do |t|
+      t.references :user, null: false, foreign_key: true
+      t.references :client, null: false, foreign_key: { to_table: :nexo_clients }
+      t.string :name
+      t.string :scope
+      t.datetime :expires_at
+
+      t.datetime :discarded_at
+
+      t.timestamps
+    end
+  end
+end