dbdoc_engine 0.1.0

data/app/controllers/dbdoc_engine/admin/dashboard_controller.rb

@@ -0,0 +1,16 @@
+# Dashbord controller
+module DbdocEngine
+  class Admin::DashboardController < Admin::BaseController
+    def index
+      @groups_count = AdminDashboardQueries.groups_count
+      @tables_count = AdminDashboardQueries.tables_count
+      @columns_count = AdminDashboardQueries.columns_count
+
+      # Get last 10 changes (no pagination)
+      @changelogs = AdminDashboardQueries.filtered_changelogs(params).limit(10)
+
+      # Prepare detailed chart data
+      @chart_data = AdminDashboardQueries.prepare_chart_data(@changelogs)
+    end
+  end
+end

data/app/controllers/dbdoc_engine/admin/data_transfer_controller.rb

@@ -0,0 +1,63 @@
+module DbdocEngine
+  class Admin::DataTransferController < Admin::BaseController
+    skip_before_action :verify_authenticity_token, only: [ :import_data, :import_schema ]
+
+    def export_data
+      data = {
+        groups: DbDesignTableGroup.where(deleted_at: nil).as_json,
+        tables: DbDesignDynamicTable.where(deleted_at: nil).as_json,
+        columns: DbDesignDynamicColumn.joins(:db_design_dynamic_table)
+                                    .where(db_design_dynamic_tables: { deleted_at: nil })
+                                    .as_json
+      }
+      render json: data
+    end
+
+    def import_data
+      json_data = JSON.parse(request.body.read)
+      ActiveRecord::Base.transaction do
+        DbDesignDynamicColumn.unscoped.delete_all
+        DbDesignDynamicTable.unscoped.delete_all
+        DbDesignTableGroup.unscoped.delete_all
+
+        DbDesignTableGroup.insert_all!(json_data["groups"]) if json_data["groups"].present?
+        DbDesignDynamicTable.insert_all!(json_data["tables"]) if json_data["tables"].present?
+        DbDesignDynamicColumn.insert_all!(json_data["columns"]) if json_data["columns"].present?
+      end
+      render json: { status: "ok" }
+    rescue => e
+      render json: { status: "error", error: e.message }, status: :unprocessable_entity
+    end
+
+    def import_schema
+      schema_content = resolve_schema_content
+      result = SchemaRbImportService.new(
+        schema_content,
+        imported_by: current_user&.username || "system"
+      ).import!
+
+      if result[:status] == "ok"
+        render json: { status: "ok", tables_count: result[:tables_count] }
+      else
+        render json: { status: "error", error: result[:error] }, status: :unprocessable_entity
+      end
+    rescue => e
+      render json: { status: "error", error: e.message }, status: :unprocessable_entity
+    end
+
+    private
+
+    def resolve_schema_content
+      source = params[:source]
+
+      if source == "project"
+        schema_path = Rails.root.join("db", "schema.rb")
+        raise "schema.rb not found at #{schema_path}" unless File.exist?(schema_path)
+
+        File.read(schema_path)
+      else
+        request.body.read
+      end
+    end
+  end
+end

data/app/controllers/dbdoc_engine/admin/db_design_dynamic_tables_controller.rb

@@ -0,0 +1,198 @@
+# Controller for managing dynamic tables
+module DbdocEngine
+  class Admin::DbDesignDynamicTablesController < Admin::BaseController
+    before_action :require_admin, only: %i[new create edit update destroy]
+    before_action :require_superadmin, only: [ :deleted_tables ]
+    before_action :set_table, only: %i[edit update destroy restore permanent_destroy]
+    before_action :load_groups, only: %i[index deleted_tables]
+
+    # Displays all dynamic tables with filters and pagination
+    def index
+      @tables = DbdocEngine::DbDesignDynamicTableQueries.all_tables_ordered_by_group
+      load_filtered_tables(params[:page])
+      @total_table_count = DbdocEngine::DbDesignDynamicTableQueries.count_all_tables
+    end
+
+    # Displays deleted tables with filters and pagination
+    def deleted_tables
+      @tables = DbdocEngine::DbDesignDynamicTableQueries.all_deleted_tables_with_columns_and_groups
+      load_filtered_tables(params[:page])
+      @total_table_count = DbdocEngine::DbDesignDynamicTableQueries.count_all_deleted_tables
+    end
+
+    def show_table_info
+      @table = DbdocEngine::DbDesignDynamicTableQueries.find_table_with_columns_and_group(params[:id])
+      @total_columns_count = @table.db_design_dynamic_columns.size
+      @columns = @table.db_design_dynamic_columns.order(is_primary_key: :desc, column_name: :asc).page(params[:page]).per(10)
+      table_name = @table.table_name
+      @recent_changelogs = DbdocEngine::DbDesignChangelog.where(
+        (DbdocEngine::DbDesignChangelog.arel_table[:entity_type].eq("table")
+          .and(DbdocEngine::DbDesignChangelog.arel_table[:entity_name].eq(table_name)))
+        .or(
+          DbdocEngine::DbDesignChangelog.arel_table[:entity_type].eq("column")
+          .and(DbdocEngine::DbDesignChangelog.arel_table[:entity_name].matches("#{table_name}.%"))
+        )
+      ).order(change_timestamp: :desc).limit(10)
+    end
+
+    # Initializes a new table with associated columns
+    def new
+      @table = DbDesignDynamicTable.new
+      @table.db_design_dynamic_columns.build
+      load_other_tables
+    end
+
+    # Creates a new dynamic table using the service layer
+    def create
+      DbDesignDynamicTableHandlerService.new(self, table_params).create
+    end
+
+    # Edits an existing dynamic table
+    def edit
+      @other_tables = DbdocEngine::DbDesignDynamicTableQueries.find_all_except(@table.id)
+    end
+
+    # Updates an existing dynamic table using the service layer
+    def update
+      DbDesignDynamicTableHandlerService.new(self, table_params, @table).update
+    end
+
+    # Deletes a table (soft delete)
+    def destroy
+      handle_table_action(:soft_delete, @table.table_name, I18n.t("dbdoc.table_deletion"),
+                          admin_db_design_dynamic_tables_path)
+    end
+
+    # Permanently deletes a table
+    def permanent_destroy
+      handle_table_action(:permanent_destroy, @table.table_name, I18n.t("dbdoc.table_permanent_deletion"),
+                          deleted_tables_admin_db_design_dynamic_tables_path)
+    end
+
+    # Restores a soft-deleted table
+    def restore
+      handle_table_action(:restore, @table.table_name, I18n.t("dbdoc.table_restore"),
+                          deleted_tables_admin_db_design_dynamic_tables_path)
+    end
+
+    # Renders additional column fields dynamically
+    def render_column_fields
+      @index = params[:index] || Time.now.to_i
+      @column = DbDesignDynamicColumn.new
+      current_table_id = params[:table_id]
+      @other_tables = if current_table_id
+                        DbdocEngine::DbDesignDynamicTableQueries.find_all_except(current_table_id)
+      else
+                        DbdocEngine::DbDesignDynamicTableQueries.all_tables_with_columns_and_groups
+      end
+
+      render partial: "column_fields", locals: { f: fields_for_column(@column, @index),
+                                                table: @table,
+                                                other_tables: @other_tables }
+    end
+
+    # Checks if a column is referenced in other tables
+    def check_column_dependency
+      table = DbdocEngine::DbDesignDynamicTableQueries.find_table_with_deleted(params[:table_id])
+      is_referenced = DbdocEngine::DbDesignDynamicTableQueries.check_column_is_referenced(
+        table.table_name,
+        params[:column_name],
+        only_active: true
+      )
+
+      render json: { is_referenced: is_referenced }
+    end
+
+    # Fetches columns of a table in JSON format
+    def columns
+      table = DbdocEngine::DbDesignDynamicTableQueries.find_by_table_name(params[:table_name])
+      render json: table ? table.db_design_dynamic_columns.select(:id, :column_name) : []
+    end
+
+    # Exports table data to Excel
+    def export_to_excel
+      DbDesignDynamicTableExportService.new(params, self).export_single
+    end
+
+    # Exports all tables data to Excel
+    def export_all_to_excel
+      DbDesignDynamicTableExportService.new(params, self).export_all
+    end
+
+    private
+
+    # Loads and filters tables with pagination
+    def load_filtered_tables(page)
+      @tables = TableFilterService.new(@tables, params).filter
+      @total_group_count = DbdocEngine::DbDesignTableGroupQueries.count_all_groups
+      @tables = @tables.page(page).per(10)
+    end
+
+    # Handles table actions (delete, restore, etc.)
+    def handle_table_action(action, table_name, action_description, redirect_path)
+      service = TableManagementService.new(@table)
+      result = service.send(action)
+
+      if result[:success]
+        success_flash(I18n.t("dbdoc.success.table_action", table_name: table_name, action_description: action_description))
+      else
+        error_flash(result[:errors].first)
+      end
+      redirect_to redirect_path
+    end
+
+    # Sets success flash message
+    def success_flash(message)
+      flash[:notice] = "✅ #{message}"
+    end
+
+    # Sets error flash message
+    def error_flash(message)
+      flash[:alert] = "❌ #{message}"
+    end
+
+    # Loads table groups for filtering
+    def load_groups
+      @groups = DbdocEngine::DbDesignTableGroupQueries.select_all_groups
+    end
+
+    # Loads other tables for references
+    def load_other_tables
+      @other_tables = DbdocEngine::DbDesignDynamicTableQueries.all_tables_with_columns_and_groups
+    end
+
+    # Handles error processing
+    def handle_errors(table, result)
+      error_handler = ErrorHandlerService.new(table, result)
+      error_handler.process_errors
+    end
+
+    # Finds a table, including soft-deleted ones
+    def set_table
+      @table = DbdocEngine::DbDesignDynamicTableQueries.find_table_with_deleted(params[:id])
+    end
+
+    # Strong parameters for dynamic table creation
+    def table_params
+      params.require(:db_design_dynamic_table).permit(
+        :table_name, :physical_table_name, :db_design_table_group_id, :description, :created_by, :updated_by,
+        db_design_dynamic_columns_attributes: %i[
+          id column_name physical_column_name data_type length decimal_precision
+          is_primary_key is_foreign_key foreign_table_name foreign_column_name relationship_type
+          is_candidate_key is_unique_key is_indexed not_null default_value sample_value
+          description created_by _destroy
+        ]
+      )
+    end
+
+    # Generates form fields for columns
+    def fields_for_column(column, index)
+      ActionView::Helpers::FormBuilder.new(
+        "db_design_dynamic_table[db_design_dynamic_columns_attributes][#{index}]",
+        column,
+        view_context,
+        {}
+      )
+    end
+  end
+end

data/app/controllers/dbdoc_engine/admin/db_design_table_groups_controller.rb

@@ -0,0 +1,107 @@
+# Controller for managing table groups in the admin panel.
+# It provides CRUD operations, soft deletion, restoration, and permanent deletion.
+module DbdocEngine
+  class Admin::DbDesignTableGroupsController < Admin::BaseController
+    before_action :require_admin, only: %i[new create edit update destroy]
+    before_action :require_superadmin, only: [:deleted_groups]
+    before_action :set_table_group, only: %i[edit update destroy restore permanent_destroy]
+
+    # Displays table groups with optional search and deleted items filtering.
+    def index
+      @search_query = params[:search]
+      showing_deleted = params[:show_deleted] == 'true'
+
+      @table_groups = DbdocEngine::DbDesignTableGroupQueries.search_all_groups(@search_query, showing_deleted)
+      @table_groups = @table_groups.page(params[:page]).per(10)
+      @showing_deleted = showing_deleted
+    end
+
+    # Displays only soft-deleted table groups.
+    def deleted_groups
+      @search_query = params[:search]
+      @table_groups = DbdocEngine::DbDesignTableGroupQueries.search_deleted_groups(@search_query)
+      @table_groups = @table_groups.page(params[:page]).per(10)
+    end
+
+    # Renders form for creating a new table group.
+    def new
+      @table_group = DbDesignTableGroup.new
+    end
+
+    # Creates a new table group.
+    def create
+      result = TableGroupsService.new(params).create_group
+
+      if result[:success]
+        flash[:notice] = result[:message]
+        redirect_to admin_db_design_table_groups_path
+      else
+        flash[:alert] = result[:message]
+        @table_group = result[:table_group]
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    # Renders form for editing an existing table group.
+    def edit; end
+
+    # Updates an existing table group.
+    def update
+      result = TableGroupsService.new(params).update_group(@table_group)
+
+      if result[:success]
+        flash[:notice] = result[:message]
+        redirect_to admin_db_design_table_groups_path
+      else
+        flash[:alert] = result[:message]
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    # Soft deletes a table group.
+    def destroy
+      result = TableGroupsService.new(params).delete_group(@table_group)
+
+      if result[:success]
+        flash[:notice] = result[:message]
+      else
+        flash[:alert] = result[:errors].join(', ')
+      end
+
+      redirect_to admin_db_design_table_groups_path
+    end
+
+    # Restores a soft-deleted table group.
+    def restore
+      result = TableGroupsService.new(params).restore_group(@table_group)
+
+      if result[:success]
+        flash[:notice] = result[:message]
+      else
+        flash[:alert] = result[:errors].join(', ')
+      end
+
+      redirect_to deleted_groups_admin_db_design_table_groups_path(show_deleted: true)
+    end
+
+    # Permanently deletes a table group.
+    def permanent_destroy
+      result = TableGroupsService.new(params).permanent_delete_group(@table_group)
+
+      if result[:success]
+        flash[:notice] = result[:message]
+      else
+        flash[:alert] = result[:errors].join(', ')
+      end
+
+      redirect_to deleted_groups_admin_db_design_table_groups_path(show_deleted: true)
+    end
+
+    private
+
+    # Finds the table group, including soft-deleted ones.
+    def set_table_group
+      @table_group = DbdocEngine::DbDesignTableGroupQueries.find_with_deleted(params[:id])
+    end
+  end
+end

data/app/controllers/dbdoc_engine/application_controller.rb

@@ -0,0 +1,65 @@
+# The ApplicationController serves as the base controller for all other controllers in the application.
+# It includes shared behavior such as internationalization, authentication helpers,
+# browser compatibility enforcement, and global data loading.
+module DbdocEngine
+  class ApplicationController < ActionController::Base
+    # Makes the following methods available to views:
+    # - current_user: returns the currently logged-in user
+    # - user_signed_in?: checks if a user is signed in
+    # - require_authentication: ensures a user is authenticated
+    helper_method :current_user, :user_signed_in?, :require_authentication
+
+    # Includes language-switching functionality
+    include DbdocEngine::Concerns::Internationalization
+
+    # Only allows modern browsers that support key modern web features such as:
+    # - WebP images, Web Push, App Badges, Import Maps
+    # - CSS nesting and the :has() pseudo-class
+    # allow_browser versions: :modern
+
+    # Loads table groups and their dynamic tables before every controller action
+    before_action :load_groups
+
+    private
+
+    # Returns the currently logged-in user, or nil if not logged in.
+    def current_user
+      @current_user ||= User.find_by(id: session[:user_id]) if session[:user_id]
+    end
+
+    # Returns true if a user is signed in, false otherwise.
+    def user_signed_in?
+      current_user.present?
+    end
+
+    # Ensures the user is authenticated.
+    # Redirects to the login page with an alert if not signed in.
+    def require_authentication
+      return if user_signed_in?
+
+      redirect_to login_path, alert: "You must log in to access this page"
+    end
+
+    # Ensures the user is an admin or higher.
+    # Redirects to the login page with an alert if not authorized.
+    def require_admin
+      return if user_signed_in? && current_user.admin_or_higher?
+
+      redirect_to login_path, alert: "You must be an admin to access this page"
+    end
+
+    # Ensures the user is a superadmin.
+    # Redirects to the login page with an alert if not authorized.
+    def require_superadmin
+      return if user_signed_in? && current_user.superadmin?
+
+      redirect_to login_path, alert: "You must be a superadmin to access this page"
+    end
+
+    # Loads all table groups and their associated dynamic tables.
+    # This is made available globally through @groups, often used in layouts or sidebars.
+    def load_groups
+      @groups = DbDesignTableGroup.includes(:db_design_dynamic_tables).all
+    end
+  end
+end

data/app/controllers/dbdoc_engine/concerns/internationalization.rb

@@ -0,0 +1,57 @@
+# app/controllers/concerns/internationalization.rb
+module DbdocEngine::Concerns::Internationalization
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_locale
+  end
+
+  private
+
+  def set_locale
+    # Find the locale from params, session, cookie, or default
+    I18n.locale = find_locale
+
+    # Store locale in session and cookie
+    session[:locale] = I18n.locale
+    cookies.signed[:user_locale] = {
+      value: I18n.locale,
+      expires: 2.weeks.from_now,
+      httponly: false # Allow JavaScript access
+    }
+
+    # Set HTML lang attribute value
+    @html_lang = I18n.locale
+  end
+
+  def find_locale
+    locale_from_params ||
+      locale_from_session ||
+      locale_from_cookie ||
+      I18n.default_locale
+  end
+
+  def locale_from_params
+    locale = params[:locale]
+    valid_locale?(locale) ? locale : nil
+  end
+
+  def locale_from_session
+    locale = session[:locale]
+    valid_locale?(locale) ? locale : nil
+  end
+
+  def locale_from_cookie
+    locale = cookies.signed[:user_locale]
+    valid_locale?(locale) ? locale : nil
+  end
+
+  def valid_locale?(locale)
+    locale.present? && I18n.available_locales.map(&:to_s).include?(locale.to_s)
+  end
+
+  # Keep locale parameter in URLs
+  def default_url_options
+    { locale: I18n.locale }
+  end
+end

data/app/controllers/dbdoc_engine/db_doc_sessions_controller.rb

@@ -0,0 +1,33 @@
+# Handles user login and logout functionality
+module DbdocEngine
+  class DbDocSessionsController < ApplicationController
+    skip_before_action :verify_authenticity_token
+    # Renders the login form
+    def new
+      # Login form
+    end
+
+    # Authenticates the user and starts a session
+    def create
+      # Find user by username
+      user = User.find_by(username: params[:username])
+
+      # Authenticate user with password
+      if user&.authenticate(params[:password])
+        # Store user ID in session and redirect to admin dashboard
+        session[:user_id] = user.id
+        redirect_to root_path, notice: 'Logged in successfully!'
+      else
+        # Redirect back to login with error message
+        redirect_to login_path, notice: '❌ Invalid Username or Password'
+      end
+    end
+
+    # Logs out the user by clearing the session
+    def destroy
+      # Clear session and redirect to home
+      session[:user_id] = nil
+      redirect_to login_path, notice: 'Logged out!'
+    end
+  end
+end

data/app/controllers/dbdoc_engine/home_controller.rb

@@ -0,0 +1,79 @@
+# Controller for user-facing pages (public area)
+module DbdocEngine
+  class HomeController < ApplicationController
+    # Use the 'header' layout for all actions in this controller
+    layout 'dbdoc_engine/header'
+
+    # Require user authentication before any action
+    before_action :require_authentication
+
+    # Home page/dashboard
+    def index
+      # Get total table count
+      @table_count = DbdocEngine::DbDesignDynamicTableQueries.count_all_tables
+      # Get total column count
+      @field_count = DbDesignDynamicColumn.count
+      # Get all groups with their tables and columns
+      @groups = DbdocEngine::DbDesignTableGroupQueries.all_groups_with_tables_and_columns
+    end
+
+    # Show details for a specific group
+    def group_details
+      # Find the group with its tables and columns by ID
+      @group = DbdocEngine::DbDesignTableGroupQueries.find_group_with_tables_and_columns(params[:id])
+
+      if @group.nil?
+        # If group not found, redirect with alert
+        flash[:alert] = 'Table group deleted or does not exist.'
+        redirect_to root_path
+      else
+        # Get table count for this group
+        @tables_count = DbdocEngine::DbDesignDynamicTableQueries.count_tables_in_group(@group)
+        # Get all groups for sidebar/nav display
+        @groups = DbdocEngine::DbDesignTableGroupQueries.all_groups_with_tables_and_columns
+      end
+    end
+
+    # Show details for a specific table
+    def table_details
+      # Find the table with its columns and group by ID
+      @table = DbdocEngine::DbDesignDynamicTableQueries.find_table_with_columns_and_group(params[:id])
+
+      if @table.nil?
+        # If table not found, redirect with alert
+        flash[:alert] = '❌ Table deleted or does not exist.'
+        redirect_to root_path
+      else
+        @columns_count = @table.db_design_dynamic_columns.size
+        # Get the group this table belongs to
+        @group = @table.db_design_table_group
+        # Get all groups for sidebar/nav display
+        @groups = DbdocEngine::DbDesignTableGroupQueries.all_groups_with_tables_and_columns
+      end
+    end
+
+    # Show paginated changelogs with optional filters
+    def changelogs
+      # Get filtered changelogs based on params
+      @changelogs = DbdocEngine::DbDesignChangelogQueries.filtered_changelogs(params)
+      # Paginate changelogs (7 per page)
+      @changelogs = @changelogs.page(params[:page]).per(7)
+      # Get all groups for sidebar/nav display
+      @groups = DbdocEngine::DbDesignTableGroupQueries.all_groups_with_tables_and_columns
+    end
+
+    # Show details for a specific changelog entry
+    def changelog_details
+      # Find the changelog entry by ID
+      @changelog = DbdocEngine::DbDesignChangelogQueries.find_changelog(params[:id])
+      if @changelog.nil?
+        # If not found, redirect with alert
+        flash[:alert] = 'Changelog entry not found.'
+        redirect_to changelogs_path
+      else
+        # Get all groups for sidebar/nav display
+        @groups = DbdocEngine::DbDesignTableGroupQueries.all_groups_with_tables_and_columns
+      end
+    end
+  end
+end