nexo 0.1.4 → 0.1.6

data/app/lib/nexo/folder_service.rb

@@ -3,60 +3,87 @@ module Nexo
   #
   # Responsabilities:
   # - Creation of Element's
-  # - Flagging Element's for deletion
-  # - Triggering the SyncElementJob
+  # - Creation of ElementVersion on local changes
+  # - Flagging Element's for removal
+  # - Enqueues UpdateRemoteResourceJob, DeleteRemoteResourceJob
   class FolderService
+    # @raise [ActiveRecord::RecordNotUnique] on ElementVersion creation
     def find_element_and_sync(folder, synchronizable)
-      # TODO: handle conflicted synchronizable
-      element = find_element(folder, synchronizable)
+      validate_synchronizable!(synchronizable)
+
+      element = folder.find_element(synchronizable:)
 
       if element.present?
+        Nexo.logger.debug { "Element found" }
+        validate_element_state!(element)
         sync_element(element)
       else
+        Nexo.logger.debug { "Element not found" }
         create_and_sync_element(folder, synchronizable)
       end
     end
 
-    def destroy_elements(synchronizable, reason)
-      synchronizable.nexo_elements.each do |element|
-        element.flag_for_deletion!(reason)
+    def destroy_elements(synchronizable, reason, exclude_elements: [])
+      Nexo.logger.debug("Destroying elements for synchronizable")
+
+      scope = synchronizable.nexo_elements
+
+      if exclude_elements.any?
+        Nexo.logger.debug("Excluding elements: #{exclude_elements}")
 
-        SyncElementJob.perform_later(element)
+        scope = scope.where.not(id: exclude_elements)
       end
-    end
 
-    private
+      scope.each do |element|
+        unless element.folder.sync_internal_changes?
+          Nexo.logger.debug("Folder dont syncs internal changes, skipping")
+          next
+        end
 
-    def find_element(folder, synchronizable)
-      folder.find_element(synchronizable:)
+        ElementService.new(element:).flag_for_removal!(reason)
+
+        DeleteRemoteResourceJob.perform_later(element)
+      end
     end
 
-    def create_and_sync_element(folder, synchronizable)
-      must_be_included = folder.policy_match?(synchronizable)
+    private
 
-      if must_be_included
-        element = Element.create!(
-          synchronizable:,
-          folder:
-        )
+    def validate_synchronizable!(synchronizable)
+      synchronizable.validate_synchronizable!
 
-        SyncElementJob.perform_later(element)
+      if synchronizable.sequence.nil?
+        raise Errors::SynchronizableSequenceIsNull
       end
     end
 
+    def validate_element_state!(element)
+      # unless element.synced?
+      #   raise Errors::Error, <<~STR
+      #     element ne_status is invalid: #{element.ne_status} \
+      #     (should be synced)
+      #   STR
+      # end
+    end
+
     def sync_element(element)
-      synchronizable = element.synchronizable
+      if element.policy_still_applies?
+        ElementService.new(element:).create_internal_version_if_none!
+      else
+        Nexo.logger.debug("Flagging for removal and enqueuing DeleteRemoteResourceJob")
+        ElementService.new(element:).flag_for_removal!(:no_longer_included_in_folder)
 
-      if synchronizable.conflicted?
-        raise Nexo::Errors::ElementConflicted, element
+        DeleteRemoteResourceJob.perform_later(element)
       end
+    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
+    def create_and_sync_element(folder, synchronizable)
+      must_be_included = folder.policy_applies?(synchronizable)
 
-      SyncElementJob.perform_later(element)
+      if must_be_included
+        ElementService.new.create_element_for!(folder, synchronizable)
+      else
+        Nexo.logger.debug { "Policy not applies, skipping creation" }
+      end
     end
   end
 end

data/app/lib/nexo/import_remote_element_version.rb

@@ -0,0 +1,75 @@
+module Nexo
+  class ImportRemoteElementVersion
+    class VersionSuperseded < Errors::Error; end
+    class ImportRemoteVersionFailed < Errors::Error; end
+
+    def perform(element_version)
+      validate_element_state!(element_version)
+
+      ElementService.new(element_version:).update_synchronizable!
+    rescue ImportRemoteVersionFailed => e
+      Nexo.logger.warn(e.inspect)
+    rescue VersionSuperseded
+      Nexo.logger.info("ImportRemoteElementVersion: version superseded")
+    end
+
+    private
+
+    def validate_element_state!(element_version)
+      element = element_version.element
+
+      raise Nexo::Errors::Error, "element version must be external" if element_version.internal?
+      raise Nexo::Errors::Error, "etag must be present" if element_version.etag.blank?
+
+      unless element_version.nev_status == "pending_sync"
+        raise Nexo::Errors::Error, "nev_status invalid, should be pending_sync"
+      end
+
+      # NOTE: this is actually very coupled to the way Google manages etag as a
+      # sequential number, if a new protocol or service is added in the future
+      # and it doesnt manage it that way, it would have to be delegated to the
+      # protocol service
+      if element.element_versions.where(nev_status: :synced)
+                .where("etag > ?", element_version.etag).any?
+
+        ElementService.new(element_version:).update_element_version!(nev_status: :superseded)
+
+        raise VersionSuperseded
+      end
+
+      if element.conflicted?
+        raise ImportRemoteVersionFailed, "element conflicted"
+      end
+
+      # if element.synchronizable.blank?
+      #   # TODO!: this could be that an external element was restored. i.e.:
+      #   # google calendar event cancelled and restored.
+      #   # this should be handled in some way, maybe configurable per folder
+      #   # options are:
+      #   #   - ignore the element
+      #   #   - create synchronizable as if it were new
+      #   #   - discard/undiscard, for this the synchronizable should have been
+      #   #     deleted
+      #   raise ImportRemoteVersionFailed, "synchronizable not found"
+      # end
+
+      # :nocov: borderline
+      if element.discarded?
+        # TODO!: this could be that an external element was restored. i.e.:
+        #   Event excluded from folder and then restored from Google Calendar
+        raise ImportRemoteVersionFailed, "element discarded"
+      end
+
+      if element.synchronizable.present?
+        if element.synchronizable.conflicted?
+          raise ImportRemoteVersionFailed, "synchronizable conflicted"
+        end
+
+        if element.synchronizable.sequence.nil?
+          raise ImportRemoteVersionFailed, "synchronizable sequence is null"
+        end
+      end
+      # :nocov:
+    end
+  end
+end

data/app/lib/nexo/policy_service.rb

@@ -1,9 +1,13 @@
 module Nexo
   class PolicyService
-    def initialize
+    def clear_finders!
       @finders = []
     end
 
+    def initialize
+      clear_finders!
+    end
+
     @instance = new
 
     private_class_method :new
@@ -12,29 +16,44 @@ module Nexo
       @instance
     end
 
-    def register_folder_policy_finder(&block)
+    def register_folder_rule_finder(&block)
       @finders << block
     end
 
     attr_reader :finders
 
-    def match?(folder, synchronizable)
+    def applies?(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
+      applied_policies = policies.select { |policy| policy.applies?(synchronizable) }
+      # :nocov: TODO
+      if applied_policies.any?
+        aplicable_policy = applied_policies.sort_by { |policy| policy.priority }.last
+        logger.debug { "Aplicable policy: #{aplicable_policy.inspect}" }
+        logger.debug { "sync_policy: #{aplicable_policy.sync_policy}" }
+        aplicable_policy.sync_policy.to_s == "include"
       else
+        logger.debug { "No applicable policies" }
         false
       end
+      # :nocov:
     end
 
     def policies_for(folder)
+      logger.debug { "Found #{@finders.length} finders" }
+
       aux = @finders.map do |finder|
         finder.call(folder)
       end
 
-      aux.flatten.compact
+      aux.flatten.compact.tap do |ret|
+        logger.debug { "Found #{ret.length} policies" }
+      end
+    end
+
+    private
+
+    def logger
+      logger = Nexo.logger
     end
   end
 end

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

@@ -33,6 +33,38 @@ module Nexo
       build_date_time(date_to, time_to)
     end
 
+    def all_day?
+      time_from.blank? && time_to.blank?
+    end
+
+    # transparent: non blocking
+    # opaque: blocking
+    def transparency
+      if all_day?
+        "transparent"
+      else
+        "opaque"
+      end
+    end
+
+    def validate_synchronizable!
+      unless datetime_from.present?
+        raise Errors::SynchronizableInvalid, "datetime_from is nil"
+      end
+
+      unless datetime_to.present?
+        raise Errors::SynchronizableInvalid, "datetime_to is nil"
+      end
+
+      unless datetime_from != datetime_to
+        raise Errors::SynchronizableInvalid, "datetime_from and datetime_to are equal"
+      end
+
+      unless summary.present?
+        raise Errors::SynchronizableInvalid, "summary is nil"
+      end
+    end
+
     private
 
     # @param [Date] date
@@ -40,7 +72,7 @@ module Nexo
     #
     # @return [Date, DateTime]
     def build_date_time(date, time = nil)
-      if time.present?
+      if time.present? && date.present?
         DateTime.new(
           date.year,
           date.month,
@@ -55,7 +87,6 @@ module Nexo
       end
     end
 
-
     # TODO: refactor https://api.rubyonrails.org/classes/ActiveSupport/Concern.html
     included do
       include Nexo::Synchronizable::Associations

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

@@ -35,6 +35,20 @@ module Nexo
           end
         end
       end
+
+      def create_from_payload!(folder, payload)
+        Nexo.logger.debug("Synchronizable#create_from_payload!")
+        service = Nexo::ServiceBuilder.instance.build_protocol_service(folder)
+        fields = service.fields_from_payload(payload)
+
+        synchronizable = new
+        attributes = synchronizable.translate_fields(fields)
+        synchronizable.assign_attributes(attributes)
+        synchronizable.sequence = payload["sequence"]
+        synchronizable.save!
+
+        synchronizable
+      end
     end
 
     def method_missing(method_name, *, &)
@@ -58,21 +72,23 @@ module Nexo
       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#nexo_protocol
+    # :nocov: borderline
+    def validate_synchronizable!
+      raise "must be implemented in subclass"
+    end
 
-        new_sequence = increment_sequence!
-        element_version.update_sequence!(new_sequence)
-      end
+    def update_from_fields!(fields)
+      raise "must be implemented in subclass"
+    end
+
+    def translate_fields(fields)
+      raise "must be implemented in subclass"
     end
     # :nocov:
 
     def increment_sequence!
       if sequence.nil?
-        Rails.logger.warn("Synchronizable sequence is nil on increment_sequence!: #{self.to_gid}")
+        Nexo.logger.warn("Synchronizable sequence is nil on increment_sequence!: #{self.to_gid}")
       end
 
       # This operation is performed directly in the database without the need

data/app/models/nexo/client.rb

@@ -2,14 +2,13 @@
 #
 # Table name: nexo_clients
 #
-#  id                        :bigint           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
+#  id         :bigint           not null, primary key
+#  service    :integer
+#  secret     :string
+#  nc_status  :integer
+#  brand_name :integer
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
 #
 require "google-apis-calendar_v3"
 require "google-apis-oauth2_v2"
@@ -27,9 +26,9 @@ module Nexo
     encrypts :secret
 
     enum :service, google: 0
-    enum :tcp_status, authorized: 0, disabled: 1, expired: 2
+    enum :nc_status, authorized: 0, disabled: 1, expired: 2
 
-    validates :service, :tcp_status, :secret, presence: true
+    validates :service, :nc_status, :secret, presence: true
 
     serialize :secret, coder: JSON
 

data/app/models/nexo/element.rb

@@ -4,71 +4,54 @@
 #
 #  id                  :bigint           not null, primary key
 #  folder_id           :bigint           not null
-#  synchronizable_id   :integer          not null
-#  synchronizable_type :string           not null
+#  synchronizable_id   :integer
+#  synchronizable_type :string
 #  uuid                :string
-#  flag_deletion       :boolean          not null
-#  deletion_reason     :integer
-#  conflicted          :boolean          default(FALSE), not null
+#  flagged_for_removal :boolean          not null
+#  removal_reason      :integer
 #  discarded_at        :datetime
 #  created_at          :datetime         not null
 #  updated_at          :datetime         not null
+#  ne_status           :integer          not null
 #
 module Nexo
   class Element < ApplicationRecord
     belongs_to :folder, class_name: "Nexo::Folder"
-    belongs_to :synchronizable, polymorphic: true
+
+    # when blank it's a brand new remote element that needs a synchronizable to
+    # be created
+    belongs_to :synchronizable, polymorphic: true, optional: 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?
+      self.flagged_for_removal = false if flagged_for_removal.nil?
     end
 
     scope :kept, -> { where(discarded_at: nil) }
 
-    enum :deletion_reason, no_longer_included_in_folder: 0, synchronizable_destroyed: 1
+    enum :removal_reason, no_longer_included_in_folder: 0, synchronizable_destroyed: 1
+    enum :ne_status, synced: 0, pending_external_sync: 1, pending_local_sync: 2, conflicted: 3
 
-    scope :conflicted, -> { where(conflicted: true) }
-
-    def policy_still_match?
-      folder.policy_match?(synchronizable)
-    end
+    scope :conflicted, -> { where(ne_status: :conflicted) }
 
-    def last_synced_sequence
-      element_versions.pluck(:sequence).max || -1
+    def policy_still_applies?
+      # :nocov: TODO
+      folder.policy_applies?(synchronizable)
+      # :nocov:
     end
 
-    def external_unsynced_change?
-      last_external_unsynced_version.present?
+    def etag
+      last_remote_version&.etag
     end
 
-    def last_external_unsynced_version
-      element_versions.where(sequence: nil).order(created_at: :desc).first
+    def last_remote_version
+      element_versions.where.not(etag: nil).order(:etag).last
     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

@@ -10,12 +10,16 @@
 #  origin     :integer          not null
 #  created_at :datetime         not null
 #  updated_at :datetime         not null
+#  nev_status :integer          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
+  #   sincronizado. si está presente, significa que fue sincronizado
+  #   incremental correlativa. puede ser discontinua si se generan updates
+  #   a una frecuencia alta
+  #   TODO!: rename to "version"
   #
   # etag
   #
@@ -30,9 +34,15 @@ module Nexo
     belongs_to :element, class_name: "Nexo::Element"
 
     enum :origin, internal: 0, external: 1
+    enum :nev_status,
+      pending_sync: 0,
+      synced: 1,
+      ignored_in_conflict: 2,
+      superseded: 3,
+      ignored_by_sync_direction: 4
 
     serialize :payload, coder: JSON
 
-    validates :payload, :etag, :origin, presence: true
+    validates :origin, presence: true
   end
 end

data/app/models/nexo/folder.rb

@@ -2,37 +2,45 @@
 #
 # Table name: nexo_folders
 #
-#  id                  :bigint           not null, primary key
-#  integration_id      :bigint           not null
-#  protocol            :integer          not null
-#  external_identifier :string
-#  name                :string
-#  description         :string
-#  discarded_at        :datetime
-#  created_at          :datetime         not null
-#  updated_at          :datetime         not null
+#  id                     :bigint           not null, primary key
+#  integration_id         :bigint           not null
+#  nexo_protocol          :integer          not null
+#  external_identifier    :string
+#  name                   :string
+#  description            :string
+#  discarded_at           :datetime
+#  created_at             :datetime         not null
+#  updated_at             :datetime         not null
+#  google_next_sync_token :string
+#  sync_direction         :integer          not null
+#  nf_status              :integer          default("initial"), not null
 #
 module Nexo
   class Folder < ApplicationRecord
     belongs_to :integration, class_name: "Nexo::Integration"
     has_many :elements, class_name: "Nexo::Element"
 
-    if respond_to?(:enumerize)
-      enumerize :nexo_protocol, in: { calendar: 0, dummy_calendar: 1 }
-    else
-      enum :nexo_protocol, calendar: 0, dummy_calendar: 1
+    enum :nexo_protocol, calendar: 0, dummy_calendar: 1
+    enum :sync_direction, sync_in_out: 0, sync_out_in: 1, sync_bidirectional: 2
+    enum :nf_status, initial: 0, ok: 1, not_found: 2
+
+    def sync_external_changes?
+      sync_out_in? || sync_bidirectional?
+    end
+
+    def sync_internal_changes?
+      sync_in_out? || sync_bidirectional?
     end
 
     scope :kept, -> { where(discarded_at: nil) }
 
     validates :nexo_protocol, :name, presence: true
 
-    # TODO!: find better name
-    # maybe policy_applies?
-    def policy_match?(synchronizable)
-      PolicyService.instance.match?(self, synchronizable)
+    def policy_applies?(synchronizable)
+      PolicyService.instance.applies?(self, synchronizable)
     end
 
+    # TODO: use find_sole_by
     def find_element(synchronizable:)
       ary = elements.where(synchronizable:, discarded_at: nil).to_a
 
@@ -54,5 +62,9 @@ module Nexo
     def discard!
       update!(discarded_at: Time.current)
     end
+
+    def to_s
+      name.presence || super
+    end
   end
 end

data/app/models/nexo/integration.rb

@@ -14,9 +14,6 @@
 #
 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"
@@ -57,6 +54,10 @@ module Nexo
       end
     end
 
+    def token?
+      token_status.in? [ :active_token, :expired_token ]
+    end
+
     def credentials
       service = ServiceBuilder.instance.build_auth_service(self)
       @credentials ||= service.get_credentials

data/app/models/nexo/token.rb

@@ -5,7 +5,7 @@
 #  id             :bigint           not null, primary key
 #  integration_id :bigint           not null
 #  secret         :string
-#  tpt_status     :integer          not null
+#  nt_status      :integer          not null
 #  environment    :string           not null
 #  created_at     :datetime         not null
 #  updated_at     :datetime         not null
@@ -14,16 +14,18 @@ module Nexo
   class Token < ApplicationRecord
     belongs_to :integration, class_name: "Nexo::Integration"
 
+    scope :active, -> { where(nt_status: :active) }
+
     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.nt_status = :active if nt_status.nil?
       self.environment = Rails.env if environment.nil?
     end
 
     encrypts :secret
 
-    enum :tpt_status, active: 0, revoked: 1, expired: 2
+    enum :nt_status, active: 0, revoked: 1, expired: 2
 
-    validates :secret, :tpt_status, :environment, presence: true
+    validates :secret, :nt_status, :environment, presence: true
   end
 end