dbdoc_engine 0.1.0

data/app/queries/dbdoc_engine/db_design_dynamic_table_commands.rb

@@ -0,0 +1,106 @@
+# queries/db_design_dynamic_table_commands.rb
+
+# Service class for handling complex operations related to dynamic tables and their columns
+# Uses transactions to ensure atomicity of operations
+module DbdocEngine
+  class DbDesignDynamicTableCommands
+    class << self
+      # Creates a new dynamic table with associated columns in a transaction
+      # @param params [Hash] Table parameters including nested columns attributes
+      # @return [Hash] Result hash with :success status and either the table or errors
+      def create_with_columns(params)
+        table = DbDesignDynamicTable.new(params)
+
+        # Important: Validate the table OUTSIDE the transaction first
+        # This ensures uniqueness validations run before the transaction starts
+        unless table.valid?
+          return { success: false, errors: collect_errors(table) }
+        end
+
+        begin
+          # Wrap operations in transaction to ensure all-or-nothing behavior
+          ActiveRecord::Base.transaction do
+            # Now validate columns too
+            if valid_columns?(table)
+              table.save!
+              return { success: true, table: table }
+            end
+            # Rollback transaction if validations fail
+            raise ActiveRecord::Rollback
+          end
+        rescue ActiveRecord::RecordInvalid
+          # This would catch any exceptions if save! fails
+        end
+
+        # Return failure status with collected errors
+        { success: false, errors: collect_errors(table) }
+      end
+
+      # Updates an existing dynamic table and its columns in a transaction
+      # @param table [DbDesignDynamicTable] Existing table to update
+      # @param params [Hash] New parameters including nested columns attributes
+      # @return [Hash] Result hash with :success status and either the table or errors
+      def update_with_columns(table, params)
+        table.assign_attributes(params)
+
+        # Validate table outside transaction first
+        unless table.valid?
+          return { success: false, errors: collect_errors(table) }
+        end
+
+        # Transaction block for atomic updates
+        ActiveRecord::Base.transaction do
+          # Now validate columns
+          if valid_columns?(table)
+            table.save!
+            return { success: true, table: table }
+          end
+
+          # Collect errors and rollback if validations fail
+          raise ActiveRecord::Rollback
+        end
+
+        # Return failure status with collected errors
+        { success: false, errors: collect_errors(table) }
+      end
+
+      private
+
+      # Validates table attributes
+      # @param table [DbDesignDynamicTable] Table instance to validate
+      # @return [Boolean] Validation status
+      def valid_table?(table)
+        table.valid?
+      end
+
+      # Validates all associated columns
+      # @param table [DbDesignDynamicTable] Table instance with columns to validate
+      # @return [Boolean] Overall validation status of all columns
+      def valid_columns?(table)
+        table.db_design_dynamic_columns.all?(&:valid?)
+      end
+
+      # Aggregates validation errors from table and columns into a single hash
+      # @param table [DbDesignDynamicTable] Table instance with errors
+      # @return [Hash] Structured error messages with keys indicating error sources
+      def collect_errors(table)
+        errors = {}
+
+        # Collect table-level errors
+        table.errors.each do |error|
+          errors[error.attribute] = error.message
+        end
+
+        # Collect column errors with indexed keys to prevent overwrites
+        table.db_design_dynamic_columns.each_with_index do |col, idx|
+          col.errors.each do |error|
+            # Format: "column_0_columnname" for first column's name error
+            errors["column#{idx}_#{error.attribute}"] = error.message
+          end
+        end
+
+        errors
+      end
+    end
+  end
+end

data/app/queries/dbdoc_engine/db_design_dynamic_table_queries.rb

@@ -0,0 +1,194 @@
+# queries/db_design_dynamic_table_queries.rb
+
+# Query class handling database operations for dynamic tables and their relationships
+module DbdocEngine
+  class DbDesignDynamicTableQueries
+    # Associations to eager load with table queries
+    INCLUDES_ASSOCIATIONS = %i[db_design_dynamic_columns db_design_table_group].freeze
+
+    class << self
+      # Centralized access to the DynamicTable model class
+      # @return [Class] DbDesignDynamicTable model class
+      def model
+        DbDesignDynamicTable
+      end
+
+      # Count tables belonging to a specific group
+      # @param group [DbDesignTableGroup] Group to count tables for
+      # @return [Integer] Number of tables in the group
+      def count_tables_in_group(group, include_deleted = false)
+        if include_deleted
+          group.db_design_dynamic_tables.with_deleted.size
+        else
+          group.db_design_dynamic_tables.size
+        end
+      end
+
+      # Find a table by ID with eager-loaded columns and group
+      # @param id [Integer] Table ID to find
+      # @return [DbDesignDynamicTable, nil] Found table or nil
+      def find_table_with_columns_and_group(id)
+        model.includes(INCLUDES_ASSOCIATIONS).find_by(id: id)
+      end
+
+      # Get all active tables with their columns and groups
+      # @return [ActiveRecord::Relation] Collection of tables with associations
+      def all_tables_with_columns_and_groups
+        model.includes(INCLUDES_ASSOCIATIONS)
+      end
+
+      # Ordered table groups with associated tables
+      def all_tables_ordered_by_group
+        model.includes(INCLUDES_ASSOCIATIONS)
+            .joins(:db_design_table_group)
+            .order(Arel.sql('LOWER(db_design_table_groups.group_name) ASC,
+                            LOWER(db_design_dynamic_tables.table_name) ASC'))
+      end
+
+      # Get soft-deleted tables with their associations
+      # @return [ActiveRecord::Relation] Collection of deleted tables
+      def all_deleted_tables_with_columns_and_groups
+        model.with_deleted.only_deleted.includes(INCLUDES_ASSOCIATIONS)
+      end
+
+      # Count all active tables
+      # @return [Integer] Total active table count
+      def count_all_tables
+        model.count
+      end
+
+      # Count all soft-deleted tables
+      # @return [Integer] Total deleted table count
+      def count_all_deleted_tables
+        model.with_deleted.only_deleted.count
+      end
+
+      # Find table including soft-deleted records
+      # @param id [Integer] Table ID to find
+      # @return [DbDesignDynamicTable] Table with deleted records
+      def find_table_with_deleted(id)
+        model.with_deleted.find(id)
+      end
+
+      # Get all tables except specified ID
+      # @param id [Integer] Table ID to exclude
+      # @return [ActiveRecord::Relation] Tables excluding specified ID
+      def find_all_except(id)
+        model.where.not(id: id)
+      end
+
+      # Find table by its name
+      # @param table_name [String] Name to search for
+      # @return [DbDesignDynamicTable, nil] Matching table or nil
+      def find_by_table_name(table_name)
+        model.find_by(table_name: table_name)
+      end
+
+      # Check if a column is referenced as foreign key
+      # @param table_name [String] Source table name
+      # @param column_name [String] Column name to check
+      # @param only_active [Boolean] Only check active tables
+      # @return [Boolean] Reference existence status
+      def check_column_is_referenced(table_name, column_name, only_active: false)
+        query = DbDesignDynamicColumn.where(
+          foreign_table_name: table_name,
+          foreign_column_name: column_name
+        )
+
+        query = active_tables_scope(query) if only_active
+        query.exists?
+      end
+
+      # Get group name for a table group ID
+      # @param group_id [Integer] Group ID to lookup
+      # @return [String, nil] Group name or nil
+      def find_table_group_name(group_id)
+        DbDesignTableGroupQueries.find_group_name(group_id)
+      end
+
+      # Get table name by ID
+      # @param table_id [Integer] Table ID to lookup
+      # @return [String, nil] Table name or nil
+      def find_table_name(table_id)
+        model.find_by(id: table_id)&.table_name
+      end
+
+      # Check if group contains active/non-deleted tables
+      # @param group_id [Integer] Group ID to check
+      # @param include_deleted [Boolean] Include deleted tables in check
+      # @return [Boolean] Existence status
+      def group_has_active_tables?(group_id, include_deleted = false)
+        query = model.where(db_design_table_group_id: group_id)
+        query = include_deleted ? query.with_deleted : query.without_deleted
+        query.exists?
+      end
+
+      # Find table with eager-loaded group information
+      # @param id [Integer] Table ID to find
+      # @return [DbDesignDynamicTable] Table with group association
+      def find_table_with_group(id)
+        model.includes(:db_design_table_group).find(id)
+      end
+
+      # Filter relation by group ID
+      # @param relation [ActiveRecord::Relation] Base query to filter
+      # @param group_id [Integer] Group ID to filter by
+      # @return [ActiveRecord::Relation] Filtered query
+      def filter_by_group(relation, group_id)
+        relation.where(db_design_table_group_id: group_id)
+      end
+
+      # Search tables by name or group name
+      # @param relation [ActiveRecord::Relation] Base query to search
+      # @param search_term [String] Term to search for
+      # @return [ActiveRecord::Relation] Modified query with search filters
+      def search_tables(relation, search_term)
+        return relation if search_term.blank?
+
+        sanitized_term = "%#{search_term.downcase}%"
+        relation.left_joins(:db_design_table_group)
+                .where("LOWER(db_design_dynamic_tables.table_name) LIKE :term OR LOWER(db_design_table_groups.group_name) LIKE :term",
+                      term: sanitized_term)
+      end
+
+      def active_tables_with_columns
+        model.where(deleted_at: nil)
+             .where(
+               "EXISTS (SELECT 1 FROM db_design_dynamic_columns " \
+               "WHERE db_design_dynamic_columns.db_design_dynamic_table_id = db_design_dynamic_tables.id)"
+             )
+      end
+
+      def table_exists?(table_name)
+        model.exists?(table_name: table_name, deleted_at: nil)
+      end
+
+      private
+
+      # Scope query to active tables only
+      # @param query [ActiveRecord::Relation] Query to modify
+      # @return [ActiveRecord::Relation] Scoped query
+      def active_tables_scope(query)
+        query.joins(:db_design_dynamic_table)
+            .where(db_design_dynamic_tables: { deleted_at: nil })
+      end
+
+      # Check for table references (private implementation)
+      # @param table_id [Integer] Table ID to check
+      # @return [Boolean] Reference existence status
+      def check_table_references(_table_id)
+        DbDesignDynamicColumn
+          .joins(:db_design_dynamic_table)
+          .where(foreign_table_name: table.table_name)
+          .exists?
+      end
+
+      # Find table with columns and group (private implementation)
+      # @param id [Integer] Table ID to find
+      # @return [DbDesignDynamicTable, nil] Found table or nil
+      def find_with_columns_and_group(id)
+        model.includes(INCLUDES_ASSOCIATIONS).find_by(id: id)
+      end
+    end
+  end
+end

data/app/queries/dbdoc_engine/db_design_table_group_queries.rb

@@ -0,0 +1,154 @@
+# queries/db_design_table_group_queries.rb
+
+# Query class handling database operations for table groups and their associations
+module DbdocEngine
+  class DbDesignTableGroupQueries
+    # Eager loading configuration for tables and columns associations
+    TABLE_INCLUDES = { db_design_dynamic_tables: :db_design_dynamic_columns }.freeze
+
+    class << self
+      # Centralized model reference for table groups
+      # @return [Class] DbDesignTableGroup model class
+      def model
+        DbDesignTableGroup
+      end
+
+      # Fetch all table groups with their associated tables and columns
+      # @return [ActiveRecord::Relation] Collection of groups with eager-loaded associations
+      def all_groups_with_tables_and_columns
+        model.includes(TABLE_INCLUDES).all
+      end
+
+      # Find a specific group by ID with preloaded tables and columns
+      # @param id [Integer] Group ID to find
+      # @return [DbDesignTableGroup, nil] Found group or nil
+      def find_group_with_tables_and_columns(id)
+        model.includes(TABLE_INCLUDES).find_by(id: id)
+      end
+
+      # Count all active (non-deleted) table groups
+      # @return [Integer] Total count of active groups
+      def count_all_groups
+        model.count
+      end
+
+      # Retrieve lightweight group data for selection lists
+      # @return [ActiveRecord::Relation] Collection of groups with only ID and name
+      def select_all_groups
+        model.select(:id, :group_name)
+      end
+
+      # Find a group including soft-deleted records
+      # @param id [Integer] Group ID to find
+      # @return [DbDesignTableGroup] Group including soft-deleted ones
+      def find_with_deleted(id)
+        model.with_deleted.find(id)
+      end
+
+      # Unified search across groups with optional deleted records
+      # @param search_term [String] Optional search string
+      # @param include_deleted [Boolean] Flag to include soft-deleted records
+      # @return [ActiveRecord::Relation] Filtered collection of groups
+      def search_all_groups(search_term = nil, include_deleted = false)
+        query = include_deleted ? model.with_deleted : model.all
+        query = apply_search_scope(query, search_term)
+        query.order(Arel.sql("LOWER(group_name) ASC")) # Add ordering here
+      end
+
+      # Search specifically in soft-deleted groups
+      # @param search_term [String] Optional search string
+      # @return [ActiveRecord::Relation] Filtered collection of deleted groups
+      def search_deleted_groups(search_term = nil)
+        apply_search_scope(model.only_deleted, search_term)
+      end
+
+      # Get group names excluding a specific entry
+      # @param excluded_id [Integer] ID to exclude from results
+      # @return [Array<String>] Array of group names
+      def group_names_except(excluded_id)
+        model.where.not(id: excluded_id).pluck(:group_name)
+      end
+
+      # Find group name by ID
+      # @param group_id [Integer] Group ID to lookup
+      # @return [String, nil] Group name or nil
+      def find_group_name(group_id)
+        model.find_by(id: group_id)&.group_name
+      end
+
+      # Check if a group name exists in active records
+      # @param group_name [String] Name to check for existence
+      # @return [Boolean] Existence status
+      def group_exists?(group_name)
+        model.without_deleted.where(group_name: group_name).exists?
+      end
+
+      # Create a new table group
+      # @param params [Hash] Group attributes
+      # @return [DbDesignTableGroup] New group instance (persisted if valid)
+      def create_table_group(params)
+        model.new(params).tap(&:save)
+      end
+
+      # Update existing table group
+      # @param table_group [DbDesignTableGroup] Group instance to update
+      # @param params [Hash] New attributes
+      # @return [Boolean] Update success status
+      def update_table_group(table_group, params)
+        table_group.update(params)
+      end
+
+      # Soft delete a table group
+      # @param table_group [DbDesignTableGroup] Group to mark as deleted
+      # @return [Boolean] Deletion success status
+      def soft_delete(table_group)
+        table_group.soft_delete
+      end
+
+      # Restore a soft-deleted group
+      # @param table_group [DbDesignTableGroup] Group to restore
+      # @return [Boolean] Restoration success status
+      def restore(table_group)
+        table_group.restore
+      end
+
+      # Permanently delete a group
+      # @param table_group [DbDesignTableGroup] Group to destroy
+      # @return [Boolean] Deletion success status
+      def permanent_delete(table_group)
+        table_group.destroy
+      end
+
+      # Get all groups for selection dropdowns
+      # @return [ActiveRecord::Relation] Ordered list of groups with ID and name
+      def all_groups_for_selection
+        model.select(:id, :group_name).order(:group_name)
+      end
+
+      # Find group with associated tables
+      # @param group_id [Integer] Group ID to find
+      # @return [DbDesignTableGroup] Group with associated tables
+      def find_group_with_tables(group_id)
+        model.includes(:db_design_dynamic_tables).find(group_id)
+      end
+
+      def groups_with_tables_having_columns
+        model.includes(db_design_dynamic_tables: :db_design_dynamic_columns)
+             .references(:db_design_dynamic_tables)
+             .where(db_design_dynamic_tables: { deleted_at: nil })
+      end
+
+      private
+
+      # Internal search scope handler
+      # @param query [ActiveRecord::Relation] Base query to modify
+      # @param search_term [String] Search string for filtering
+      # @return [ActiveRecord::Relation] Modified query with search filters
+      def apply_search_scope(query, search_term)
+        return query if search_term.blank?
+
+        query.where("group_name ILIKE ?", "%#{search_term.strip}%")
+      end
+    end
+  end
+end

data/app/services/dbdoc_engine/db_design_dynamic_table_export_service.rb

@@ -0,0 +1,38 @@
+# app/services/db_design_dynamic_table_export_service.rb
+module DbdocEngine
+class DbDesignDynamicTableExportService
+  def initialize(params, controller)
+    @params = params                      # Parameters passed from the controller
+    @controller = controller              # Reference to the controller instance
+  end
+
+  # Handles export of a single table to Excel
+  def export_single
+    table = DbdocEngine::DbDesignDynamicTableQueries.find_table_with_deleted(@params[:id])     # Find table by ID (including soft-deleted)
+    columns = table.db_design_dynamic_columns                                     # Get all columns for the table
+
+    @controller.instance_variable_set(:@table, table)                             # Set instance variable for table
+    @controller.instance_variable_set(:@columns, columns)                         # Set instance variable for columns
+
+    @controller.respond_to do |format|                                            # Prepare Excel response
+      format.xlsx do
+        filename = "#{table.table_name.parameterize}_details.xlsx"                # Set download filename
+        @controller.response.headers["Content-Disposition"] = "attachment; filename=#{filename}"
+      end
+    end
+  end
+
+  # Handles export of all tables to Excel
+  def export_all
+    tables = DbdocEngine::DbDesignDynamicTableQueries.all_tables_with_columns_and_groups       # Get all tables with columns and groups
+    @controller.instance_variable_set(:@tables, tables)                           # Set instance variable for use in view
+
+    @controller.respond_to do |format|                                            # Prepare Excel response
+      format.xlsx do
+        filename = "all_tables_details_#{Date.today.strftime('%Y%m%d')}.xlsx"     # Set download filename with today's date
+        @controller.response.headers["Content-Disposition"] = "attachment; filename=#{filename}"
+      end
+    end
+  end
+end
+end

data/app/services/dbdoc_engine/db_design_dynamic_table_handler_service.rb

@@ -0,0 +1,49 @@
+# Handles create and update operations for DbDesignDynamicTable
+module DbdocEngine
+  class DbDesignDynamicTableHandlerService
+    def initialize(controller_context, table_params, table = nil)
+      @controller = controller_context               # Reference to the controller instance
+      @table_params = table_params                   # Table parameters from the controller
+      @table = table                                 # Existing table object (optional, for update)
+    end
+
+    # Handles table creation operation
+    def create
+      result = service.create_table # Call service to create the table
+
+      if result[:success]
+        @controller.flash[:notice] = I18n.t("dbdoc.table_creation") # Success message
+        @controller.redirect_to @controller.admin_db_design_dynamic_tables_path # Redirect to the table list
+      else
+        handle_failure(result, :new) # Handle failure (render 'new' view)
+      end
+    end
+
+    # Handles table update operation
+    def update
+      result = service.update_table(@table) # Call service to update the table
+
+      if result[:success]
+        @controller.flash[:notice] = I18n.t("dbdoc.table_updation") # Success message
+        @controller.redirect_to @controller.admin_db_design_dynamic_tables_path # Redirect to the table list
+      else
+        handle_failure(result, :edit) # Handle failure (render 'edit' view)
+      end
+    end
+
+    private
+
+    # Initializes and caches the service object for table operations
+    def service
+      @service ||= DbDesignDynamicTablesService.new(@table_params) # Instantiate the service with table parameters
+    end
+
+    # Handles failure scenario (render the appropriate view with errors)
+    def handle_failure(result, render_view)
+      @controller.instance_variable_set(:@table, @table || DbDesignDynamicTable.new(@table_params)) # Set table instance
+      @controller.send(:load_other_tables) # Load other tables for reference in the view
+      @controller.send(:handle_errors, @controller.instance_variable_get(:@table), result) # Handle and display errors
+      @controller.render render_view, status: :unprocessable_entity # Render the appropriate view with errors
+    end
+  end
+end

data/app/services/dbdoc_engine/db_design_dynamic_tables_service.rb

@@ -0,0 +1,21 @@
+# Service for managing dynamic table creation and updates.
+# This service handles the creation and updating of dynamic tables,
+# including the validation of table and nested column data,
+# and ensures that all changes are committed within a transaction.
+module DbdocEngine
+class DbDesignDynamicTablesService
+  def initialize(params)
+    @params = params
+  end
+
+  # Create new table.
+  def create_table
+    DbDesignDynamicTableCommands.create_with_columns(@params)
+  end
+
+  # Update existing table.
+  def update_table(table)
+    DbDesignDynamicTableCommands.update_with_columns(table, @params)
+  end
+end
+end

data/app/services/dbdoc_engine/error_handler_service.rb

@@ -0,0 +1,43 @@
+# Service for handling errors in table operations
+module DbdocEngine
+class ErrorHandlerService
+  attr_reader :table, :result, :table_params
+
+  def initialize(table, result, table_params = nil)
+    @table = table
+    @result = result
+    @table_params = table_params
+  end
+
+  # Process errors and add them to the appropriate objects
+  def process_errors
+    return unless result[:errors].present?
+
+    result[:errors].each do |attribute, messages|
+      if attribute.to_s.start_with?("db_design_dynamic_columns.")
+        handle_column_error(attribute, messages)
+      else
+        handle_table_error(attribute, messages)
+      end
+    end
+  end
+
+  private
+
+  # Handle errors for specific columns
+  def handle_column_error(attribute, messages)
+    match = attribute.to_s.match(/db_design_dynamic_columns\.(\d+)/)
+    return unless match
+
+    index = match[1].to_i
+    return unless table.db_design_dynamic_columns[index]
+
+    table.db_design_dynamic_columns[index].errors.add(:base, messages)
+  end
+
+  # Handle errors for the table itself
+  def handle_table_error(attribute, messages)
+    Array(messages).each { |message| table.errors.add(attribute, message) }
+  end
+end
+end