nexo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9dfe1d04459f1395bc88a4f93449f8d43c883271c9f217f95f8074cfd2069ca9
+  data.tar.gz: e11b5ee8142fdb61d7f5dd919c98aabd2b1bf3447e0d6f084785c37964d3298b
+SHA512:
+  metadata.gz: d519f576a9c86874ca0fc8430a33f51751934911908010a8dea9f62d14f99bddfdfa7b171017be789d3bee510674ea66189efacdb72a2f4b5d927eaddfd2a40a
+  data.tar.gz: 9ee812b64c7342916f0a9d2cf6cbe874507da2ba0c0bca7cb3531f6093ee0edc5d4231260ec4830df5fde6cef50dfe63b09a911dd688d2a864eae638e725f4a9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Martín Rosso
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Nexo
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "nexo"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install nexo
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/helpers/nexo/controller_helper.rb

@@ -0,0 +1,10 @@
+module Nexo
+  module ControllerHelper
+    def nexo_integration_params(params)
+      # When upgrading to Rails 8, use "expect"
+      params.require(:integration).permit(:client_id, :name, scope: []).tap do |it|
+        raise Errors::InvalidParamsError, "scope is required" unless it[:scope].present?
+      end
+    end
+  end
+end

data/app/jobs/nexo/api_clients.rb

@@ -0,0 +1,25 @@
+module Nexo
+  module ApiClients
+    extend ActiveSupport::Concern
+
+    included do
+      include GoodJob::ActiveJobExtensions::Concurrency
+
+      queue_as :api_clients
+
+      good_job_control_concurrency_with(
+        perform_limit: 1,
+
+        perform_throttle: (Nexo.api_jobs_throttle || [ 100, 5.minute ]),
+
+        key: -> { "#{queue_name}" }
+      )
+
+      retry_on(
+        GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError,
+        attempts: Float::INFINITY,
+        wait: ->(executions) { ((executions**3) + (Kernel.rand * (executions**3) * 0.5)) + 2 }
+      )
+    end
+  end
+end

data/app/jobs/nexo/base_job.rb

@@ -0,0 +1,8 @@
+module Nexo
+  class BaseJob < ActiveJob::Base
+    def self.limits_concurrency(*)
+      # TODO: implementar
+      puts "ERROR: Implementar limits_concurrency"
+    end
+  end
+end

data/app/jobs/nexo/delete_remote_resource_job.rb

@@ -0,0 +1,10 @@
+module Nexo
+  class DeleteRemoteResourceJob < BaseJob
+    include ApiClients
+
+    def perform(element)
+      ServiceBuilder.instance.build_protocol_service(element.folder).remove(element)
+      # TODO!: mark as deleted, or something
+    end
+  end
+end

data/app/jobs/nexo/folder_sync_job.rb

@@ -0,0 +1,25 @@
+module Nexo
+  class FolderSyncJob < BaseJob
+    def perform(folder)
+      policies = PolicyService.instance.policies_for(folder)
+      # flat_map should be equivalent to:
+      #   policies.map(&:synchronizable_queries).flatten(1)
+      queries = policies.flat_map(&:synchronizable_queries)
+
+      queries.each do |query|
+        # TODO: avoid calling more than once per synchronizable
+        query.find_each do |synchronizable|
+          folder_service.find_element_and_sync(folder, synchronizable)
+        end
+      end
+    end
+
+    private
+
+    # :nocov: mocked
+    def folder_service
+      @folder_service ||= FolderService.new
+    end
+    # :nocov:
+  end
+end

data/app/jobs/nexo/sync_element_job.rb

@@ -0,0 +1,91 @@
+module Nexo
+  # Handles synchronization of an Element. Its called anytime there is an internal or external change
+  #
+  # Always must be executed asynchronously to ensure the concurrency limit applies
+  #
+  # Responsabilities:
+  # - Triggering the DeleteRemoteResourceJob
+  # - Triggering the UpdateRemoteResourceJob
+  # - Removing/discarding Element's
+  # - Flagging Synchronizable's as conflicted
+  # - Updating Synchronizable's on external incoming changes
+  #
+  # TODO: implement external ElementVersion creation, not here, on another place
+  class SyncElementJob < BaseJob
+    limits_concurrency key: ->(element) { element.to_gid }
+
+    # discard_on Errors::SyncElementJobError
+    # retry_on StandardError, wait: :polynomially_longer
+
+    def perform(element)
+      validate_element_state!(element)
+
+      if element.flagged_for_deletion?
+        DeleteRemoteResourceJob.perform_later(element)
+
+        element.discard!
+      else
+        current_sequence = element.synchronizable.sequence
+        last_synced_sequence = element.last_synced_sequence
+
+        if element.external_unsynced_change?
+          # :nocov: TODO
+          raise Errors::SyncElementJobError, "not yet implemented"
+          # :nocov:
+
+          # if current_sequence == last_synced_sequence
+          #   sync_to_local_element(element)
+          # elsif current_sequence > last_synced_sequence
+          #   element.flag_as_conflicted!
+          # else
+          #   # :nocov: type: borderline
+          #   report_sequence_bigger_than_current_one!
+          #   # :nocov:
+          # end
+        else
+          if current_sequence == last_synced_sequence
+            # TODO: log "Element already synced: #{element.to_gid}"
+          elsif current_sequence > last_synced_sequence
+            UpdateRemoteResourceJob.perform_later(element)
+          else
+            # :nocov: borderline
+            raise Errors::LastSyncedSequenceBiggerThanCurrentOne, element
+            # :nocov:
+          end
+        end
+      end
+    end
+
+    private
+
+    def validate_element_state!(element)
+      if element.discarded?
+        # TODO: maybe check the case of external incoming changes to flag the element as conflicted
+        raise Errors::ElementDiscarded, element
+      end
+
+      if element.synchronizable.blank? && !element.flagged_for_deletion?
+        # element should have been flagged for deletion
+        raise Errors::SynchronizableNotFound, element
+      end
+
+      if element.conflicted?
+        raise Errors::ElementConflicted, element
+      end
+
+      if element.synchronizable.present? && element.synchronizable.conflicted?
+        raise Errors::SynchronizableConflicted, element
+      end
+
+      if element.synchronizable.present? && element.synchronizable.sequence.nil?
+        raise Errors::SynchronizableSequenceIsNull, element
+      end
+    end
+
+    # def sync_to_local_element(element)
+    #   last_external_unsynced_version = element.last_external_unsynced_version
+
+    #   element.synchronizable.update_from!(last_external_unsynced_version)
+    # end
+  end
+end

data/app/jobs/nexo/synchronizable_changed_job.rb

@@ -0,0 +1,25 @@
+module Nexo
+  class SynchronizableChangedJob < BaseJob
+    limits_concurrency key: ->(synchronizable) { synchronizable.to_gid }
+
+    # TODO: check
+    # https://github.com/rails/solid_queue?tab=readme-ov-file#jobs-and-transactional-integrity
+    #
+    # TODO: handle exceptions
+
+    def perform(synchronizable)
+      # Maybe restrict this query to a more specific scope
+      scope = Folder.all
+
+      scope.each do |folder|
+        folder_service.find_element_and_sync(folder, synchronizable)
+      end
+    end
+
+    private
+
+    def folder_service
+      @folder_service ||= FolderService.new
+    end
+  end
+end

data/app/jobs/nexo/update_remote_resource_job.rb

@@ -0,0 +1,56 @@
+module Nexo
+  class UpdateRemoteResourceJob < BaseJob
+    include ApiClients
+
+    attr_reader :element
+
+    def perform(element)
+      @element = element
+
+      validate_element_state!
+
+      remote_service = ServiceBuilder.instance.build_protocol_service(element.folder)
+
+      response =
+        if element.element_versions.any?
+          remote_service.update(element)
+        else
+          remote_service.insert(element.folder, element.synchronizable).tap do |response|
+            element.update(uuid: response.id)
+          end
+        end
+
+      save_element_version(response)
+    end
+
+    private
+
+    def validate_element_state!
+      if element.synchronizable.conflicted?
+        raise Errors::ElementConflicted
+      end
+
+      if element.external_unsynced_change?
+        raise Errors::ExternalUnsyncedChange
+      end
+
+      current_sequence = element.synchronizable.sequence
+      last_synced_sequence = element.last_synced_sequence
+
+      unless current_sequence > last_synced_sequence
+        raise Errors::ElementAlreadySynced
+      end
+    end
+
+    # @todo sequence should be fetched before to avoid being outdated
+    def save_element_version(service_response)
+      ElementVersion.create!(
+        element:,
+        origin: :internal,
+        etag: service_response.etag,
+        payload: service_response.payload,
+        sequence: element.synchronizable.sequence,
+      )
+    end
+  end
+end

data/app/lib/nexo/active_record_google_token_store.rb

@@ -0,0 +1,43 @@
+require "googleauth/token_store"
+
+module Nexo
+  class ActiveRecordGoogleTokenStore < Google::Auth::TokenStore
+    # (see Google::Auth::Stores::TokenStore#load)
+    def load(id)
+      token = find_by_id(id)
+
+      if token.present?
+        token.secret
+      else
+        nil
+      end
+    end
+
+    # (see Google::Auth::Stores::TokenStore#store)
+    def store(integration, token)
+      ActiveRecord::Base.transaction do
+        # Maybe these should be destroyed
+        integration.tokens.active.update_all(tpt_status: :expired)
+
+        Token.create!(integration:, secret: token)
+      end
+    end
+
+    # (see Google::Auth::Stores::TokenStore#delete)
+    def delete(id)
+      token = find_by_id(id)
+
+      if token.present?
+        token.update!(tpt_status: :revoked)
+      else
+        # TODO: pg_warn("Couldn't find token for revocation: #{id}")
+      end
+    end
+
+    private
+
+    def find_by_id(id)
+      Token.where(environment: Rails.env, integration: id, tpt_status: :active).last
+    end
+  end
+end

data/app/lib/nexo/api_client/api_response.rb

@@ -0,0 +1,4 @@
+module Nexo
+  class ApiResponse < Struct.new(:status, :etag, :payload, :id)
+  end
+end

data/app/lib/nexo/api_client/calendar_service.rb

@@ -0,0 +1,9 @@
+module Nexo
+  class CalendarService
+    attr_accessor :integration
+
+    def initialize(integration)
+      @integration = integration
+    end
+  end
+end

data/app/lib/nexo/api_client/google_auth_service.rb

@@ -0,0 +1,89 @@
+require "googleauth"
+require "google-apis-oauth2_v2"
+
+module Nexo
+  # This is actually an OAuth 2.0 flow, and that logic should be extracted to
+  # a generic OAuth2Service
+  class GoogleAuthService
+    class << self
+      def handle_auth_callback_deferred(request)
+        target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
+
+        target_url
+      end
+    end
+
+    def initialize(integration)
+      @integration = integration
+    end
+
+    EXCEPTIONS = [
+      Signet::AuthorizationError,
+
+      # user revoked access
+      Google::Apis::ClientError,
+
+      Google::Apis::AuthorizationError
+    ]
+
+    def token_info
+      service = Google::Apis::Oauth2V2::Oauth2Service.new
+      credentials = get_credentials
+      if credentials.present?
+        service.authorization = credentials
+
+        # Si el token expiró o le restan pocos segundos para expirar, se
+        # renovará el token.
+        service.tokeninfo
+      end
+    rescue *EXCEPTIONS => e
+      # TODO: handle this
+      # :nocov: TODO
+      Nexo::ActiveRecordGoogleTokenStore.new.delete(@integration)
+      e.class.to_s
+      # :nocov:
+    end
+
+    def revoke_authorization!
+      authorizer.revoke_authorization(@integration)
+    end
+
+    # @param [Rack::Request] request
+    #
+    # Debe estar presente en la autorización (cuando google callback redirige
+    # al show)
+    #
+    # Guarda el Token
+    # Si el client tiene más permisos que los que el user solicitó
+    def get_credentials(request = nil)
+      if request.present? && request.session["code_verifier"].present?
+        # :nocov: tricky
+        authorizer.code_verifier = request.session["code_verifier"]
+        # :nocov:
+      end
+      authorizer.get_credentials @integration, request
+    rescue Signet::AuthorizationError
+      # TODO: log
+    end
+
+    def get_authorization_url(request)
+      request.session["code_verifier"] ||= Google::Auth::WebUserAuthorizer.generate_code_verifier
+      authorizer.code_verifier = request.session["code_verifier"]
+      authorizer.get_authorization_url(request:)
+      # authorizer.get_authorization_url(request:, login_hint: "bla@gmail.com")
+    end
+
+    private
+
+    def authorizer
+      client = @integration.client
+      client_id = Google::Auth::ClientId.from_hash(client.secret)
+
+      token_store = Nexo::ActiveRecordGoogleTokenStore.new
+
+      @authorizer ||=
+        Google::Auth::WebUserAuthorizer.new(
+          client_id, @integration.external_api_scope, token_store, "/u/google/callback")
+    end
+  end
+end

data/app/lib/nexo/api_client/google_calendar_service.rb

@@ -0,0 +1,113 @@
+require "google-apis-calendar_v3"
+
+module Nexo
+  # Wrapper around +Google::Apis::CalendarV3+
+  #
+  # @raise [Google::Apis::ClientError] possible messages:
+  #   - duplicate: The requested identifier already exists.
+  #   - notFound: Not Found
+  #   - forbidden: Forbidden (cuando se intenta updatear un evento que ya fue borrado)
+  class GoogleCalendarService < CalendarService
+    # Create an event in a Google Calendar
+    #
+    # @param [Folder] folder
+    #
+    # @todo Debería recibir un {Element}?
+    def insert(folder, calendar_event)
+      validate_folder_state!(folder)
+
+      event = build_event(calendar_event)
+      response = client.insert_event(folder.external_identifier, event)
+      ApiResponse.new(payload: response.to_json, status: :ok, etag: response.etag, id: response.id)
+    end
+
+    # Update an event in a Google Calendar
+    def update(element)
+      validate_folder_state!(element.folder)
+
+      event = build_event(element.synchronizable)
+      response = client.update_event(element.folder.external_identifier, element.uuid, event)
+      ApiResponse.new(payload: response.to_json, status: :ok, etag: response.etag)
+    end
+
+    # Delete an event in a Google Calendar
+    def remove(element)
+      validate_folder_state!(element.folder)
+
+      # TODO: try with cancelled
+      client.delete_event(element.folder.external_identifier, element.uuid)
+      ApiResponse.new(payload: nil, status: :ok, etag: nil)
+    end
+
+    # Create a Google calendar
+    def insert_calendar(folder)
+      cal = build_calendar(folder)
+      response = client.insert_calendar(cal)
+      ApiResponse.new(payload: response.to_json, status: :ok, etag: response.etag, id: response.id)
+    end
+
+    def remove_calendar(folder)
+      client.delete_calendar(folder.external_identifier)
+      ApiResponse.new(status: :ok)
+    end
+
+    # @!visibility private
+    # :nocov: non-production
+    def clear_calendars
+      Folder.all.each do |folder|
+        cid = folder.external_identifier
+        events = client.list_events(cid).items
+        events.each do |event|
+          client.delete_event(cid, event.id)
+        end
+      end
+    end
+    # :nocov:
+
+    private
+
+    def validate_folder_state!(folder)
+      if folder.external_identifier.blank?
+        raise Errors::InvalidFolderState, folder
+      end
+    end
+
+    def build_event(calendar_event)
+      estart = build_event_date_time(calendar_event.datetime_from)
+      eend = build_event_date_time(calendar_event.datetime_to)
+
+      Google::Apis::CalendarV3::Event.new(
+        start: estart,
+        end: eend,
+        summary: calendar_event.summary,
+        description: calendar_event.description
+      )
+    end
+
+    def build_calendar(folder)
+      cal = Google::Apis::CalendarV3::Calendar.new(
+        summary: folder.name,
+        description: folder.description,
+        time_zone: folder.time_zone
+      )
+    end
+
+    # @param [Date, DateTime] datetime
+    def build_event_date_time(datetime)
+      if datetime.respond_to?(:hour)
+        Google::Apis::CalendarV3::EventDateTime.new(date_time: datetime)
+      else
+        Google::Apis::CalendarV3::EventDateTime.new(date: datetime)
+      end
+    end
+
+    def client
+      # :nocov: mocked
+      @client ||=
+        Google::Apis::CalendarV3::CalendarService.new.tap do |cli|
+          cli.authorization = integration.credentials
+        end
+      # :nocov:
+    end
+  end
+end

data/app/lib/nexo/api_client/google_dummy_calendar_service.rb

@@ -0,0 +1,31 @@
+# :nocov: tricky
+module Nexo
+  # Dummy calendar service
+  class GoogleDummyCalendarService < CalendarService
+    def insert(folder, calendar_event)
+      puts "Dummy: Creating event '#{calendar_event.summary}'"
+      ApiResponse.new(payload: "payload", status: :ok, etag: "etag", id: "dummy_id")
+    end
+
+    def update(element)
+      puts "Dummy: Updating event"
+      ApiResponse.new(payload: "payload", status: :ok, etag: "etag", id: "dummy_id")
+    end
+
+    def remove(element)
+      puts "Dummy: Removing event"
+      ApiResponse.new(payload: "payload", status: :ok, etag: "etag", id: "dummy_id")
+    end
+
+    def insert_calendar(folder)
+      puts "Dummy: Creating calendar"
+      ApiResponse.new(payload: "payload", status: :ok, etag: "etag", id: "dummy_id")
+    end
+
+    def remove_calendar(folder)
+      puts "Dummy: Removing calendar"
+      ApiResponse.new(payload: "payload", status: :ok, etag: "etag", id: "dummy_id")
+    end
+  end
+end
+# :nocov:

data/app/lib/nexo/errors.rb

@@ -0,0 +1,28 @@
+module Nexo
+  class Errors
+    class Error < StandardError; end
+
+    class ElementConflicted < Error; end
+    class ExternalUnsyncedChange < Error; end
+    class ElementAlreadySynced < Error; end
+    class MoreThanOneElementInFolderForSynchronizable < Error; end
+    class InvalidFolderState < Error; end
+
+    # on ControllerHelper
+    class InvalidParamsError < Error; end
+
+    # on Synchronizable
+    class InterfaceMethodNotImplemented < Error; end
+
+    # on EventReceiver
+    class InvalidSynchronizableState < Error; end
+
+    # on SyncElementJob
+    class SyncElementJobError < Errors::Error; end
+    class SynchronizableConflicted < Error; end
+    class ElementDiscarded < Error; end
+    class SynchronizableNotFound < Error; end
+    class SynchronizableSequenceIsNull < Error; end
+    class LastSyncedSequenceBiggerThanCurrentOne < Error; end
+  end
+end