feat: возможность отражения информации действий по базам данных

Reviewed-on: madeliri/shiny_form#1

.Rprofile

@@ -4,7 +4,6 @@ source("renv/activate.R")
 (function() {
 
   paths <- c(
-    "R_CONFIG_ACTIVE",
     "AUTH_DB_KEY"
   )
 
@@ -18,3 +17,27 @@ source("renv/activate.R")
     ))
   }
 })()
+
+(function() {
+
+  if (Sys.getenv("R_CONFIG_ACTIVE") == "") {
+    Sys.setenv(R_CONFIG_ACTIVE = "prod")
+    cli::cli_inform(c(
+      "i" = "Не указана конфигурация по умолчанию, автоматически установлен 'prod'. Для изменения конфигурации добавьте в {.file .Renviron}:"
+    ))
+    cli::cli_code(paste0("R_CONFIG_ACTIVE", "="))
+
+  }
+
+})()
+
+
+# при первом запуске скопировать пример конфига
+(function() {
+
+  if (!file.exists("config.yml")) {
+    file.copy("config_example.yml", "config.yml")
+  }
+
+})()
+

.gitignore

@@ -3,6 +3,8 @@
 /_devel
 
 scheme.rds
+config.yml
+
 .Renviron
 .DS_Store
 .lintr

CHANGELOG.md

@@ -1,3 +1,19 @@
+### 0.18.1 (2026-06-08)
+##### fix
+- правильный экспорт текстовых данных
+
+### 0.18.0 (2026-06-06)
+##### features
+- возможность отрганичить доступ к базам данных для отдельных пользователей
+
+### 0.17.0 (2026-04-24)
+##### features
+- модуль с задачами: для каждой записи в базе можно создать задачи, на главном экране отображается общее количество активных задач, по сроку выполнения на сегодня и просроченные задачи;
+- проверка на наличие орфанных записей в базе (сверка существующих ключей из главной таблицы `main` с каждой вложенной таблицей)
+
+##### changes
+- определение активных схем - теперь в файле `config.yml`
+
 ### 0.16.0 (2026-04-21)
 ##### features
 - возможность импорта данных в базу данных из ранее экспортированных .xlsx таблиц;

README.md

@@ -23,10 +23,11 @@ git clone https://gitea.madelirihs.ru/madeliri/shiny_form.git
 
 Восстановление окружения
 ```r
+renv::activate()
 renv::init()
 ```
 
-# Насторйки
+# Настройки
 
 ## переменные окружения
 
@@ -46,7 +47,8 @@ FORM_APP_LOCAL_DB_BACKUP_PATH="path_to_backups"
 
 Проверка осуществляется при каждом запуске приложения, бэкапы создаются раз в день (при первом запуске).
 
-Количество сохраняемых бэкапов:
+Количество послдних сохраненных бэкапов:
+
 ```
 FORM_APP_LOCAL_DB_BACKUP_LIMITS=3
 ```

app/forms.R

@@ -0,0 +1,34 @@
+options(box.path = here::here())
+box::use(
+  modules/utils,
+)
+
+#' @export
+load_data_to_form <- function(
+  df,
+  table_name = "main",
+  mhcs,
+  ns
+) {
+
+  input_types <- unname(mhcs()$get_id_type_list(table_name))
+  input_ids   <- names(mhcs()$get_id_type_list(table_name))
+  if (missing(ns)) ns <- NULL
+
+  # rewrite input forms
+  purrr::walk2(
+    .x = input_types,
+    .y = input_ids,
+    .f = \(x_type, x_id) {
+
+      # updating forms with loaded data
+      utils$update_forms_with_data(
+        form_id   = x_id,
+        form_type = x_type,
+        value = df[[x_id]],
+        scheme = mhcs()$get_scheme(table_name),
+        ns = ns
+      )
+    }
+  )
+}

app/logs.R

@@ -0,0 +1,129 @@
+box::use(
+  shiny[...],
+  bslib[...]
+)
+
+options(box.path = here::here())
+box::use(
+  modules/db,
+  modules/utils,
+  app/forms
+)
+
+#' @export
+server <- function(id, values, scheme, mhcs) {
+
+  ns <- NS(id)
+
+  moduleServer(id, function(input, output, session) {
+
+    # отображение DT-таблицы со списком последних действий
+    observeEvent(input$show_last_actions, {
+
+      con <- db$make_db_connection(scheme(),"show_last_actions")
+      on.exit(db$close_db_connection(con, "show_last_actions"), add = TRUE)
+
+      log_df <- DBI::dbReadTable(con, "log")
+
+      # новые записи вначале, формат даты с временем
+      log_df <- log_df |>
+        dplyr::arrange(dplyr::desc(date)) |>
+        dplyr::mutate(date = format(as.POSIXct(date), "%d.%m.%Y %H:%M"))
+
+      output$dt_logs <- DT::renderDataTable(
+        DT::datatable(
+          log_df,
+          # caption = 'Table 1: This is a simple caption for the table.',
+          rownames = FALSE,
+          colnames = logs_colnames,
+          extensions = c('KeyTable', "FixedColumns"),
+          # editable = 'cell',
+          class = 'cell-border stripe',
+          selection = "single",
+          options = list(
+            # dom = 'tipf',
+            scrollX = TRUE,
+            fixedColumns = list(leftColumns = 1),
+            keys = TRUE,
+            autoWidth = TRUE,
+            columnDefs = list(
+              list(width = "150px", targets = c(0,6)),
+              list(width = "110px", targets = c(1:4))
+            )
+          )
+        )
+      )
+
+      showModal(modalDialog(
+        DT::dataTableOutput(ns("dt_logs")),
+        size = "xl",
+        # footer = tagList(
+        #   actionButton("nested_form_dt_save", "сохранить изменения")
+        # ),
+        easyClose = TRUE
+      ))
+
+    })
+
+    # observe({
+    #   print(input$dt_logs_rows_selected)
+    # })
+
+    output$display_log <- renderUI({
+      req(values$main_key)
+
+      # получение логов
+      con <- db$make_db_connection(scheme(),"display_log")
+      on.exit(db$close_db_connection(con, "display_log"), add = TRUE)
+
+      query <- sprintf("SELECT * FROM \"log\" WHERE key = '%s'", values$main_key)
+      log_df_for_id <- DBI::dbGetQuery(con, query)
+
+      if (nrow(log_df_for_id) > 0) {
+
+        lines <- log_df_for_id |>
+          dplyr::mutate(
+            date = as.POSIXct(date),
+            date = date + lubridate::hours(3), # fix datetime
+            date_day = as.Date(date)
+          ) |>
+          dplyr::mutate(cons_actions = dplyr::consecutive_id(action, user)) |>
+          dplyr::mutate(n_actions = dplyr::row_number(), .by = c(cons_actions, user, action, date_day)) |>
+          dplyr::slice(which.max(n_actions), .by = c(user, action, date_day)) |>
+          dplyr::arrange(date) |>
+          dplyr::mutate(string_to_print = sprintf(
+            "<b>[%s %s]</b> %s: %s (%s)",
+            format(date, "%d.%m.%y"),
+            format(date, "%H:%M"),
+            user,
+            action,
+            n_actions
+          )) |>
+          dplyr::pull(string_to_print) |>
+          paste(collapse = "</br>")
+
+      } else {
+        lines <- ""
+      }
+
+      div(
+        strong("Последние действия:"),
+        br(),
+        HTML(lines),
+        style = "font-size:10px;"
+      )
+
+    })
+
+  })
+}
+
+logs_colnames <- c(
+  "время"        = "date",
+  "пользователь" = "user",
+  "приложение"   = "app_id",
+  "версия"       = "app_ver",
+  "ip"           = "remote_addr",
+  "ID записи"    = "key",
+  "действие"     = "action"
+)

app/tasks.R

@@ -0,0 +1,474 @@
+box::use(
+  shiny[...],
+  bslib[...]
+)
+
+options(box.path = here::here())
+box::use(
+  modules/db,
+  modules/utils,
+  app/forms
+)
+
+#' @export
+server <- function(id, values, scheme, mhcs) {
+
+  ns <- NS(id)
+
+  moduleServer(id, function(input, output, session) {
+
+    # BOOKMARKS SETUP ========================
+    # observe({
+    #   # print(values$current_user)
+    # })
+
+    # functions -------------------
+    ## new tasks ----------------
+    get_default_task <- function() {
+
+      tibble::tibble(
+        task_id = paste0(format(Sys.time(), "%Y%m%d%H%M%S"), "_", values$main_key),
+        task_main_key = values$main_key,
+        task_status = "active",
+        task_title = "НОВАЯ ЗАДАЧА",
+        task_description = "",
+        task_due_date = NA,
+        task_user_created = values$current_user,
+        task_datetime_created = Sys.time(),
+        task_user_last_updated = NA,
+        task_datetime_last_updated = NA,
+        task_user_completed = NA,
+        task_datetime_completed = NA
+      )
+    }
+
+    # logic ---------------------
+    ## modal fun -----
+    show_modal_for_tasks <- function() {
+
+      if (!is.null(values$tasks_data)) {
+
+        tasks_selector <- values$tasks_data |>
+          dplyr::filter(task_status == "active") |>
+          dplyr::pull(task_id)
+
+        tasks_selector <- unique(c(values$tasks_id, tasks_selector))
+        tasks_selector <- sort(tasks_selector)
+
+        if (length(values$tasks_id) == 0) {
+          values$tasks_id <- if (length(tasks_selector) == 0) NULL else tasks_selector[[1]]
+        }
+
+      } else {
+
+        tasks_selector <- NULL
+
+      }
+
+      # ui --------------------
+      # очень большой костыль
+      subroup_scheme <- mhcs()$get_scheme("tasks") |>
+        dplyr::filter(form_id != "dummy")
+
+      tab <- if (length(tasks_selector) > 0) {
+        bslib::nav_panel(
+          title = "no name provided",
+          purrr::pmap(
+            .l = dplyr::distinct(subroup_scheme, form_id, form_label, form_type),
+            .f = utils$render_forms,
+            main_scheme = subroup_scheme,
+            ns = ns
+          )
+        )
+      } else {
+        bslib::nav_panel("", div("Нет доступных записей.", br(), "Необходимо создать новую запись."))
+      }
+
+      ui <- layout_sidebar(
+        sidebar = tagList(
+          selectizeInput(ns("tasks_id_selector"), label = "ID задачи:", choices = tasks_selector, selected = values$tasks_id),
+          actionButton(ns("tasks_create_new_task"), "Новая задача", icon("plus")),
+          actionButton(ns("tasks_add_autoreview"), "Новая авто-задача (тест)", icon("calendar")),
+          actionButton(ns("tasks_DT_VIEW"), "DT", icon("table"))
+        ),
+        tab
+      )
+    
+      showModal(modalDialog(
+        ui,
+        size = "l",
+        footer = tagList(
+          actionButton(ns("tasks_saving_button"), "Сохранить изменения", icon("floppy-disk"))
+        ),
+        easyClose = TRUE
+      ))
+    }
+
+    ## отображение окна -----------------
+    observeEvent(input$display_task_modal, {
+      
+      if (is.null(values$main_key)) {
+        showNotification("необходимо выбрать запись", type = "error")
+        return()
+      }
+
+      con <- db$make_db_connection(scheme(),"display_task_modal")
+      on.exit(db$close_db_connection(con, "display_task_modal"), add = TRUE)
+
+      values$tasks_data <- if ("tasks" %in% DBI::dbListTables(con)) {
+
+        DBI::dbGetQuery(con, glue::glue("SELECT * FROM tasks WHERE task_main_key = '{values$main_key}'")) |>
+          dplyr::mutate(dplyr::across(c("task_datetime_created", "task_datetime_last_updated", "task_datetime_completed"), as.POSIXct)) |>
+          dplyr::mutate(dplyr::across(c("task_due_date"), as.Date))
+
+      } else {
+
+        NULL
+
+      }
+
+      values$tasks_id <- NULL
+      show_modal_for_tasks()
+
+    })
+
+    ## изменение выбранной задачи -------
+    observeEvent(input$tasks_id_selector, {
+      req(input$tasks_id_selector)
+      req(values$tasks_id)
+
+      # выбранный ключ в форме - перемещаем в RV
+      values$tasks_id <- input$tasks_id_selector
+
+    })
+
+    ## обновление формы при измененнии id ключа ------
+    observeEvent(values$tasks_id, {
+
+      df <- values$tasks_data |>
+        dplyr::filter(task_id == values$tasks_id)
+
+      forms$load_data_to_form(
+        df         = df,
+        table_name = "tasks",
+        mhcs
+        # ns = ns
+      )
+    })
+
+    ## saving button ------------------------------
+    observeEvent(input$tasks_saving_button, {
+
+      con <- db$make_db_connection(scheme(),"tasks_saving_button")
+      on.exit(db$close_db_connection(con, "tasks_saving_button"), add = TRUE)
+
+      if (!values$main_key %in% db$get_keys_from_table("main", mhcs(), con)) {
+        showNotification("Невозможно создать задачу для данного ID (нет в базе)", type = "error")
+        return()
+      }
+
+      id_and_types_list <- mhcs()$get_id_type_list("tasks")
+      input_types   <- unname(id_and_types_list)
+      input_ids     <- names(id_and_types_list)
+
+      exported_values <- purrr::map2(
+        .x = input_ids,
+        .y = input_types,
+        .f = \(x_id, x_type) {
+
+          input_d <- input[[x_id]]
+
+          # return empty if 0 element
+          if (length(input_d) == 0) {
+            return(utils$get_empty_data(x_type))
+          } else {
+            input_d
+          }
+        }
+      )
+
+      exported_df <- stats::setNames(exported_values, input_ids) |>
+        dplyr::as_tibble()
+
+      df <- values$tasks_data
+
+      df[df$task_id == values$tasks_id,]$task_status                <- exported_df$task_status
+      df[df$task_id == values$tasks_id,]$task_title                 <- exported_df$task_title
+      df[df$task_id == values$tasks_id,]$task_description           <- exported_df$task_description
+      df[df$task_id == values$tasks_id,]$task_due_date              <- exported_df$task_due_date
+      df[df$task_id == values$tasks_id,]$task_user_last_updated     <- values$current_user
+      df[df$task_id == values$tasks_id,]$task_datetime_last_updated <- Sys.time()
+
+      if (exported_df$task_status == "completed") {
+        df[df$task_id == values$tasks_id,]$task_user_completed     <- values$current_user 
+        df[df$task_id == values$tasks_id,]$task_datetime_completed <- Sys.time() 
+      }
+
+      values$tasks_data <- df
+
+      if ("tasks" %in% DBI::dbListTables(con)) {
+        query <- glue::glue("
+          DELETE 
+          FROM tasks 
+          WHERE task_main_key = '{values$main_key}'
+        ")
+        DBI::dbExecute(con, query)
+      }
+
+      DBI::dbWriteTable(con, "tasks", df, append = TRUE)
+
+      update_task_button_count(con, values)
+      showNotification("Задача успешно создана/обновлена", type = "message")
+
+      tasks_selector <- values$tasks_data |>
+        dplyr::filter(task_status != "completed") |>
+        dplyr::pull(task_id)
+
+      selector <- ifelse(!values$tasks_id %in% tasks_selector, tasks_selector[1], values$tasks_id)
+
+      updateSelectInput(inputId = "tasks_id_selector", choices = tasks_selector, selected = selector)
+
+    })
+
+    ## show DT --------------------------
+    observeEvent(input$tasks_DT_VIEW, {
+
+      rename_cols <- tasks_colnames[tasks_colnames %in% colnames(values$tasks_data)]
+      
+      date_cols <- c("task_datetime_created", "task_datetime_completed", "task_datetime_last_updated", "task_due_date")
+      date_cols <- which(colnames(values$tasks_data) %in% date_cols)
+
+      output$dt_tasks <- DT::renderDataTable(
+        DT::datatable(
+          values$tasks_data,
+          caption = 'Table 1: This is a simple caption for the table.',
+          rownames = FALSE,
+          colnames = rename_cols,
+          extensions = c('KeyTable', "FixedColumns"),
+          # editable = 'cell',
+          class = 'cell-border stripe',
+          selection = "none",
+          options = list(
+            dom = 'tip',
+            scrollX = TRUE,
+            fixedColumns = list(leftColumns = 1),
+            keys = TRUE,
+            autoWidth = TRUE,
+            columnDefs = list(
+              list(
+                targets = 3:4,
+                width = '200px',
+                render = htmlwidgets::JS(
+                  "function(data, type, row, meta) {",
+                  "return type === 'display' && data.length > 20 ?",
+                  "'<span title=\"' + data + '\">' + data.substr(0, 20) + '...</span>' : data;",
+                  "}")
+              )
+            )
+          )
+        ) |>
+          DT::formatDate(date_cols, "toLocaleDateString", params = list('ru-RU'))
+      )
+
+      showModal(modalDialog(
+        DT::dataTableOutput(ns("dt_tasks")),
+        size = "xl",
+        # footer = tagList(
+        #   actionButton("nested_form_dt_save", "сохранить изменения")
+        # ),
+        easyClose = TRUE
+      ))
+
+    })
+
+    ## создание новой задачи -------------
+    observeEvent(input$tasks_create_new_task, {
+      new_task <- get_default_task()
+      
+      values$tasks_data <- rbind(values$tasks_data, new_task)
+      values$tasks_id <- new_task$task_id
+
+      tasks_selector <- values$tasks_data |>
+        dplyr::filter(task_status != "completed") |>
+        dplyr::pull(task_id)
+
+      updateSelectInput(inputId = "tasks_id_selector", choices = tasks_selector, selected = values$tasks_id)
+      removeModal()
+      show_modal_for_tasks()
+    })
+    
+    ## создание новой авто-задачи -------------
+    observeEvent(input$tasks_add_autoreview, {
+      new_task <- get_default_task()
+
+      new_task$task_title       <- "autoreview"
+      new_task$task_description <- "напоминание об актуализации данных"
+      new_task$task_due_date <- Sys.Date() + 28
+      
+      values$tasks_data <- rbind(values$tasks_data, new_task)
+      values$tasks_id <- new_task$task_id
+
+      tasks_selector <- values$tasks_data |>
+        dplyr::filter(task_status != "completed") |>
+        dplyr::pull(task_id)
+
+      updateSelectInput(inputId = "tasks_id_selector", choices = tasks_selector, selected = values$tasks_id)
+      removeModal()
+      show_modal_for_tasks()
+    })
+
+    # review задач ----------------
+    ### все активные задачи ------------
+    observeEvent(input$show_dt_all, {
+
+      con <- db$make_db_connection(scheme(),"display_task_modal")
+      on.exit(db$close_db_connection(con, "display_task_modal"), add = TRUE)
+
+      values$tasks_data <- DBI::dbGetQuery(con, glue::glue("SELECT * FROM tasks WHERE task_status = 'active'")) |>
+        dplyr::mutate(dplyr::across(c("task_datetime_created", "task_datetime_last_updated", "task_datetime_completed"), as.POSIXct)) |>
+        dplyr::mutate(dplyr::across(c("task_due_date"), as.Date))
+
+      display_tasks_dt_review()
+    })
+
+    ### задачи для текущего дня ------------
+    observeEvent(input$show_dt_today, {
+
+      con <- db$make_db_connection(scheme(),"display_task_modal")
+      on.exit(db$close_db_connection(con, "display_task_modal"), add = TRUE)
+
+      values$tasks_data <- DBI::dbGetQuery(con, glue::glue("SELECT * FROM tasks WHERE task_status = 'active' AND task_due_date = {as.integer(Sys.Date())}")) |>
+        dplyr::mutate(dplyr::across(c("task_datetime_created", "task_datetime_last_updated", "task_datetime_completed"), as.POSIXct)) |>
+        dplyr::mutate(dplyr::across(c("task_due_date"), as.Date))
+
+      display_tasks_dt_review()
+    })
+
+    ### просроченные ------------
+    observeEvent(input$show_dt_overdue, {
+
+      con <- db$make_db_connection(scheme(),"display_task_modal")
+      on.exit(db$close_db_connection(con, "display_task_modal"), add = TRUE)
+
+      values$tasks_data <- DBI::dbGetQuery(con, glue::glue("SELECT * FROM tasks WHERE task_status = 'active' AND task_due_date < {as.integer(Sys.Date())}")) |>
+        dplyr::mutate(dplyr::across(c("task_datetime_created", "task_datetime_last_updated", "task_datetime_completed"), as.POSIXct)) |>
+        dplyr::mutate(dplyr::across(c("task_due_date"), as.Date))
+
+      display_tasks_dt_review()
+    })
+
+    ### modal -----
+    display_tasks_dt_review <- function() {
+
+      values$tasks_data <- values$tasks_data |>
+        dplyr::select(task_id:task_datetime_last_updated) |>
+        dplyr::arrange(task_due_date)
+
+      rename_cols <- tasks_colnames[tasks_colnames %in% colnames(values$tasks_data)]
+      
+      date_cols <- c("task_datetime_created", "task_datetime_completed", "task_datetime_last_updated", "task_due_date")
+      date_cols <- which(colnames(values$tasks_data) %in% date_cols)
+
+      output$dt_todays_tasks <- DT::renderDataTable(
+        DT::datatable(
+          values$tasks_data,
+          caption = 'Table 1: This is a simple caption for the table.',
+          rownames = FALSE,
+          colnames = rename_cols,
+          extensions = c("FixedColumns"),
+          # editable = 'cell',
+          class = 'cell-border stripe',
+          selection = "single",
+          options = list(
+            dom = 'tip',
+            scrollX = TRUE,
+            fixedColumns = list(leftColumns = 1),
+            autoWidth = TRUE,
+            columnDefs = list(
+              list(
+                targets = 3:4,
+                width = '200px',
+                render = htmlwidgets::JS(
+                  "function(data, type, row, meta) {",
+                  "return type === 'display' && data.length > 20 ?",
+                  "'<span title=\"' + data + '\">' + data.substr(0, 20) + '...</span>' : data;",
+                  "}")
+              )
+            )
+          )
+        ) |>
+        DT::formatDate(date_cols, "toLocaleDateString", params = list('ru-RU'))
+      )
+
+      showModal(modalDialog(
+        DT::dataTableOutput(ns("dt_todays_tasks")),
+        size = "xl",
+        footer = tagList(
+          actionButton(ns("jump_to_main_key"), "перейти к id", icon("right-to-bracket"))
+        ),
+        easyClose = TRUE
+      ))
+
+    }
+
+    ### jump to main_key ---------
+    observeEvent(input$jump_to_main_key, {
+
+      if (is.null(input$dt_todays_tasks_rows_selected)) {
+        showNotification("необходимо выбрать задачу", type = "error")
+      } else {
+
+        # get key
+        main_key_to_jump <- values$tasks_data[input$dt_todays_tasks_rows_selected,]$task_main_key
+        values$main_key <- main_key_to_jump
+
+        removeModal()
+
+      }
+    })
+
+  })
+}
+
+#' @export
+update_task_button_count <- function(con, values, ns) {
+
+  inputID <- "display_task_modal"
+  if (!missing(ns)) inputID <- ns(inputID)
+  
+  # если ключ не определен - выход из функции
+  if (is.null(values$main_key)) {
+
+    updateActionButton(inputId = inputID, label = "Задачи")
+    return()
+  }
+
+  # при наличии таблицы - полу
+  if ("tasks" %in% DBI::dbListTables(con)) {
+
+    tasks_num <- DBI::dbGetQuery(con, glue::glue("SELECT COUNT ('task_id') FROM tasks WHERE task_main_key = '{values$main_key}' AND task_status = 'active'")) |>
+      dplyr::pull()
+
+    if (tasks_num > 0) {
+      updateActionButton(inputId = inputID, label = paste("активных задач:", tasks_num))
+    } else {
+      updateActionButton(inputId = inputID, label = "Задачи: нет активных")
+    }
+  }
+
+}
+
+tasks_colnames <- c(
+  "id задачи"       = "task_id",
+  "id записи"       = "task_main_key",
+  "статус"          = "task_status",
+  "задача"          = "task_title",
+  "описание"        = "task_description",
+  "срок выполнения" = "task_due_date",
+  "создана"         = "task_user_created",
+  "дата создания"   = "task_datetime_created",
+  "обновлено"       = "task_user_last_updated",
+  "дата обновления" = "task_datetime_last_updated",
+  "завершено"       = "task_user_completed",
+  "дата выполнения" = "task_datetime_completed"
+)

config.yml

@@ -1,13 +0,0 @@
-default:
-  form_app_version: 0.16.0
-  form_id: new_formy
-  form_name: NEW FORMY
-
-prod:
-  form_app_configure_path: "."
-  form_auth_enabled: false
-
-devel:
-  form_app_configure_path: _devel/antifib
-  form_auth_enabled: false
-  form_app_version: 0.16.0 dev

config_example.yml

@@ -0,0 +1,10 @@
+default:
+  form_app_version: !expr config::get("form_app_version", file = "descr.yml")
+  form_id:          !expr config::get("form_id", file = "descr.yml")
+  form_name:        !expr config::get("form_name", file = "descr.yml")
+
+prod:
+  form_app_configure_path: "example_scheme"
+  form_auth_enabled: false
+  form_schemes:
+    example_of_scheme: Тестовая база данных

configs/enabled_schemes.R

@@ -1,4 +0,0 @@
-#' @export
-enabled_schemes <- c(
-  `Тестовая база данных` = "example_of_scheme"
-)

descr.yml

@@ -0,0 +1,4 @@
+default:
+  form_app_version: 0.18.1
+  form_id: formy
+  form_name: FORMY

modules/data_validation.R

@@ -71,6 +71,7 @@ val_is_a_number = function(x) {
 
   # exit if empty
   if (is_this_empty_value(x)) return(NULL)
+
   # хак для пропуска значений
   if (x == "NA") return(NULL)
 

modules/db.R

@@ -10,6 +10,7 @@ make_db_connection = function(scheme, where = "") {
     scheme, 
     ext = "sqlite"
   ))
+
 }
 
 #' @export
@@ -46,14 +47,13 @@ check_if_table_is_exist_and_init_if_not = function(
 
       if (table_name %in% DBI::dbListTables(con)) {
 
-        cli::cli_inform(c("*" = "проверка таблицы в базе данных: '{table_name}'"))
-
         # если таблица существует, производим проверку структуры таблицы
         compare_existing_table_with_schema(
           table_name = table_name,
           schm = schm
         )
 
+      # инициализируем все таблицы
       } else {
 
         if (table_name == "main") {
@@ -63,6 +63,7 @@ check_if_table_is_exist_and_init_if_not = function(
               .before = 1
             )
         }
+
         if (table_name != "main") {
           dummy_df <- get_dummy_df(forms_id_type_list) |>
             dplyr::mutate(
@@ -121,6 +122,8 @@ compare_existing_table_with_schema = function(
   con = rlang::env_get(rlang::caller_env(), nm = "con")
 ) {
 
+  cli::cli_progress_step("проверка таблицы в базе данных: '{table_name}'")
+
   main_key  <- schm$get_main_key_id
   key_id    <- schm$get_key_id(table_name)
   forms_ids <- schm$get_forms_ids(table_name)
@@ -198,7 +201,8 @@ write_df_to_db = function(
 
   date_columns   <- subset(scheme, form_type == "date", form_id, drop = TRUE)
   number_columns <- subset(scheme, form_type == "number", form_id, drop = TRUE)
-  other_cols     <- which(colnames(df) %in% c(date_columns, number_columns))
+  # other_cols     <- which(colnames(df) %in% c(date_columns, number_columns))
+  other_cols     <- colnames(df)[!(colnames(df) %in% c(date_columns, number_columns))]
 
   df <- df |>
     dplyr::mutate(
@@ -206,7 +210,7 @@ write_df_to_db = function(
       dplyr::across(tidyselect::all_of({{date_columns}}), \(x) purrr::map_chr(x, excel_to_db_dates_converter)),
       # числа - к единому формату десятичных значений
       dplyr::across(tidyselect::all_of({{number_columns}}), ~ gsub("\\.", "," , .x)),
-      dplyr::across(tidyselect::all_of({{other_cols}}), as.character),
+      dplyr::across(tidyselect::all_of({{other_cols}}), \(x) dplyr::if_else(x == "", as.character(NA), as.character(x)))
     )
 
   if (table_name == "main") {
@@ -392,8 +396,8 @@ local_db_backup <- function(
         file.remove(utils::tail(existed_files, length(existed_files) - backups_limit))
       }
 
-      # если количество существующих бэкапов равно имеющемуся и пора делать бэкап - делаем бэкап, удаляем послендий файл
-      if (dates[1] + schedule_days == Sys.Date()) {
+      # если количество существующих бэкапов равно имеющемуся и пора делать бэкап - делаем бэкап
+      if (dates[1] + schedule_days <= Sys.Date()) {
 
         file.copy(db_full_path, todays_backup)
         cli::cli_alert_success("создан {schedule_name}-бэкап для '{db_name}'")
@@ -403,3 +407,59 @@ local_db_backup <- function(
   )
 }
 
+#' @export
+db_clean_orphans = function(schm, con) {
+
+  main_key      <- schm$get_main_key_id
+  nested_tables <- schm$nested_tables_names
+
+  all_main_keys <- DBI::dbGetQuery(con, glue::glue("SELECT DISTINCT {main_key} FROM main"))
+  all_main_keys <- dplyr::pull(all_main_keys)
+
+  purrr::walk(
+    .x = nested_tables,
+    .f = \(table_name) clear_orphans(table_name = table_name, main_key = main_key, all_main_keys = all_main_keys, con = con)
+  )
+
+  clear_orphans(table_name = "tasks", main_key = "task_main_key", all_main_keys = all_main_keys, con = con, drop_na_keys = FALSE)
+  clear_orphans(table_name = "log", main_key = "key", all_main_keys = all_main_keys, con = con, drop_na_keys = FALSE)
+
+}
+
+clear_orphans <- function(
+  table_name,
+  main_key,
+  all_main_keys,
+  con,
+  drop_na_keys = TRUE
+) {
+
+  if (!table_name %in% DBI::dbListTables(con)) return(invisible())
+
+  all_main_keys_from_nested <- DBI::dbGetQuery(con, glue::glue("SELECT DISTINCT {main_key} FROM {table_name}"))
+  all_main_keys_from_nested <- dplyr::pull(all_main_keys_from_nested)
+
+  if (!drop_na_keys) {
+    all_main_keys_from_nested <- all_main_keys_from_nested[!is.na(all_main_keys_from_nested)]
+  }
+
+  if (all(all_main_keys_from_nested %in% all_main_keys)) {
+    cli::cli_alert_success("Все ключи в таблице '{table_name}' соответствуют действующим")
+  } else {
+
+    orphaned_keys <- all_main_keys_from_nested[!all_main_keys_from_nested %in% all_main_keys]
+    cli::cli_alert_warning(c("В таблице '{table_name}' найдены орфанные записи для следующих ID: ", paste("\n  -", orphaned_keys)))
+    
+    orphaned_keys <- paste0("'", orphaned_keys, "'", collapse = ", ")
+    del_query <- glue::glue("DELETE FROM {table_name} WHERE {main_key} IN ({orphaned_keys})")
+    deleted <- DBI::dbExecute(con, del_query)
+
+    if (drop_na_keys) {
+      deleted <- deleted + DBI::dbExecute(con, glue::glue("DELETE FROM {table_name} WHERE {main_key} IS NULL"))
+    }
+
+    cli::cli_alert_success("Из таблицы '{table_name}' было удалено {deleted} орфанных записей")
+
+  }
+
+}

modules/global_options.R

@@ -10,15 +10,19 @@ set_global_options = function(
   
   config_params_to_check <- c(
     "form_app_version",
+    "form_id",
+    "form_name",
     "form_app_configure_path",
     "form_auth_enabled",
-    "form_id",
-    "form_name"
+    "form_schemes"
   )
   
   expected_params_in_config <- config_params_to_check %in% names(config::get())
   if (!all(expected_params_in_config)) {
-    cli::cli_abort(c("ну так не пойдет:", paste("-", config_params_to_check[!expected_params_in_config])))
+    cli::cli_abort(c(
+      "Необходимо добавить в файл конфига  {.file config.yml} следующие параметры:", 
+      paste0(config_params_to_check[!expected_params_in_config], ":")
+    ))
   }
 
   options(
@@ -43,18 +47,20 @@ check_and_init_scheme = function() {
   options(box.path = here::here())
   box::use(modules/db[local_db_backup])
 
-  options(box.path = config::get("form_app_configure_path"))
-  box::use(configs/enabled_schemes[enabled_schemes])
-
   # список файлов, изменение которых, приведут к переинициализиации схемы
   files_to_watch <- c(
-    fs::path(config::get("form_app_configure_path"), "configs", "enabled_schemes.R"),
+    "config.yml",
     "modules/scheme_generator.R",
     "modules/utils.R"
   )
 
-  scheme_names <- enabled_schemes
-  scheme_file <- paste0(config::get("form_app_configure_path"), "/configs/schemas/", scheme_names, ".xlsx")
+  # проверка существования отслеживаемых файлов
+  if (!all(file.exists(files_to_watch))) {
+    cli::cli_abort("проверка схем: {files_to_watch[!file.exists(files_to_watch)]} is not exists")
+  }
+
+  scheme_names <- names(config::get()$form_schemes)
+  scheme_file  <- paste0(config::get("form_app_configure_path"), "/schemas/", scheme_names, ".xlsx")
   scheme_file  <- stats::setNames(scheme_file, scheme_names)
 
   if (!all(file.exists(scheme_file))) {
@@ -113,6 +119,7 @@ init_scheme = function(scheme_file) {
   if (!dir.exists(db_path)) dir.create(db_path)
 
   cli::cli_h1("Инициализация схемы")
+
   schms <- purrr::map2(
     .x = scheme_file,
     .y = names(scheme_file),
@@ -121,8 +128,15 @@ init_scheme = function(scheme_file) {
       con <- db$make_db_connection(y)
       on.exit(db$close_db_connection(con), add = TRUE)
 
+      # новый объект
       schm <- scheme_R6$new(x)
+
+      # проверка схемы с существующей базой данных и инициализация таблиц
       db$check_if_table_is_exist_and_init_if_not(schm, con)
+
+      # удаление орфанных записей
+
+      db$db_clean_orphans(schm = schm, con = con)
       schm
     }
   )
@@ -132,13 +146,13 @@ init_scheme = function(scheme_file) {
     names(schms),
     \(x) schms[[x]]$nested_tables_names
   )
+
   nested_tables_ids <- unlist(nested_tables_ids)
   tab <- table(nested_tables_ids)
 
   # если встречается хоть одно значение несколько раз - начать истошно кричать (могут возникнуть пробемы при вызове всплывающих окон в формах)
   if (!all(!tab > 1)) {
     cli::cli_abort(c("В одной или нескольких схемах наименования вложенных форм совпадают:", paste("-", names(tab)[tab > 1])))
-    
   }
   
   saveRDS(schms, "scheme.rds")

modules/scheme_generator.R

@@ -48,8 +48,8 @@ scheme_R6 <- R6::R6Class(
         "task_status",        "select_one",  "Статус задачи",          NA,                 "completed",
         "task_status",        "select_one",  "Статус задачи",          NA,                 "deleted",
         "task_title",         "text",        "Название задачи",        NA,                 NA,
-        "task_description",   "text",        "Описание задачи",        "краткое описание", NA,
-        "task_due_date",      "date",        "Дата выполнения задачи", "YE DJN",           NA,
+        "task_description",   "text",        "Описание задачи",        "краткое описание", "3",
+        "task_due_date",      "date",        "Дата выполнения задачи", NA,                 NA,
       ) |>
         dplyr::mutate(condition = NA)
 

modules/utils.R

@@ -135,7 +135,8 @@ render_forms = function(
     form <- shiny::textAreaInput(
       inputId = form_id,
       label = label,
-      rows = 1
+      rows = 1,
+      resize = "none"
     )
   }
 

utils/init_login_db.r

@@ -3,10 +3,11 @@
 # SETUP AUTH =============================
 # Init DB using credentials data
 credentials <- data.frame(
-  user     = c("admin", "user"),
-  password = c("admin", "user"),
+  user     = c("admin", "user", "user2"),
+  password = c("admin", "user", "user2"),
   # password will automatically be hashed
-  admin = c(TRUE, FALSE),
+  admin = c(TRUE, FALSE, FALSE),
+  scheme_access = c(NA, "all", "example_of_scheme"), # NA - none | all - all | string with seperate
   stringsAsFactors = FALSE
 )