pfad geändert

Merge branch 'main' of https://git.oswaldonline.de/cosw/gemfin-shiny

# Conflicts:
#	db/data_transfer.R
#	db/development.sqlite
#	www/documents/1028.jpg
#	www/documents/1069.PDF

db/data_transfer.R

@@ -3,12 +3,11 @@
 ## Keeps Hibiscus payload fields unchanged
 ##
 
-library("tidyverse")
-library("dbx")
-library("tools")
-library("RJDBC")
-library("DBI")
-library("RSQLite")
+library(tidyverse)
+library(dbx)
+library(RJDBC)
+library(DBI)
+library(RSQLite)
 
 source("~/R/rfunc/fehler_add.R")
 
@@ -27,30 +26,14 @@ fm_driver_jar   <- "~/R/fmjdbc.jar"
 
 sqlite_path <- "db/development.sqlite"
 
-# optional future switch
-USE_CENTS <- FALSE
 
 # Helpers ----
-
-to_cents <- function(x) {
-  if (is.null(x)) return(NA_integer_)
-  if (is.factor(x)) x <- as.character(x)
-  
-  if (is.character(x)) {
-    x <- trimws(x)
-    x[x == ""] <- NA
-    x <- gsub("\\.", "", x)
-    x <- gsub(",", ".", x)
-  }
-  
-  d <- suppressWarnings(as.numeric(x))
-  ifelse(is.na(d), NA_integer_, as.integer(round(d * 100)))
+exec_sql <- function(sql) dbExecute(con_s, sql)
+f_anzahl <- function(tabelle){
+dbxSelect(con_s, paste0("SELECt count(id) FROM ", tabelle)) %>% pull
 } 
 
-exec_sql <- function(sql) dbExecute(con_s, sql)
-
 # Connections ----
-
 if (ok) {
   drv <- JDBC(fm_driver_class, fm_driver_jar)
   con_f <- dbConnect(
@@ -70,55 +53,87 @@ if (ok) {
   error_f <- fehler_add("SQLite connection established", TRUE, error_f)
 }
 
-# Schema creation ----
-
-## * Accounts ----
-if(ok){
-  exec_sql("CREATE TABLE accounts (
+## * Transfer Accounts ----
+if (ok) {
+  exec_sql("DROP TABLE IF EXISTS konten;")
+  exec_sql("CREATE TABLE konten (
     id INTEGER PRIMARY KEY,
-    account_name TEXT NOT NULL,
+    kontoname TEXT NOT NULL,
     bank_name TEXT,
-    hibiscus_account_id INTEGER,
+    hibiscus_konto_id INTEGER,
     budget_id INTEGER,
-    wiso_account TEXT,
-    bank_account_no TEXT,
-    is_donations INTEGER,
-    notes TEXT,
+    wiso_kategorie TEXT,
+    bank_konto_nr TEXT,
+    ist_spende INTEGER,
+    notiz TEXT,
     created_at TEXT,
     updated_at TEXT
   );")
-  accounts <- dbxSelect(con_f, "
+  
+  konten <- dbxSelect(con_f, "
     SELECT id, konto, budget_id, bankname, updated_at, created_at,
            konto_hibiscus, konto_wiso, kontonummer_bank, notizen, ist_spende
     FROM Konten
   ") %>%
     transmute(
       id = as.integer(id),
-      account_name = konto,
+      kontoname = konto,
       bank_name = bankname,
-      hibiscus_account_id = as.integer(konto_hibiscus),
+      hibiscus_konto_id = as.integer(konto_hibiscus),
       budget_id = as.integer(budget_id),
-      wiso_account = konto_wiso,
-      bank_account_no = kontonummer_bank,
-      is_donations = as.integer(ist_spende),
-      notes = notizen,
+      wiso_kategorie = konto_wiso,
+      bank_konto_nr = kontonummer_bank,
+      ist_spende = as.integer(ist_spende),
+      notiz = notizen,
       created_at = created_at,
       updated_at = updated_at
     )
-  dbWriteTable(con_s, "accounts", accounts, append = TRUE)
-  ok <- "accounts"  %in% dbListTables(con_s)
-  error_f <- fehler_add("Die Accounts Tabelle wurde erstellt", ok, error_f)
-} ## -------------------------------------------------------  2026-05-12 16:54 
+  dbWriteTable(con_s, "konten", konten, append = TRUE)
+  ok <- dbExistsTable(con_s, "konten")
+  ok <- f_anzahl("konten") == nrow(konten) & ok
+  error_f <- fehler_add("Konten übertragen", TRUE, error_f)
+}
 
+## * Transfer Projekte ----
+if (ok) {
+  exec_sql("DROP TABLE IF EXISTS projekte;")
+  exec_sql("CREATE TABLE projekte (
+    id INTEGER PRIMARY KEY,
+    projektname TEXT NOT NULL,
+    jahr INTEGER,
+    projekt_wiso TEXT,
+    bereich TEXT,
+    notiz TEXT,
+    created_at TEXT,
+    updated_at TEXT
+  );")
+  projekte <- dbxSelect(con_f, "
+    SELECT id, projektname, bereich, notiz, jahr, created_at, updated_at from Projekte") %>%
+    transmute(
+      id = as.integer(id),
+      projektname = projektname,
+      bereich = bereich,
+      notiz = notiz,
+      jahr = as.integer(jahr),
+      created_at = created_at,
+      updated_at = updated_at
+    )
   
-## * Budgets Tabelle ----
-if(ok){
+  dbWriteTable(con_s, "projekte", projekte, append = TRUE)
+  ok <- dbExistsTable(con_s, "projekte")
+  ok <- f_anzahl("projekte") == nrow(projekte) & ok
+  error_f <- fehler_add("Projekte übertragen", TRUE, error_f)
+}
+
+## * Transfer Budgets ----
+if (ok) {
+  exec_sql("DROP TABLE IF EXISTS budgets;")
   exec_sql("CREATE TABLE budgets (
     id INTEGER PRIMARY KEY,
-    row_no INTEGER,
-    area TEXT,
-    label TEXT,
-    direction TEXT,
+    reihe INTEGER,
+    bereich TEXT,
+    bezeichnung TEXT,
+    richtung TEXT,
     created_at TEXT,
     updated_at TEXT
   );")
@@ -128,209 +143,305 @@ if(ok){
   ") %>%
     transmute(
       id = as.integer(id),
-      row_no = as.integer(reihe),
-      area = bereich,
-      label = bezeichnung,
-      direction = richtung,
+      reihe = as.integer(reihe),
+      bereich = bereich,
+      bezeichnung = bezeichnung,
+      richtung = richtung,
       created_at = format(Sys.time(), ""),
       updated_at = format(Sys.time(), "")
     )
   dbWriteTable(con_s, "budgets", budgets, append = TRUE)
-  ok <- "budgets"  %in% dbListTables(con_s)
-  error_f <- fehler_add("Die Budgets Tabelle wurde erstellt", ok, error_f)
-} ## -------------------------------------------------------  2026-05-12 16:57 
+  ok <- dbExistsTable(con_s, "budgets")
+  ok <- f_anzahl("budgets") == nrow(budgets) & ok
+  error_f <- fehler_add("Budgets übertragen", TRUE, error_f)
+}
 
-## * Contacts Tabelle ----
-if(ok){
-  exec_sql("CREATE TABLE contacts (
+### ** Transfer Budget-Werte
+  if(ok){
+    exec_sql("DROP TABLE IF EXISTS budget_werte;")
+    exec_sql("CREATE TABLE budget_werte (
     id INTEGER PRIMARY KEY,
-    first_name TEXT,
-    last_name TEXT,
-    street TEXT,
-    postal_code TEXT,
-    city TEXT,
-    country TEXT,
-    phone TEXT,
-    mobile TEXT,
-    email TEXT,
-    salutation TEXT,
-    gender TEXT,
-    donor TEXT,
-    member INTEGER,
-    notes TEXT,
-    receipt_salutation TEXT,
-    receipt_name TEXT,
-    display_name TEXT,
-    partner_id INTEGER,
-    is_couple INTEGER,
-    is_company INTEGER,
+    budget_id   INTEGER,
+    jahr INTEGER,
+    betrag DECIMAL,
+    budget_listen_nr INTEGER,
     created_at TEXT,
     updated_at TEXT
   );")
-  contacts <- dbxSelect(con_f, "
+    budget_werte <- dbReadTable(con_f, "Budgets_werte") %>%
+      transmute(
+        id = as.integer(id),
+        budget_id = as.integer(budget_id),
+        jahr = as.integer(jahr),
+        betrag = betrag,
+        budget_listen_nr = as.integer(budget_listen_nr),
+        created_at = format(Sys.time(), ""),
+        updated_at = format(Sys.time(), "")
+      )
+    dbWriteTable(con_s, "budget_werte", budget_werte, append = TRUE)
+  ok <- dbExistsTable(con_s, "budget_werte") 
+  ok <- f_anzahl("budget_werte") == nrow(budget_werte) & ok
+  error_f <- fehler_add("budget_werte übertragen", TRUE, error_f)
+} ## -------------------------------------------------------  2026-06-19 08:52 
+
+
+## * Transfer Adressen ----
+if (ok) {
+  exec_sql("DROP TABLE IF EXISTS adressen;")
+  exec_sql("CREATE TABLE adressen (
+    id INTEGER PRIMARY KEY,
+    vorname TEXT,
+    nachname TEXT,
+    strasse TEXT,
+    plz TEXT,
+    ort TEXT,
+    land TEXT,
+    telefon TEXT,
+    mobil TEXT,
+    email TEXT,
+    anrede TEXT,
+    geschlecht TEXT,
+    ist_mitglied INTEGER,
+    ist_firma INTEGER,
+    quittung_anrede TEXT,
+    quittung_name TEXT,
+    display_name TEXT,
+    partner_id INTEGER,
+    notiz TEXT,
+    created_at TEXT,
+    updated_at TEXT
+  );")
+  
+  adressen <- dbxSelect(con_f, "
     SELECT id, vorname, nachname, strasse, plz, ort, Land,
-           telefon, mobil, email, anrede, geschlecht, spender, mitglied, notiz,
+           telefon, mobil, email, anrede, geschlecht,  mitglied, notiz,
            quittung_anrede, quittung_name, bezeichnung, partner_id, b_paar, b_firma
     FROM Adressen
   ") %>%
     as_tibble() %>%
     transmute(
       id = as.integer(id),
-      first_name = vorname,
-      last_name = nachname,
-      street = strasse,
-      postal_code = plz,
-      city = ort,
-      country = Land,
-      phone = telefon,
-      mobile = mobil,
+      vorname = vorname,
+      nachname = nachname,
+      strasse = strasse,
+      plz = plz,
+      ort = ort,
+      land = Land,
+      telefon = telefon,
+      mobil = mobil,
       email = email,
-      salutation = anrede,
-      gender = geschlecht,
-      donor = spender,
-      member = as.integer(mitglied),
-      notes = notiz,
-      receipt_salutation = quittung_anrede,
-      receipt_name = quittung_name,
+      anrede = anrede,
+      geschlecht = geschlecht,
+      ist_mitglied = as.integer(mitglied),
+      ist_firma = as.integer(b_firma),
+      quittung_anrede = quittung_anrede,
+      quittung_name = quittung_name,
       display_name = bezeichnung,
       partner_id = as.integer(partner_id),
-      is_couple = as.integer(b_paar),
-      is_company = as.integer(b_firma),
+      notiz = notiz,
       created_at = format(Sys.time(), ""),
       updated_at = format(Sys.time(), "")
     )
+  dbWriteTable(con_s, "adressen", adressen, append = TRUE)
+  ok <- dbExistsTable(con_s, "adressen") 
+  ok <- f_anzahl("adressen") == nrow(adressen) & ok
+  error_f <- fehler_add("adressen übertragen", TRUE, error_f)
+}
 
-  dbWriteTable(con_s, "contacts", contacts, append = TRUE)
-  ok <- "contacts"  %in% dbListTables(con_s)
-  error_f <- fehler_add("Die contacts Tabelle wurde erstellt", ok, error_f)
-} ## -------------------------------------------------------  2026-05-12 16:58 
+## * Transfer Transaktionen ----
 
-## * Bankverbindungen ----
-if(ok){
-  exec_sql("CREATE TABLE bank_connections (
+if (ok) {
+  exec_sql("DROP TABLE IF EXISTS transaktionen;")
+  exec_sql("CREATE TABLE transaktionen (
     id INTEGER PRIMARY KEY,
-    contact_id INTEGER,
-    contact_text TEXT,
-    iban TEXT,
-    bic TEXT,
-    bank_name TEXT,
-    remote_name TEXT,
+    adress_id INTEGER,
+    vwz TEXT,
+    notiz TEXT,
+    bank_kontakt TEXT,
     created_at TEXT,
     updated_at TEXT
   );")
-  bank_connections <- dbxSelect(con_f, "
-    SELECT id, adress_id, kontakt, iban, bic, kreditinstitut, 
-           remote_name, created_at, updated_at
-    FROM Bankverbindungen
-  ") %>%
-    transmute(
-      id          = as.integer(id),
-      contact_id  = as.integer(adress_id),
-      contact_text = kontakt,
-      iban        = iban,
-      bic         = bic,
-      bank_name   = kreditinstitut,
-      remote_name = remote_name,
-      created_at  = as.character(created_at),
-      updated_at  = as.character(updated_at)
-    )
-  sum(duplicated(bank_connections$id))
-  dbWriteTable(con_s, "bank_connections", bank_connections, append = TRUE)
-  ok <- "bank_connections"  %in% dbListTables(con_s)
-  error_f <- fehler_add(
-    paste(nrow(bank_connections), "Bankverbindungen übertragen"), TRUE, error_f
-  )
-} ## -------------------------------------------------------  2026-05-12 17:00 
   
-
-## * Entries Tabelle ----
-if(ok){
-  exec_sql("CREATE TABLE entries (
-    id INTEGER PRIMARY KEY,
-    contact_id INTEGER,
-    purpose TEXT,
-    note TEXT,
-    remote_name TEXT,
-    created_at TEXT,
-    updated_at TEXT
-  );")
-  entries <- dbxSelect(con_f, "
+  transaktionen <- dbxSelect(con_f, "
     SELECT id, adress_id, verwendungszweck, notiz, kontakt, created_at, updated_at
     FROM trans
   ") %>%
     as_tibble() %>%
     transmute(
       id = as.integer(id),
-      contact_id = as.integer(adress_id),
-      purpose = verwendungszweck,
-      note = notiz,
-      remote_name = kontakt,
+      adress_id = as.integer(adress_id),
+      vwz = verwendungszweck,
+      notiz = notiz,
+      bank_kontakt = kontakt,
       created_at = created_at,
       updated_at = updated_at
     )
-  dbWriteTable(con_s, "entries", entries, append = TRUE)
-  ok <- "entries"  %in% dbListTables(con_s)
-  error_f <- fehler_add("Die entries Tabelle wurde erstellt", ok, error_f)
-} ## -------------------------------------------------------  2026-05-12 17:02 
   
+  dbWriteTable(con_s, "transaktionen", transaktionen, append = TRUE)
+  ok <- dbExistsTable(con_s, "transaktionen") 
+  ok <- f_anzahl("transaktionen") == nrow(transaktionen) & ok
+  error_f <- fehler_add("transaktionen übertragen", TRUE, error_f)
+}
 
-## * Postings Tabelle  ----
-if(ok){
-  exec_sql("CREATE TABLE postings (
+## * Transfer Postings ----
+
+if (ok) {
+  exec_sql("DROP TABLE IF EXISTS buchungen;")
+  exec_sql("CREATE TABLE buchungen (
       id INTEGER PRIMARY KEY,
-      entry_id INTEGER NOT NULL,
-      account_id INTEGER NOT NULL,
+      trans_id INTEGER NOT NULL,
+      konto_id INTEGER NOT NULL,
       valuta TEXT NOT NULL,
-      booking_date TEXT,
-      amount NUMERIC NOT NULL,
-      invoice_no TEXT,
-      note TEXT,
+      buchungsdatum TEXT,
+      betrag DECIMAL,
+      rechnungsnummer TEXT,
+      notiz TEXT,
       status TEXT,
-      waived INTEGER,
-      bank_transaction_id INTEGER,
+      ist_verzicht INTEGER,
+      umsatz_id INTEGER,
       wiso_id INTEGER,
-      receipt_id INTEGER,
-      project_id INTEGER,
-      coin_share_amount NUMERIC,
+      quittung_id INTEGER,
+      projekt_id INTEGER,
+      betrag_muenzen DECIMAL,
       created_at TEXT,
       updated_at TEXT
     );")
-  postings <- dbxSelect(con_f, "
+  buchungen <- dbxSelect(con_f, "
     SELECT id, trans_id, konto_id, wertstellung, buchungsdatum, betrag,
            rechnungsnummer, notiz, status, b_verzicht, umsatz_id, wiso_id,
            quittung_id, projekt_id, betrag_muenzen, created_at, updated_at
     FROM buchungen
   ") %>%
     as_tibble()
-  postings <- postings %>%
+  buchungen <- buchungen %>%
+      transmute(
+        id = as.integer(id),
+        trans_id = as.integer(trans_id),
+        konto_id = as.integer(konto_id),
+        valuta = as.character(wertstellung),
+        buchungsdatum = as.character(buchungsdatum),
+        betrag = betrag,
+        rechnungsnummer = rechnungsnummer,
+        notiz = notiz,
+        status = status,
+        ist_verzicht = as.integer(b_verzicht),
+        umsatz_id = as.integer(umsatz_id),
+        wiso_id = as.integer(wiso_id),
+        quittung_id = as.integer(quittung_id),
+        projekt_id = as.integer(projekt_id),
+        betrag_muenzen = betrag_muenzen,
+        created_at = created_at,
+        updated_at = updated_at
+      )
+  dbWriteTable(con_s, "buchungen", buchungen, append = TRUE)
+  ok <- dbExistsTable(con_s, "buchungen") 
+  ok <- f_anzahl("buchungen") == nrow(buchungen) & ok
+  error_f <- fehler_add("buchungen übertragen", TRUE, error_f)
+}
+
+## * Transfer Attachments ----
+if(ok){
+  exec_sql("DROP TABLE IF EXISTS attachments;")
+  exec_sql("CREATE TABLE attachments (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  trans_id      INTEGER,
+  quittung_id   INTEGER,
+  adress_id     INTEGER,
+  wiso_id       INTEGER,
+  btisch_id     TEXT,
+  original_name TEXT,
+  kategorie     TEXT,
+  ext          TEXT    NOT NULL,
+  notiz          TEXT,
+  created_at    TEXT    DEFAULT (datetime('now')),
+  updated_at    TEXT    DEFAULT (datetime('now'))
+);")
+  
+  att <- dbxSelect(con_f, "SELECT id, trans_id, quittung_id, wiso_id, btisch_id, 
+    adress_id, ft_dateiname, beschreibung, created_at, updated_at, ft_extension FROM Dokumente") %>%
     transmute(
       id = as.integer(id),
-      entry_id = as.integer(trans_id),
-      account_id = as.integer(konto_id),
-      valuta = as.character(wertstellung),
-      booking_date = as.character(buchungsdatum),
-      amount = betrag,
-      invoice_no = rechnungsnummer,
-      note = notiz,
-      status = status,
-      waived = as.integer(b_verzicht),
-      bank_transaction_id = as.integer(umsatz_id),
+      trans_id = as.integer(trans_id),
+      quittung_id = as.integer(quittung_id),
       wiso_id = as.integer(wiso_id),
-      receipt_id = as.integer(quittung_id),
-      project_id = as.integer(projekt_id),
-      coin_share_amount = betrag_muenzen,
-      created_at = created_at,
-      updated_at = updated_at
+      btisch_id = as.integer(btisch_id),
+      adress_id = as.integer(adress_id),
+      created_at = as.character(created_at),
+      updated_at = as.character(updated_at),
+      original_name = ft_dateiname,
+      ext = paste0(id,".", ft_extension)
     ) 
-  dbWriteTable(con_s, "postings", postings, append = TRUE)
-  ok <- "postings"  %in% dbListTables(con_s)
-  error_f <- fehler_add("Die Postings Tabelle wurde erstellt", ok, error_f)
-} ## -------------------------------------------------------  2026-05-12 17:03 
+  dbWriteTable(con_s, "attachments", att, append = T)
+  ok <- dbExistsTable(con_s, "attachments") 
+  ok <- f_anzahl("attachments") == nrow(att) & ok
+  error_f <- fehler_add("attachments übertragen", TRUE, error_f)
+  
+} ## -------------------------------------------------------  2026-03-19 16:38 
 
 
-## * Umsatz-Tabelle ----
+### ** Dateien übertragen ----
 if(ok){
-  exec_sql("CREATE TABLE hibiscus_transactions (
+  pfad <- "~/Insync/Projekte/Gemeindefinanzen/gemfin-fm/gemfin04/Dokumente/datei/"
+  zielpfad <- "~/Documents/workspace/gemfin-shiny/www/documents/"
+  vorhanden <- list.files(pfad, pattern = "pdf")
+  eintraege <- att$original_name
+  anz <- length(eintraege)
+  for(ind in 1:length(eintraege)){
+    if( exists(paste0(zielpfad, eintraege[ind]))  ){
+      cat(ind, " von ", anz, "\n")
+      file.copy(
+        from = paste0(pfad, vorhanden[ind]), 
+        to = "~/Documents/workspace/gemfin-shiny/www/documents/")
+    }
+  }
+  neue_dateien <- list.files("~/Documents/workspace/gemfin-shiny/www/documents/")
+  length(neue_dateien)
+  eintraege <- att$original_name
+  length(eintraege)
+  nv <- att[-which(eintraege %in% neue_dateien),]
+  error_f <- fehler_add("Alle Dateien übertragen", nrow(nv) == 0, error_f)
+} ## -------------------------------------------------------  2026-04-28 18:40 
+
+
+## * Transfer Bankverbindungen ----
+if (ok) {
+  exec_sql("DROP TABLE IF EXISTS bvb;")
+  exec_sql("CREATE TABLE bvb (
+    id INTEGER PRIMARY KEY,
+    adress_id INTEGER,
+    remote_name TEXT,
+    iban TEXT,
+    bic TEXT,
+    kreditinstitut TEXT,
+    created_at TEXT,
+    updated_at TEXT
+  );")
+  bvb <- dbxSelect(con_f, "
+    SELECT id, adress_id, kontakt, iban, bic, kreditinstitut, 
+           created_at, updated_at
+    FROM Bankverbindungen
+  ") %>%
+    transmute(
+      id          = as.integer(id),
+      adress_id  = as.integer(adress_id),
+      remote_name = kontakt,
+      iban        = iban,
+      bic         = bic,
+      kreditinstitut   = kreditinstitut,
+      created_at  = as.character(created_at),
+      updated_at  = as.character(updated_at)
+    )
+  dbWriteTable(con_s, "bvb", bvb, append = TRUE)
+  ok <- dbExistsTable(con_s, "bvb") 
+  ok <- f_anzahl("bvb") == nrow(bvb) & ok
+  error_f <- fehler_add("bvb übertragen", TRUE, error_f)
+}
+
+
+## * Transfer Hibiscus ----
+  if(ok){
+    exec_sql("DROP TABLE IF EXISTS umsatz;")
+    exec_sql("CREATE TABLE umsatz (
     id INTEGER PRIMARY KEY,
     konto_id INTEGER,
     empfaenger_konto TEXT,
@@ -343,151 +454,43 @@ if(ok){
     datum TEXT,
     valuta TEXT,
     saldo REAL,
-    primanota INTEGER,
-    art TEXT,
     customerref TEXT,
     kommentar TEXT,
-    endtoendid TEXT,
-    mandateid TEXT,
-    empfaenger_name2 TEXT
+    endtoendid TEXT
   );")
-  daten_hibiscus <- sync_hibiscus() %>%
-    transmute(
-      id = as.integer(ID),
-      konto_id = as.integer(KONTO_ID),
-      empfaenger_konto = EMPFAENGER_KONTO,
-      empfaenger_blz = EMPFAENGER_BLZ,
-      empfaenger_name = EMPFAENGER_NAME,
-      betrag = as.numeric(BETRAG),
-      zweck =ZWECK,
-      zweck2 =ZWECK2,
-      zweck3 =ZWECK3,
-      datum =as.character(DATUM),
-      valuta = as.character(VALUTA),
-      saldo = SALDO,
-      primanota = PRIMANOTA,
-      art =ART,
-      customerref =CUSTOMERREF,
-      kommentar = KOMMENTAR,
-      endtoendid = ENDTOENDID,
-      mandateid = MANDATEID,
-      empfaenger_name2 =EMPFAENGER_NAME2
-    )
-  dbWriteTable(con_s, "hibiscus_transactions", daten_hibiscus, append = T)
-  anz <- dbxSelect(con_s, "select count(id) FROM hibiscus_transactions") %>% pull
-  ok <-   nrow(daten_hibiscus) == anz
-  error_f <- fehler_add("Die Tabelle der Umsätze (Hibiscus) wurde erstellt", ok, error_f)
-} ## -------------------------------------------------------  2026-05-12 17:05 
-
-## * Attachments Tabelle ----
-if(ok){
-  exec_sql("CREATE TABLE attachments (
-  id            INTEGER PRIMARY KEY AUTOINCREMENT,
-  entry_id      INTEGER,
-  quittung_id   INTEGER,
-  adress_id     INTEGER,
-  wiso_id       INTEGER,
-  btisch_id     TEXT,
-  original_name TEXT,
-  kategorie     TEXT,
-  path          TEXT    NOT NULL,
-  note          TEXT,
-  created_at    TEXT    DEFAULT (datetime('now')),
-  updated_at    TEXT    DEFAULT (datetime('now'))
-);")
-  att <- dbxSelect(con_f, "SELECT id, trans_id, quittung_id, wiso_id, btisch_id, 
-    adress_id, ft_dateiname, beschreibung, created_at, updated_at, ft_extension FROM Dokumente") %>%
-    mutate(
-      id = as.integer(id),
-      trans_id = as.integer(trans_id),
-      quittung_id = as.integer(quittung_id),
-      wiso_id = as.integer(wiso_id),
-      btisch_id = as.integer(btisch_id),
-      adress_id = as.integer(adress_id),
-      created_at = as.character(created_at),
-      updated_at = as.character(updated_at),
-      path = paste0(id,".", ft_extension)
-    ) %>%
-    rename(
-      entry_id = trans_id,
-      note = beschreibung, 
-      original_name = ft_dateiname
-    ) %>%
-    select(-ft_extension)
-  dbWriteTable(con_s, "attachments", att, append = T)
-  ok <- "attachments"  %in% dbListTables(con_s)
-  error_f <- fehler_add("Die Attachments Tabelle wurder erstellt", ok, error_f)
-} ## -------------------------------------------------------  2026-05-12 17:07 
-
-
-## * Projekt - Tabelle  ----
-if(ok){
-  exec_sql("CREATE TABLE projects (
-  id            INTEGER PRIMARY KEY AUTOINCREMENT,
-  projektname   TEXT,
-  bereich       TEXT,
-  notiz         TEXT,
-  jahr          INTEGER,
-  created_at    TEXT    DEFAULT (datetime('now')),
-  updated_at    TEXT    DEFAULT (datetime('now'))
-);")
-  projects <- dbxSelect(con_f, "
-    SELECT id, projektname, bereich, notiz, jahr, created_at, updated_at from Projekte") %>%
-    transmute(
-      id = as.integer(id),
-      projektname = projektname,
-      bereich = bereich,
-      notiz = notiz,
-      jahr = as.integer(jahr),
-      created_at = created_at,
-      updated_at = updated_at
-    )
-  dbWriteTable(con_s, "projects", projects, append = TRUE)
-  ok <- "projects"  %in% dbListTables(con_s)
-  error_f <- fehler_add("Die Projekte - Tabelle wurde erstellt", ok, error_f)
-} ## -------------------------------------------------------  2026-05-12 17:08 
-
-
-
-## * Dateien übertragen ----
-if(ok){
-  pfad <- "~/Documents/workspace/gemfin-fm/gemfin04/Dokumente/datei/"
-  zielpfad <- "~/Documents/workspace/gemfin-shiny/www/documents/"
-  vorhanden <- list.files(pfad, pattern = "pdf")
-  eintraege <- att %>%
-    filter(!is.na(original_name)) %>%
-    mutate(
-      ext = file_ext(original_name),
-      zielname = paste0(zielpfad, id, ".", ext)
-    )
-  anz <- nrow(eintraege)
-  for(ind in 1:nrow(eintraege)){
-    herkunft <- paste0(pfad, eintraege$original_name[ind])
-    zielname <- eintraege$zielname[ind]
-    
-    if( file.exists(herkunft)  ){
-      # cat(ind, " von ", anz, "\n")
-      file.copy(
-        from = herkunft, 
-        to = zielname,
-        overwrite = F)
-    }
-  }
-  # Check
-  neue_dateien <- list.files("~/Documents/workspace/gemfin-shiny/www/documents/")
-  length(neue_dateien)
-  length(eintraege)
-  nv <- att[-which(eintraege %in% neue_dateien),]
-  error_f <- fehler_add("Alle Dateien übertragen", nrow(nv) == 0, error_f)
-} ## -------------------------------------------------------  2026-04-28 18:40 
-
-
+    umsatz <- dbReadTable(con_f, "Umsatz") %>%
+      transmute(
+        id = as.integer(id),
+        konto_id = as.integer(konto_id),
+        empfaenger_konto = empfaenger_konto,
+        empfaenger_blz = empfaenger_blz,
+        empfaenger_name = empfaenger_name,
+        betrag = betrag,
+        zweck = zweck,
+        zweck2 = zweck2,
+        zweck3 = zweck2,
+        datum = datum,
+        valuta = valuta,
+        saldo =  saldo,
+        kommentar = kommentar,
+        endtoendid = endtoendid
+        )
+    dbWriteTable(con_s, "umsatz", umsatz, append = TRUE) 
+    ok <- sum(duplicated(umsatz$id)) == 0
+    ok <- dbExistsTable(con_s, "umsatz") & ok
+    ok <- f_anzahl("umsatz") == nrow(umsatz) & ok
+  error_f <- fehler_add("Tabelle Umsatz existiert", ok, error_f)
+} ## -------------------------------------------------------  2026-06-19 08:34 
 
 
 # Close ----
 
+dbListTables(con_s)
 dbDisconnect(con_s)
 dbDisconnect(con_f)
 
 print("Migration finished.")
 
+
+
+