commit a19651c02902a5a949ed44671eaf7ee584d6a333 Author: Marius Mutu Date: Wed Jun 24 11:19:07 2026 +0300 Documentatie date facturare pentru modernizare RoRIS Specificatie minima cu datele de care depinde facturarea ROA, pentru caietul de sarcini al modernizarii RoRIS. Include: - DOCUMENTATIE_DATE_FACTURARE_RORIS.md/.docx (livrabil) - dictionar_date_facturare.csv (anexa tehnica) - PACK_ACN_IMPORT.pck (sursa analizata) - CLAUDE.md (context) Co-Authored-By: Claude Opus 4.8 (1M context) diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e84feee --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +# fișiere temporare generate la conversia MD -> DOCX +_md2docx.ps1 +_doc_tmp.html +_doc_new.docx + +# fișiere temporare Word +~$*.docx diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..675136f --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,84 @@ +# CLAUDE.md + +Context pentru asistarea pe acest folder. Citește înainte de a relua lucrul. + +## Ce este acest folder + +Folder de lucru pentru o **documentație de modernizare RoRIS** cerută de ACN. Autorul/clientul +este **Marius Mutu (ROMFAST SRL)** — firma care a dezvoltat ERP-ul de facturare **ROA** +(aplicația `ROAACNPRO`). ACN a depus cerere de finanțare pentru modernizarea sistemului **RoRIS** +și are nevoie de o specificație cu datele de care depinde facturarea, ca să o impună în caietul de +sarcini către firma care va face modernizarea. + +## Arhitectura sistemelor (de reținut) + +- **RoRIS** = sistemul sursă (date operaționale tranzit barje/nave, ecluzări, acostări). + Bază de date **SQL Server**. +- **ROA** (`ROAACNPRO`, dezvoltat de ROMFAST) = ERP-ul de facturare. Bază de date **Oracle**, + aplicație Visual FoxPro 9. +- ROA (Oracle) preia datele din RoRIS (SQL Server) printr-un **database link** (gateway heterogen + Oracle → SQL Server, `RORISSQL`). Importul e o copiere (`merge`) în tabele Oracle `ips_*`. + **Nu există API/REST** — clientul vrea explicit să păstreze acest model, nu să-l înlocuiască. + +## Fișierele din acest folder + +- `PACK_ACN_IMPORT.pck` — pachetul Oracle care importă din RoRIS în ROA (sursa analizei). +- `DOCUMENTATIE_DATE_FACTURARE_RORIS.md` — **livrabilul principal** (specificație minimă, în + română, ton impersonal). Structură: 1) Principiu integrare; 2) Entități + nomenclatoare (2.1); + 3) Câmpuri esențiale; 4) Impact asupra facturării (tabel de riscuri). +- `DOCUMENTATIE_DATE_FACTURARE_RORIS.docx` — versiunea Word, **generată din .md** (vezi mai jos). +- `dictionar_date_facturare.csv` — anexă tehnică, dicționar complet de câmpuri (delimitator `;`, + se deschide nativ în Excel România). + +## Sursa de adevăr (codul ROA real) + +Programul de facturare e în `D:\ROA\ROAACNPRO`. Pentru detalii de cod, relevante: +- `D:\ROA\ROAACNPRO\PACK_ACN_IMPORT.pck` (copie și aici) — ce entități se importă. +- `D:\ROA\ROAACNPRO\Programe\proceduri_acnpro.prg` — calcul/salvare facturare; rapoarte de + indicatori `vizualizare_tranzit_nave` (~linia 228) și `vizualizare_cheiaj_nave` (~383); + distribuția pe ecluze (`completeaza_regdoc_tranzit`, ~2259–2606); tarife `ips_tarife_tranzit` + (`vizualizare_tarife_tranzit`, ~4820). +- `D:\ROA\ROAACNPRO\database.txt` — sinonime/granturi RoRIS. +- `D:\ROA\ROAACNPRO\docs\fluxuri_calcul_facturare.md` și `docs\facturare.md` — fluxuri de calcul. +- `D:\ROA\ROAACNPRO\CLAUDE.md` — ghidul aplicației ROA. + +## Constatări cheie (deja încorporate în documentație) + +1. **Ecluzele se potrivesc pe DENUMIRE, nu pe `id_lock`.** Codul filtrează `lock_name LIKE + '%AGIGEA%'/'%CERNAVODA%'/'%OVIDIU%'/'%NAVODARI%'` și `chamber_name` exact `SAS1`/`SAS2` (canal + principal CDMN) sau `C1`/`C2` (canal PAMN, Năvodari). `id_lock` poate fi orice. Camera trebuie + **obligatoriu completată** (există `verificare_roris_ecluze.exe` care semnalează lipsurile). +2. **ID-urile entităților din RoRIS trebuie stabile în timp.** Sunt folosite ca FK în tarife, + contracte și vânzările deja facturate → relistarea facturilor istorice depinde de ele. +3. **Nomenclatoarele de grupare/tarifare NU există în RoRIS — sunt create în ROA** și referă prin + ID entitățile RoRIS: grupe tip navă (`ips_grup_tip_nave`), grupe marfă (`ips_goods_groups`), + UM (`ips_vas_um`), echivalențe (`ips_vas_echivalent`), dane (`ips_dane`), tarifele + (`ips_tarife_tranzit`). Tariful de tranzit se alege pe combinația **grupă tip navă + grupă/tip + marfă + rută + capacitate**, totul pe ID-uri RoRIS. Dacă RoRIS schimbă ID-urile de bază, + configurarea din ROA se desincronizează. +4. **Entități importate din RoRIS** (12): contacts, countries, goods (RISGOODS), vessels, + vessel_types (RIS_VES_TYPES), route_points, voyages, voyage_members, cargoes, voyage_locks + (VOYAGE_LOCK), berthings; `ips_routes` e generat în ROA din voyage_members + route_points. + +## Cum se regenerează DOCX din MD + +Nu există pandoc; există Word 2010 (COM). Workflow: MD → HTML curat → Word salvează ca .docx. +Scriptul convertor (`_md2docx.ps1`) se creează ad-hoc, se rulează și **se șterge după** (e temporar, +nu se păstrează în folder). Pași: +1. Scrie `_md2docx.ps1` (convertor MD→HTML cu suport pentru titluri, tabele, **bold**, `cod`, + blockquote, liste; apoi Word COM `SaveAs` format 16 = .docx). +2. Salvează întâi într-un `_doc_new.docx`, apoi `Move-Item` peste cel final (dacă fișierul final e + deschis în Word, e blocat — anunță utilizatorul să închidă Word). +3. Șterge fișierele temporare `_md2docx.ps1`, `_doc_new.docx`, `_doc_tmp.html`. + +Verificare: documentul Word este uneori deschis în IDE/Word și blochează suprascrierea. + +## Preferințe ale utilizatorului (din interacțiuni) + +- Documentație **minimă, lizibilă pentru oameni**, nu restrictivă/verbose. +- **Ton impersonal** — fără adresare cu „tu". +- Folosește terminologia din sistem (ex. `TRN`, nu „NRT"). +- Accent pe **afectarea cât mai mică a facturării** și pe **păstrarea modelului actual** (import + din vederi RoRIS, fără API/REST); dacă e nevoie de strat de compatibilitate, de menționat că + trebuie prevăzut în **buget**. +- Limba documentelor: **română**. diff --git a/DOCUMENTATIE_DATE_FACTURARE_RORIS.docx b/DOCUMENTATIE_DATE_FACTURARE_RORIS.docx new file mode 100644 index 0000000..281c9e3 Binary files /dev/null and b/DOCUMENTATIE_DATE_FACTURARE_RORIS.docx differ diff --git a/DOCUMENTATIE_DATE_FACTURARE_RORIS.md b/DOCUMENTATIE_DATE_FACTURARE_RORIS.md new file mode 100644 index 0000000..b84923d --- /dev/null +++ b/DOCUMENTATIE_DATE_FACTURARE_RORIS.md @@ -0,0 +1,160 @@ +# Date necesare pentru facturare — modernizare RORIS (specificație minimă) + +**Beneficiar:** ACN — facturare tranzit/ecluzare barje și nave, cheiaj +**Sistem sursă (actual):** RORIS — bază de date **SQL Server** +**Sistem care consumă datele:** ROA (aplicația de facturare) — bază de date **Oracle** +**Scop:** stabilirea datelor minime pe care noul RORIS trebuie să le pună la dispoziția facturării. +**Autor:** ROMFAST SRL — dezvoltatorul ERP-ului ROA și al programului de facturare. +**Data:** 24.06.2026 + +--- + +## 1. Principiu de integrare (mod actual, de păstrat) + +Facturarea ROA (Oracle) preia astăzi datele din RORIS (SQL Server) **prin vederi/tabele expuse de +RORIS**, citite de Oracle printr-un **database link** (gateway heterogen Oracle → SQL Server, +`RORISSQL`). Importul este o simplă copiere (`merge`) din aceste surse în tabelele Oracle ale ROA, +**fără API sau servicii web**. Vederile/tabelele relevante poartă prefixul `ips_*` (date) și +`ips_v*` (vederi de calcul). + +**Cerința de bază a modernizării:** noul RORIS trebuie să expună în continuare, pe partea sa de +SQL Server, **aceleași vederi/tabele, cu aceleași denumiri de coloane și aceeași semnificație**, +accesibile prin database link din Oracle, astfel încât importul actual să funcționeze neschimbat +sau cu adaptări minime. + +> **De prevăzut în buget:** dacă noul RORIS este construit pe altă platformă sau cu altă structură +> de date (alte tabele/coloane, alt model), modernizarea trebuie să includă un **strat de +> compatibilitate** pe partea RORIS (vederi SQL Server / tabele intermediare / replicare) care să +> reproducă structura de mai jos și să rămână accesibil prin database link Oracle. +> **Nu se dorește rescrierea importului pe API/REST** — aceasta ar însemna refacerea integrală a +> mecanismului de facturare și costuri suplimentare nejustificate. + +--- + +## 2. Entitățile necesare facturării (12) + +| # | Sursă RORIS | Conținut | Folosită la | +|---|-------------|----------|-------------| +| 1 | `IPS_CONTACTS` | Firme (transportatori, plătitori) | Client/plătitor pe factură | +| 2 | `IPS_COUNTRIES` | Țări | Atribut navă/voiaj/marfă | +| 3 | `IPS_RISGOODS` | Mărfuri (NSTR, IMO, periculos) | Încadrare tarifară pe marfă | +| 4 | `IPS_VESSELS` | Nave/barje (tonaj, putere, LBD, tip) | Cantitate facturată tranzit/cheiaj | +| 5 | `IPS_RIS_VES_TYPES` | Tipuri de navă | Încadrare tarifară pe tip/grupă | +| 6 | `IPS_ROUTE_POINTS` | Puncte de rută (km/porturi/dane) | Rută, distanță, dană | +| 7 | `IPS_VOYAGES` | Voiaje/convoaie (avizare, declarație) | Antet tranzit; perioadă facturare | +| 8 | `IPS_VOYAGE_MEMBERS` | Membri convoi (navă + traseu + distanță) | Linia de bază a tranzitului | +| 9 | `IPS_CARGOES` | Marfă pe membru convoi (cantitate, UM) | Cantitate și încadrare marfă | +| 10 | `IPS_VOYAGE_LOCK` | Ecluzări (ecluză, cameră, durată) | Repartiția valorii pe ecluze | +| 11 | `IPS_BERTHINGS` | Acostări/staționări la dană | Baza facturării cheiajului | +| 12 | Nomenclatoare de config (în ROA) | Grupă tip navă, grupă marfă, UM, dane — pe baza ID-urilor RORIS | Selecția tarifului (vezi 2.1 și cap. 4) | + +Detaliul complet pe câmpuri (toate coloanele, tip, obligativitate) se află în anexa +**`dictionar_date_facturare.csv`**. Mai jos sunt doar câmpurile **esențiale** pentru facturare. + +### 2.1. Nomenclatoare folosite la facturare (listă completă) + +Nomenclatoarele sunt listele de clasificare/referință de care depinde facturarea (în special +selecția tarifelor — vezi cap. 4). Toate trebuie furnizate de noul sistem, cu **ID-uri stabile**. + +Coloana **„Mod de populare"** arată dacă nomenclatorul este **importat din RORIS** (copiat într-o +tabelă ROA), **creat și întreținut în ROA** (nu există în RORIS; configurarea lui — grupări, +tarife, echivalențe — se bazează pe **ID-urile din RORIS**) sau **generat în ROA** din date +importate. + +| Nomenclator | Conținut | Rol la facturare | Mod de populare | +|-------------|----------|------------------|-----------------| +| `IPS_CONTACTS` | Firme (transportatori, plătitori, armatori) | Client/plătitor pe factură | **Importat din RORIS** | +| `IPS_COUNTRIES` | Țări | Pavilion navă, țară marfă/voiaj | **Importat din RORIS** | +| `IPS_RISGOODS` | Mărfuri (cu NSTR, clasă IMO, indicator periculos) | Încadrare tarifară pe marfă | **Importat din RORIS** | +| `IPS_GOODS_GROUPS` | Grupe de marfă | Încadrare tarifară pe grupă de marfă | **Creat în ROA** (config pe baza ID-urilor RORIS — nu există în RORIS) | +| `IPS_RIS_VES_TYPES` | Tipuri de navă | Atribut navă; bază pentru grupa de tip navă | **Importat din RORIS** | +| `IPS_GRUP_TIP_NAVE` | Grupe de tip navă | Încadrare tarifară (tariful se definește pe grupă) | **Creat în ROA** (config pe baza ID-urilor RORIS — nu există în RORIS) | +| `IPS_ARAMIS_TIP_NAVE` | Tipuri de navă — clasificare ARAMIS | Clasificarea navei la cheiaj | **Creat în ROA** (config pe baza ID-urilor RORIS — nu există în RORIS) | +| `IPS_ROUTE_POINTS` | Puncte de rută (km, porturi, dane) | Definirea rutei, distanței și danei | **Importat din RORIS** | +| `IPS_ROUTES` | Rute (pereche punct plecare–sosire + distanță) | Încadrare tarifară pe rută | **Generat în ROA** din date RORIS (din `voyage_members` + `route_points`) | +| `IPS_VAS_UM` | Unități de măsură ale tarifelor (TC, TRN, LBD, CP, ZI) | Selecția unității de măsură a tarifului | **Creat în ROA** (config pe baza ID-urilor RORIS — nu există în RORIS) | +| `IPS_VAS_ECHIVALENT` | Echivalențe între unitățile de măsură | Conversii de UM la calcul | **Creat în ROA** (config pe baza ID-urilor RORIS — nu există în RORIS) | +| `IPS_DANE` | Dane | Identificarea danei la cheiaj | **Creat în ROA** (config pe baza ID-urilor RORIS — nu există în RORIS) | + +> **Observații:** +> - `IPS_CONTACTS`, `IPS_COUNTRIES`, `IPS_RISGOODS`, `IPS_RIS_VES_TYPES` și `IPS_ROUTE_POINTS` +> apar și în tabelul entităților (1-6) — sunt în același timp date de tranzacție și nomenclatoare. +> **Acestea trebuie furnizate de noul sistem**, cu ID-uri stabile. +> - Nomenclatoarele marcate **„Creat în ROA" NU există în RORIS** și **nu trebuie furnizate de +> noul sistem**. Ele sunt configurate manual în ROA (de exemplu: gruparea tipurilor de navă în +> grupe tarifare, gruparea mărfurilor, echivalențele de unități de măsură, danele) și **referă +> prin ID** entitățile din RORIS (tip navă, marfă, punct de rută). La fel, `IPS_ROUTES` este +> construit în ROA din datele importate. +> - **Consecință critică:** deoarece aceste configurări din ROA sunt legate de **ID-urile din +> RORIS**, dacă noul sistem schimbă ID-urile entităților de bază (tip navă, marfă, punct de rută, +> navă, firmă), toate grupările și tarifele configurate în ROA **se desincronizează** și trebuie +> refăcute manual. De aceea **stabilitatea ID-urilor din RORIS este esențială** (vezi cap. 4). +> - **Tarifele propriu-zise** (`IPS_TARIFE_TRANZIT` și similare) sunt tot în ROA și **referă prin +> ID** nomenclatoarele de mai sus (vezi cap. 4, pct. 5). + +--- + +## 3. Câmpuri esențiale per entitate + +> „ID" = identificator unic; toate ID-urile sunt text (uzual ≤36 caractere). Câmpurile marcate +> sunt cele fără de care facturarea nu funcționează. Restul câmpurilor — în CSV. + +**Firme (`IPS_CONTACTS`):** `id`, `name`. + +**Mărfuri (`IPS_RISGOODS`):** `id`, `name`, `dangerous` (periculos → coeficient). + +**Nave (`IPS_VESSELS`):** `id`, `name`, `gross_tonn` (capacitate), `trn` (tonaj registru net), `lbd`, +`horsepower`, `vtp_id` (tip navă). + +**Tipuri navă (`IPS_RIS_VES_TYPES`):** `id`, `name`. + +**Puncte rută (`IPS_ROUTE_POINTS`):** `id`, `name`. + +**Voiaje (`IPS_VOYAGES`):** `id`, data avizării, data declarației, `convoy_name`, `declaration`, +`ctt_id` (firmă), `origin`, `destination`. + +**Membri convoi (`IPS_VOYAGE_MEMBERS`):** `id`, `vye_id` (voiaj), `vsl_id` (navă), +`rstart_id`/`rfin_id` (plecare/sosire), `distance`, `distance_cdmn` (distanța pe canalul principal). + +**Marfă (`IPS_CARGOES`):** `id`, `vms_id` (membru), `risgds_id` (marfă), `quantity`, `unit`. + +**Ecluzări (`IPS_VOYAGE_LOCK`):** `id`, `vye_id`, `fk_voyage_member` (membru), `chamber_nr`, +`chamber_name`, `lock_name`, `date`. **(vezi cap. 4 — denumiri și camere obligatorii)** + +**Acostări (`IPS_BERTHINGS`):** `id`, `ves_id` (navă), `arrival_time`, `departure_time`, +`tip` (1=port, 2=dană așteptare, 9=altele), `rpt_id` (dană). + +--- + +## 4. Impact asupra facturării + +Tariful unei tranzitări se alege în ROA după **ID-urile din RORIS**, nu după denumiri — în funcție +de combinația **grupă de tip navă + grupă/tip de marfă + rută + capacitate**. Gruparea (tip +navă → grupă, marfă → grupă) și tarifele se configurează **în ROA**; din RORIS se folosesc doar +**ID-urile** de tip navă, marfă și punct de rută, plus atributele de calcul ale navei (capacitate, +cuplat/necuplat, distanțe pe canale). + +Următoarele modificări ale noului sistem **afectează direct facturarea**. Pentru fiecare, dacă nu +se respectă regula, va fi nevoie de un **adaptor** la nivelul importului/calculului ROA, care +trebuie prevăzut ca efort și **buget**. + +| # | Risc / modificare | Efect asupra facturării | Cerință / adaptor necesar | +|---|-------------------|-------------------------|----------------------------| +| 1 | **ID-uri schimbate** la migrare (voiaje, nave, mărfuri, puncte rută, firme) | Se rup legăturile cu tarifele/contractele și **relistarea facturilor istorice** | ID-uri păstrate identic, sau **tabel de echivalență ID_vechi↔ID_nou** pentru remapare | +| 2 | **Denumiri ecluze modificate** | Repartiția valorii pe ecluze devine 0; valoarea trece greșit pe „senal" | `lock_name` trebuie să conțină **AGIGEA / CERNAVODA / OVIDIU / NAVODARI** | +| 3 | **Coduri cameră ecluză modificate** | Aceeași problemă ca mai sus, pe cameră | `chamber_name` exact: **SAS1 / SAS2** (canal principal), **C1 / C2** (canal Năvodari) | +| 4 | **Camera ecluzei necompletată** | Ecluzarea nu se poate factura corect (caz deja problematic azi) | Completarea camerei **obligatorie** la fiecare ecluzare | +| 5 | **ID-uri de bază RORIS schimbate** (tip navă, marfă, punct de rută) | Grupările și tarifele configurate **în ROA** (pe baza acestor ID-uri) nu se mai potrivesc → tranzitul nu se facturează | ID-uri RORIS stabile, ca să rămână valide configurările din ROA (gruparea tip→grupă/marfă→grupă se întreține în ROA) | +| 6 | **Structură/denumiri coloane diferite** în vederi | Importul actual din vederi nu mai rulează | Păstrarea acelorași vederi și denumiri de coloane (cap. 1) | +| 7 | **Date fără oră** (avizare/declarație, sosire/plecare) | Perioada de facturare și durata la cheiaj sunt greșite | Livrare ca **dată + oră** completă | +| 8 | **Unități de măsură marfă/navă inconsistente** | Cantitățile facturate se denaturează | UM stabile și consecvente în timp | + +> **Notă privind responsabilitatea:** ERP-ul ROA și programul de facturare sunt dezvoltate și +> întreținute de **ROMFAST SRL**. Adaptările de pe partea de import/calcul ROA pot fi realizate de +> ROMFAST, dar **numai dacă noul sistem respectă regulile de mai sus**. Orice abatere (în special +> ID-uri instabile, denumiri de ecluze/camere schimbate, sau lipsa vederilor) transferă efort +> suplimentar și risc asupra facturării și trebuie evitată sau, după caz, prevăzută explicit în buget. + +--- + +*Anexă tehnică: `dictionar_date_facturare.csv` — lista completă a câmpurilor pe fiecare entitate.* diff --git a/PACK_ACN_IMPORT.pck b/PACK_ACN_IMPORT.pck new file mode 100644 index 0000000..a7b0947 --- /dev/null +++ b/PACK_ACN_IMPORT.pck @@ -0,0 +1,651 @@ +create or replace package PACK_ACN_IMPORT is + + -- Author : MARIUS MUTU + -- Created : 4/10/2019 4:00:22 PM + -- Purpose : IMPORT RORIS-ROA + + Procedure import_roris_job(ttLastGenerationTime date default null); + + procedure import_roris(ttLastGenerationTime date default null); + +end PACK_ACN_IMPORT; +/ +CREATE OR REPLACE PACKAGE BODY "PACK_ACN_IMPORT" is + + -- 25.09.2019 + -- import_roris: import ips_vessel_types + + -- 11.02.2020 + -- import_roris + -- Nu import nimic inainte de 01.01.2020 + -- Am schimbat in ips_voyages.generation (data declaratiei) cu notificati (data avizare) pentru ca erau incurcate + -- Am facut modificarea pentru convoaiele incepand cu 01.01.2020 sa nu afectez rapoartele pe anii precedenti + + -- 28.02.2020 + -- import_roris + -- ips_voyage_locks + chamber_nr, chamber_name + + -- 04.03.2020 + -- import_roris + -- ips_voyage_locks - tin cont ca vms_id poate fi null daca nu este completat in RORIS (nu se stie de ce nu este completat la unele tranzitari) + + -- 22.04.2020 + -- import_roris + -- nu mai sterg din ips_voyage_members. mi-a dat eroare ca mai exista referinte in ips_voyage_members_vanzari + + -- 08.05.2020 + -- import_roris + -- sterg din ips_cargoes daca id nu mai este in rorissql, in loc de vms_id + + -- 16.06.2020 + -- import_roris + -- nu sterg din ips_voyage_locks id-urile care incep cu '*NUSTERGE' + + -- 28.07.2021 + -- import_roris + -- nu sterg din ips_berthings id-urile care incep cu '*NUSTERGE' + + -- 14.12.2022 + -- import_roris + -- ips_berthings.tip (1=port, 2=dana asteptare, 9=altele) + + -- 08.04.2024 + -- import_roris + -- ips_vessels, ips_voyages, ips_cargoes + .country_id + + ------------------------------------------------- + -- Creeaza si lanseaza job IMPORTRORIS_JOB cu executia imediata + ------------------------------------------------- + Procedure import_roris_job(ttLastGenerationTime date default null) is + begin + dbms_scheduler.create_job(job_name => 'IMPORT_RORIS_JOB', + job_type => 'STORED_PROCEDURE', + job_action => 'PACK_ACN_IMPORT.IMPORT_RORIS', + number_of_arguments => 1, + start_date => systimestamp, + end_date => null, + repeat_interval => '', + enabled => false, + auto_drop => true, + comments => 'Lanseaza import din RORIS asincron.'); + + DBMS_SCHEDULER.SET_JOB_ANYDATA_VALUE(job_name => 'ACN.IMPORT_RORIS_JOB', + argument_position => 1, + argument_value => sys.anydata.convertDate(ttLastGenerationTime)); + + dbms_scheduler.enable(name => 'ACN.IMPORT_RORIS_JOB'); + + end import_roris_job; + + procedure import_roris(ttLastGenerationTime date default null) is + -- ttLastGenerationTime data de la care se preiau date din RORIS (implicit 6 luni in urma = data curenta - 180 zile) + ltLastGenerationTime date; + begin + + ltLastGenerationTime := case + when ttLastGenerationTime is null then + trunc(sysdate) - 30 + else + ttLastGenerationTime + end; + + -- Nu import nimic inainte de 01.01.2020 + -- Am schimbat in ips_voyages.generation (data declaratiei) cu notificati (data avizare) pentru ca erau incurcate + -- Am facut modificarea pentru convoaiele incepand cu 01.01.2020 sa nu afectez rapoartele pe anii precedenti + ltLastGenerationTime := greatest(ltLastGenerationTime, to_date('01012020', 'ddmmyyyy')); + + pinfo(tcmesaj => '1. Import data >= ' || + to_char(ttLastGenerationTime, + 'dd/mm/yyyy hh24:mi:ss'), + tclocatia => 'import_roris'); + + merge into ips_contacts a + using (Select trim(id) as id, + trim(substr(acronym, 1, 6)) as acronym, + trim(name) as name + From IPS_CONTACTS@RORISSQL) b + on (a.id = b.id) + when not matched then + insert (id, acronym, name) values (b.id, b.acronym, b.name); + + pinfo(tcmesaj => '2. ips_contacts ' || sql%rowcount || + ' inregistrari noi', + tclocatia => 'import_roris'); + + merge into ips_countries a + using (Select trim(id) as id, + trim(acronym) as acronym, + trim(name) as name + From IPS_COUNTRIES@RORISSQL) b + on (a.id = b.id) + when not matched then + insert (id, acronym, name) values (b.id, b.acronym, b.name); + + pinfo(tcmesaj => '3. ips_countries ' || sql%rowcount || + ' inregistrari noi', + tclocatia => 'import_roris'); + + merge into ips_goods a + using (Select trim(id) as id, + trim(name) as name, + trim(alternativ) as alternativ, + trim(dangerous) as dangerous, + trim(nstr_code) as nstr_code, + trim(nstr_name) as nstr_name, + trim(code) as code, + trim(imoclass) as imoclass, + trim(imoclass_name) as imoclass_n, + '2007' as standard + From IPS_RISGOODS@RORISSQL) b + on (a.id = b.id) + when not matched then + insert + (id, + name, + alternativ, + dangerous, + nstr_code, + nstr_name, + code, + imoclass, + imoclass_n, + standard) + values + (b.id, + b.name, + b.alternativ, + b.dangerous, + b.nstr_code, + b.nstr_name, + b.code, + b.imoclass, + b.imoclass_n, + b.standard); + + pinfo(tcmesaj => '4. ips_goods ' || sql%rowcount || + ' inregistrari noi', + tclocatia => 'import_roris'); + + merge into ips_vessels a + using (Select trim(id) as id, + vtmis_id, + trim(name) as name, + lbd, + length, + breadth, + trim(ctt_id) as ctt_id, + gross_tonn, + horsepower, + trn, + trim(risvtp_id) as vtp_id, + trim(country_id) as country_id + From IPS_VESSELS@RORISSQL) b + on (a.id = b.id) + when matched then + update + set name = b.name, + lbd = b.lbd, + length = b.length, + breadth = b.breadth, + ctt_id = b.ctt_id, + gross_tonn = b.gross_tonn, + horsepower = b.horsepower, + trn = b.trn, + vtp_id = b.vtp_id, + vtmis_id = b.vtmis_id, + country_id = b.country_id + when not matched then + insert + (id, + vtmis_id, + name, + lbd, + length, + breadth, + ctt_id, + gross_tonn, + horsepower, + trn, + vtp_id, + country_id) + values + (b.id, + b.vtmis_id, + b.name, + b.lbd, + b.length, + b.breadth, + b.ctt_id, + b.gross_tonn, + b.horsepower, + b.trn, + b.vtp_id, + b.country_id); + + pinfo(tcmesaj => '5. ips_vessels ' || sql%rowcount || + ' inregistrari noi/modificate', + tclocatia => 'import_roris'); + + merge into ips_vessel_types a + using (Select trim(id) as id, trim(name) as name + From IPS_RIS_VES_TYPES@RORISSQL) b + on (a.id = b.id) + when not matched then + insert (id, name) values (b.id, b.name); + + pinfo(tcmesaj => '6. ips_ris_ves_types ' || sql%rowcount || + ' inregistrari noi', + tclocatia => 'import_roris'); + + merge into ips_route_points a + using (Select trim(id) as id, + vtmis_id, + trim(name) as name, + TRIM(SUBSTR(name, 1, 6)) as acronym, + cnl_id + From IPS_ROUTE_POINTS@RORISSQL) b + on (a.id = b.id) + when matched then + update + set vtmis_id = b.vtmis_id, + name = b.name, + acronym = b.acronym, + cnl_id = b.cnl_id + when not matched then + insert + (id, vtmis_id, name, acronym, cnl_id) + values + (b.id, b.vtmis_id, b.name, b.acronym, b.cnl_id); + + pinfo(tcmesaj => '7. ips_route_points ' || sql%rowcount || + ' inregistrari noi/modificate', + tclocatia => 'import_roris'); + + -- voyages + merge into ips_voyages a + using (select trim(id) as id, + generation as notificati, + trim(mtr_name) as mtr_name, + trim(ctt_id) as ctt_id, + trim(vms_id) as vms_id, + trim(convoy_name) as convoy_nam, + trim(declaration) as declaratio, + notificati as generation, + trim(notificat2) as notificat2, + trim(origin) as origin, + trim(destinatio) as destinatio, + state, + trim(country_id) as country_id + from ips_voyages@RORISSQL + where notificati >= ltLastGenerationTime) b + on (a.id = b.id) + when matched then + update + set generation = b.generation, + mtr_name = b.mtr_name, + ctt_id = b.ctt_id, + vms_id = b.vms_id, + convoy_nam = b.convoy_nam, + declaratio = b.declaratio, + notificati = b.notificati, + notificat2 = b.notificat2, + origin = b.origin, + destinatio = b.destinatio, + state = b.state, + country_id = b.country_id + when not matched then + insert + (id, + generation, + mtr_name, + ctt_id, + vms_id, + convoy_nam, + declaratio, + notificati, + notificat2, + origin, + destinatio, + state, + country_id) + values + (b.id, + b.generation, + b.mtr_name, + b.ctt_id, + b.vms_id, + b.convoy_nam, + b.declaratio, + b.notificati, + b.notificat2, + b.origin, + b.destinatio, + b.state, + b.country_id); + + pinfo(tcmesaj => '8. ips_voyages ' || sql%rowcount || + ' inregistrari noi/modificate', + tclocatia => 'import_roris'); + + merge into ips_voyage_members a + using (select trim(vm.id) as id, + trim(vm.vye_id) as vye_id, + trim(vm.vsl_id) as vsl_id, + trim(vm.ctt_id) as ctt_id, + vm.dirty_tank, + trim(vm.rstart_id) as rstart_id, + trim(vm.rfin_id) as rfin_id, + vm.distance, + vm.distance_cdmn as distance_c, + vm.cnt_mnvr + From IPS_VOYAGE_MEMBERS@RORISSQL vm + JOIN IPS_VOYAGES@RORISSQL v + ON vm.vye_id = v.id + Where v.notificati >= ltLastGenerationTime) b + on (a.id = b.id) + when matched then + update + set vye_id = b.vye_id, + vsl_id = b.vsl_id, + ctt_id = b.ctt_id, + dirty_tank = b.dirty_tank, + rstart_id = b.rstart_id, + rfin_id = b.rfin_id, + distance = b.distance, + distance_c = b.distance_c, + cnt_mnvr = b.cnt_mnvr + when not matched then + insert + (id, + vye_id, + vsl_id, + ctt_id, + dirty_tank, + rstart_id, + rfin_id, + distance, + distance_c, + cnt_mnvr) + values + (b.id, + b.vye_id, + b.vsl_id, + b.ctt_id, + b.dirty_tank, + b.rstart_id, + b.rfin_id, + b.distance, + b.distance_c, + b.cnt_mnvr); + + pinfo(tcmesaj => '9. ips_voyage_members ' || sql%rowcount || + ' inregistrari noi/modificate', + tclocatia => 'import_roris'); + + -- sterg inregistrarile care nu mai sunt in RORIS +/* insert into ips_ids_temp + (idc) + (select v1.id + from (select vm.id as id + From IPS_VOYAGE_MEMBERS vm + JOIN IPS_VOYAGES v + ON vm.vye_id = v.id + Where v.generation >= ltLastGenerationTime) v1 + left join (select trim(vm.id) as id + From IPS_VOYAGE_MEMBERS@RORISSQL vm + JOIN IPS_VOYAGES@RORISSQL v + ON vm.vye_id = v.id + Where v.notificati >= ltLastGenerationTime) v2 + on v1.id = v2.id + where v2.id is null);*/ + +/* delete from ips_cargoes where vms_id in (select idc from ips_ids_temp);*/ + delete from ips_cargoes where id in (select c1.id + from ips_cargoes c1 + join ips_voyage_members vm + on c1.vms_id = vm.id + join ips_voyages v + ON vm.vye_id = v.id + left join ips_cargoes@rorissql c2 + on c1.id = trim(c2.id) + Where v.generation >= ltLastGenerationTime and c2.id is null); + + pinfo(tcmesaj => '10. ips_cargoes ' || sql%rowcount || + ' inregistrari sterse', + tclocatia => 'import_roris'); + + /* + -- nu mai sterg din ips_voyage_members. mi-a dat eroare ca mai exista referinte in ips_voyage_members_vanzari + delete from ips_voyage_members + where id in (select idc from ips_ids_temp); + pinfo(tcmesaj => '11. ips_voyage_members ' || sql%rowcount || + ' inregistrari sterse', + tclocatia => 'import_roris'); +*/ + delete from ips_ids_temp; + + merge into ips_cargoes a + using (select trim(c.id) as id, + trim(c.vms_id) as vms_id, + trim(c.risgds_id) as gds_id, + c.container, + trim(c.source) as source, + trim(c.cty_id) as cty_id, + trim(c.destination) as destinatio, + c.quantity, + trim(c.unit) as unit, + trim(c.country_id) as country_id + From IPS_CARGOES@RORISSQL c + join IPS_VOYAGE_MEMBERS@RORISSQL vm + ON c.vms_id = vm.id + JOIN IPS_VOYAGES@RORISSQL v + ON vm.vye_id = v.id + Where v.notificati >= ltLastGenerationTime) b + on (a.id = b.id) + when matched then + update + set vms_id = b.vms_id, + gds_id = b.gds_id, + container = b.container, + source = b.source, + cty_id = b.cty_id, + destinatio = b.destinatio, + quantity = b.quantity, + unit = b.unit, + country_id = b.country_id + when not matched then + insert + (id, + vms_id, + gds_id, + container, + source, + cty_id, + destinatio, + quantity, + unit, + country_id) + values + (b.id, + b.vms_id, + b.gds_id, + b.container, + b.source, + b.cty_id, + b.destinatio, + b.quantity, + b.unit, + b.country_id); + + pinfo(tcmesaj => '12. ips_cargoes ' || sql%rowcount || + ' inregistrari noi/modificate', + tclocatia => 'import_roris'); + + -- exista tranzite la care la ecluza ovidiu, impingatorul trece cu o barja prin camera 1, si cu alta barja prin camera 2 + -- astfel impingatorul apare de 2 ori, prin cate o camera + -- cheie primara este id (ecluzare), vms_id (membru convoi), chamber_nr (camera ecluza) + merge into ips_voyage_locks a + using (Select trim(vl.id) as id, + trim(vl.vye_id) as vye_id, + VL."DATE" as ddate, + trim(vl.rpt_id) as rpt_id, + vl.op_min, + vl.op_prep, + trim(vl.id_lock) as id_lock, + trim(vl.lock_name) as lock_name, + vl.chamber_nr, + vl.chamber_name, + trim(vl.fk_voyage_member) as vms_id + From IPS_VOYAGE_LOCK@RORISSQL vl + JOIN IPS_VOYAGES@RORISSQL v + ON vl.vye_id = v.id + Where v.notificati >= ltLastGenerationTime) b + on (a.id = b.id and NVL(a.vms_id, 'X') = NVL(b.vms_id, 'X') and a.chamber_nr = b.chamber_nr) + when matched then + update set a."date" = b.ddate, a.rpt_id = b.rpt_id, a.op_min = b.op_min, a.op_prep = b.op_prep + when not matched then + insert + (id, vye_id, "date", rpt_id, op_min, op_prep, id_lock, lock_name, chamber_nr, chamber_name, vms_id) + values + (b.id, + b.vye_id, + b.ddate, + b.rpt_id, + b.op_min, + b.op_prep, + b.id_lock, + b.lock_name, + b.chamber_nr, + b.chamber_name, + b.vms_id); + + pinfo(tcmesaj => '13. ips_voyage_locks ' || sql%rowcount || + ' inregistrari noi/modificate', + tclocatia => 'import_roris'); + + -- sterg inregistrarile care nu mai sunt in RORIS + delete from ips_voyage_locks + where id not like '*NUSTERGE%' and id || NVL(vms_id,'X') || chamber_nr in (select v1.id + from (select vl.id || NVL(vl.vms_id, 'X') || chamber_nr as id + from ips_voyage_locks vl + join ips_voyages v + on vl.vye_id = v.id + where v.generation >= ltLastGenerationTime) v1 + left join (select trim(vl.id) || NVL(trim(vl.fk_voyage_member), 'X') || trim(vl.chamber_nr) as id + From IPS_VOYAGE_LOCK@RORISSQL vl + JOIN IPS_VOYAGES@RORISSQL v + ON vl.vye_id = v.id + Where v.notificati >= ltLastGenerationTime) v2 + on v1.id = v2.id + where v2.id is null); + + pinfo(tcmesaj => '14. ips_voyage_locks ' || sql%rowcount || + ' inregistrari sterse', + tclocatia => 'import_roris'); + + merge into ips_berthings a + using (Select trim(id) as id, + arrival_time as arrival_ti, + trim(ves_id) as ves_id, + max(tip) as tip, + max(trim(voy_id)) as voy_id, + max(departure_time) as departure_, + max(trim(rpt_id)) as rpt_id, + max(trim(ctt_id)) as ctt_id + From IPS_BERTHINGS@RORISSQL + where arrival_time >= ltLastGenerationTime + group by id, arrival_time, ves_id) b + on (a.id = b.id and a.ves_id = b.ves_id and a.arrival_ti = b.arrival_ti) + when matched then + update + set voy_id = b.voy_id, + departure_ = b.departure_, + rpt_id = b.rpt_id, + ctt_id = b.ctt_id, + tip = b.tip + when not matched then + insert + (id, arrival_ti, voy_id, departure_, rpt_id, ctt_id, ves_id, tip) + values + (b.id, + b.arrival_ti, + b.voy_id, + b.departure_, + b.rpt_id, + b.ctt_id, + b.ves_id, + b.tip); + + pinfo(tcmesaj => '15. ips_berthings ' || sql%rowcount || + ' inregistrari noi/modificate', + tclocatia => 'import_roris'); + + -- sterg inregistrarile care nu mai sunt in RORIS + delete from ips_berthings + where id not like '*NUSTERGE%' and + id || ves_id || to_char(arrival_ti, 'yyyymmddhh24miss') in + (select v1.id || v1.ves_id || + to_char(v1.arrival_ti, 'yyyymmddhh24miss') as id + from (select id, ves_id, arrival_ti + from ips_berthings + where arrival_ti >= ltLastGenerationTime) v1 + left join (select trim(id) as id, + trim(ves_id) as ves_id, + arrival_time as arrival_ti + from ips_berthings@RORISSQL + where arrival_time >= ltLastGenerationTime) v2 + on v1.id = v2.id + and v1.ves_id = v2.ves_id + and v1.arrival_ti = v2.arrival_ti + where v2.id is null); + + pinfo(tcmesaj => '16. ips_berthings ' || sql%rowcount || + ' inregistrari sterse', + tclocatia => 'import_roris'); + + merge into ips_routes a + using (Select VM.RSTART_ID AS RPT_ID, + VM.RFIN_ID AS RPT_ID_HAS, + TRIM(SUBSTR(R1.NAME, 1, 49)) || '-' || + TRIM(SUBSTR(R2.NAME, 1, 50)) AS NAME, + R.ID, + MAX(ROUND(NVL(VM.DISTANCE, 0) / 1000, 2)) AS DISTANTA + FROM IPS_VOYAGE_MEMBERS VM + JOIN IPS_VOYAGES v + ON vm.vye_id = v.id + JOIN IPS_ROUTE_POINTS R1 + ON VM.RSTART_ID = R1.ID + JOIN IPS_ROUTE_POINTS R2 + ON VM.RFIN_ID = R2.ID + LEFT JOIN IPS_ROUTES R + ON VM.RSTART_ID = R.RPT_ID + AND VM.RFIN_ID = R.RPT_ID_HAS + Where v.generation >= ltLastGenerationTime + GROUP BY VM.RSTART_ID, + VM.RFIN_ID, + TRIM(SUBSTR(R1.NAME, 1, 49)) || '-' || + TRIM(SUBSTR(R2.NAME, 1, 50)), + R.ID) b + on (a.id = b.id) + when matched then + update set a.distanta = b.distanta + when not matched then + insert + (rpt_id, rpt_id_has, name, distanta, acronym) + values + (b.rpt_id, + b.rpt_id_has, + b.name, + b.distanta, + DBMS_RANDOM.STRING('U', 6)); + + pinfo(tcmesaj => '17. ips_routes ' || sql%rowcount || + ' inregistrari noi/modificate', + tclocatia => 'import_roris'); + COMMIT; + -- Raise_Application_Error (-20343, 'Eroare de test!'); + pinfo(tcmesaj => '18. COMMIT IMPORT FINALIZAT', tclocatia => 'import_roris'); + end import_roris; + +end PACK_ACN_IMPORT; +/ diff --git a/dictionar_date_facturare.csv b/dictionar_date_facturare.csv new file mode 100644 index 0000000..f52fbcf --- /dev/null +++ b/dictionar_date_facturare.csv @@ -0,0 +1,95 @@ +Entitate_ROA;Tabela_RORIS_sursa;Camp_ROA;Sursa_RORIS;Tip;Obligatoriu;Rol_la_facturare +ips_contacts;IPS_CONTACTS;id;id;VARCHAR(<=36);D;ID unic firma (FK pe voiaj/navat/marfa/acostare; leaga contract/client) +ips_contacts;IPS_CONTACTS;acronym;substr(acronym,1,6);VARCHAR(6);R;Acronim/cod scurt firma +ips_contacts;IPS_CONTACTS;name;name;VARCHAR;D;Denumire firma (apare pe factura) +ips_countries;IPS_COUNTRIES;id;id;VARCHAR;D;ID unic tara (FK pe navat/voiaj/marfa) +ips_countries;IPS_COUNTRIES;acronym;acronym;VARCHAR;R;Cod tara +ips_countries;IPS_COUNTRIES;name;name;VARCHAR;R;Denumire tara +ips_goods;IPS_RISGOODS;id;id;VARCHAR;D;ID unic marfa (FK pe ips_cargoes; baza tarif pe marfa) +ips_goods;IPS_RISGOODS;name;name;VARCHAR;D;Denumire marfa +ips_goods;IPS_RISGOODS;alternativ;alternativ;VARCHAR;O;Denumire alternativa +ips_goods;IPS_RISGOODS;dangerous;dangerous;CHAR/flag;D;Marfa periculoasa -> coeficient corector tranzit +ips_goods;IPS_RISGOODS;nstr_code;nstr_code;VARCHAR;R;Cod NSTR +ips_goods;IPS_RISGOODS;nstr_name;nstr_name;VARCHAR;R;Denumire NSTR +ips_goods;IPS_RISGOODS;code;code;VARCHAR;R;Cod marfa +ips_goods;IPS_RISGOODS;imoclass;imoclass;VARCHAR;R;Clasa IMO +ips_goods;IPS_RISGOODS;imoclass_n;imoclass_name;VARCHAR;O;Denumire clasa IMO +ips_goods;IPS_RISGOODS;standard;constant '2007';VARCHAR;O;Standard clasificare (fix la import) +ips_vessels;IPS_VESSELS;id;id;VARCHAR;D;ID unic navat (FK pe membru convoi/acostare) +ips_vessels;IPS_VESSELS;vtmis_id;vtmis_id;VARCHAR/NUM;O;ID navat in VTMIS +ips_vessels;IPS_VESSELS;name;name;VARCHAR;D;Numele navei (apare pe factura/recapitulatie) +ips_vessels;IPS_VESSELS;lbd;lbd;NUMBER;D;LBD - UM tarifara posibila +ips_vessels;IPS_VESSELS;length;length;NUMBER;R;Lungime navat +ips_vessels;IPS_VESSELS;breadth;breadth;NUMBER;R;Latime navat +ips_vessels;IPS_VESSELS;ctt_id;ctt_id;VARCHAR;R;Firma proprietar/operator (FK ips_contacts) +ips_vessels;IPS_VESSELS;gross_tonn;gross_tonn;NUMBER;D;Tonaj brut/capacitate - baza cantitate cheiaj/tranzit +ips_vessels;IPS_VESSELS;horsepower;horsepower;NUMBER;D;Putere (CP/HP) - UM tarifara posibila +ips_vessels;IPS_VESSELS;trn;trn;NUMBER;D;Tonaj registru net (NRT) - UM tarifara posibila +ips_vessels;IPS_VESSELS;vtp_id;risvtp_id;VARCHAR;D;Tip navat (FK ips_vessel_types) - incadrare tarifara +ips_vessels;IPS_VESSELS;country_id;country_id;VARCHAR;R;Tara navei (pavilion) +ips_vessel_types;IPS_RIS_VES_TYPES;id;id;VARCHAR;D;ID unic tip navat (FK din ips_vessels.vtp_id) +ips_vessel_types;IPS_RIS_VES_TYPES;name;name;VARCHAR;D;Denumire tip navat +ips_route_points;IPS_ROUTE_POINTS;id;id;VARCHAR;D;ID unic punct ruta (FK rute/ecluzari/acostari) +ips_route_points;IPS_ROUTE_POINTS;vtmis_id;vtmis_id;VARCHAR/NUM;O;Referinta VTMIS +ips_route_points;IPS_ROUTE_POINTS;name;name;VARCHAR;D;Denumire punct (km/port/dana) +ips_route_points;IPS_ROUTE_POINTS;acronym;substr(name,1,6);VARCHAR(6);R;Acronim punct +ips_route_points;IPS_ROUTE_POINTS;cnl_id;cnl_id;VARCHAR;R;Canalul de care apartine punctul +ips_voyages;IPS_VOYAGES;id;id;VARCHAR;D;ID unic voiaj (FK pe membri/ecluzari; cheie facturare tranzit) +ips_voyages;IPS_VOYAGES;generation;notificati (vezi 2.6);DATE;D;Data avizarii - criteriu selectie import/facturare +ips_voyages;IPS_VOYAGES;notificati;generation (vezi 2.6);DATE;D;Data declaratiei +ips_voyages;IPS_VOYAGES;notificat2;notificat2;DATE;O;A doua data de avizare +ips_voyages;IPS_VOYAGES;mtr_name;mtr_name;VARCHAR;R;Numele motorului/impingatorului +ips_voyages;IPS_VOYAGES;ctt_id;ctt_id;VARCHAR;D;Firma transportatoare/platitoare (FK ips_contacts) +ips_voyages;IPS_VOYAGES;vms_id;vms_id;VARCHAR;R;Membrul principal al convoiului +ips_voyages;IPS_VOYAGES;convoy_nam;convoy_name;VARCHAR;D;Numele convoiului (apare pe factura) +ips_voyages;IPS_VOYAGES;declaratio;declaration;VARCHAR;D;Nr declaratie tranzit +ips_voyages;IPS_VOYAGES;origin;origin;VARCHAR;R;Origine voiaj +ips_voyages;IPS_VOYAGES;destinatio;destination;VARCHAR;R;Destinatie voiaj +ips_voyages;IPS_VOYAGES;state;state;NUMBER/flag;R;Starea voiajului +ips_voyages;IPS_VOYAGES;country_id;country_id;VARCHAR;R;Tara voiajului +ips_voyage_members;IPS_VOYAGE_MEMBERS;id;id;VARCHAR;D;ID unic membru convoi (FK din cargoes/voyage_locks.vms_id) +ips_voyage_members;IPS_VOYAGE_MEMBERS;vye_id;vye_id;VARCHAR;D;Voiajul (FK ips_voyages) +ips_voyage_members;IPS_VOYAGE_MEMBERS;vsl_id;vsl_id;VARCHAR;D;Nava/barja (FK ips_vessels) +ips_voyage_members;IPS_VOYAGE_MEMBERS;ctt_id;ctt_id;VARCHAR;R;Firma pe membru (FK ips_contacts) +ips_voyage_members;IPS_VOYAGE_MEMBERS;dirty_tank;dirty_tank;flag;O;Tanc murdar (caz special) +ips_voyage_members;IPS_VOYAGE_MEMBERS;rstart_id;rstart_id;VARCHAR;D;Punct plecare (FK ips_route_points) +ips_voyage_members;IPS_VOYAGE_MEMBERS;rfin_id;rfin_id;VARCHAR;D;Punct sosire (FK ips_route_points) +ips_voyage_members;IPS_VOYAGE_MEMBERS;distance;distance;NUMBER;D;Distanta parcursa - baza coeficient distanta +ips_voyage_members;IPS_VOYAGE_MEMBERS;distance_c;distance_cdmn;NUMBER;D;Distanta pe canalul principal (CDMN) - repartitie CDMN/PAMN +ips_voyage_members;IPS_VOYAGE_MEMBERS;cnt_mnvr;cnt_mnvr;NUMBER;R;Nr manevre +ips_cargoes;IPS_CARGOES;id;id;VARCHAR;D;ID unic marfa-pe-membru +ips_cargoes;IPS_CARGOES;vms_id;vms_id;VARCHAR;D;Membrul de convoi (FK ips_voyage_members) +ips_cargoes;IPS_CARGOES;gds_id;risgds_id;VARCHAR;D;Marfa (FK ips_goods) - incadrare tarifara +ips_cargoes;IPS_CARGOES;quantity;quantity;NUMBER;D;Cantitate marfa - baza cantitate facturata +ips_cargoes;IPS_CARGOES;unit;unit;VARCHAR;D;Unitate de masura a cantitatii +ips_cargoes;IPS_CARGOES;container;container;flag/num;R;Container (da/nu) +ips_cargoes;IPS_CARGOES;source;source;VARCHAR;O;Sursa/provenienta marfa +ips_cargoes;IPS_CARGOES;cty_id;cty_id;VARCHAR;O;Legatura suplimentara +ips_cargoes;IPS_CARGOES;destinatio;destination;VARCHAR;O;Destinatia marfii +ips_cargoes;IPS_CARGOES;country_id;country_id;VARCHAR;R;Tara marfii +ips_voyage_locks;IPS_VOYAGE_LOCK;id;id;VARCHAR;D;ID ecluzare (parte din cheia compusa) +ips_voyage_locks;IPS_VOYAGE_LOCK;vye_id;vye_id;VARCHAR;D;Voiajul (FK ips_voyages) +ips_voyage_locks;IPS_VOYAGE_LOCK;vms_id;fk_voyage_member;VARCHAR;D;Membrul de convoi (parte cheie compusa; poate fi null) +ips_voyage_locks;IPS_VOYAGE_LOCK;chamber_nr;chamber_nr;NUMBER;D;Nr camera ecluza (parte din cheia compusa) +ips_voyage_locks;IPS_VOYAGE_LOCK;chamber_name;chamber_name;VARCHAR;D;COD CAMERA: SAS1/SAS2 (CDMN) sau C1/C2 (PAMN) - vezi 2.2 +ips_voyage_locks;IPS_VOYAGE_LOCK;lock_name;lock_name;VARCHAR;D;DENUMIRE ecluza - trebuie sa contina AGIGEA/CERNAVODA/OVIDIU/NAVODARI - vezi 2.2 +ips_voyage_locks;IPS_VOYAGE_LOCK;id_lock;id_lock;VARCHAR(36);R;GUID ecluza (NU se foloseste la repartitie) +ips_voyage_locks;IPS_VOYAGE_LOCK;date;date;DATE;D;Data/ora ecluzarii +ips_voyage_locks;IPS_VOYAGE_LOCK;rpt_id;rpt_id;VARCHAR;R;Punctul de ruta al ecluzei (FK ips_route_points) +ips_voyage_locks;IPS_VOYAGE_LOCK;op_min;op_min;NUMBER;O;Durata operare (min) +ips_voyage_locks;IPS_VOYAGE_LOCK;op_prep;op_prep;NUMBER;O;Durata pregatire +ips_berthings;IPS_BERTHINGS;id;id;VARCHAR;D;ID acostare (parte cheie compusa cu ves_id+arrival_ti) +ips_berthings;IPS_BERTHINGS;ves_id;ves_id;VARCHAR;D;Nava (FK ips_vessels) +ips_berthings;IPS_BERTHINGS;arrival_ti;arrival_time;DATE+ora;D;Data/ora sosirii - inceput durata stationare +ips_berthings;IPS_BERTHINGS;departure_;departure_time;DATE+ora;D;Data/ora plecarii - sfarsit durata stationare +ips_berthings;IPS_BERTHINGS;tip;tip;NUMBER;D;Tip dana: 1=port, 2=dana asteptare, 9=altele +ips_berthings;IPS_BERTHINGS;voy_id;voy_id;VARCHAR;R;Voiajul asociat +ips_berthings;IPS_BERTHINGS;rpt_id;rpt_id;VARCHAR;D;Dana/punctul de ruta (FK ips_route_points) +ips_berthings;IPS_BERTHINGS;ctt_id;ctt_id;VARCHAR;R;Firma platitoare (FK ips_contacts) +CONFIG_ROA_grupa_tip_nava;ROA (config, nu exista in RORIS);id;-;NUMBER;D;Creat in ROA; grupare a tipurilor de navat pe baza ID-urilor RORIS; tariful tranzit legat pe gtn_id - vezi 2.1/cap.4 +CONFIG_ROA_grupa_tip_nava;ROA (config, nu exista in RORIS);nume;-;VARCHAR(20);D;Denumire grupa tip navat (in ROA) +CONFIG_ROA_relatie_tip_grupa;ROA (config);vtp_id(RORIS)->grupa;maparea tip navat -> grupa;relatie;D;Maparea se intretine in ROA; depinde de ID-ul de tip navat din RORIS - vezi cap.4 +CONFIG_ROA_grupa_marfa;ROA (config, nu exista in RORIS);id;-;NUMBER;D;Creat in ROA; grupare a marfurilor; tariful tranzit legat pe gdsg_id - vezi 2.1/cap.4 +CONFIG_ROA_relatie_marfa_grupa;ROA (config);gds_id(RORIS)->grupa;maparea marfa -> grupa;relatie;D;Maparea se intretine in ROA; depinde de ID-ul de marfa din RORIS - vezi cap.4 +CONFIG_ROA_um_tarif;ROA (config, nu exista in RORIS);id;-;NUMBER;D;Creat in ROA; unitatea de masura a tarifului (vum_id in tarife) +CONFIG_ROA_aramis_tip_nava;ROA (config, nu exista in RORIS);id;-;NUMBER;R;Creat in ROA; clasificare ARAMIS tip navat (folosita la cheiaj)