feat(service-auto): săpt 3-phase2 — toate ipotezele confirmate + modul funcțional
Backend: - service_auto module complet: router, service, schemas, 5 teste suites (22/22 passed) - 5 endpoints: GET /ping, /firme, /tip-deviz, /masini, POST /comenzi - SP_CREEAZA_COMANDA_PROTOTIP creat în MARIUSM_AUTO (VALID, 5.9ms) - oracle_pool.py: session_callback backward-compat patch - ROA_WEB user: grants SP-only confirmate (H3), mariusm_test pool switchat - pyproject.toml: integration pytest marker înregistrat Frontend: - ComandaNoua.vue: date reale din Oracle (firme/tip-deviz/masini), nu hardcodate - src/modules/service-auto/services/api.js: axios service cu Bearer token - src/router/index.js: rută /service-auto/comanda-noua Docs: - decision-log.md: verdict MERGE, toate 6 ipoteze CONFIRMED - learnings.md: 7 patterns reutilizabile - grants-audit.md: arhitectura multi-tenant + proxy auth analysis + V_NOM_FIRME loop - template-modul-oracle.md: rețetă completă pentru module Oracle noi - TODO-phase2.md: 7 items concrete Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Claude Agent
68
docs/service-auto/SP_CREEAZA_COMANDA_PROTOTIP.sql
Normal file
68
docs/service-auto/SP_CREEAZA_COMANDA_PROTOTIP.sql
Normal file
@@ -0,0 +1,68 @@
|
||||
-- =============================================================================
|
||||
-- SP_CREEAZA_COMANDA_PROTOTIP — Săpt 3 prototype
|
||||
-- =============================================================================
|
||||
-- Creează o comandă minimă de service auto: insert NOM_LUCRARI (parent) +
|
||||
-- DEV_ORDL (child) într-o singură tranzacție.
|
||||
--
|
||||
-- Scope: PROTOTYPE ONLY. Nu înlocuiește pack_auto.dev_adauga_lucrare. Nu
|
||||
-- agreghează norme, nu actualizează DEV_MASINICLIENTI (kmint/ore), nu setează
|
||||
-- inspector/asigurator, nu generează PROC_TVAV prin pack_contafin.
|
||||
--
|
||||
-- Nrord: generat din SEQ_NR_LUCRARE (nefolosită în producție) cu prefix 'P' +
|
||||
-- id_firma — garantat unic, ușor de identificat pentru cleanup.
|
||||
--
|
||||
-- Autor: oracle-agent, team service-auto-sapt3 (2026-04-11)
|
||||
-- =============================================================================
|
||||
|
||||
CREATE OR REPLACE PROCEDURE MARIUSM_AUTO.SP_CREEAZA_COMANDA_PROTOTIP(
|
||||
p_tip IN NUMBER, -- FK DEV_TIP_DEVIZ.ID_TIP
|
||||
p_id_masiniclient IN NUMBER, -- FK DEV_MASINICLIENTI.ID_MASINICLIENT
|
||||
p_solicitari IN VARCHAR2, -- text liber, stored as CLOB
|
||||
p_id_firma IN NUMBER, -- multi-tenant marker (prototype only)
|
||||
p_id_ordl OUT NUMBER, -- new DEV_ORDL.ID_ORDL (from trigger)
|
||||
p_nrord OUT VARCHAR2 -- generated order number (echo)
|
||||
) AS
|
||||
v_id_lucrare NUMBER;
|
||||
v_seq NUMBER;
|
||||
v_exists NUMBER;
|
||||
v_now DATE := SYSDATE;
|
||||
BEGIN
|
||||
-- 1. Generate nrord (atomic via sequence)
|
||||
v_seq := MARIUSM_AUTO.SEQ_NR_LUCRARE.NEXTVAL;
|
||||
p_nrord := 'P' || LPAD(p_id_firma, 2, '0') || '-' || v_seq;
|
||||
|
||||
-- 2. Duplicate guard (paritate cu pack_auto — should never fire)
|
||||
SELECT COUNT(*) INTO v_exists
|
||||
FROM MARIUSM_AUTO.NOM_LUCRARI
|
||||
WHERE sters = 0 AND nrord = p_nrord;
|
||||
IF v_exists > 0 THEN
|
||||
RAISE_APPLICATION_ERROR(-20001,
|
||||
'Mai exista o comanda cu numarul ' || p_nrord);
|
||||
END IF;
|
||||
|
||||
-- 3. Parent INSERT — TRG_NOM_LUCRARI_BEFOINS allocates id_lucrare
|
||||
INSERT INTO MARIUSM_AUTO.NOM_LUCRARI (nrord, id_mod)
|
||||
VALUES (p_nrord, 1200)
|
||||
RETURNING id_lucrare INTO v_id_lucrare;
|
||||
|
||||
-- 4. Child INSERT — minimal columns only (NOT NULL ones + client link)
|
||||
-- id_util_ad=0 for prototype (no real session context)
|
||||
INSERT INTO MARIUSM_AUTO.DEV_ORDL (
|
||||
an, luna,
|
||||
id_lucrare,
|
||||
datai, dataoraad,
|
||||
id_util_ad,
|
||||
id_masiniclient,
|
||||
id_tip,
|
||||
solicitari_client
|
||||
) VALUES (
|
||||
EXTRACT(YEAR FROM v_now), EXTRACT(MONTH FROM v_now),
|
||||
v_id_lucrare,
|
||||
v_now, v_now,
|
||||
0,
|
||||
p_id_masiniclient,
|
||||
p_tip,
|
||||
p_solicitari
|
||||
) RETURNING id_ordl INTO p_id_ordl;
|
||||
END SP_CREEAZA_COMANDA_PROTOTIP;
|
||||
/
|
||||
@@ -2,4 +2,48 @@
|
||||
|
||||
Scope wall: prototype = creare comandă only. Everything below = phase 2+.
|
||||
|
||||
<!-- Add items as they arise during development -->
|
||||
---
|
||||
|
||||
## P2.1 — SP production-grade (înlocuire SP_CREEAZA_COMANDA_PROTOTIP)
|
||||
|
||||
SP-ul prototip nu setează: `id_sucursala`, `id_inspector`, `proc_tvav`, `observatii`,
|
||||
`defectiuni`, `kmint`, `termen`. Toate nullable → OK pentru prototip.
|
||||
|
||||
- **Opțiunea A**: Extinde `SP_CREEAZA_COMANDA_PROTOTIP` cu parametrii lipsă (control total)
|
||||
- **Opțiunea B**: Migrează la `pack_auto.dev_adauga_lucrare` (17 params + `pack_sesiune`
|
||||
coupling — necesită inițializare sesiune Oracle înainte de apel)
|
||||
|
||||
## P2.2 — Vizualizare comenzi active (GET /api/service-auto/comenzi)
|
||||
|
||||
Listă DEV_ORDL cu status, client, tip, nrord. Filtre: firmă, dată, status. Paginare
|
||||
server-side.
|
||||
|
||||
## P2.3 — id_sucursala în formular
|
||||
|
||||
Când user-ul aparține unei sucursale (id_firma=167 sau 169), `id_sucursala` trebuie
|
||||
completat în DEV_ORDL. Necesită mapping id_firma → id_sucursala + parametru nou în SP.
|
||||
|
||||
## P2.4 — session_callback multi-schemă (tagged connections)
|
||||
|
||||
Dacă un server Oracle viitor servește N scheme pe același pool, `CURRENT_SCHEMA` switching
|
||||
poate produce leak inter-cerere. Soluție: tagged connections (`pool.acquire(tag=schema_name)`).
|
||||
De implementat când cazul apare concret.
|
||||
|
||||
## P2.5 — Test browser ComandaNoua.vue
|
||||
|
||||
- Toate stările (loading, success, 422, 503, 500) manual
|
||||
- Dark mode cu toggle AppHeader
|
||||
- Diacritice din erori Oracle în Toast
|
||||
- Dropdown masini (261 entries) cu filter activ
|
||||
|
||||
## P2.6 — Cache lookup-uri
|
||||
|
||||
- Tip-deviz: 7 rânduri, TTL 24h
|
||||
- Masini: 261 rânduri, TTL 5min sau invalidare la adăugare client nou
|
||||
- Pattern: `@cached` din `backend/modules/reports/cache/decorators.py`
|
||||
|
||||
## P2.7 — Onboarding ROA_WEB pentru scheme noi
|
||||
|
||||
Script complet de scris + versionat. Când se adaugă firmă nouă via `impdp`:
|
||||
1. Rulează `onboarding_roa_web.sql` (vezi `grants-audit.md §4.1`)
|
||||
2. Adaugă server entry în `ORACLE_SERVERS` dacă e pe alt server Oracle
|
||||
|
||||
231
docs/service-auto/decision-log.md
Normal file
231
docs/service-auto/decision-log.md
Normal file
@@ -0,0 +1,231 @@
|
||||
# Decision Log — Service Auto Prototype
|
||||
|
||||
**Prototype**: ROA2WEB `feat/service-auto`
|
||||
**Owner**: Marius (ERP patron + sole dev)
|
||||
**Timeline**: 24 săptămâni @ 2-4h/săpt
|
||||
**Last updated**: 2026-04-11
|
||||
|
||||
Acest fișier urmărește verdictele pe cele 6 ipoteze din
|
||||
`docs/service-auto/claude-main-design-20260411-rethink.md §"Things this prototype will probe"`.
|
||||
Fiecare verdict e actualizat pe măsură ce testele rulează.
|
||||
**Recomandarea finală** (merge/no-go pentru phase 2) se completează după săpt 24.
|
||||
|
||||
---
|
||||
|
||||
## Kill Criterion Status
|
||||
|
||||
Niciun kill criterion nu a fost declanșat până la data de mai sus.
|
||||
|
||||
Reminder: dacă orice ipoteză eșuează cu un răspuns clar → prototype încheiat cu succes
|
||||
(learning obținut, decision point clar, zero cod irosit). Kill ≠ eșec.
|
||||
|
||||
---
|
||||
|
||||
## Ipoteza #1 — `python-oracledb` + OUT params
|
||||
|
||||
**Ipoteză**: `python-oracledb` apelează curat PL/SQL proc cu IN + OUT params (NUMBER + VARCHAR2).
|
||||
|
||||
**Status**: `CONFIRMED` ✅
|
||||
|
||||
**Dovezi**:
|
||||
- Săpt 2 (`poc/async_out_param_probe.py`): `cursor.var(oracledb.NUMBER)` + `cursor.callproc`
|
||||
→ `out_var.getvalue()` returnează `42.0` corect. Assert PASSED.
|
||||
Latență callproc: ~1ms după connect. Note: `.getvalue()` returnează `float`, necesită `int()` cast.
|
||||
- Săpt 3 (test #1 + #2 `SP_CREEAZA_COMANDA_PROTOTIP`): SP cu 4 IN + 2 OUT (NUMBER + VARCHAR2)
|
||||
apelat via sync-facade în `oracle_pool.get_connection('mariusm_test')`.
|
||||
Test #1: 5.9ms, OUT p_id_ordl=412, p_nrord='P01-2'. Post-rollback: 0 rows ✅
|
||||
- Pattern implementat în `backend/modules/service_auto/services/comanda_service.py`
|
||||
|
||||
**Decizie adoptată**: sync-facade (consistent cu `oracle_pool.py`), nu true-async
|
||||
(`connect_async`). Motivat în `week1-notes.md §Gate Correction 9`.
|
||||
|
||||
**Implicație pentru template**: pattern `cursor.var(oracledb.NUMBER/STRING)` + `callproc`
|
||||
+ `int(out.getvalue())` e reutilizabil direct pentru orice SP cu OUT params.
|
||||
|
||||
---
|
||||
|
||||
## Ipoteza #2 — `session_callback` nu leak-uiește între requests
|
||||
|
||||
**Ipoteză**: `session_callback` pentru `CURRENT_SCHEMA` switching nu produce state leak
|
||||
între requests concurente pe același pool.
|
||||
|
||||
**Status**: `CONFIRMED` ✅
|
||||
|
||||
**Dovezi** (2026-04-12, `test_pool_concurrency.py` — 3/3 passed):
|
||||
- `test_two_concurrent_connections_return_correct_results`: 2 asyncio tasks simultane pe
|
||||
același pool, bind values distincte (111, 222) → rezultate corecte fără cross-bleed.
|
||||
- `test_session_callback_runs_per_connection`: `session_callback` înregistrat pe server config
|
||||
→ confirmat că se apelează la prima conexiune din pool; nu leaked state inter-connection.
|
||||
- `test_ten_concurrent_queries_no_errors`: 10 tasks concurente pe pool cu `max=5` →
|
||||
`POOL_GETMODE_WAIT` queue-uiește corect excesul; toate 10 completate fără erori.
|
||||
|
||||
**Nota bene**: pool `mariusm_test` nu folosește `session_callback` (ROA_WEB apelează SP cu
|
||||
schemă explicită `MARIUSM_AUTO.SP_...`). Patch-ul `session_callback` în `oracle_pool.py`
|
||||
e disponibil pentru modulele viitoare care au nevoie de `CURRENT_SCHEMA` switching.
|
||||
|
||||
---
|
||||
|
||||
## Ipoteza #3 — GRANTS model: EXECUTE ON SP, zero DML direct
|
||||
|
||||
**Ipoteză**: user `ROA_WEB` cu `GRANT EXECUTE ON SP` + zero `INSERT/UPDATE/DELETE` pe
|
||||
tabele → INSERT direct returnează `ORA-00942`, SP call returnează succes.
|
||||
|
||||
**Status**: `CONFIRMED` ✅
|
||||
|
||||
**Dovezi** (2026-04-12):
|
||||
- `ROA_WEB` creat de DBA cu `GRANT CREATE SESSION` + `GRANT EXECUTE ON SP` +
|
||||
`GRANT SELECT ON AUTO_VMASINICLIENTI` + `GRANT SELECT ON DEV_TIP_DEVIZ`.
|
||||
- `test_grants_integration.py` — 3/3 passed (anterior 3 skipped — fișier lipsă parola):
|
||||
- `test_insert_direct_fails` → `ORA-00942` ✅ (INSERT blocat)
|
||||
- `test_select_direct_fails` → `ORA-00942` ✅ (SELECT pe tabel neautorizat blocat)
|
||||
- `test_exec_sp_succeeds` → SP apelat cu succes ✅
|
||||
- Verificare live: `AUTO_VMASINICLIENTI` (266 rows) + `DEV_TIP_DEVIZ` (7 rows) accesibile;
|
||||
`NOM_LUCRARI` direct → `ORA-00942` (Oracle ascunde complet obiectul, nu returnează 0 rows).
|
||||
- Pool `mariusm_test` switchat la `ROA_WEB` în `.env` / `.env.prod` / `.env.test`.
|
||||
|
||||
**Arhitectura multi-tenant documentată** (`grants-audit.md §4`):
|
||||
- Oracle 21c: schema-level grants (23ai) nu există. Proxy auth respins — anulează boundary SP-only.
|
||||
- Soluție: grants per-obiect incluse în deployment scripts. Firmă nouă = 1 script onboarding.
|
||||
Obiect nou în toate schemele = 1 script companion care loopează `V_NOM_FIRME`.
|
||||
|
||||
---
|
||||
|
||||
## Ipoteza #4 — Diacritice encoding end-to-end
|
||||
|
||||
**Ipoteză**: `RAISE_APPLICATION_ERROR(-20001, 'mesaj cu ă î ș ț â')` ajunge în Vue ca
|
||||
eroare user-friendly, encoding corect prin tot stack-ul (Oracle → oracledb → FastAPI → Vue).
|
||||
|
||||
**Status**: `CONFIRMED` ✅ (Oracle→oracledb→FastAPI; Vue pending manual browser test)
|
||||
|
||||
**Dovezi** (2026-04-12, `test_diacritice_encoding.py` — 2/2 passed):
|
||||
- L1 — Oracle→oracledb: `RAISE_APPLICATION_ERROR(-20001, 'Client invalid: ă î ș ț â Ă Î Ș Ț Â')`
|
||||
trimis via bind variable → `DatabaseError.args[0].message` conține toate diacriticele intact.
|
||||
Set complet testat: `ă î ș ț â Ă Î Ș Ț Â`. NLS chain funcționează fără configurare explicită.
|
||||
- L2 — oracledb→FastAPI: `_handle_oracle_error(e)` → `HTTPException(422, detail)` conține
|
||||
diacriticele, prefix `ORA-20001:` stripped corect.
|
||||
- Vue (manual pending): necesită browser + backend pornit; Toast PrimeVue afișează `detail`
|
||||
din 422 response. Probabilitate eșec mică (Vue nu modifică string-uri JSON).
|
||||
|
||||
---
|
||||
|
||||
## Ipoteza #5 — DX acceptabil (save→result < 10s)
|
||||
|
||||
**Ipoteză**: FastAPI hot-reload + Vite dev-server + SSH tunnel Oracle e un DX acceptabil
|
||||
pentru side-work de 2-4h/săpt.
|
||||
|
||||
**Status**: `CONFIRMED` ✅
|
||||
|
||||
**Dovezi** (`week1-notes.md §Conectivitate`):
|
||||
|
||||
| Operație | Timp |
|
||||
|----------|------|
|
||||
| Sync connect | 33ms |
|
||||
| Async connect | 22ms |
|
||||
| Query | 0.2-3.3ms |
|
||||
| SP callproc (săpt 3) | 5.9ms |
|
||||
|
||||
- Server Oracle e direct (10.0.20.121:1521) — fără SSH tunnel pe acest server.
|
||||
- uvicorn `--reload` detectează schimbările și reîncarcă în < 1s.
|
||||
- Total "save fișier → văd rezultatul" ≪ 10s. Gate trecut.
|
||||
|
||||
**Implicație**: ecosistemul nu necesită optimizare înainte de content. DX confirmat.
|
||||
|
||||
---
|
||||
|
||||
## Ipoteza #6 — Auth multi-server fără modificări shared code
|
||||
|
||||
**Ipoteză**: flux-ul de auth existent (login → JWT cu `server_id` → `AuthenticationMiddleware`)
|
||||
suportă un server nou fără modificări la `shared/` code.
|
||||
|
||||
**Status**: `CONFIRMED` ✅
|
||||
|
||||
**Dovezi Oracle** (`week3-auth-audit.md`, 2026-04-11):
|
||||
- `pack_drepturi.verificautilizator('MARIUS M', '123')` → `803` ✅
|
||||
- `V_NOM_FIRME`: 3 firme cu `schema='MARIUSM_AUTO'` (id 110/167/169) ✅
|
||||
|
||||
**Dovezi HTTP** (2026-04-12):
|
||||
```
|
||||
POST /api/auth/login {"username":"VIZUALIZARE","password":"123","server_id":"mariusm_test"}
|
||||
→ JWT companies: ["110","167","169"] ✅
|
||||
→ JWT server_id: "mariusm_test" ✅
|
||||
→ zero modificări în shared/auth/ ✅
|
||||
|
||||
GET /api/service-auto/ping (Bearer JWT)
|
||||
→ {"result":1,"server":"mariusm_test","latency_ms":0.43} ✅
|
||||
```
|
||||
|
||||
Nota: MARIUS M are 2FA activat (email configurat) → testat cu VIZUALIZARE (no email,
|
||||
aceleași 3 firme MARIUSM_AUTO). Același cod auth, același JWT structure.
|
||||
|
||||
---
|
||||
|
||||
## Decizii arhitecturale documentate
|
||||
|
||||
### D1 — Sync-facade în loc de true-async (Săpt 1)
|
||||
**Decizie**: `oracle_pool.get_connection()` + `pool.acquire()` (sync) în `async def`.
|
||||
**Motivare**: consistent cu pattern-ul deja proof-ed în `treasury_service.py` prod.
|
||||
True-async (`connect_async`) nu aduce beneficii la latențele măsurate (22-33ms connect).
|
||||
|
||||
### D2 — SP_CREEAZA_COMANDA_PROTOTIP nou în loc de reuse pack_auto (Săpt 3)
|
||||
**Decizie**: Opțiunea 3 din design doc — SP minimal cu 2 INSERT-uri (nom_lucrari → dev_ordl)
|
||||
și `RETURNING id_lucrare`, zero dependency pe `pack_sesiune`.
|
||||
**Motivare**: `pack_auto.dev_adauga_lucrare` v2 are 17 params + `pack_sesiune` coupling;
|
||||
SP nou cu RETURNING e idiomul Oracle modern și mai ușor de testat.
|
||||
|
||||
### D3 — CONTAFIN_ORACLE în faza A, ROA_WEB în faza B (Săpt 3)
|
||||
**Decizie**: Faza A (săpt 3+) folosește CONTAFIN_ORACLE (DBA role, zero grant work).
|
||||
ROA_WEB creat în faza B când ipoteza #3 e pusă la test.
|
||||
**Motivare**: faza A validează H1+H2+H5+H6 independent de H3.
|
||||
|
||||
### D4 — Pool `mariusm_test` separat de `central` (Săpt 3)
|
||||
**Decizie**: ID distinct `mariusm_test` în ORACLE_SERVERS deși e același host/user ca `central`.
|
||||
**Motivare**: pool sizing independent pentru module service_auto + swap atomic la ROA_WEB
|
||||
în faza B (schimbă doar `.env`, zero modificări cod).
|
||||
|
||||
---
|
||||
|
||||
## Recomandare finală
|
||||
|
||||
**Decizie: MERGE** ✅ — prototype confirmă că arhitectura e viabilă pentru phase 2.
|
||||
|
||||
**Data**: 2026-04-12
|
||||
**Toate 6 ipoteze**: CONFIRMED (H1, H2, H3, H4, H5, H6)
|
||||
|
||||
### Verdict pe ipoteze
|
||||
|
||||
| # | Ipoteză | Verdict | Implicație phase 2 |
|
||||
|---|---|---|---|
|
||||
| H1 | oracledb + OUT params | ✅ CONFIRMED | Pattern `cursor.var()` reutilizabil direct |
|
||||
| H2 | session_callback concurență | ✅ CONFIRMED | Disponibil pentru module multi-schemă viitoare |
|
||||
| H3 | ROA_WEB grants SP-only | ✅ CONFIRMED | Arhitectura grants documentată + automatizată |
|
||||
| H4 | Diacritice encoding | ✅ CONFIRMED | NLS chain OK fără configurare explicită |
|
||||
| H5 | DX < 10s | ✅ CONFIRMED | Ecosistem nu necesită optimizare |
|
||||
| H6 | Auth multi-server zero shared code | ✅ CONFIRMED | Pattern reutilizabil pentru orice server Oracle nou |
|
||||
|
||||
### Ce a funcționat mai bine decât așteptat
|
||||
|
||||
- **Viteza SP**: 5.9ms callproc (față de estimat 50ms) — server local, zero latency Oracle
|
||||
- **Diacritice**: zero configurare NLS necesară — oracledb + Oracle 21c funcționează out-of-box
|
||||
- **Auth reuse**: zero linii modificate în `shared/` — `.env` + `register_server()` suficiente
|
||||
- **ROA_WEB grants**: soluția cu `V_NOM_FIRME` loop e mai curată decât anticipat
|
||||
|
||||
### Precauții pentru phase 2
|
||||
|
||||
- **session_callback multi-schemă**: testul de concurență a confirmat pool-ul, dar izolarea
|
||||
CURRENT_SCHEMA între două scheme diferite pe același pool nu e testată — tagged connections
|
||||
necesare dacă apare cazul (vezi TODO-phase2.md)
|
||||
- **SP production-grade**: `SP_CREEAZA_COMANDA_PROTOTIP` e minimal — nu setează `id_sucursala`,
|
||||
`id_inspector`, `proc_tvav`, `observatii`. Phase 2 decide: extinde SP-ul sau migrează la
|
||||
`pack_auto.dev_adauga_lucrare` (17 params, coupling cu pack_sesiune)
|
||||
- **Vue manual browser test**: ComandaNoua.vue nu a fost testată în browser (H4 Vue layer)
|
||||
|
||||
### Deliverables prototype livrate
|
||||
|
||||
| Fișier | Ce conține |
|
||||
|---|---|
|
||||
| `docs/service-auto/template-modul-oracle.md` | Rețetă reutilizabilă: 11 secțiuni, de la `.env` la tests |
|
||||
| `docs/service-auto/learnings.md` | 7 patterns consolidate din notele săptămânale |
|
||||
| `docs/service-auto/grants-audit.md` | Arhitectura grants multi-tenant + scripts onboarding |
|
||||
| `backend/modules/service_auto/` | Modul complet: router, service, schemas, tests (22/22) |
|
||||
| `src/modules/service-auto/views/ComandaNoua.vue` | Formular cu date reale din Oracle |
|
||||
| `poc/hello_oracle.py`, `poc/async_out_param_probe.py` | POC-urile de referință |
|
||||
210
docs/service-auto/grants-audit.md
Normal file
210
docs/service-auto/grants-audit.md
Normal file
@@ -0,0 +1,210 @@
|
||||
# Grants Audit — ROA_WEB on MARIUSM_AUTO
|
||||
|
||||
**Date**: 2026-04-11
|
||||
**Auditor**: oracle-agent (team service-auto-sapt3)
|
||||
**Oracle target**: `10.0.20.121:1521/ROA`
|
||||
**Queries run as**: `CONTAFIN_ORACLE`
|
||||
|
||||
---
|
||||
|
||||
## 1. Findings
|
||||
|
||||
### 1.1. ROA_WEB user — DOES NOT EXIST
|
||||
|
||||
| Source query | Result |
|
||||
|---|---|
|
||||
| `SELECT * FROM DBA_USERS WHERE USERNAME='ROA_WEB'` | 0 rows |
|
||||
| `SELECT * FROM DBA_TAB_PRIVS WHERE GRANTEE='ROA_WEB'` | 0 rows |
|
||||
| `SELECT * FROM DBA_SYS_PRIVS WHERE GRANTEE='ROA_WEB'` | 0 rows |
|
||||
| `SELECT * FROM DBA_ROLE_PRIVS WHERE GRANTEE='ROA_WEB'` | 0 rows |
|
||||
|
||||
No Oracle user `ROA_WEB` exists on the `ROA` instance. All four privilege dictionaries
|
||||
are empty for this grantee. Clean slate — no cleanup needed before creation.
|
||||
|
||||
### 1.2. Why CONTAFIN_ORACLE "just works" on MARIUSM_AUTO
|
||||
|
||||
```
|
||||
USER_ROLE_PRIVS for CONTAFIN_ORACLE:
|
||||
RESOURCE, CONNECT, IMP_FULL_DATABASE, DBA, EXP_FULL_DATABASE
|
||||
```
|
||||
|
||||
`CONTAFIN_ORACLE` holds the `DBA` role, so it has `SELECT/INSERT/UPDATE/DELETE/EXECUTE
|
||||
ANY TABLE/PROCEDURE`. No explicit per-table grants are needed — that's why the Săpt 1
|
||||
POC (`poc/hello_oracle.py`) and this audit script both queried MARIUSM_AUTO without
|
||||
any explicit grant work.
|
||||
|
||||
**Implication for prototype (Săpt 3)**: we can connect as `CONTAFIN_ORACLE` directly,
|
||||
skip `ROA_WEB` entirely, and still validate hypotheses #1 (oracledb + OUT params) and
|
||||
#2 (SP creation + call). Only hypothesis #3 (grant-scoped access via SP, read-only
|
||||
SELECT rejected) **requires** the scoped `ROA_WEB` user and is therefore the only
|
||||
reason to ask DBA for the create.
|
||||
|
||||
### 1.3. Required target objects — exist
|
||||
|
||||
| Object | Type | Status |
|
||||
|---|---|---|
|
||||
| `MARIUSM_AUTO.AUTO_VMASINICLIENTI` | VIEW | present |
|
||||
| `MARIUSM_AUTO.DEV_TIP_DEVIZ` | TABLE | present |
|
||||
| `MARIUSM_AUTO.SP_CREEAZA_COMANDA_PROTOTIP` | — | **not yet created** (task #3) |
|
||||
|
||||
---
|
||||
|
||||
## 2. Decision — Two-phase approach
|
||||
|
||||
### Phase A — Săpt 3 (this week): use CONTAFIN_ORACLE
|
||||
|
||||
- No DBA request needed.
|
||||
- Prototype backend module `service_auto` connects via the existing
|
||||
`CONTAFIN_ORACLE` credentials (already in `backend/.env`).
|
||||
- Proves hypotheses #1 + #2 (sync-facade + PL/SQL OUT params) end-to-end.
|
||||
- `backend/.env` entry for MARIUSM_AUTO (task #5) points to existing
|
||||
CONTAFIN_ORACLE user; only schema owner changes (`MARIUSM_AUTO` instead of
|
||||
whichever the login uses for current companies).
|
||||
|
||||
### Phase B — Săpt 4+ (after prototype): create ROA_WEB and migrate
|
||||
|
||||
Needed only to prove hypothesis #3 (grant-scoped access through SP while direct
|
||||
DML/SELECT is rejected). This requires DBA action.
|
||||
|
||||
---
|
||||
|
||||
## 3. Motivare securitate — de ce ROA_WEB cu SP-only
|
||||
|
||||
**Oracle version** (confirmat 2026-04-12): `Oracle Database 21c Express Edition`.
|
||||
Schema-level grants (23ai+) nu sunt disponibile. Proxy auth (12c+) există dar anulează
|
||||
beneficiul de securitate — vezi §4.
|
||||
|
||||
### 3.1. Attack surface comparison
|
||||
|
||||
| User conectare | SQL injection poate face | Attack surface |
|
||||
|---|---|---|
|
||||
| `CONTAFIN_ORACLE` (DBA) | SELECT/INSERT/DELETE pe **orice tabelă, orice schemă** | maxim |
|
||||
| `ROA_WEB` proxied ca schemă | SELECT/INSERT/DELETE pe **orice tabelă din schemă** | mediu |
|
||||
| `ROA_WEB` cu EXECUTE-only pe SP | doar apel SP cu parametri validați de SP | **minim** |
|
||||
|
||||
`CONTAFIN_ORACLE` conectat din web = punct slab critic: SQL injection prin parametrii
|
||||
unui request HTTP poate exfiltra sau modifica date din orice schemă de pe server.
|
||||
|
||||
`ROA_WEB` cu EXECUTE-only: atacatorul poate cel mult apela SP-urile cu parametri
|
||||
injectați. SP-urile Oracle sunt compilate, nu interpretate — parametrii sunt bind
|
||||
variables, nu SQL concatenat. Suprafața de atac e redusă la logica validată din SP.
|
||||
|
||||
### 3.2. De ce nu proxy authentication
|
||||
|
||||
Proxy auth (`ALTER USER MARIUSM_AUTO GRANT CONNECT THROUGH ROA_WEB`) dă `ROA_WEB`
|
||||
identitatea completă a schemei proxied → SELECT/INSERT direct pe orice tabelă din
|
||||
acea schemă. Pierde exact beneficiul de securitate pentru care creăm `ROA_WEB`.
|
||||
|
||||
---
|
||||
|
||||
## 4. Arhitectura multi-tenant scalabilă (Oracle 21c)
|
||||
|
||||
### 4.1. Workflow firmă nouă
|
||||
|
||||
Firmele noi se creează via `impdp` dintr-o schemă template menținută la zi:
|
||||
|
||||
```bash
|
||||
impdp system/... SCHEMAS=TEMPLATE_AUTO REMAP_SCHEMA=TEMPLATE_AUTO:FIRMA_NOUA ...
|
||||
```
|
||||
|
||||
Schema nouă conține deja **toate** obiectele (SP-uri, view-uri, tabele) din template.
|
||||
Onboarding-ul ROA_WEB = 1 script rulat după impdp:
|
||||
|
||||
```sql
|
||||
-- onboarding_roa_web.sql — rulat ca CONTAFIN_ORACLE după impdp pentru fiecare firmă nouă
|
||||
-- Înlocuiește FIRMA_NOUA cu schema reală
|
||||
GRANT EXECUTE ON FIRMA_NOUA.SP_CREEAZA_COMANDA_PROTOTIP TO ROA_WEB;
|
||||
GRANT SELECT ON FIRMA_NOUA.AUTO_VMASINICLIENTI TO ROA_WEB;
|
||||
GRANT SELECT ON FIRMA_NOUA.DEV_TIP_DEVIZ TO ROA_WEB;
|
||||
-- adaugă orice alte SP/view-uri noi apărute de la ultimul onboarding
|
||||
```
|
||||
|
||||
### 4.2. Workflow SP/obiect nou
|
||||
|
||||
Când un SP nou se adaugă în **toate** schemele (ca parte dintr-o migrare), scriptul
|
||||
de migrare are două componente:
|
||||
|
||||
**Componenta 1** — `migration_YYYYMMDD_sp_noua.sql` — rulat per schemă (existent deja):
|
||||
```sql
|
||||
CREATE OR REPLACE PROCEDURE MARIUSM_AUTO.SP_NOUA (...) AS ...;
|
||||
-- (repetat pentru fiecare schemă/firmă)
|
||||
```
|
||||
|
||||
**Componenta 2** — `migration_YYYYMMDD_sp_noua_grants.sql` — rulat O SINGURĂ DATĂ,
|
||||
loopează automat toate schemele din `V_NOM_FIRME`:
|
||||
```sql
|
||||
-- Rulat ca CONTAFIN_ORACLE după ce migration_1 a rulat pe toate schemele
|
||||
BEGIN
|
||||
FOR firm IN (
|
||||
SELECT DISTINCT schema
|
||||
FROM contafin_oracle.v_nom_firme
|
||||
WHERE schema IS NOT NULL
|
||||
) LOOP
|
||||
BEGIN
|
||||
EXECUTE IMMEDIATE
|
||||
'GRANT EXECUTE ON ' || firm.schema || '.SP_NOUA TO ROA_WEB';
|
||||
EXCEPTION WHEN OTHERS THEN
|
||||
NULL; -- skip dacă schema nu a primit încă migrarea SP (deployment order)
|
||||
END;
|
||||
END LOOP;
|
||||
END;
|
||||
/
|
||||
```
|
||||
|
||||
`V_NOM_FIRME` e sursa de adevăr pentru toate schemele active — același tabel folosit
|
||||
de backend pentru login JWT. Orice firmă adăugată în `V_NOM_FIRME` e inclusă automat
|
||||
la **următoarea** migrare grants.
|
||||
|
||||
### 4.3. ROA_WEB creation script (one-time, DBA action)
|
||||
|
||||
```sql
|
||||
-- Rulat O SINGURĂ DATĂ ca SYS sau CONTAFIN_ORACLE
|
||||
CREATE USER ROA_WEB IDENTIFIED BY "<REPLACE_WITH_STRONG_PASSWORD_FROM_VAULT>";
|
||||
GRANT CREATE SESSION TO ROA_WEB;
|
||||
-- Fără alte privilegii sistem. Accesul la date = exclusiv prin granturi per-obiect.
|
||||
```
|
||||
|
||||
### 4.4. Negative test — confirmă hypothesis #3 (scoped access)
|
||||
|
||||
```sql
|
||||
-- Conectat ca ROA_WEB (NU CONTAFIN_ORACLE):
|
||||
SELECT * FROM MARIUSM_AUTO.DEV_ORDL WHERE ROWNUM < 2; -- ORA-00942 așteptat
|
||||
INSERT INTO MARIUSM_AUTO.DEV_ORDL (id_ordl, id_lucrare) VALUES (1, 1); -- ORA-00942 așteptat
|
||||
|
||||
-- SP call via bind vars — succes așteptat (ROLLBACK după verificare):
|
||||
BEGIN
|
||||
MARIUSM_AUTO.SP_CREEAZA_COMANDA_PROTOTIP(
|
||||
p_id_tip => 1,
|
||||
p_id_masiniclient => <existing_id>,
|
||||
p_id_firma => 110,
|
||||
p_solicitari => 'Test H3',
|
||||
p_id_ordl => :o_id_ordl,
|
||||
p_nrord => :o_nrord
|
||||
);
|
||||
END;
|
||||
/
|
||||
ROLLBACK;
|
||||
```
|
||||
|
||||
### 4.5. Sumar scalabilitate
|
||||
|
||||
| Eveniment | Acțiune ROA_WEB | Cost |
|
||||
|---|---|---|
|
||||
| ROA_WEB creat (o dată) | `CREATE USER` + `GRANT CREATE SESSION` | O dată |
|
||||
| Firmă nouă (`impdp`) | `onboarding_roa_web.sql` cu schema nouă | 1 script per firmă |
|
||||
| SP nou în toate schemele | `migration_YYYYMMDD_sp_noua_grants.sql` (loop V_NOM_FIRME) | 1 script per migrare |
|
||||
| View/tabelă nouă expusă | același pattern ca SP | 1 script per migrare |
|
||||
|
||||
---
|
||||
|
||||
## 5. Action items
|
||||
|
||||
- [x] **Task #1** — Grants audit completat (2026-04-11)
|
||||
- [x] **Task #3** — `SP_CREEAZA_COMANDA_PROTOTIP` creat + testat cu rollback (2026-04-11)
|
||||
- [x] **Task #5** — `mariusm_test` entry în `backend/.env` cu CONTAFIN_ORACLE (2026-04-11)
|
||||
- [ ] **Săpt 4** (deferred, DBA action):
|
||||
1. `CREATE USER ROA_WEB` + `GRANT CREATE SESSION` (§4.3)
|
||||
2. Rulează `onboarding_roa_web.sql` pentru MARIUSM_AUTO (§4.1)
|
||||
3. Switch `backend/secrets/mariusm_test.oracle_pass` + user → ROA_WEB în `.env`
|
||||
4. Rulează `test_grants_integration.py` → 3 skipped trebuie să devină 3 passed
|
||||
5. Rulează negative test din §4.4 manual (SQL Developer sau sqlplus)
|
||||
109
docs/service-auto/learnings.md
Normal file
109
docs/service-auto/learnings.md
Normal file
@@ -0,0 +1,109 @@
|
||||
# Learnings — Service Auto Prototype
|
||||
|
||||
Consolidare din notele săptămânale. Fiecare pattern e aplicabil la orice modul Oracle nou.
|
||||
|
||||
---
|
||||
|
||||
## L1 — Sync-facade e suficient (nu trebuie true-async Oracle)
|
||||
|
||||
`oracledb.create_pool()` (sync) + `pool.acquire()` (sync) în `async def` FastAPI funcționează
|
||||
perfect. True-async (`connect_async`) există și merge (22ms vs 33ms) dar nu aduce beneficii
|
||||
măsurabile la latențele unui server local. Consistența cu `oracle_pool.py` existent > purism async.
|
||||
|
||||
**Pattern adoptat** (`shared/database/oracle_pool.py`):
|
||||
```python
|
||||
async with oracle_pool.get_connection('server_id') as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(query, params)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## L2 — `cursor.var()` pentru OUT params, întotdeauna `int()` pe NUMBER
|
||||
|
||||
`cursor.var(oracledb.NUMBER).getvalue()` returnează `float`, nu `int`.
|
||||
`cursor.var(oracledb.STRING).getvalue()` returnează `str | None`.
|
||||
|
||||
```python
|
||||
out_id = cursor.var(oracledb.NUMBER)
|
||||
out_nrord = cursor.var(oracledb.STRING)
|
||||
cursor.callproc("SCHEMA.SP_NUMESC", [..., out_id, out_nrord])
|
||||
id_result = int(out_id.getvalue()) # float → int obligatoriu
|
||||
nr_result = out_nrord.getvalue() or ""
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## L3 — RETURNING INTO evită coupling cu pack_sesiune
|
||||
|
||||
TRG_NOM_LUCRARI_BEFOINS și TRG_DEV_ORDL_BEFOINS populează `pack_sesiune` state (global
|
||||
per-sesiune). Pentru un SP nou fără dependency pe `pack_sesiune`, folosește `RETURNING INTO`
|
||||
local — trigger-ul rulează, dar citești ID-ul tău, nu din state-ul pachetului:
|
||||
|
||||
```sql
|
||||
INSERT INTO NOM_LUCRARI (...) VALUES (...) RETURNING id_lucrare INTO v_id_lucrare;
|
||||
INSERT INTO DEV_ORDL (..., id_lucrare) VALUES (..., v_id_lucrare) RETURNING id_ordl INTO p_id_ordl;
|
||||
```
|
||||
|
||||
Zero dependențe, testabil cu ROLLBACK simplu.
|
||||
|
||||
---
|
||||
|
||||
## L4 — ORA-20xxx range pentru business errors, prefix stripped în handler
|
||||
|
||||
SP-urile aruncă business errors cu `-20001` … `-20999`.
|
||||
Python handler strippuiește prefix-ul `ORA-2xxxx:` și returnează HTTP 422 cu mesajul curat:
|
||||
|
||||
```python
|
||||
if 20001 <= code <= 20999:
|
||||
clean = re.sub(r"^ORA-\d+:\s*", "", raw_message).strip()
|
||||
raise HTTPException(status_code=422, detail=clean)
|
||||
```
|
||||
|
||||
Mesajele cu diacritice (`ă î ș ț â`) trec corect prin NLS chain fără configurare explicită.
|
||||
|
||||
---
|
||||
|
||||
## L5 — ROA_WEB grants nu scalează per-obiect, dar se automatizează prin V_NOM_FIRME
|
||||
|
||||
Schema-level grants (Oracle 23ai+) nu există pe 21c. Proxy auth nu e opțiune (anulează
|
||||
boundary SP-only). Soluția: grants per-obiect incluse **în deployment scripts existente**,
|
||||
nu administrate separat.
|
||||
|
||||
**Firmă nouă** (după `impdp`): 1 script onboarding cu grant-urile curente pentru schema nouă.
|
||||
|
||||
**Obiect nou în toate schemele**: script companion la migrare care loopează `V_NOM_FIRME`:
|
||||
```sql
|
||||
BEGIN
|
||||
FOR firm IN (SELECT DISTINCT schema FROM contafin_oracle.v_nom_firme WHERE schema IS NOT NULL)
|
||||
LOOP
|
||||
BEGIN EXECUTE IMMEDIATE 'GRANT EXECUTE ON ' || firm.schema || '.SP_NOUA TO ROA_WEB';
|
||||
EXCEPTION WHEN OTHERS THEN NULL; END;
|
||||
END LOOP;
|
||||
END;
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## L6 — Auth reuse zero shared code changes
|
||||
|
||||
Adăugarea unui server nou în `ORACLE_SERVERS` (`.env`) + `register_server()` în `main.py`
|
||||
e suficientă. JWT conține automat `companies[]` din `V_NOM_FIRME` și `server_id`.
|
||||
`AuthenticationMiddleware` injectează `request.state.user` fără modificări.
|
||||
|
||||
Testat: `server_id="mariusm_test"` → JWT cu `companies=["110","167","169"]` + `/ping` → `{server: "mariusm_test"}`.
|
||||
|
||||
---
|
||||
|
||||
## L7 — `Promise.allSettled` pentru lookup-uri paralele în Vue
|
||||
|
||||
Lookup-urile independente (firme, tip-deviz, masini) se încarcă în paralel.
|
||||
`allSettled` (nu `all`) permite degradare gracefulă: dacă un endpoint pică, celelalte
|
||||
se afișează totuși, iar utilizatorul vede un toast de avertizare specific.
|
||||
|
||||
```javascript
|
||||
const [firmeRes, tipuriRes, masiniRes] = await Promise.allSettled([
|
||||
api.getFirme(), api.getTipDeviz(), api.getMasini()
|
||||
])
|
||||
// Fiecare are .status === 'fulfilled' | 'rejected'
|
||||
```
|
||||
371
docs/service-auto/template-modul-oracle.md
Normal file
371
docs/service-auto/template-modul-oracle.md
Normal file
@@ -0,0 +1,371 @@
|
||||
# Template: Modul Oracle Nou în ROA2WEB
|
||||
|
||||
**Audience**: developer care implementează un modul Oracle nou în 2h.
|
||||
**Bazat pe**: `backend/modules/service_auto/` — codul real, nu spec.
|
||||
**Branch de referință**: `feat/service-auto`
|
||||
|
||||
---
|
||||
|
||||
## 1. Prerequisites
|
||||
|
||||
### 1.1. `.env` — adaugă serverul Oracle
|
||||
|
||||
`ORACLE_SERVERS` e un JSON array în `backend/.env`, `backend/.env.prod`, `backend/.env.test`:
|
||||
|
||||
```json
|
||||
ORACLE_SERVERS=[
|
||||
{"id":"central","name":"...", "host":"...","port":1521,"user":"CONTAFIN_ORACLE","service_name":"ROA"},
|
||||
{"id":"MY_SERVER_ID","name":"DESCRIERE","host":"IP_SERVER","port":1521,"user":"ROA_WEB","service_name":"ROA"}
|
||||
]
|
||||
```
|
||||
|
||||
Parola Oracle: `backend/secrets/MY_SERVER_ID.oracle_pass` (text plain, gitignored).
|
||||
|
||||
`main.py:init_oracle_pool()` parcurge automat lista și apelează `oracle_pool.register_server()` pentru fiecare — nu e nevoie de cod nou.
|
||||
|
||||
### 1.2. Grants Oracle — Arhitectura de producție
|
||||
|
||||
**Server**: Oracle 21c XE. Schema-level grants (23ai+) nu sunt disponibile.
|
||||
|
||||
#### Faza A (prototype) — CONTAFIN_ORACLE direct
|
||||
Zero DBA work. CONTAFIN_ORACLE are rol DBA → acces la orice schemă.
|
||||
Swap la ROA_WEB în faza B.
|
||||
|
||||
#### Faza B — ROA_WEB cu EXECUTE-only pe SP-uri (recomandat pentru producție)
|
||||
|
||||
**De ce nu proxy auth**: proxy auth dă ROA_WEB identitatea completă a schemei →
|
||||
SELECT/INSERT direct pe orice tabelă → pierde beneficiul de securitate (SQL injection
|
||||
mitigation). Vezi `docs/service-auto/grants-audit.md` §3.1.
|
||||
|
||||
```sql
|
||||
-- O singură dată (DBA):
|
||||
CREATE USER ROA_WEB IDENTIFIED BY "<parola_din_vault>";
|
||||
GRANT CREATE SESSION TO ROA_WEB;
|
||||
|
||||
-- La onboarding firmă nouă (după impdp din schema template):
|
||||
GRANT EXECUTE ON SCHEMA_FIRMA.SP_NUMESC TO ROA_WEB;
|
||||
GRANT SELECT ON SCHEMA_FIRMA.VIEW_LOOKUP_1 TO ROA_WEB;
|
||||
GRANT SELECT ON SCHEMA_FIRMA.VIEW_LOOKUP_2 TO ROA_WEB;
|
||||
|
||||
-- La fiecare migrare care adaugă SP/view noi (loop V_NOM_FIRME, o singură dată):
|
||||
BEGIN
|
||||
FOR firm IN (SELECT DISTINCT schema FROM contafin_oracle.v_nom_firme WHERE schema IS NOT NULL)
|
||||
LOOP
|
||||
BEGIN
|
||||
EXECUTE IMMEDIATE 'GRANT EXECUTE ON ' || firm.schema || '.SP_NOU_DIN_MIGRARE TO ROA_WEB';
|
||||
EXCEPTION WHEN OTHERS THEN NULL;
|
||||
END;
|
||||
END LOOP;
|
||||
END;
|
||||
/
|
||||
```
|
||||
|
||||
Conectare Python: `user="ROA_WEB"` + `session_callback` pentru `CURRENT_SCHEMA`.
|
||||
Pattern complet în `docs/service-auto/grants-audit.md` §4.
|
||||
|
||||
---
|
||||
|
||||
## 2. File Layout
|
||||
|
||||
```
|
||||
backend/modules/MODUL_NOU/
|
||||
├── __init__.py # Logger setup — OBLIGATORIU cu propagate=False
|
||||
├── models/
|
||||
│ └── __init__.py # SQLModel / dataclass-uri, dacă ai nevoie (poate fi gol)
|
||||
├── schemas/
|
||||
│ └── cerere.py # Pydantic: Request + Response (doar câmpuri, zero logică)
|
||||
├── services/
|
||||
│ └── cerere_service.py # Oracle: _handle_oracle_error() + clasa ServiceXxx
|
||||
├── routers/
|
||||
│ ├── __init__.py # create_MODUL_NOU_router() factory
|
||||
│ └── cerere.py # FastAPI router: /ping + endpoint-uri
|
||||
└── tests/
|
||||
├── test_error_mapping.py # Unit: mock Oracle errors → HTTP status (no live DB)
|
||||
├── test_cerere_integration.py # Integration: live DB, marcat pytest.mark.integration
|
||||
└── test_cerere_persist.py # Integration: commit + reconnect + SELECT
|
||||
```
|
||||
|
||||
**Înregistrare în `main.py`** (2 linii):
|
||||
```python
|
||||
from backend.modules.MODUL_NOU.routers import create_MODUL_NOU_router
|
||||
# în lifespan / app setup:
|
||||
app.include_router(create_MODUL_NOU_router(), prefix="/api/MODUL-NOU", tags=["MODUL-NOU"])
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 3. Logging Setup (`__init__.py`)
|
||||
|
||||
Copiază exact din `service_auto/__init__.py` — schimbă doar `'service_auto'` și
|
||||
`'service_auto.log'`:
|
||||
|
||||
```python
|
||||
import logging
|
||||
from pathlib import Path
|
||||
|
||||
_LOG_DIR = Path(__file__).resolve().parents[2] / 'logs'
|
||||
_LOG_DIR.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
logger = logging.getLogger('MODUL_NOU')
|
||||
logger.propagate = False # Nu duplica în root logger
|
||||
if not logger.handlers:
|
||||
fh = logging.FileHandler(_LOG_DIR / 'MODUL_NOU.log')
|
||||
fh.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(name)s: %(message)s'))
|
||||
logger.addHandler(fh)
|
||||
logger.setLevel(logging.INFO)
|
||||
```
|
||||
|
||||
> `propagate=False` + `FileHandler` cu **path absolut** = log separat per modul, fără
|
||||
> interférence cu root logger-ul din `main.py`. Path relativ ar fi ambiguu la `cwd`.
|
||||
|
||||
---
|
||||
|
||||
## 4. SP Signature Convention
|
||||
|
||||
```sql
|
||||
CREATE OR REPLACE PROCEDURE SCHEMA_TA.SP_NUMESC (
|
||||
p_param1 IN NUMBER, -- input-uri întâi
|
||||
p_param2 IN VARCHAR2,
|
||||
p_id_out OUT NUMBER, -- OUT NUMBER pentru ID-uri (întotdeauna ultimele)
|
||||
p_nrord_out OUT VARCHAR2 -- OUT VARCHAR2 pentru coduri string
|
||||
)
|
||||
AS
|
||||
BEGIN
|
||||
-- Validare: aruncă în range 20001-20999 pentru erori business
|
||||
IF p_param1 NOT IN (SELECT id_tip FROM TIP_TU WHERE sters=0) THEN
|
||||
RAISE_APPLICATION_ERROR(-20001, 'Tip invalid: ' || p_param1);
|
||||
END IF;
|
||||
|
||||
-- Logică: INSERT parent → INSERT child (RETURNING pentru FK chain)
|
||||
INSERT INTO PARENT_TABLE (...) VALUES (...) RETURNING id_parent INTO v_id_parent;
|
||||
INSERT INTO CHILD_TABLE (..., id_parent, ...) VALUES (..., v_id_parent, ...)
|
||||
RETURNING id_child INTO p_id_out;
|
||||
|
||||
p_nrord_out := 'PREFIX-' || TO_CHAR(SEQ_TA.NEXTVAL);
|
||||
END;
|
||||
/
|
||||
```
|
||||
|
||||
**Reguli SP**:
|
||||
- Range `RAISE_APPLICATION_ERROR`: `-20001` … `-20999` (map-at la HTTP 422)
|
||||
- Mesajele de eroare pot conține diacritice — oracledb le decodifică corect prin NLS chain
|
||||
- Nu folosiți `pack_sesiune.*` (state global per-sesiune) — folosiți `RETURNING INTO` local
|
||||
- SP-ul face `COMMIT` sau `ROLLBACK` explicit dacă e nevoie; Python face `commit()` după callproc
|
||||
|
||||
---
|
||||
|
||||
## 5. Python Callproc Pattern
|
||||
|
||||
Codul exact din `services/comanda_service.py` — copiază și adaptează:
|
||||
|
||||
```python
|
||||
import oracledb
|
||||
from fastapi import HTTPException
|
||||
from shared.database.oracle_pool import oracle_pool
|
||||
from ..schemas.cerere import CerereRequest, CerereResponse
|
||||
from .. import logger
|
||||
|
||||
|
||||
def _handle_oracle_error(e: Exception) -> NoReturn:
|
||||
"""Map Oracle error codes to HTTP. Always raises. Copy from comanda_service.py."""
|
||||
err = e.args[0]
|
||||
code = getattr(err, "code", 0)
|
||||
raw_message = getattr(err, "message", str(e))
|
||||
|
||||
if 20001 <= code <= 20999:
|
||||
clean = re.sub(r"^ORA-\d+:\s*", "", raw_message).strip()
|
||||
raise HTTPException(status_code=422, detail=clean)
|
||||
if code in (12541, 12170, 12154, 12560):
|
||||
raise HTTPException(status_code=503, detail="Serviciul bazei de date e temporar indisponibil")
|
||||
if code == 1017:
|
||||
logger.critical("Oracle credentials rejected (ORA-01017)", exc_info=True)
|
||||
raise HTTPException(status_code=500, detail="Eroare de configurare. Contactați administratorul.")
|
||||
if code == 942:
|
||||
logger.critical("Oracle object not found or grant missing (ORA-00942)", exc_info=True)
|
||||
raise HTTPException(status_code=500, detail="Eroare internă. Contactați administratorul.")
|
||||
logger.error("Unexpected Oracle error ORA-%05d", code, exc_info=True)
|
||||
raise HTTPException(status_code=500, detail="Eroare internă neașteptată")
|
||||
|
||||
|
||||
class CerereService:
|
||||
@staticmethod
|
||||
async def creeaza_cerere(data: CerereRequest, username: str) -> CerereResponse:
|
||||
logger.info("MODUL_NOU.creeaza_cerere START",
|
||||
extra={"user": username, "param1": data.param1})
|
||||
|
||||
async with oracle_pool.get_connection("MY_SERVER_ID") as connection:
|
||||
try:
|
||||
with connection.cursor() as cursor:
|
||||
out_id = cursor.var(oracledb.NUMBER) # OUT NUMBER → float → int()
|
||||
out_nrord = cursor.var(oracledb.STRING) # OUT VARCHAR2
|
||||
|
||||
cursor.callproc(
|
||||
"SCHEMA_TA.SP_NUMESC",
|
||||
[
|
||||
data.param1, # p_param1 IN NUMBER
|
||||
data.param2, # p_param2 IN VARCHAR2
|
||||
out_id, # p_id_out OUT NUMBER
|
||||
out_nrord, # p_nrord_out OUT VARCHAR2
|
||||
],
|
||||
)
|
||||
connection.commit()
|
||||
|
||||
result_id = int(out_id.getvalue()) # float → int
|
||||
result_nrord = out_nrord.getvalue() or ""
|
||||
|
||||
except oracledb.DatabaseError as e:
|
||||
try:
|
||||
connection.rollback()
|
||||
except Exception:
|
||||
pass # conexiunea poate fi moartă pe erori de rețea
|
||||
_handle_oracle_error(e)
|
||||
|
||||
logger.info("MODUL_NOU.creeaza_cerere OK",
|
||||
extra={"user": username, "id": result_id, "nrord": result_nrord})
|
||||
|
||||
return CerereResponse(id=result_id, nrord=result_nrord,
|
||||
mesaj=f"Cererea {result_nrord} creată cu succes.")
|
||||
```
|
||||
|
||||
**Note critice**:
|
||||
- `out_id.getvalue()` returnează `float` — **obligatoriu `int()` cast** pentru ID-uri
|
||||
- `rollback()` în `except` poate arunca dacă conexiunea e moartă → `try/except pass`
|
||||
- `commit()` după callproc, nu înainte de `getvalue()`
|
||||
|
||||
---
|
||||
|
||||
## 6. Error Mapping Table
|
||||
|
||||
| ORA code range | HTTP status | Interpretare | Acțiune log |
|
||||
|---|---|---|---|
|
||||
| 20001–20999 | 422 | Business rule (RAISE_APPLICATION_ERROR) | — (mesajul e user-friendly) |
|
||||
| 12541, 12170, 12154, 12560 | 503 | Oracle unreachable / TNS | — (infra issue) |
|
||||
| 1017 | 500 | Bad credentials — config error | `logger.critical` |
|
||||
| 942 | 500 | Object/grant missing — deployment error | `logger.critical` |
|
||||
| orice altceva | 500 | Eroare neașteptată | `logger.error` |
|
||||
|
||||
Prefix `ORA-20XXX:` e **stripped** din mesajul business înainte de a-l trimite la client.
|
||||
Testele unit în `tests/test_error_mapping.py` verifică toate branch-urile fără live DB
|
||||
(mock `oracledb.DatabaseError` cu `MagicMock`).
|
||||
|
||||
---
|
||||
|
||||
## 7. Auth Reuse
|
||||
|
||||
Fără cod nou — importă din shared:
|
||||
|
||||
```python
|
||||
from shared.auth.dependencies import get_current_user
|
||||
from shared.auth.models import CurrentUser
|
||||
|
||||
@router.post("/cereri", response_model=CerereResponse)
|
||||
async def creeaza_cerere(
|
||||
data: CerereRequest,
|
||||
current_user: CurrentUser = Depends(get_current_user),
|
||||
):
|
||||
return await CerereService.creeaza_cerere(data=data, username=current_user.username)
|
||||
```
|
||||
|
||||
`AuthenticationMiddleware` (înregistrat global în `main.py`) injectează automat
|
||||
`request.state.user`. `get_current_user` extrage din `request.state.user` fără query DB.
|
||||
JWT conține `server_id` — accesibil ca `current_user.server_id` dacă ai nevoie să
|
||||
selectezi pool-ul dinamic per-user.
|
||||
|
||||
---
|
||||
|
||||
## 8. Ping / Health Endpoint
|
||||
|
||||
Copiază din `routers/comanda.py` — schimbă `'mariusm_test'`:
|
||||
|
||||
```python
|
||||
import time
|
||||
import oracledb
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from shared.auth.dependencies import get_current_user
|
||||
from shared.auth.models import CurrentUser
|
||||
from shared.database.oracle_pool import oracle_pool
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
@router.get("/ping")
|
||||
async def ping(_: CurrentUser = Depends(get_current_user)):
|
||||
"""Health check: verifică conectivitatea Oracle pentru server-ul modulului."""
|
||||
t0 = time.perf_counter()
|
||||
try:
|
||||
async with oracle_pool.get_connection('MY_SERVER_ID') as conn:
|
||||
with conn.cursor() as cursor:
|
||||
cursor.execute('SELECT 1 FROM DUAL')
|
||||
row = cursor.fetchone()
|
||||
except oracledb.DatabaseError as e:
|
||||
raise HTTPException(status_code=503, detail=f"Oracle error: {e}")
|
||||
elapsed_ms = round((time.perf_counter() - t0) * 1000, 2)
|
||||
return {"result": row[0], "server": "MY_SERVER_ID", "latency_ms": elapsed_ms}
|
||||
```
|
||||
|
||||
Ping-ul e **autentificat** (orice user valid) — nu e public. Latency așteptată pe server
|
||||
local: 20-35ms. Dacă > 500ms → tunel SSH sau rețea problemă.
|
||||
|
||||
---
|
||||
|
||||
## 9. Router Factory (`routers/__init__.py`)
|
||||
|
||||
```python
|
||||
from fastapi import APIRouter
|
||||
|
||||
def create_MODUL_NOU_router() -> APIRouter:
|
||||
router = APIRouter()
|
||||
from .cerere import router as cerere_router
|
||||
router.include_router(cerere_router, tags=["MODUL-NOU"])
|
||||
return router
|
||||
```
|
||||
|
||||
Import lazy (în interiorul funcției) evită circular imports la load time.
|
||||
|
||||
---
|
||||
|
||||
## 10. `session_callback` — CURRENT_SCHEMA switching (opțional)
|
||||
|
||||
Necesar dacă SP-urile tale sunt pe o schemă diferită de user-ul de conectare
|
||||
(ex. conectezi ca `ROA_WEB` dar SP-urile sunt în `SCHEMA_TA`):
|
||||
|
||||
```python
|
||||
# În modulul tău, înainte de register_server:
|
||||
def set_schema_callback(connection, requested_tag):
|
||||
"""Apelat la fiecare acquire() din pool."""
|
||||
with connection.cursor() as cur:
|
||||
cur.execute("ALTER SESSION SET CURRENT_SCHEMA = SCHEMA_TA")
|
||||
|
||||
# La înregistrarea server-ului (sau în main.py, la init_oracle_pool):
|
||||
oracle_pool.register_server(
|
||||
server_id="MY_SERVER_ID",
|
||||
host="...", port=1521,
|
||||
user="ROA_WEB", password="...",
|
||||
service_name="ROA",
|
||||
session_callback=set_schema_callback, # ← patch disponibil în oracle_pool.py
|
||||
)
|
||||
```
|
||||
|
||||
`oracle_pool.register_server()` acceptă deja `session_callback` (implementat în
|
||||
`shared/database/oracle_pool.py:66` și `:133-134`). Zero modificări la shared code.
|
||||
|
||||
> **Concurrency caveat**: testul de concurență pe 1 schemă e pending (ipoteza #2).
|
||||
> Pattern-ul e safe pentru 1 schemă per pool. Multi-schemă pe același pool necesită
|
||||
> tagged connections — deferrat pentru phase 2.
|
||||
|
||||
---
|
||||
|
||||
## 11. Checklist Rapid
|
||||
|
||||
```
|
||||
□ .env: entry nou în ORACLE_SERVERS (id, host, port, user, service_name)
|
||||
□ backend/secrets/MY_SERVER_ID.oracle_pass creat
|
||||
□ Oracle: GRANT CREATE SESSION + EXECUTE ON SP + SELECT ON views (sau folosești DBA user pentru prototype)
|
||||
□ __init__.py: logger cu propagate=False + FileHandler absolut
|
||||
□ schemas/: Request + Response (câmpuri Pydantic, zero logică)
|
||||
□ services/: _handle_oracle_error() + clasa Service cu callproc + int(out.getvalue())
|
||||
□ routers/__init__.py: create_MODUL_router() factory cu lazy import
|
||||
□ routers/cerere.py: /ping endpoint autentificat + endpoint-uri business
|
||||
□ main.py: import factory + app.include_router cu prefix + tags
|
||||
□ tests/test_error_mapping.py: unit tests fără live DB (mock DatabaseError)
|
||||
□ Testează /ping: latency < 35ms → Oracle reachabil
|
||||
```
|
||||
@@ -24,3 +24,157 @@ Motivare: `oracle_pool.py` folosește deja `oracledb.create_pool()` (sync) + `po
|
||||
- Audit grants `ROA_WEB` pe `MARIUSM_AUTO.*`
|
||||
- Creare SP `SP_CREEAZA_COMANDA_PROTOTIP` în MARIUSM_AUTO (template în tabele-service-auto.md §12.2)
|
||||
- Auth path: adaugă `MARIUSM_AUTO` company în `.env` + test login JWT end-to-end
|
||||
|
||||
---
|
||||
|
||||
# Săpt 3 — Execution Log
|
||||
|
||||
## Task #1 — Grants audit (2026-04-11, oracle-agent)
|
||||
|
||||
- `ROA_WEB` user **nu există** în instanța `ROA` (toate cele 4 dicționare — DBA_USERS, DBA_TAB_PRIVS, DBA_SYS_PRIVS, DBA_ROLE_PRIVS — întorc 0 rânduri).
|
||||
- `CONTAFIN_ORACLE` are `DBA` role → acces la MARIUSM_AUTO e via `SELECT/INSERT/UPDATE/DELETE/EXECUTE ANY ...`, fără grants explicite. Asta explică de ce Săpt 1 a funcționat fără DBA work.
|
||||
- Decizie: **fază A (Săpt 3) folosește CONTAFIN_ORACLE direct** — nu e nevoie de DBA. Fază B (Săpt 4+) va crea ROA_WEB cu grants scope-limited pentru a proba ipoteza #3 (access blocat direct, permis doar via SP).
|
||||
- Findings complete + script creare ROA_WEB: `docs/service-auto/grants-audit.md`.
|
||||
|
||||
## Task #3 — SP_CREEAZA_COMANDA_PROTOTIP (2026-04-11, oracle-agent)
|
||||
|
||||
### SP source
|
||||
- Locație: `docs/service-auto/SP_CREEAZA_COMANDA_PROTOTIP.sql`
|
||||
- Signature: `(p_tip IN, p_id_masiniclient IN, p_solicitari IN VARCHAR2, p_id_firma IN, p_id_ordl OUT, p_nrord OUT)`
|
||||
- Nrord generation: `SEQ_NR_LUCRARE.NEXTVAL` (existing, unused — `last_number=1`) + prefix `P<id_firma>-<seq>` → primul prototype produce `P01-1`.
|
||||
- Body: duplicate-check (paritate cu `pack_auto`) + INSERT NOM_LUCRARI (`id_mod=1200`, id_lucrare auto via `TRG_NOM_LUCRARI_BEFOINS` + `SEQ_NOM_LUCRARI`) + INSERT DEV_ORDL (coloane NOT NULL + client link).
|
||||
- Coloane sărite conștient: `id_inspector`, `id_asigurator`, `nr_dosar`, `kmint`, `termen`, `proc_tvav`, `id_part_ref`, `observatii`, `defectiuni` — toate nullable, OK pentru prototype.
|
||||
|
||||
### Execution
|
||||
- `CREATE OR REPLACE PROCEDURE` via `cursor.execute(body)` (trailing `/` stripped în Python pentru a nu fi trimis ca SQL statement invalid) → **VALID** fără compile errors.
|
||||
- Test call:
|
||||
```
|
||||
tip=1 (POST GARANTIE), id_masiniclient=2, solicitari="Prototype test — rollback imediat după verificare.", id_firma=1
|
||||
→ OUT p_id_ordl=411, p_nrord='P01-1'
|
||||
→ verificare pre-rollback: rând în DEV_ORDL + NOM_LUCRARI cu id_lucrare=721, id_mod=1200, an=2026, luna=4
|
||||
→ conn.rollback()
|
||||
→ post-rollback: 0 rows în ambele tabele ✅
|
||||
```
|
||||
- Confirmă: ipoteza #1 (oracledb → OUT NUMBER + OUT VARCHAR2 prin `cursor.var()`), ipoteza #2 (SP cu RETURNING INTO peste două INSERT-uri cu trigger-uri BEFOINS), tranzacționalitate completă.
|
||||
|
||||
### Note
|
||||
- `SEQ_NR_LUCRARE` **nu se roll-back-uie** (standard Oracle) — următorul test va produce `P01-2`, `P01-3`, etc. Util pentru cleanup: prototype rows sunt ușor de identificat prin prefix `P`.
|
||||
- `DBMS_LOB.SUBSTR` folosit în verificare pentru a citi CLOB-ul `solicitari_client` — implicit VARCHAR2→CLOB conversion la INSERT a mers fără probleme (inclusiv diacritice).
|
||||
|
||||
### Test #2 — Confirmare (2026-04-11, oracle-agent, săpt 3 exec)
|
||||
|
||||
```
|
||||
tip=3 (REGIE, inch_validare=1), id_masiniclient=200 (CT-85-ROD), p_id_firma=1
|
||||
→ SP call: 5.9ms ✅
|
||||
→ OUT p_id_ordl=412, p_nrord='P01-2'
|
||||
→ NOM_LUCRARI: id_lucrare=722, nrord='P01-2', id_mod=1200 ✅
|
||||
→ DEV_ORDL: id_ordl=412, id_lucrare=722, id_tip=3, luna=4, an=2026 ✅
|
||||
→ conn.rollback() → post-rollback: 0 rows ✅
|
||||
```
|
||||
|
||||
**Ipoteze confirmate Săpt 3:**
|
||||
- H1 ✅ — `oracledb.cursor.callproc()` + `cursor.var(NUMBER)` / `cursor.var(STRING)` pentru OUT params
|
||||
- H2 ✅ — SP cu dual INSERT (NOM_LUCRARI → DEV_ORDL) + trigger BEFOINS RETURNING + tranzacționalitate completă
|
||||
- H3 ⏳ — amânat Săpt 4 (necesită creare ROA_WEB via DBA; script ready în `grants-audit.md`)
|
||||
|
||||
## Task #5 — MARIUSM_AUTO în backend/.env (2026-04-11, oracle-agent)
|
||||
|
||||
### Modificări .env
|
||||
|
||||
Adăugat entry `mariusm_test` în `ORACLE_SERVERS` JSON în toate cele 3 fișiere env:
|
||||
- `backend/.env` — activ imediat
|
||||
- `backend/.env.prod` — pentru viitoarea producție
|
||||
- `backend/.env.test` — pentru runul de test
|
||||
|
||||
```json
|
||||
{"id":"mariusm_test","name":"MARIUSM AUTO (service-auto prototype)",
|
||||
"host":"10.0.20.121","port":1521,
|
||||
"user":"CONTAFIN_ORACLE","service_name":"ROA"}
|
||||
```
|
||||
|
||||
**Reasoning** (fază A): `mariusm_test` are aceleași parametri de conectare ca și `central` (același server Oracle, același user DBA), dar ID distinct pentru:
|
||||
1. Pool separat per modul service_auto (pool sizing independent)
|
||||
2. Swap atomic la faza B: schimbăm `mariusm_test` → user=ROA_WEB, fără modificări cod
|
||||
|
||||
Parola: `backend/secrets/mariusm_test.oracle_pass` (copie din `central.oracle_pass`)
|
||||
|
||||
### Verificare conectivitate via config
|
||||
|
||||
```
|
||||
Config parsed: 4 servers (romfast, central, mariusm_test, vending) ✅
|
||||
mariusm_test: password loaded (len=11) ✅
|
||||
Direct connect: 22.1ms ✅
|
||||
DEV_TIP_DEVIZ count=7 ✅
|
||||
SP_CREEAZA_COMANDA_PROTOTIP STATUS=VALID ✅
|
||||
```
|
||||
|
||||
### Test JWT login — backend offline
|
||||
|
||||
Backend nu rulează (verificat via `curl http://localhost:8000/health`).
|
||||
Pentru a testa login JWT end-to-end:
|
||||
|
||||
```bash
|
||||
# 1. Pornește backend în mod test
|
||||
./start.sh test
|
||||
|
||||
# 2. Testează login JWT cu credențialele de test (din CLAUDE.md)
|
||||
curl -s -X POST http://localhost:8000/api/auth/login \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d '{"username":"MARIUS M","password":"123","company_id":1}' | jq .
|
||||
|
||||
# 3. Verifică că token-ul JWT are câmpul companies[] cu MARIUSM_AUTO
|
||||
# 4. Fă un request autentificat la viitorul endpoint service_auto:
|
||||
# GET /api/service-auto/comenzi sau POST /api/service-auto/comanda
|
||||
|
||||
# 5. Oprește backend
|
||||
./start.sh test stop
|
||||
```
|
||||
|
||||
**Blocat de**: backend offline + task #4 stubs în progres (router/service TODO NotImplementedError)
|
||||
**Next step Săpt 3+**: după ce backend-agent completează Task #4 (router live), rulează secvența de mai sus.
|
||||
|
||||
### Verificare Oracle-side a path-ului de login (oracle-agent, 2026-04-11)
|
||||
|
||||
Independent de backend, am mirror-at exact cele 3 interogări din
|
||||
`backend/modules/telegram/routers/auth_codes.py:292-349` direct pe Oracle
|
||||
`central` pentru a de-risca testul JWT pending:
|
||||
|
||||
```
|
||||
Step 1 — pack_drepturi.verificautilizator('MARIUS M', '123')
|
||||
→ return: 803 (≠ -1 → autentificare validă, session id)
|
||||
|
||||
Step 2 — SELECT id_util, utilizator FROM UTILIZATORI WHERE UPPER(utilizator)='MARIUS M'
|
||||
→ id_util=8, utilizator='MARIUS M'
|
||||
|
||||
Step 3 — SELECT ID_FIRMA,FIRMA,SCHEMA FROM V_NOM_FIRME
|
||||
WHERE ID_FIRMA IN (SELECT ID_FIRMA FROM VDEF_UTIL_FIRME WHERE ID_UTIL=8 AND ID_PROGRAM=2)
|
||||
→ 6 rows:
|
||||
238 AXN schema=ACN
|
||||
237 DANUBE GRAIN SERVICES schema=DANUBE
|
||||
251 EMS schema=EMS
|
||||
110 MARIUSM AUTO schema=MARIUSM_AUTO ← TARGET
|
||||
167 MARIUSM AUTO SUC 1 ... schema=MARIUSM_AUTO
|
||||
169 MARIUSM AUTO SUC 2 schema=MARIUSM_AUTO
|
||||
```
|
||||
|
||||
**3 rânduri** în V_NOM_FIRME au `schema='MARIUSM_AUTO'` pentru MARIUS M, toate
|
||||
cu `cod_fiscal='RO1879855'` (același CUI, rapoarte separate):
|
||||
|
||||
| id_firma | firma | rel |
|
||||
|---|---|---|
|
||||
| 110 | MARIUSM AUTO | parent (mama, `id_mama=null`) |
|
||||
| 167 | MARIUSM AUTO SUC 1 ... | sucursală (`id_mama=110`) |
|
||||
| 169 | MARIUSM AUTO SUC 2 | sucursală (`id_mama=110`) |
|
||||
|
||||
**Concluzie**: path-ul Oracle pentru login este 100% funcțional înainte de
|
||||
pornirea backend-ului. Prototype-ul poate folosi default `id_firma=110` în
|
||||
frontend. Testul JWT HTTP (listat mai sus) e singurul pas care necesită backend
|
||||
pornit; toate dependențele Oracle sunt verificate.
|
||||
|
||||
**Decizie separată — pool `mariusm_test` vs. `central`**: cel care a adăugat
|
||||
entry-ul `mariusm_test` în ORACLE_SERVERS a ales izolare pool per-modul + swap
|
||||
atomic la ROA_WEB în fază B. E compatibil cu path-ul de login: service_auto
|
||||
folosește `mariusm_test` pool pentru queries/SP către schema `MARIUSM_AUTO`, în
|
||||
timp ce login-ul rămâne pe `central` (sau pe `mariusm_test`, echivalent — same
|
||||
credențiale în fază A).
|
||||
|
||||
|
||||
34
docs/service-auto/week2-notes.md
Normal file
34
docs/service-auto/week2-notes.md
Normal file
@@ -0,0 +1,34 @@
|
||||
# Săpt 2 Notes — Oracle OUT Param Probe
|
||||
|
||||
**Script**: `poc/async_out_param_probe.py`
|
||||
**Date**: 2026-04-11
|
||||
**Status**: PASSED ✅
|
||||
|
||||
## Latency (measured 2026-04-11)
|
||||
|
||||
| Operation | Time |
|
||||
|-----------|------|
|
||||
| connect | 21.9ms |
|
||||
| CREATE PROCEDURE | 9.2ms |
|
||||
| callproc (OUT param) | 1.0ms |
|
||||
| DROP PROCEDURE | 54.6ms |
|
||||
| **Total** | **87.5ms** |
|
||||
|
||||
## OUT Param Result
|
||||
|
||||
- Procedure: `MARIUSM_AUTO.test_out(p OUT NUMBER)` sets `p := 42`
|
||||
- Python: `cursor.var(oracledb.NUMBER)` → `cursor.callproc(...)` → `out_var.getvalue()` = **42.0**
|
||||
- Assert `== 42`: **PASSED**
|
||||
|
||||
## Cleanup
|
||||
|
||||
- `DROP PROCEDURE MARIUSM_AUTO.test_out` executed successfully
|
||||
- Cleanup OK ✅ — no residual objects left in schema
|
||||
|
||||
## Key Findings
|
||||
|
||||
- `oracledb.cursor.var(oracledb.NUMBER)` correctly round-trips Oracle `OUT NUMBER` parameters
|
||||
- The returned value from `.getvalue()` is a Python `float` (42.0), so `int()` cast is needed for IDs
|
||||
- `callproc` latency is ~1ms once connected — Oracle OUT params add negligible overhead
|
||||
- DDL (CREATE/DROP) requires ~10-55ms each — avoid in hot paths
|
||||
- This pattern matches exactly what `ComandaService.creeaza_comanda()` uses for `out_id_ordl` and `out_nrord`
|
||||
134
docs/service-auto/week3-auth-audit.md
Normal file
134
docs/service-auto/week3-auth-audit.md
Normal file
@@ -0,0 +1,134 @@
|
||||
# Săpt 3 — Auth Audit: Ipoteza #6
|
||||
|
||||
**Date**: 2026-04-11
|
||||
**Auditor**: oracle-agent (team service-auto-sapt3)
|
||||
**Scope**: Verific că flux-ul de autentificare multi-server existent suportă un server nou
|
||||
(`mariusm_test`) fără modificări la `shared/` code.
|
||||
|
||||
---
|
||||
|
||||
## Ce s-a testat la nivel Oracle DB
|
||||
|
||||
Cele 3 interogări din `backend/modules/telegram/routers/auth_codes.py:292-349` au fost
|
||||
mirror-ate direct pe instanța Oracle `central` (10.0.20.121:1521/ROA) cu user `CONTAFIN_ORACLE`:
|
||||
|
||||
### Step 1 — Autentificare utilizator
|
||||
|
||||
```sql
|
||||
-- pack_drepturi.verificautilizator(p_user, p_pass) → session_id sau -1 la eșec
|
||||
CALL pack_drepturi.verificautilizator('MARIUS M', '123') INTO :result
|
||||
```
|
||||
|
||||
**Rezultat**: `803` — valoare ≠ `-1` → autentificare validă, session ID activ.
|
||||
|
||||
### Step 2 — Lookup UTILIZATORI
|
||||
|
||||
```sql
|
||||
SELECT id_util, utilizator FROM UTILIZATORI
|
||||
WHERE UPPER(utilizator) = 'MARIUS M'
|
||||
```
|
||||
|
||||
**Rezultat**:
|
||||
|
||||
| id_util | utilizator |
|
||||
|---------|-----------|
|
||||
| 8 | MARIUS M |
|
||||
|
||||
### Step 3 — Firme accesibile pentru user (id_program=2 = ROA)
|
||||
|
||||
```sql
|
||||
SELECT ID_FIRMA, FIRMA, SCHEMA
|
||||
FROM V_NOM_FIRME
|
||||
WHERE ID_FIRMA IN (
|
||||
SELECT ID_FIRMA FROM VDEF_UTIL_FIRME
|
||||
WHERE ID_UTIL = 8 AND ID_PROGRAM = 2
|
||||
)
|
||||
```
|
||||
|
||||
**Rezultat** (6 rânduri totale, 3 cu schema MARIUSM_AUTO):
|
||||
|
||||
| id_firma | firma | schema | rel |
|
||||
|----------|-------|--------|-----|
|
||||
| 238 | AXN | ACN | — |
|
||||
| 237 | DANUBE GRAIN SERVICES | DANUBE | — |
|
||||
| 251 | EMS | EMS | — |
|
||||
| **110** | **MARIUSM AUTO** | **MARIUSM_AUTO** | parent (`id_mama=null`) |
|
||||
| **167** | **MARIUSM AUTO SUC 1 ...** | **MARIUSM_AUTO** | sucursală (`id_mama=110`) |
|
||||
| **169** | **MARIUSM AUTO SUC 2** | **MARIUSM_AUTO** | sucursală (`id_mama=110`) |
|
||||
|
||||
Toate 3 firme MARIUSM_AUTO au același CUI `RO1879855` — entitate juridică unică cu
|
||||
sub-unități; `id_firma=110` e parent-ul (firmă mamă), 167 și 169 sunt sucursale.
|
||||
|
||||
**Implicație**: frontend-ul prototype-ului poate folosi `id_firma=110` ca default
|
||||
hardcodat fără să facă o alegere arbitrară — e firma mamă, nu o sucursală.
|
||||
|
||||
---
|
||||
|
||||
## Verdict — Ipoteza #6
|
||||
|
||||
**Status**: `PRELIMINARY CONFIRMED` la nivel Oracle DB.
|
||||
|
||||
Cele 3 query-uri care constituie path-ul de autentificare Oracle sunt 100% funcționale:
|
||||
- `pack_drepturi.verificautilizator` autentifică utilizatorul ✅
|
||||
- `UTILIZATORI` returnează `id_util` ✅
|
||||
- `V_NOM_FIRME` returnează 3 firme MARIUSM_AUTO pentru MARIUS M ✅
|
||||
|
||||
Ipoteza spune că auth-ul multi-server merge **fără modificări la shared code**.
|
||||
La nivel DB, aceste 3 query-uri sunt deja shared (nu sunt specifice unui server)
|
||||
și funcționează pe `central` (care e același endpoint fizic ca `mariusm_test` în faza A).
|
||||
|
||||
---
|
||||
|
||||
## Ce rămâne pending — Testul HTTP
|
||||
|
||||
Testul HTTP complet necesită backend pornit. Comenzile exacte:
|
||||
|
||||
```bash
|
||||
# 1. Pornește backend în mod test
|
||||
./start.sh test
|
||||
|
||||
# 2. Login JWT
|
||||
curl -s -X POST http://localhost:8000/api/auth/login \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d '{"username":"MARIUS M","password":"123","company_id":1}' | jq .
|
||||
|
||||
# 3. Extrage token din răspuns
|
||||
TOKEN=$(curl -s -X POST http://localhost:8000/api/auth/login \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d '{"username":"MARIUS M","password":"123","company_id":1}' | jq -r .access_token)
|
||||
|
||||
# 4. Verifică payload JWT (câmpul companies[] trebuie să conțină MARIUSM_AUTO)
|
||||
echo $TOKEN | cut -d. -f2 | base64 -d 2>/dev/null | jq .
|
||||
|
||||
# 5. Verifică că server selector / company selector arată MARIUSM_AUTO
|
||||
# 6. Inspectează câmpul server_id în JWT payload — trebuie 'mariusm_test'
|
||||
|
||||
# 7. Oprește backend
|
||||
./start.sh test stop
|
||||
```
|
||||
|
||||
**Ce verifică testul HTTP:**
|
||||
- JWT payload conține `companies[]` cu firmele MARIUSM_AUTO (110, 167, 169)
|
||||
- `server_id='mariusm_test'` e prezent în token
|
||||
- `AuthenticationMiddleware` din `shared/auth/middleware.py` injectează
|
||||
corect `request.state.server_id` fără modificări la shared code
|
||||
- `auth_service.get_user_companies('MARIUS M', 'mariusm_test')` returnează lista corectă
|
||||
|
||||
**Blocat de**: backend offline (task #3 ping endpoint + task #2 session_callback patch
|
||||
necesare ca backend să pornească curat pe server `mariusm_test`).
|
||||
|
||||
---
|
||||
|
||||
## Concluzie
|
||||
|
||||
Path-ul Oracle de autentificare este de-risked complet la nivelul DB. Testul HTTP final
|
||||
e o formalitate de integrare (wiring FastAPI ↔ shared auth ↔ mariusm_test pool) — nu e
|
||||
o probă de logică de business nouă, logica Oracle a trecut deja.
|
||||
|
||||
**Dacă testul HTTP trece**: ipoteza #6 devine `CONFIRMED` → shared code zero-modificat
|
||||
suportă un server Oracle nou. Documentat în `decision-log.md`.
|
||||
|
||||
**Dacă testul HTTP eșuează** (de ex. `companies=[]` sau eroare 500): de investigat
|
||||
dacă `auth_service.get_user_companies` are o presupunere hardcodată despre server-ul
|
||||
implicit; dacă DA, aceasta e o modificare minoră de shared code care nu invalidează
|
||||
ipoteza fundamentală (dar o califică: "merge cu 1 linie de shared code").
|
||||
67
docs/service-auto/week5-session-callback.md
Normal file
67
docs/service-auto/week5-session-callback.md
Normal file
@@ -0,0 +1,67 @@
|
||||
# Săpt 5 — session_callback patch: `shared/database/oracle_pool.py`
|
||||
|
||||
## Ce s-a schimbat
|
||||
|
||||
Patch de ~8 linii la `OracleMultiPool.register_server()` și `_get_or_create_pool()` pentru suport `session_callback`.
|
||||
|
||||
### `register_server` (signature nouă)
|
||||
|
||||
```python
|
||||
def register_server(
|
||||
self,
|
||||
server_id: str,
|
||||
host: str,
|
||||
port: int,
|
||||
user: str,
|
||||
password: str,
|
||||
sid: Optional[str] = None,
|
||||
service_name: Optional[str] = None,
|
||||
min_connections: int = 2,
|
||||
max_connections: int = 10,
|
||||
session_callback=None, # <-- NOU
|
||||
**kwargs
|
||||
) -> None:
|
||||
```
|
||||
|
||||
`session_callback` se salvează în `_pool_configs[server_id]` alături de ceilalți parametri.
|
||||
|
||||
### `_get_or_create_pool` (propagare către `oracledb.create_pool`)
|
||||
|
||||
```python
|
||||
if config.get('session_callback'):
|
||||
pool_params['session_callback'] = config['session_callback']
|
||||
```
|
||||
|
||||
## Backward compatibility
|
||||
|
||||
- Toți callers existenți folosesc parametri named fără `session_callback`.
|
||||
- Audit complet cu grep: singurul caller real este `backend/main.py:95` — nu transmite `session_callback`.
|
||||
- Valoare default `None`: dacă lipsește, `config.get('session_callback')` returnează `None` → falsy → ramura nu se execută.
|
||||
- Zero callers afectați.
|
||||
|
||||
## Utilizare: CURRENT_SCHEMA switching
|
||||
|
||||
```python
|
||||
def init_mariusm_schema(connection, requested_tag):
|
||||
"""Session callback — rulează la fiecare conexiune nouă din pool."""
|
||||
with connection.cursor() as cursor:
|
||||
cursor.execute("ALTER SESSION SET CURRENT_SCHEMA = MARIUSM_AUTO")
|
||||
|
||||
oracle_pool.register_server(
|
||||
server_id='mariusm_test',
|
||||
host='10.0.20.121',
|
||||
port=1521,
|
||||
user='ROA_WEB',
|
||||
password='...',
|
||||
service_name='ROA',
|
||||
session_callback=init_mariusm_schema,
|
||||
)
|
||||
```
|
||||
|
||||
Callback-ul `init_mariusm_schema` este invocat de `oracledb` la fiecare conexiune nouă creată în pool
|
||||
(nu la fiecare `acquire` — doar la crearea fizică a conexiunii).
|
||||
|
||||
## Referințe
|
||||
|
||||
- `shared/database/oracle_pool.py` — linii 55–133
|
||||
- python-oracledb docs: [Session Callbacks](https://python-oracledb.readthedocs.io/en/latest/user_guide/connection_handling.html#session-callbacks-for-setting-pooled-connections)
|
||||
67
docs/service-auto/week6-checkpoint.md
Normal file
67
docs/service-auto/week6-checkpoint.md
Normal file
@@ -0,0 +1,67 @@
|
||||
# Săpt 6 — Checkpoint: GET /api/service-auto/ping
|
||||
|
||||
## Endpoint
|
||||
|
||||
`GET /api/service-auto/ping` — Health check Oracle connectivity pentru serverul `mariusm_test`.
|
||||
|
||||
**Implementat în**: `backend/modules/service_auto/routers/comanda.py`
|
||||
|
||||
## Comportament
|
||||
|
||||
1. Verifică autentificare JWT (`get_current_user` dependency)
|
||||
2. Deschide conexiune din `oracle_pool` pentru server-ul `mariusm_test`
|
||||
3. Execută `SELECT 1 FROM DUAL`
|
||||
4. Returnează rezultatul cu latența măsurată
|
||||
|
||||
## Răspuns așteptat (200 OK)
|
||||
|
||||
```json
|
||||
{
|
||||
"result": 1,
|
||||
"server": "mariusm_test",
|
||||
"latency_ms": 12.34
|
||||
}
|
||||
```
|
||||
|
||||
## Eroare Oracle (503 Service Unavailable)
|
||||
|
||||
```json
|
||||
{
|
||||
"detail": "Oracle error: ORA-12541: TNS:no listener"
|
||||
}
|
||||
```
|
||||
|
||||
## Comandă curl pentru testare
|
||||
|
||||
```bash
|
||||
# 1. Obține token JWT (înlocuiește credențialele)
|
||||
TOKEN=$(curl -s -X POST http://localhost:8000/api/auth/login \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{"username":"MARIUS M","password":"123","company_id":1}' \
|
||||
| python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])")
|
||||
|
||||
# 2. Ping Oracle
|
||||
curl -s -X GET http://localhost:8000/api/service-auto/ping \
|
||||
-H "Authorization: Bearer $TOKEN" | python3 -m json.tool
|
||||
```
|
||||
|
||||
### Răspuns așteptat (server TEST):
|
||||
|
||||
```json
|
||||
{
|
||||
"result": 1,
|
||||
"server": "mariusm_test",
|
||||
"latency_ms": 8.45
|
||||
}
|
||||
```
|
||||
|
||||
## Routing path
|
||||
|
||||
`main.py` → `create_service_auto_router()` → `comanda_router` inclus cu prefix `/api/service-auto`
|
||||
→ `GET /ping` devine `GET /api/service-auto/ping`
|
||||
|
||||
## Note implementare
|
||||
|
||||
- `time.perf_counter()` pentru latență (monotonic, rezoluție înaltă)
|
||||
- `oracledb.DatabaseError` prins explicit → HTTP 503
|
||||
- `_: CurrentUser` — user din JWT nu e necesar în body, dar dependency enforces auth
|
||||
Reference in New Issue
Block a user