harmonia 0.1.7

data/lib/generators/harmonia/install_generator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Harmonia
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_database_connector
+        copy_file "database_connector.rb", "app/services/database_connector.rb"
+      end
+
+      def copy_trophonius_extension
+        copy_file "trophonius_model_extension.rb", "config/initializers/trophonius_model_extension.rb"
+      end
+
+      def copy_application_record_extension
+        copy_file "application_record_extension.rb", "app/models/application_record.rb"
+      end
+
+      def copy_sync_model
+        copy_file "harmonia_sync.rb", "app/models/harmonia/sync.rb"
+      end
+
+      def generate_migration
+        migration_template "create_harmonia_syncs.rb", "db/migrate/create_harmonia_syncs.rb"
+      end
+
+      def show_readme
+        readme_content = <<~README
+
+          ========================================
+          Harmonia has been installed!
+          ========================================
+
+          Files created:
+          - app/services/database_connector.rb
+          - config/initializers/trophonius_model_extension.rb
+          - app/models/application_record.rb (with to_fm extension)
+          - app/models/harmonia/sync.rb
+          - db/migrate/..._create_harmonia_syncs.rb
+
+          Next steps:
+          1. Run migrations: rails db:migrate
+          2. Update database_connector.rb with your FileMaker database name
+          3. Add FileMaker credentials to Rails credentials
+          4. Replace all instances of YourTrophoniusModel with your actual model names
+          5. Generate syncers:
+             - rails generate harmonia:sync ModelName (FileMaker -> ActiveRecord)
+             - rails generate harmonia:reverse_sync ModelName (ActiveRecord -> FileMaker)
+
+        README
+
+        say readme_content, :green if behavior == :invoke
+      end
+
+      # Required for migration_template to work
+      def self.next_migration_number(dirname)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+    end
+  end
+end

data/lib/generators/harmonia/reverse_sync_generator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Harmonia
+  module Generators
+    class ReverseSyncGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      argument :name, type: :string, required: true, banner: "ModelName"
+
+      def create_sync_file
+        template "activerecord_to_filemaker_syncer_template.rb", "app/syncers/#{file_name}_to_filemaker_syncer.rb"
+      end
+
+      def generate_migration
+        migration_template "add_filemaker_id_to_table.rb", "db/migrate/add_filemaker_id_to_#{table_name}.rb"
+      end
+
+      def show_readme
+        readme_content = <<~README
+
+          ========================================
+          #{class_name}ToFileMakerSyncer has been generated!
+          ========================================
+
+          Files created:
+          - app/syncers/#{file_name}_to_filemaker_syncer.rb
+          - db/migrate/..._add_filemaker_id_to_#{table_name}.rb
+
+          Next steps:
+          1. Run migrations: rails db:migrate
+
+          2. Implement the #{class_name}.to_fm method in your model:
+             class #{class_name} < ApplicationRecord
+               def self.to_fm(record)
+                 {
+                   'FieldMakerFieldName' => record.attribute_name,
+                   # ... map other fields
+                 }
+               end
+             end
+
+          3. Implement the records_to_create method
+             - Set @total_create_required to the total number of records that should be created
+             - Return an array of ActiveRecord records to create in FileMaker
+
+          4. Implement the records_to_update method
+             - Set @total_update_required to the total number of records that should be updated
+             - Return an array of ActiveRecord records to update in FileMaker
+
+          5. Implement the find_filemaker_record method
+             - Find corresponding FileMaker record for a given ActiveRecord record
+
+          6. Implement the records_to_delete method (optional)
+             - Return an array of FileMaker record IDs to delete
+
+          Note: The total_required count used for sync tracking is automatically calculated
+          from @total_create_required + @total_update_required
+
+        README
+
+        say readme_content, :green if behavior == :invoke
+      end
+
+      # Required for migration_template to work
+      def self.next_migration_number(dirname)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      private
+
+      def file_name
+        name.underscore
+      end
+
+      def class_name
+        name.camelize
+      end
+
+      def table_name
+        name.underscore.pluralize
+      end
+    end
+  end
+end

data/lib/generators/harmonia/sync_generator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Harmonia
+  module Generators
+    class SyncGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      argument :name, type: :string, required: true, banner: "ModelName"
+
+      def create_sync_file
+        template "filemaker_to_activerecord_syncer_template.rb", "app/syncers/#{file_name}_syncer.rb"
+      end
+
+      def generate_migration
+        migration_template "add_filemaker_id_to_table.rb", "db/migrate/add_filemaker_id_to_#{table_name}.rb"
+      end
+
+      def show_readme
+        readme_content = <<~README
+
+          ========================================
+          #{class_name}Syncer has been generated!
+          ========================================
+
+          Files created:
+          - app/syncers/#{file_name}_syncer.rb
+          - db/migrate/..._add_filemaker_id_to_#{table_name}.rb
+
+          Next steps:
+          1. Run migrations: rails db:migrate
+
+          2. Implement the records_to_create method
+             - Set @total_create_required to the total number of records that should be created
+             - Return an array of Trophonius records to create
+
+          3. Implement the records_to_update method
+             - Set @total_update_required to the total number of records that should be updated
+             - Return an array of Trophonius records to update
+
+          4. Implement the records_to_delete method (optional)
+             - Return an array of record identifiers to delete
+
+          Note: The total_required count used for sync tracking is automatically calculated
+          from @total_create_required + @total_update_required
+
+        README
+
+        say readme_content, :green if behavior == :invoke
+      end
+
+      # Required for migration_template to work
+      def self.next_migration_number(dirname)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      private
+
+      def file_name
+        name.underscore
+      end
+
+      def class_name
+        name.camelize
+      end
+
+      def table_name
+        name.underscore.pluralize
+      end
+    end
+  end
+end

data/lib/generators/harmonia/templates/activerecord_to_filemaker_syncer_template.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+class <%= class_name %>ToFileMakerSyncer
+  attr_accessor :database_connector
+
+  def initialize(database_connector)
+    @database_connector = database_connector
+    @last_synced_on = Harmonia::Sync.last_sync_for('<%= table_name %>', 'ActiveRecord to FileMaker')&.ran_on || (Time.now - 15.years)
+  end
+
+  # Main sync method
+  # Executes the sync process for <%= class_name %> records to FileMaker
+  def run
+    raise StandardError, 'No database connector set' if @database_connector.blank?
+
+    sync_record = create_sync_record
+
+    @database_connector.open_database do
+      sync_record.start!
+      sync_records(sync_record)
+    end
+  rescue StandardError => e
+    sync_record&.fail!(e.message)
+    raise
+  end
+
+  private
+
+  def sync_records(sync_record)
+    updated_count = update_records
+    created_count = create_records
+    delete_records
+
+    total_synced = created_count + updated_count
+    total_required = (@total_create_required || 0) + (@total_update_required || 0)
+
+    sync_record.finish!(
+      records_synced: total_synced,
+      records_required: total_required
+    )
+  end
+
+  # Returns an array of ActiveRecord records that need to be created in FileMaker
+  # Use <%= class_name %>.to_fm(record) to convert to FileMaker attributes
+  # Set @total_create_required to the total number of records that should exist after creation
+  # @return [Array<<%= class_name %>>] Array of ActiveRecord records
+  def records_to_create
+    # TODO: Implement logic to fetch records from PostgreSQL that need to be created in FileMaker
+    # Example:
+    # pg_records = <%= class_name %>.all
+    # @total_create_required = pg_records.length
+    # existing_ids = YourTrophoniusModel.all.map { |r| r.field_data['PostgreSQLID'] }
+    # pg_records.reject { |record| existing_ids.include?(record.id.to_s) }
+    @total_create_required = 0
+    []
+  end
+
+  # Returns an array of ActiveRecord records that need to be updated in FileMaker
+  # Use <%= class_name %>.to_fm(record) to convert to FileMaker attributes
+  # Set @total_update_required to the total number of records that should be updated
+  # @return [Array<<%= class_name %>>] Array of ActiveRecord records
+  def records_to_update
+    # TODO: Implement logic to fetch records from PostgreSQL that need to be updated in FileMaker
+    # Example:
+    # pg_records = <%= class_name %>.where('updated_at > ?', 1.hour.ago)
+    # records_needing_update = pg_records.select { |pg_record|
+    #   fm_record = find_filemaker_record(pg_record)
+    #   fm_record && needs_update?(pg_record, fm_record)
+    # }
+    # @total_update_required = records_needing_update.length
+    # records_needing_update
+    @total_update_required = 0
+    []
+  end
+
+  # Returns an array of FileMaker record IDs that need to be deleted
+  # @return [Array] Array of FileMaker record IDs
+  def records_to_delete
+    # TODO: Implement logic to determine which FileMaker records should be deleted
+    # Example:
+    # pg_ids = <%= class_name %>.pluck(:id).map(&:to_s)
+    # YourTrophoniusModel.all.select { |fm_record|
+    #   !pg_ids.include?(fm_record.field_data['PostgreSQLID'])
+    # }.map(&:record_id)
+    []
+  end
+
+  def create_records
+    records = records_to_create
+    return 0 if records.empty?
+
+    records.each do |pg_record|
+      fm_attributes = pg_record.to_fm
+      YourTrophoniusModel.create(fm_attributes)
+    end
+
+    records.size
+  end
+
+  def update_records
+    records = records_to_update
+    return 0 if records.empty?
+
+    records.each do |pg_record|
+      fm_attributes = pg_record.to_fm
+
+      # Find the FileMaker record by PostgreSQL ID or other unique identifier
+      fm_record = find_filemaker_record(pg_record)
+      next unless fm_record
+
+      fm_record.update(fm_attributes)
+    end
+
+    records.size
+  end
+
+  def delete_records
+    record_ids = records_to_delete
+    return if record_ids.empty?
+
+    record_ids.each do |record_id|
+      fm_record = YourTrophoniusModel.find(record_id)
+      fm_record.destroy
+    rescue Trophonius::RecordNotFoundError
+      # Record already deleted, skip
+      next
+    end
+  end
+
+  # Helper method to find a FileMaker record based on a PostgreSQL record
+  # @param pg_record [ActiveRecord::Base] The PostgreSQL record
+  # @return [Trophonius::Model, nil] The corresponding FileMaker record or nil
+  def find_filemaker_record(pg_record)
+    # TODO: Implement logic to find the corresponding FileMaker record
+    # Example:
+    # YourTrophoniusModel.find_by_field('PostgreSQLID', pg_record.id.to_s)
+    nil
+  end
+
+  # Determine if a FileMaker record needs to be updated based on PostgreSQL record
+  # @param pg_record [ActiveRecord::Base] The PostgreSQL record
+  # @param fm_record [Trophonius::Model] The FileMaker record
+  # @return [Boolean] true if update is needed
+  def needs_update?(pg_record, fm_record)
+    # TODO: Implement your comparison logic
+    # Example:
+    # fm_attributes = pg_record.to_fm
+    # fm_attributes.any? { |key, value| fm_record.field_data[key.to_s] != value }
+    true
+  end
+
+  def create_sync_record
+    Harmonia::Sync.create!(
+      table: '<%= table_name %>',
+      ran_on: Time.now,
+      status: 'pending',
+      direction: 'ActiveRecord to FileMaker'
+    )
+  end
+end

data/lib/generators/harmonia/templates/add_filemaker_id_to_table.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class AddFilemakerIdTo<%= table_name.camelize %> < ActiveRecord::Migration[<%= Rails::VERSION::MAJOR %>.<%= Rails::VERSION::MINOR %>]
+  def change
+    unless column_exists?(:<%= table_name %>, :filemaker_id)
+      add_column :<%= table_name %>, :filemaker_id, :string
+      add_index :<%= table_name %>, :filemaker_id, unique: true
+    end
+  end
+end

data/lib/generators/harmonia/templates/application_record_extension.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+
+  # Converts an ActiveRecord record to FileMaker-compatible attributes
+  # This method should be overridden in each model that syncs to FileMaker
+  # @param record [ActiveRecord::Base] The ActiveRecord record instance to convert
+  # @return [Hash] Hash of FileMaker field names and values
+  def to_fm(record)
+    raise NotImplementedError, "#{self.class.name}#to_fm must be implemented to convert ActiveRecord records to FileMaker attributes"
+  end
+end

data/lib/generators/harmonia/templates/create_harmonia_syncs.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class CreateHarmoniaSyncs < ActiveRecord::Migration[<%= Rails::VERSION::MAJOR %>.<%= Rails::VERSION::MINOR %>]
+  def change
+    create_table :harmonia_syncs do |t|
+      t.datetime :ran_on
+      t.string :table
+      t.integer :records_synced, default: 0
+      t.integer :records_required, default: 0
+      t.string :status, default: 'pending'
+      t.string :direction
+      t.text :error_message
+
+      t.timestamps
+    end
+
+    add_index :harmonia_syncs, [:table, :ran_on]
+    add_index :harmonia_syncs, :status
+  end
+end

data/lib/generators/harmonia/templates/database_connector.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class DatabaseConnector
+  attr_accessor :hostname
+
+  def open_database(&block)
+    raise ArgumentError, 'No hostname set' if @hostname.blank?
+    raise ArgumentError, 'No block given' if block.blank?
+
+    connect
+    yield block
+  ensure
+    disconnect
+  end
+
+  private
+
+  def connect
+    Trophonius.configure do |config|
+      config.host = @hostname
+      config.database = 'DatabaseName'
+      config.username = Rails.application.credentials.dig(:filemaker, :username)
+      config.password = Rails.application.credentials.dig(:filemaker, :password)
+      config.ssl = true # or false depending on whether https or http should be used
+      config.debug = true # will output more information when true
+      config.pool_size = ENV.fetch('trophonius_pool', 5) # use multiple data api connections with a loadbalancer to improve performance
+    end
+    @connection_manager = Trophonius.connection_manager
+  end
+
+  def disconnect
+    @connection_manager.disconnect_all
+  end
+end

data/lib/generators/harmonia/templates/filemaker_to_activerecord_syncer_template.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+class <%= class_name %>Syncer
+  attr_accessor :database_connector
+
+  def initialize(database_connector)
+    @database_connector = database_connector
+    @last_synced_on = Harmonia::Sync.last_sync_for('<%= table_name %>', 'FileMaker to ActiveRecord')&.ran_on || (Time.now - 15.year)
+  end
+
+  # Main sync method
+  # Executes the sync process for <%= class_name %> records
+  def run
+    raise StandardError, 'No database connector set' if @database_connector.blank?
+
+    sync_record = create_sync_record
+
+    @database_connector.open_database do
+      sync_record.start!
+      sync_records(sync_record)
+    end
+  rescue StandardError => e
+    sync_record&.fail!(e.message)
+    raise
+  end
+
+  private
+
+  def sync_records(sync_record)
+    updated_count = update_records
+    created_count = create_records
+    delete_records
+
+    total_synced = created_count + updated_count
+    total_required = (@total_create_required || 0) + (@total_update_required || 0)
+
+    sync_record.finish!(
+      records_synced: total_synced,
+      records_required: total_required
+    )
+  end
+
+  # Returns an array of Trophonius records that need to be created
+  # Use YourTrophoniusModel.to_pg(record) to convert to PostgreSQL attributes
+  # Set @total_create_required to the total number of records that should exist after creation
+  # @return [Array<Trophonius::Record>] Array of Trophonius records
+  def records_to_create
+    # TODO: Implement logic to fetch records from FileMaker that need to be created in PostgreSQL
+    # Example:
+    # filemaker_records = YourTrophoniusModel.all
+    # @total_create_required = filemaker_records.length
+    # existing_ids = <%= class_name %>.pluck(:filemaker_id)
+    # filemaker_records.reject { |record| existing_ids.include?(record.record_id) }
+    @total_create_required = 0
+    []
+  end
+
+  # Returns an array of Trophonius records that need to be updated
+  # Use YourTrophoniusModel.to_pg(record) to convert to PostgreSQL attributes
+  # Set @total_update_required to the total number of records that should be updated
+  # @return [Array<Trophonius::Record>] Array of Trophonius records
+  def records_to_update
+    # TODO: Implement logic to fetch records from FileMaker that need to be updated in PostgreSQL
+    # Example:
+    # filemaker_records = YourTrophoniusModel.all
+    # records_needing_update = filemaker_records.select { |fm_record|
+    #   pg_record = <%= class_name %>.find_by(filemaker_id: fm_record.record_id)
+    #   pg_record && needs_update?(fm_record, pg_record)
+    # }
+    # @total_update_required = records_needing_update.length
+    # records_needing_update
+    @total_update_required = 0
+    []
+  end
+
+  # Returns an array of record identifiers that need to be deleted
+  # @return [Array] Array of record identifiers
+  def records_to_delete
+    # TODO: Implement logic to determine which PostgreSQL records should be deleted
+    # Example:
+    # filemaker_ids = YourTrophoniusModel.all.map(&:record_id)
+    # <%= class_name %>.where.not(filemaker_id: filemaker_ids).pluck(:id)
+    []
+  end
+
+  def needs_update?(fm_record, pg_record)
+    pg_attributes = YourTrophoniusModel.to_pg(fm_record)
+
+    pg_attributes.any? { |key, value| pg_record.send(key) != value }
+  end
+
+  def create_records
+    records = records_to_create
+    return 0 if records.empty?
+
+    attributes_array = records.map do |trophonius_record|
+      YourTrophoniusModel.to_pg(trophonius_record).merge(
+        created_at: Time.current,
+        updated_at: Time.current
+      )
+    end
+
+    <%= class_name %>.insert_all(attributes_array)
+    records.size
+  end
+
+  def update_records
+    records = records_to_update
+    return 0 if records.empty?
+
+    records.each do |trophonius_record|
+      pg_attributes = YourTrophoniusModel.to_pg(trophonius_record)
+
+      <%= class_name %>.where(filemaker_id: trophonius_record.record_id).update_all(
+        pg_attributes.merge(updated_at: Time.current)
+      )
+    end
+
+    records.size
+  end
+
+  def delete_records
+    ids = records_to_delete
+    return if ids.empty?
+
+    <%= class_name %>.where(id: ids).destroy_all
+  end
+
+  def create_sync_record
+    Harmonia::Sync.create!(
+      table: '<%= table_name %>',
+      ran_on: Time.now,
+      status: 'pending',
+      direction: 'FileMaker to ActiveRecord'
+    )
+  end
+end

data/lib/generators/harmonia/templates/harmonia_sync.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Harmonia
+  class Sync < ApplicationRecord
+    self.table_name = 'harmonia_syncs'
+
+    validates :table, presence: true
+    validates :ran_on, presence: true
+    validates :status, presence: true, inclusion: { in: %w[pending in_progress completed failed] }
+
+    # Scope to get syncs for a specific table
+    scope :for_table, ->(table_name) { where(table: table_name) }
+    scope :for_direction, ->(direction) {where(direction:)}
+
+    # Scope to get recent syncs
+    scope :recent, -> { order(ran_on: :desc) }
+
+    # Scope to get syncs by date
+    scope :on_date, ->(date) { where(ran_on: date) }
+
+    # Scope by status
+    scope :pending, -> { where(status: 'pending') }
+    scope :in_progress, -> { where(status: 'in_progress') }
+    scope :completed, -> { where(status: 'completed') }
+    scope :failed, -> { where(status: 'failed') }
+
+    # Get the most recent sync for a table in a given direction
+    def self.last_sync_for(table_name, direction)
+      for_direction(direction).for_table(table_name).recent.first
+    end
+
+    # Calculate sync completion percentage
+    def completion_percentage
+      return 0 if records_required.to_i.zero?
+      ((records_synced.to_f / records_required.to_f) * 100).round(2)
+    end
+
+    # Check if sync was complete
+    def complete?
+      status == 'completed' && records_synced == records_required
+    end
+
+    # Mark sync as started
+    def start!
+      update!(status: 'in_progress')
+    end
+
+    # Mark sync as completed
+    def finish!(records_synced:, records_required:)
+      update!(
+        status: 'completed',
+        records_synced: records_synced,
+        records_required: records_required
+      )
+    end
+
+    # Mark sync as failed
+    def fail!(error_message)
+      update!(
+        status: 'failed',
+        error_message: error_message
+      )
+    end
+  end
+end

data/lib/generators/harmonia/templates/trophonius_model_extension.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Trophonius
+  class Model
+    # Converts a Trophonius record to PostgreSQL-compatible attributes
+    # @param record [Trophonius::Record] The Trophonius record instance to convert
+    def self.to_pg(record)
+      raise StandardError, 'Implement to_pg'
+    end
+  end
+end

data/lib/harmonia/railtie.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Harmonia
+  class Railtie < Rails::Railtie
+    generators do
+      require 'generators/harmonia/install_generator'
+      require 'generators/harmonia/sync_generator'
+    end
+  end
+end