Overview

Ciclo di vita dei metadati

Il ciclo di vita dei metadati tiene lo storico di tutto cio' che compone un'app WUIC (route, menu, permessi, traduzioni, dashboard, workflow, report...), permette di confrontare due versioni, creare release, esportarle in un pacchetto .wuicpkg e promuoverle da un ambiente all'altro (dev → test → prod) con un piano a secco, l'applicazione in una transazione, la verifica e il rollback. Le API sono in api/meta-lifecycle/* (controller dedicato, solo superadmin verificato sul DB); la pagina e' Amministrazione → Ciclo di vita app (route meta-lifecycle). L'amministratore creato dal wizard di primo avvio e' superadmin (ruolo Admin): su un'installazione nuova usa subito il ciclo di vita.

Quando usarlo (use-case)

  • Sapere chi ha cambiato cosa: ogni salvataggio dei designer e del CRUD sui metadati lascia una versione con autore e data.
  • Confrontare una route, una dashboard o un workflow con una versione precedente e ripristinarla.
  • Promuovere le modifiche fatte in sviluppo verso test e produzione con un solo file, senza script SQL a mano.
  • Proteggere la produzione: modifiche di design bloccate (design lock), doppia approvazione, pacchetti firmati.
  • Automatizzare il rilascio in una pipeline CI/CD con la CLI scripts/wuic-meta.ps1.

Concetti

  • Artefatto: l'unita' di versione e di promozione. Una route comprende in un unico JSON la riga di _metadati__tabelle, le colonne, gli stili, le azioni, le condizioni e i link di nested grid. Gli altri tipi: route-grants, menu, translations (per namespace, i primi due segmenti della chiave), theme, scheduler-job, mailing-template, webhook-event, webhook-endpoint, dashboard, pivot, workflow, report, scene3d, scene3d-asset, routing, bi-universe.
  • Forma canonica: JSON neutrale rispetto al DBMS, chiavi ordinate, nomi delle proprieta' csProperty, id locali (md_id, mc_id, mm_id, id dei ruoli) sostituiti da riferimenti simbolici ({"$ref":"route","key":"clienti"}, ruoli per nome), valori d'ambiente sostituiti da binding (${conn:...}, ${secret:...}), derivati tolti.
  • uid: identita' stabile dell'artefatto (UUID v5 da tipo + chiave naturale), uguale in tutti gli ambienti. La identity map (_wuic_meta_identity) di ogni ambiente collega l'uid all'id locale.
  • Hash: SHA-256 della forma canonica = versione dell'artefatto. Due ambienti con lo stesso hash hanno lo stesso contenuto; il confronto fra ambienti costa un confronto di hash.

Cosa si versiona e cosa no

ClasseEsempiTrattamento
APProute, menu, permessi per ruolo, traduzioni dell'app, temi, job, dashboard, pivot, workflow, reportstorico, confronto, pacchetti
DERIVATOtransizioni e SLA dei workflow, job wf_sla_tick::* e PivotDynamicRefresh_*, binding delle scenenon si copia: si rigenera nel target
AMBIENTEutenti, Aziende, connection string, URL e segreti di webhook e scheduler, destinatari dei mailingmai nel pacchetto: diventa un binding
RUNTIMElog, istanze dei workflow, notifiche, esecuzioni dello scheduler, chatescluso
SISTEMArighe con md_is_system_metadata / issystemroute, md_id < 1001, menu di sistema, chiavi di traduzione del frameworkbaseline del framework: non entra nei pacchetti

I permessi per singolo utente e quelli legati a un'azione sono esportati con un avviso (i permessi per ruolo si promuovono per nome del ruolo).

Storico e confronto

  • Ogni salvataggio dei metadati lascia un segnale in _wuic_meta_dirty (con l'autore, letto dal DB per l'utente della sessione); il job builtin meta_history_job (ogni minuto) esporta gli artefatti segnati e registra una versione solo se l'hash e' cambiato. Una volta al giorno la riconciliazione registra anche le modifiche fatte fuori dalle API (SQL diretto); il primo giro crea il commit baseline.
  • Scheda Storico: artefatti con l'ultima versione, versioni di un artefatto, commit esplicito con messaggio e tag.
  • Scheda Confronta: due lati (una versione o lo stato attuale live) nel DiffEditor di Monaco, con l'elenco delle differenze per proprieta'. Il rumore dei designer (posizioni x/y dei nodi del workflow, tag/inputProps delle dashboard) non compare come modifica.
  • Pulsante Storico / Confronta nei designer: workflow designer (menu), designer delle dashboard (toolbar), pivot builder, theme builder ed editor dei metadati (menu Metadata). Workflow e dashboard hanno anche il diff visuale (canvas con nodi e collegamenti colorati per stato; dashboard affiancate in sola lettura).
  • Ripristina questa versione: piano d'importazione a 3 vie con base la versione successiva (quella che si annulla): se l'elemento e' cambiato ancora dopo sulle stesse proprieta' il piano mostra il conflitto e si sceglie (tieni il mio, prendi la sorgente o unione per proprieta'), come in una promozione. Senza versioni successive il ripristino e' diretto.
  • Annulla questa registrazione (solo sull'ultima registrazione applicata con elementi; le vuote non contano): gli elementi che ha toccato tornano alla versione precedente con un piano a 3 vie, e l'apply salva una registrazione rollback. Le registrazioni intermedie non si annullano (si accantonano), la baseline non si annulla ne' si accantona. Una registrazione vuota (0 elementi) e' evidenziata con l'etichetta "vuota" e ha solo Rimuovi, che la toglie dallo storico senza cambiare niente (non la baseline, ne' una registrazione citata da una release o da un accantonamento).
  • Annulla su un elemento della griglia "Elementi registrati" (anche di una registrazione intermedia): solo se la versione registrata e' ancora quella attuale dell'elemento (applicata o riapplicata) e non e' la baseline; riporta il solo elemento alla versione precedente (tolto se era nuovo, ricreato se era cancellato), piano a 3 vie e registrazione rollback.
  • Accantona (riga della versione e scheda Confronta) riporta l'elemento alla versione precedente (se era nuovo lo toglie, se era una cancellazione lo ricrea); Accantona la registrazione fa lo stesso per tutti i suoi elementi con un solo piano. La versione accantonata resta nell'elenco, evidenziata, con stato accantonata. Riapplica (sulla versione o sulla registrazione) la rimette con il piano a 3 vie: se l'elemento e' cambiato nel frattempo il piano mostra il conflitto. Colonna Stato di versioni e registrazioni: applicata, accantonata, riapplicata, sostituita (c'e' una versione successiva); filtro Solo accantonate. Gli accantonamenti valgono per ambiente e li vedono tutti i superadmin; release e pacchetti esportano lo stato attuale (un accantonamento non riapplicato non c'e').
  • Elementi senza righe: ogni route ha il suo elemento route-grants anche quando non ha permessi propri; nelle tabelle (elenco dello Storico, differenze di una registrazione, piano, release) la riga resta ma e' attenuata, con l'etichetta nessun permesso (il tooltip lo spiega); il filtro Nascondi senza permessi la toglie dagli elenchi dello Storico.
  • Ripristini, accantonamenti e riapplicazioni passano dal piano nella scheda Pacchetti; Applica chiede conferma con il messaggio della registrazione (proposto, modificabile: "ripristino della registrazione del ...", "accantonamento della versione ...", "riapplicazione di ..."). L'apply salva una registrazione di tipo restore, shelve o reapply; il rollback della promozione annulla anche l'accantonamento o la riapplicazione.
  • Storico dal vivo: con la pagina aperta, ogni registrazione con elementi (job automatico, manuale, import, riconciliazione, ripristino, accantonamento) arriva come un messaggio meta-history-commit sul canale /ws/notifications, solo ai superadmin del tenant, senza campanella ne' notifiche. Le righe toccate si aggiornano (versioni, data, elementi nuovi e tolti) e restano evidenziate finche' non si sceglie la riga; ordinamento, filtri e scelta restano; se l'elemento scelto e' fra i toccati le sue versioni si rileggono. Una registrazione vuota non manda niente.
APIUso
GET history/artifacts?type=&q=artefatti con l'ultima versione
GET history/{type}/{uid}versioni di un artefatto
GET history/versions/{id}forma canonica di una versione
GET history/compare?type=&uid=&left=&right=due lati (id di versione o live) e differenze
GET history/visual?type=&uid=&left=&right=lati del diff visuale (workflow, dashboard)
POST history/versions/{id}/restore-planpiano del ripristino di una versione
POST history/commitcommit esplicito { "message": "...", "tag": "..." }
GET history/commits/{id}/itemselementi salvati da una registrazione (versione, precedente, nuovo/modificato/cancellato, stato): la pagina li mostra cliccando la registrazione, "Differenze con lo stato attuale" mostra invece cosa e' cambiato da allora
POST history/commits/{id}/restore-plan[?versionId=]piano dell'annullamento dell'ultima registrazione, o di un solo suo elemento con versionId (409 not_latest_version; not_latest_commit, baseline_protected)
DELETE history/commits/{id}rimuove una registrazione vuota (409 commit_not_empty, commit_in_use, baseline_protected)
POST history/versions/{id}/shelve-planpiano dell'accantonamento di una versione
POST history/commits/{id}/shelve-planpiano dell'accantonamento di tutti gli elementi di una registrazione
POST history/shelves/{id}/reapply-planpiano della riapplicazione di un accantonamento
POST history/commits/{id}/reapply-planpiano della riapplicazione degli accantonati di una registrazione
POST promotions/{id}/apply { "planHash": "...", "message": "..." }apply; message = messaggio della registrazione (piani dallo Storico)

Snapshot

Fotografia logica delle tabelle di definizione del DB metadati, con verifica di congruenza e ripristino per differenza. Ogni apply ne crea una (before-import) come punto di ripristino. Gli snapshot si gestiscono solo via API (tabella sotto): la pagina "Ciclo di vita app" non ha una scheda Snapshot.

APIUso
GET snapshots / POST snapshotselenco / crea { "label": "..." }
POST snapshots/{id}/verifylo stato attuale e' congruente con lo snapshot?
POST snapshots/{id}/restoreripristino (prima crea uno snapshot before-restore) e verifica

Release

Una release e' una fotografia con nome dello stato dell'app: il manifest congelato uid → hash di ogni artefatto (_wuic_meta_release_item), con il changelog (artefatti nuovi, cambiati, tolti, esclusi; autori e date).

  • Nuova release (scheda Release): anteprima delle modifiche dall'ultima release, esclusioni a spunta (un artefatto escluso resta con l'hash della release precedente: il lavoro a meta' non si promuove), tag e messaggio.
  • Confronto fra release e diff di un artefatto fra due release.
  • Export: pacchetto completo della release o delta rispetto a una release precedente.
APIUso
GET releases / POST releaseselenco / crea { "tag": "1.4.0", "message": "...", "exclude": ["route/<uid>"] }
GET releases/previewcosa entrerebbe nella prossima release
GET releases/{tag}manifest e changelog
GET releases/{tag}/diff?against=<tag>confronto fra due release (&type=&uid= per un artefatto)
POST releases/{tag}/exportpacchetto; { "deltaFrom": "<tag>" } per il delta

Pacchetti

Il pacchetto .wuicpkg e' uno ZIP con manifest.json (SHA-256 di ogni file, ambiente sorgente, frameworkMin, release note), gli artefatti in forma canonica e i file (report .mrt senza connessioni, CSS, asset 3D).

TipoContenutoUso
completotutti gli artefatti dell'app (stato attuale o di una release)promozione standard: vale su qualunque stato del target
deltasolo gli artefatti cambiati fra due releaseapplicabile solo a un target esattamente alla release base, senza prune
singolola sola versione da ripristinare"Ripristina questa versione"

Firma: con MetaLifecycle:SigningKey l'export firma il manifest.json (RSA-PSS SHA-256, signature.json nel pacchetto). Al caricamento la firma risulta trusted (chiave in MetaLifecycle:TrustedPackageKeys), untrusted, unsigned, invalid (sempre rifiutata) o local (pacchetto generato dal server stesso).

Export dalla pagina: in background e per tipo

Dalla pagina "Ciclo di vita app" Esporta (Pacchetti) ed Esporta / Esporta delta (Release) non aspettano il file: il server lo genera in background con l'utente e il tenant della richiesta e risponde subito ("Esportazione avviata"); si puo' cambiare pagina. A fine lavoro arriva una notifica nella campanella ("Esportazione pronta", o l'errore se non e' riuscita) che porta alla scheda da cui e' partita e scarica il file; con la pagina aperta l'elenco degli export mostra lo stato e il pulsante Scarica. Il file sta in Tmp_export con un nome casuale e si cancella dopo tmpExportRetentionHours (default 24 h), come gli export delle griglie; a differenza di quelli si scarica solo dalla pagina e solo dall'utente che l'ha chiesto (403 per gli altri, anche superadmin).

Accanto a Esporta si scelgono i tipi da mettere nel pacchetto (default tutti = pacchetto completo; "Tutti" / "Nessuno"); il nome del file li elenca quando non sono tutti (app-menu+route-grants-<data>.wuicpkg). Senza il tipo route la pagina avvisa: gli elementi che puntano a una route la cercano per nome nell'installazione di destinazione e, se manca, il piano si ferma con l'errore "la route '...' e' richiesta ma non c'e' ne' nel pacchetto ne' nel target". Il prune tocca solo i tipi presenti nel pacchetto.

APIUso
POST packages/export-jobsavvia l'export del pacchetto ({ "types": [...] }, vuoto = tutto) → job
POST releases/{tag}/export-jobsavvia l'export della release ({ "deltaFrom": "<tag>" } per il delta)
GET packages/export-jobs, GET packages/export-jobs/{id}export dell'utente / stato (running, done, failed)
GET packages/export-jobs/{id}/downloadfile pronto (404 scaduto, 403 altro utente, 409 non pronto)

Gli export sincroni (POST packages/export, POST releases/{tag}/export) restano per la CLI e le pipeline.

Import: piano, conflitti, apply, verifica, rollback

1. Carica il pacchetto (POST packages/upload, corpo binario o multipart): integrita', limiti, zip-slip, firma.

2. Piano (sempre a secco, POST promotions/plan): per ogni artefatto confronta tre hash, base (la release del target che la sorgente conosce), sorgente (pacchetto) e target (stato attuale):

CasoEsito
sorgente = targetskip
cambiato solo nella sorgenteupdate
cambiato solo nel target (hotfix)keep con avviso
cambiato da entrambi i latiunione automatica per proprieta'; dove i due lati differiscono, conflict
assente nel targetcreate
solo nel targetdelete solo con prune
nessuna release in comuneogni differenza e' un conflitto da confermare

3. Conflitti (scheda Pacchetti, vista dei conflitti): per artefatto o per proprieta' si sceglie sorgente o target (POST promotions/{id}/resolve, oppure resolveAll = source/target nel piano); ogni scelta ricalcola il piano e il suo hash. Con conflitti aperti l'apply e' rifiutato (409 errors.meta_lifecycle.conflicts_unresolved).

4. Apply (POST promotions/{id}/apply con { "planHash": "..." }): snapshot before-import, una transazione sul DB metadati, file in staging, rigenerazione dei derivati, riallineamento delle identity, invalidazione della cache, commit import nello storico e registrazione della release nel target. Un piano cambiato nel frattempo e' rifiutato (409 errors.meta_lifecycle.plan_outdated).

5. Verifica: riesportazione degli artefatti importati e confronto degli hash; una differenza marca la promozione failed.

Ritorno automatico: se l'apply fallisce (errore a meta' o verifica non riuscita) i metadati tornano da soli allo snapshot before-import e i file toccati al contenuto di prima; poi si verifica che lo stato sia di nuovo quello. Esito: result.status = failed con result.autoRollback (rolledBack, metadataCongruent, filesRestored, filesNotRestored, dataPhaseKept, errors = errori originali, error = perche' il ritorno non e' riuscito); la promozione diventa rolled_back con l'evento auto-rollback nell'audit. Un errore a meta' risponde 409 errors.meta_lifecycle.apply_failed (tutto annullato), apply_failed_data_kept (annullato, ma il DB dati resta), apply_failed_not_rolled_back (anche il ritorno e' fallito: la promozione resta failed e si annulla con il rollback del passo 6) o apply_failed_auto_rollback_off. La fase del DB dati (tabelle e colonne create, registro _wuic_data_migration) non si annulla mai: lo dicono l'esito e il registro della promozione. Per la diagnosi MetaLifecycle:Apply:AutoRollback=false lascia le scritture al loro posto (default: automatico).

6. Rollback (POST promotions/{id}/rollback): ripristina lo snapshot before-import e i file, verifica la congruenza e annulla la registrazione della release.

Altre API: POST packages/export ({ "types": [...] }, vuoto = tutto), POST packages/{id}/diff, GET promotions, GET promotions/{id} (piano e audit), GET promotions/{id}/artifacts/{type}/{uid} (base, sorgente, target e unione).

Ambienti, design lock, approvazioni, firma

Snippet 1JSON
{
  "MetaLifecycle": {
    "Environment": { "Name": "prod-eu", "Role": "prod" },
    "DesignLock": "warn",
    "RequireSecondApprover": "",
    "RequireSignature": "",
    "SigningKey": "C:\\secrets\\wuic-dev-signing.pem",
  • Environment:Role (dev, test, prod, other): la configurazione vince sul registro _wuic_meta_env del DB.
  • DesignLock: off, warn (banner nei designer), on (423 errors.meta_lifecycle.design_locked sui salvataggi di design: AsmxProxy dei designer, CRUD sulle tabelle di definizione, report designer); vuoto = warn in prod, off altrove. Con on cambiano i metadati solo apply e rollback del ciclo di vita. GET design-lock (ogni utente autenticato) alimenta i banner.
  • RequireSecondApprover: chi ha pianificato (o risolto i conflitti) non puo' applicare; vuoto = attivo solo in prod.
  • RequireSignature: pacchetti non firmati o con chiave non fidata rifiutati (403); vuoto = attivo solo in prod.
  • SigningKey (PEM o percorso, mai nel pacchetto), SigningKeyPassword, SigningKeyId (default: impronta della chiave), TrustedPackageKeys:<id> (chiavi pubbliche fidate). Chiave RSA di almeno 2048 bit.
  • GET environment restituisce ruolo, design lock, doppia approvazione, firma richiesta e id delle chiavi.
  • Audit: ogni piano, risoluzione, apply (anche rifiutato) e rollback in _wuic_meta_promotion con utente, IP, hash e firma del pacchetto.

CLI per le pipeline

scripts/wuic-meta.ps1 (PowerShell 7) chiama le stesse API con un token personale con scope `meta-lifecycle`, creato dal dialog "Token API" da un superamministratore (il token vale solo su /api/meta-lifecycle/*, non legge OData; il proprietario deve restare superadmin).

Snippet 2PowerShell
$env:WUIC_META_URL = 'https://dev.example.com'; $env:WUIC_META_TOKEN = '<token di dev>'
pwsh -File scripts/wuic-meta.ps1 release-create --tag 1.4.0 --message "sprint 12"
pwsh -File scripts/wuic-meta.ps1 export --tag 1.4.0 --out release-1.4.0.wuicpkg
$env:WUIC_META_URL = 'https://prod.example.com'; $env:WUIC_META_TOKEN = '<token di chi pianifica>'
pwsh -File scripts/wuic-meta.ps1 plan --package release-1.4.0.wuicpkg --json > plan.json
pwsh -File scripts/wuic-meta.ps1 apply --promotion <id> --plan-hash <hash>

Comandi: status, export, releases, release-create, diff, plan, resolve, apply, rollback. Exit code: 0 ok, 2 conflitti aperti, 3 rifiutato (401/403/409/423, piano con errori), 1 errore.

Multi-tenant

Con il multi-tenant attivo ogni azienda ha il suo DB metadati: identity map, storico, release, pacchetti e promozioni sono per tenant (tabelle nel DB del tenant). La promozione puo' avere come target una lista di tenant:

  • GET tenants: primario (scope 0) + aziende con un DB metadati proprio e una connessione presente nella configurazione (le aziende mappate su MetaDataSQLConnection sono il primario).
  • POST promotions/tenants/plan { "packageId": "...", "tenants": [0, 1, 2], "stopOnFirstError": true }: piano per tenant in sequenza; il pacchetto si ricarica in ogni tenant (firma verificata con le sue regole) dopo aver portato il suo DB metadati alle migration del primario. Ogni tenant ha la sua promozione e il suo hash del piano.
  • POST promotions/tenants/apply e POST promotions/tenants/rollback { "items": [{ "tenantId": 1, "promotionId": "...", "planHash": "..." }], "stopOnFirstError": true }.
  • Il riepilogo riporta per tenant stato (planned, applied, rolled_back, failed, skipped), conteggi per azione ed errore tipizzato; con "stop al primo errore" i tenant successivi restano skipped.
  • ?tenant=<id> su GET promotions, GET promotions/{id}, resolve, artifacts, apply e rollback agisce su un singolo tenant; un tenant non configurato da' 404 errors.meta_lifecycle.tenant_unknown.
  • Nella scheda Pacchetti, con piu' di un tenant, compare la scelta dei tenant con "Fermati al primo errore".

Conservazione dello storico

Il job builtin meta_history_retention_job (ogni 60 minuti, per tenant) cancella le versioni intermedie piu' vecchie di MetaLifecycle:History:KeepDays giorni (default 180; 0 = conservazione illimitata) tenendo sempre le ultime MetaLifecycle:History:MinVersions di ogni artefatto (default 10). Non cancella mai: versioni dei commit con tag o di una release, versioni citate da un manifest di release, file binari (asset 3D), snapshot manuali, il punto di ripristino di una promozione non ancora superata da un apply successivo. Gli snapshot automatici (before-import, before-restore, before-framework-upgrade) oltre la conservazione si cancellano.

Le versioni di un accantonamento non riapplicato (la versione accantonata e quella a cui l'elemento e' tornato) non si cancellano mai.

Righe di sistema e aggiornamenti del framework

Le righe di SISTEMA (route, colonne, stili, azioni, condizioni, permessi e menu che il framework porta con gli script di primo avvio) non entrano nei pacchetti: le aggiorna il framework stesso. Ogni versione incorpora nella DLL la sua baseline di sistema (framework-system-baseline.json.gz, una sezione per DBMS, chiave = chiave primaria: gli id di sistema sono fissi e le righe dell'app li citano per numero). A ogni avvio, dopo le migration e le traduzioni, e per ogni DB metadati di tenant, il framework confronta a 3 vie riga per riga la base registrata nel DB (_wuic_meta_system_baseline, la riga del framework dell'ultimo riallineamento), la riga del framework nuovo e la riga

attuale:

CasoCosa succede
attuale = frameworkniente; la base diventa la riga del framework
attuale = base, framework cambiatola riga si aggiorna (solo le colonne cambiate)
framework = base, attuale cambiatapersonalizzazione: non si tocca
cambiati tutti e due su colonne diversesi prendono solo le colonne cambiate dal framework
cambiati tutti e due sulla stessa colonnaconflitto: quella colonna resta com'e', le altre si aggiornano
riga mancante, mai registratasi inserisce con la sua chiave
riga registrata e poi cancellataresta cancellata
riga tolta dal frameworkmai cancellata, solo segnalata
id occupato da un'altra riga (dell'app) o riga gia' presente con un altro idnon si tocca, si segnala

Al primo riallineamento (nessuna base registrata, per esempio la prima volta dopo l'aggiornamento a questa versione) non si sovrascrive nulla: si inseriscono solo le righe mancanti e le differenze vanno da rivedere. Le scritture stanno in una transazione preceduta da uno snapshot before-framework-upgrade (ripristinabile con POST snapshots/{id}/restore); lo storico registra gli effetti sugli artefatti dell'app con un commit framework-upgrade dell'autore framework, mai di un utente.

La scheda Modificato rispetto al framework della pagina elenca le righe da rivedere (personalizzate, in conflitto, senza base, cancellate, tolte dal framework, con l'id occupato) con base / framework / attuale per colonna e una scelta esplicita: Tieni la mia, Prendi il framework o Applica l'unione (colonna per colonna). La scelta resta registrata: la riga torna nell'elenco solo se cambiano il framework o la riga. API: GET system-baseline, POST system-baseline/resolve { "table", "key", "choice": "keep|framework|merged", "columns": { "col": "mine|framework" } }, POST system-baseline/run (giro a richiesta), tutte con ?tenant=.

Il riallineamento all'avvio si regola con MetaLifecycle:SystemBaseline:Mode: apply (default), report (solo rapporto nel log, nessuna scrittura), off.

Con il multi-tenant, all'avvio si riallineano solo i tenant gia' portati alle migration del ciclo di vita (come in F7, le migration all'avvio girano sul primario); gli altri al primo uso: POST system-baseline/run?tenant=<id> li migra e li riallinea, e lo fa anche il primo avvio dopo un piano per tenant.

Aggiornamenti disponibili

La scheda Aggiornamenti della pagina (sola lettura) mostra la versione installata e quella disponibile del framework e, se nella radice del contenuto c'e' il manifest wuic-app.json di una free app, anche della app, con il link alle note di rilascio e cosa fare: per un'installazione binaria le istruzioni manuali (scarica lo zip, sezione "Aggiornamento" delle note), per un'installazione da sorgenti il comando da eseguire nel repository (pwsh scripts/wuic-app-upgrade.ps1 -To <versione> per una free app, aggiornamento di WuicCore su NuGet e wuic-framework-lib su npm per un'app propria). Dal browser non si applica niente. Con una free app binaria il framework nuovo arriva solo con una release nuova della app; se la versione nuova della app chiede un framework piu' recente (frameworkMin) la scheda lo dice.

Cosa controlla e cosa invia: il server legge il feed Updates:FeedUrl (default https://wuic-framework.com/downloads/releases.json) qualche minuto dopo l'avvio e poi ogni 24 ore, con un solo GET senza header propri, cookie o identificativi dell'installazione; il confronto si fa sul server. Feed irraggiungibile o non valido: una riga nel log, nessun errore all'utente. A ogni versione nuova i superadmin ricevono una notifica nella campanella (stato in App_Data/update-check.json). Updates:Check=false spegne il controllo (nessuna richiesta); Updates:TimeoutSeconds (default 10) e Updates:InitialDelayMinutes (default 3) regolano tempi. API (solo superadmin): GET updates (ultimo esito), POST updates/check (controlla ora).

Limiti

  • 4 DBMS: storico, release, pacchetti, piano, apply e rollback sono verificati su SQL Server, MySQL, PostgreSQL e Oracle dai test di parita' (MetaLifecycleParity*).
  • Stesso DBMS: la promozione fra DBMS diversi non e' supportata (il SQL libero nei metadati non si traduce).
  • DB dati: struttura, migrazioni e dati di riferimento delle app esistenti non sono coperti; il pacchetto porta solo tabelle, dati di riferimento e dati demo delle app create dal generatore.
  • Trasporto solo a file (.wuicpkg + CLI): niente push diretto fra ambienti.
  • Righe di SISTEMA: non si promuovono fra ambienti; gli aggiornamenti del framework le riallineano a 3 vie senza mai sovrascrivere le personalizzazioni (sopra). Le traduzioni del framework arrivano solo come chiavi mancanti.
  • Multi-tenant: i file dell'installazione (report, CSS, asset) sono condivisi fra i tenant.

Esempio rapido via API

Snippet 3Bash
# dev: release e pacchetto
curl -s -X POST "$WUIC/api/meta-lifecycle/releases" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -d '{"tag":"1.4.0","message":"sprint 12"}'
curl -s -X POST "$WUIC/api/meta-lifecycle/releases/1.4.0/export" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -d '{}' -o release-1.4.0.wuicpkg
# prod: carica, pianifica, applica
curl -s -X POST "$PROD/api/meta-lifecycle/packages/upload" -H "Authorization: Bearer $PROD_TOKEN" -H "Content-Type: application/octet-stream" --data-binary @release-1.4.0.wuicpkg
curl -s -X POST "$PROD/api/meta-lifecycle/promotions/plan" -H "Authorization: Bearer $PROD_TOKEN" -H "Content-Type: application/json" -d '{"packageId":"<packageId>"}'
curl -s -X POST "$PROD/api/meta-lifecycle/promotions/<promotionId>/apply" -H "Authorization: Bearer $APPROVER_TOKEN" -H "Content-Type: application/json" -d '{"planHash":"<hash>"}'

Screenshot

Storico: le versioni della route cities con data, autore e messaggio di ogni registrazione
Storico: le versioni della route cities con data, autore e messaggio di ogni registrazione
Confronta: diff visuale fra due versioni e tabella delle proprieta' cambiate
Confronta: diff visuale fra due versioni e tabella delle proprieta' cambiate
Release registrate con la release precedente, il numero di elementi e l'esportazione completa o delta
Release registrate con la release precedente, il numero di elementi e l'esportazione completa o delta
Piano di una promozione: conflitto a 3 vie sulla route cities (base, sorgente, target) con la scelta per proprieta'; l'apply resta bloccato finche' ci sono conflitti aperti
Piano di una promozione: conflitto a 3 vie sulla route cities (base, sorgente, target) con la scelta per proprieta'; l'apply resta bloccato finche' ci sono conflitti aperti