{"elements":[{"id":7008,"title":"Sistema Cache","body":"
\n
\n

Caching trasparente<\/h2>\n

DressAPI include un livello di caching trasparente tra la logica applicativa e il database. Quando abilitato, ogni lettura (SELECT) viene automaticamente cachata e ogni operazione di scrittura (INSERT, UPDATE, DELETE) invalida automaticamente le voci di cache pertinenti, incluse quelle delle tabelle correlate.<\/p>\n\n

Principi di progettazione<\/h3>\n
    \n
  • Zero codice applicativo richiesto<\/strong> – il caching è gestito a livello framework tramite i metodi CDB<\/code><\/li>\n
  • Due backend intercambiabili<\/strong> – basato su file (filesystem RAM \/dev\/shm\/<\/code>) o Redis<\/li>\n
  • Isolamento per utente<\/strong> – le voci di cache possono essere associate a un utente o globali<\/li>\n
  • Invalidazione automatica<\/strong> – le operazioni di scrittura cancellano la cache per la tabella interessata e tutte le tabelle collegate via chiavi esterne<\/li>\n
  • Crittografia opzionale<\/strong> – i dati in cache possono essere cifrati a riposo con AES-256-CBC<\/li>\n <\/ul>\n <\/div>\n<\/section>\n\n
    \n
    \n

    Architettura<\/h2>\n

    Il sistema cache segue il pattern classico interfaccia\/factory\/implementazione:<\/p>\n

    \n
    Struttura delle classi<\/div>\nICache<\/span> (interfaccia)\n ├── CFileCache<\/span> (implementazione filesystem)\n └── CRedisCache<\/span> (implementazione Redis)\n\nCCache<\/span> (factory)\n └── CreateInstance<\/span>() → restituisce ICache<\/span>|null<\/span> in base alla configurazione\n <\/div>\n\n

    Metodi dell'interfaccia ICache<\/h3>\n

    L'interfaccia ICache<\/code> definisce metodi accoppiati per operazioni specifiche per utente e globali:<\/p>\n

    \n \n \n \n
    Per utente<\/th>Globale<\/th>Descrizione<\/th><\/tr>\n <\/thead>\n
    Set()<\/code><\/td>SetGlobal()<\/code><\/td>Memorizza un valore<\/td><\/tr>\n
    Get()<\/code><\/td>GetGlobal()<\/code><\/td>Recupera un valore<\/td><\/tr>\n
    Exists()<\/code><\/td>ExistsGlobal()<\/code><\/td>Verifica se la chiave esiste<\/td><\/tr>\n <\/tbody>\n <\/table>\n <\/div>\n

    Il metodo ClearArea()<\/code> cancella tutte le voci di cache per una data area (nome tabella). Delete()<\/code> rimuove un singolo elemento.<\/p>\n\n

    File chiave<\/h3>\n
    \n \n \n \n
    File<\/th>Scopo<\/th><\/tr>\n <\/thead>\n
    core\/src\/cache\/ICache.php<\/code><\/td>Interfaccia che definisce tutte le operazioni di cache<\/td><\/tr>\n
    core\/src\/cache\/CCache.php<\/code><\/td>Classe factory che istanzia il driver corretto<\/td><\/tr>\n
    core\/src\/cache\/CFileCache.php<\/code><\/td>Implementazione cache su filesystem<\/td><\/tr>\n
    core\/src\/cache\/CRedisCache.php<\/code><\/td>Implementazione cache Redis (usa predis\/predis<\/code>)<\/td><\/tr>\n
    core\/src\/cache\/config-cache.php<\/code><\/td>Configurazione generale (switch principale, selezione driver)<\/td><\/tr>\n
    core\/src\/cache\/config-file-cache.php<\/code><\/td>Impostazioni cache su file (percorso, crittografia)<\/td><\/tr>\n
    core\/src\/cache\/config-redis-cache.php<\/code><\/td>Impostazioni connessione Redis<\/td><\/tr>\n <\/tbody>\n <\/table>\n <\/div>\n <\/div>\n<\/section>\n\n
    \n
    \n

    Implementazione cache su file (CFileCache)<\/h2>\n

    Memorizza ogni elemento come file serializzato (e opzionalmente cifrato) sul filesystem. Il percorso predefinito \/dev\/shm\/<\/code> è un filesystem basato su RAM su Linux, fornendo velocità di lettura prossime a zero latenza.<\/p>\n\n

    Struttura del percorso di archiviazione<\/h3>\n
    \n
    Formato percorso<\/div>\n{CACHE_PATH}{DOMAIN_NAME}\/cache\/{APP_NAME}\/{area_name}\/{user_part}.{safe_name}.cache\n\n\/\/ Esempio concreto:<\/span>\n\/dev\/shm\/dressapi.com\/cache\/core\/blog_post\/user_5.a3f8c1d9e2b4.cache\n <\/div>\n\n

    Vantaggi<\/h3>\n
      \n
    • Nessuna dipendenza esterna<\/li>\n
    • Alte prestazioni quando si usa \/dev\/shm\/<\/code> (tmpfs basato su RAM)<\/li>\n
    • Semplice da ispezionare e debuggare (file su disco)<\/li>\n <\/ul>\n

      Considerazioni<\/h3>\n
        \n
      • I file persistono solo finché il filesystem esiste (\/dev\/shm\/<\/code> viene svuotato al riavvio)<\/li>\n
      • Non condiviso tra più server a meno che non si usi un filesystem condiviso<\/li>\n <\/ul>\n <\/div>\n<\/section>\n\n
        \n
        \n

        Implementazione cache Redis (CRedisCache)<\/h2>\n

        Memorizza ogni elemento come coppia chiave-valore Redis. Utilizza la libreria PHP predis\/predis<\/code>.<\/p>\n\n

        Installazione<\/h3>\n
        \n
        Terminale<\/div>\ncd<\/span> core\/\ncomposer require<\/span> predis\/predis\n <\/div>\n\n

        Struttura della chiave<\/h3>\n
        \n
        Formato chiave Redis<\/div>\n{DOMAIN_NAME}:{APP_NAME}:{area_name}:{user_part}:{safe_name}\n\n\/\/ Esempio concreto:<\/span>\ndressapi.com:core:blog_post:user_5:a3f8c1d9e2b4\n <\/div>\n\n

        Vantaggi<\/h3>\n
          \n
        • Condiviso tra più server applicativi<\/li>\n
        • Supporta TTL nativo (time-to-live)<\/li>\n
        • Usa Redis SCAN<\/code> per iterazione sicura e non bloccante durante la cancellazione della cache<\/li>\n <\/ul>\n

          Considerazioni<\/h3>\n
            \n
          • Richiede un server Redis in esecuzione e la libreria predis\/predis<\/code><\/li>\n
          • Se Redis è irraggiungibile alla costruzione, il client viene impostato a null<\/code> e tutte le operazioni degradano silenziosamente a no-op<\/li>\n <\/ul>\n <\/div>\n<\/section>\n\n
            \n
            \n

            Struttura della chiave di cache<\/h2>\n

            Le chiavi di cache sono costruite da più componenti per garantire l'isolamento tra domini, applicazioni, moduli e utenti.<\/p>\n\n

            \n \n \n \n
            Componente<\/th>Sorgente<\/th>Scopo<\/th><\/tr>\n <\/thead>\n
            Dominio<\/strong><\/td>Costante DOMAIN_NAME<\/code><\/td>Isola la cache tra diversi siti\/domini<\/td><\/tr>\n
            Applicazione<\/strong><\/td>Costante APP_NAME<\/code><\/td>Isola la cache tra diverse app sullo stesso dominio<\/td><\/tr>\n
            Area<\/strong><\/td>Nome tabella o gruppo logico<\/td>Raggruppa le voci correlate per invalidazione massiva<\/td><\/tr>\n
            Parte utente<\/strong><\/td>global<\/code> o user_{id}<\/code><\/td>Separa i dati per utente dai dati condivisi<\/td><\/tr>\n
            Nome<\/strong><\/td>Hash della query (tramite DB_ENC_ALGORITHM<\/code>)<\/td>Identifica univocamente il dato specifico<\/td><\/tr>\n <\/tbody>\n <\/table>\n <\/div>\n\n

            Generazione delle chiavi in CDB<\/h3>\n
            \n
            CDB::GetCacheKey()<\/div>\n\/\/ La chiave viene generata tramite hash<\/span>\n$cache_key<\/span> = hash<\/span>(DB_ENC_ALGORITHM<\/span>, $key<\/span>);\n\/\/ dove $key è tipicamente: "{sql_query}.{method_name}.{parameters}"<\/span>\n\n\/\/ Esempio per GetCachedFetchAssoc():<\/span>\n$cache_key<\/span> = GetCacheKey<\/span>($sql<\/span> . '.getCachedFetchAssoc.'<\/span> . $pos_row<\/span> . '.'<\/span> . implode<\/span>('.'<\/span>, $bind_param_values<\/span>));\n <\/div>\n

            Questo garantisce che query diverse, offset di paginazione diversi e valori dei parametri diversi producano chiavi di cache distinte.<\/p>\n <\/div>\n<\/section>\n\n

            \n
            \n

            Scope per utente vs globali<\/h2>\n

            Gli elementi globali<\/strong> (memorizzati con uid = 0<\/code>) sono condivisi tra tutti gli utenti. Questo viene usato per dati che non variano per utente:<\/p>\n

              \n
            • Strutture delle tabelle del database (area structures<\/code>)<\/li>\n
            • Definizioni dei moduli<\/li>\n
            • Stringhe di traduzione<\/li>\n
            • Mappature delle rotte<\/li>\n <\/ul>\n

              Gli elementi per utente<\/strong> sono limitati all'ID dell'utente corrente, garantendo che i risultati delle query influenzati da ACL o filtri only_owner<\/code> rimangano correttamente isolati.<\/p>\n\n

              \n
              Utilizzo scope<\/div>\n\/\/ Cache globale (condivisa tra tutti gli utenti)<\/span>\n$this<\/span>->GetCachedData<\/span>($cache_key<\/span>, 'structures'<\/span>, true<\/span>);\n$this<\/span>->SetCachedData<\/span>($cache_key<\/span>, $data<\/span>, 'structures'<\/span>, true<\/span>);\n\n\/\/ Cache per utente (predefinita)<\/span>\n$this<\/span>->GetCachedData<\/span>($cache_key<\/span>, $this<\/span>->table);\n$this<\/span>->SetCachedData<\/span>($cache_key<\/span>, $data<\/span>, $this<\/span>->table);\n <\/div>\n <\/div>\n<\/section>\n\n
              \n
              \n

              Caching automatico delle GET<\/h2>\n

              Tutti i metodi GetCached*<\/code> in CDB<\/code> seguono lo stesso pattern:<\/p>\n

                \n
              1. Costruisci la chiave di cache da SQL + parametri<\/li>\n
              2. Tenta di leggere dalla cache<\/li>\n
              3. Se HIT<\/strong> → restituisci i dati dalla cache (nessuna query al DB)<\/li>\n
              4. Se MISS<\/strong> → esegui la query, memorizza il risultato nella cache, restituisci i dati<\/li>\n <\/ol>\n\n

                Metodi cached disponibili in CDB<\/h3>\n
                \n \n \n \n
                Metodo<\/th>Cosa cacha<\/th><\/tr>\n <\/thead>\n
                GetCachedFetchAssoc()<\/code><\/td>Singola riga come array associativo<\/td><\/tr>\n
                GetCachedFetchRow()<\/code><\/td>Singola riga come array numerico<\/td><\/tr>\n
                GetCachedDataValue()<\/code><\/td>Singolo valore scalare<\/td><\/tr>\n
                GetCachedDataTable()<\/code><\/td>Intero result set come array<\/td><\/tr>\n
                GetCachedArrayByName()<\/code><\/td>Coppie chiave-valore dal result set<\/td><\/tr>\n
                GetCachedIDsArray()<\/code><\/td>Singola colonna come array<\/td><\/tr>\n <\/tbody>\n <\/table>\n <\/div>\n

                Ciascuno ha una controparte non cached (GetQueryFetchAssoc()<\/code>, GetQueryDataTable()<\/code>, ecc.) che accede sempre al database.<\/p>\n\n

                Ciclo di vita della richiesta con cache<\/h3>\n
                \n
                Flusso richiesta<\/div>\nRichiesta Client (GET \/blog_post)\n ↓\nbootstrap.php\n ├─ CCache::CreateInstance() → ICache o null\n ├─ CRequest::CreateInstance($connection_manager, $cache, ...)\n ├─ CUser::CreateInstance($request, $connection_manager, $cache, ...)\n └─ CTranslator::Init($connection_manager, $cache, ...)\n ↓\nCBaseController::Exec()\n └─ ExecGET()\n └─ CBaseModel::GetData()\n └─ CDB::GetCachedDataTable() ← ricerca cache qui\n ├─ cache HIT? restituisci dati\n └─ cache MISS? query DB, memorizza, restituisci\n <\/div>\n <\/div>\n<\/section>\n\n
                \n
                \n

                Invalidazione della cache<\/h2>\n

                Ogni operazione di scrittura in CDB<\/code> (InsertRecord<\/code>, UpdateRecord<\/code>, DeleteRecord<\/code>) chiama InvalidateRelatedCache()<\/code> in caso di successo.<\/p>\n\n

                Invalidazione delle tabelle correlate<\/h3>\n

                InvalidateRelatedCache()<\/code> non cancella solo la cache per la tabella modificata – cancella anche la cache per ogni tabella che ha una chiave esterna che punta alla tabella modificata.<\/p>\n

                \n
                InvalidateRelatedCache()<\/div>\nprotected function<\/span> InvalidateRelatedCache<\/span>(?string<\/span> $table<\/span>): void<\/span>\n{\n if<\/span> ($this<\/span>->cache)\n {\n $table<\/span> ??= $this<\/span>->table;\n $this<\/span>->cache->ClearArea<\/span>($table<\/span>);\n\n \/\/ Trova tutte le tabelle che referenziano questa via chiave esterna<\/span>\n $related_fieldname<\/span> = str_replace<\/span>('[related_table]'<\/span>, $table<\/span>, RELATED_TABLE_ID<\/span>);\n $all_dbtables<\/span> = $this<\/span>->GetAllTables<\/span>();\n\n foreach<\/span> ($all_dbtables<\/span> as<\/span> $table_rel<\/span> => $fields<\/span>)\n if<\/span> (isset<\/span>($fields<\/span>[$related_fieldname<\/span>]))\n $this<\/span>->cache->ClearArea<\/span>($table_rel<\/span>);\n }\n}\n <\/div>\n

                Ad esempio, se si inserisce nella tabella category<\/code>: (1) tutta la cache nell'area category<\/code> viene cancellata, (2) ogni tabella con una colonna id_category<\/code> ha la sua area cancellata.<\/p>\n\n

                Invalidazione manuale<\/h3>\n
                \n
                Cancellazione manuale<\/div>\n\/\/ Cancella un'intera area (es. dopo un import massivo)<\/span>\n$cache<\/span>->ClearArea<\/span>('blog_post'<\/span>);\n\n\/\/ Elimina un singolo elemento<\/span>\n$cache<\/span>->Delete<\/span>('specific_key'<\/span>);\n <\/div>\n <\/div>\n<\/section>\n\n
                \n
                \n

                Crittografia a riposo<\/h2>\n

                Sia CFileCache<\/code> che CRedisCache<\/code> supportano la crittografia opzionale dei dati tramite OpenSSL. Il processo è:<\/p>\n

                  \n
                1. I dati vengono serializzati con serialize()<\/code> di PHP<\/li>\n
                2. Se la crittografia è abilitata, la stringa viene cifrata con openssl_encrypt()<\/code> usando un IV casuale<\/li>\n
                3. L'IV viene anteposto al testo cifrato e il risultato viene codificato in base64<\/li>\n
                4. In lettura il processo è inverso: decodifica base64, estrai IV, decifra, deserializza<\/li>\n <\/ol>\n\n

                  Costanti di crittografia<\/h3>\n
                  \n \n \n \n
                  Costante<\/th>Predefinito<\/th>Descrizione<\/th><\/tr>\n <\/thead>\n
                  CACHE_ENCRYPTION_ENABLED<\/code><\/td>true<\/code><\/td>Abilita\/disabilita la crittografia dei dati in cache<\/td><\/tr>\n
                  CACHE_ENCRYPTION_KEY<\/code><\/td>'change-this-...'<\/code><\/td>Chiave di crittografia AES. Deve essere cambiata in produzione!<\/strong><\/td><\/tr>\n
                  CACHE_ENCRYPTION_CIPHER<\/code><\/td>'aes-256-cbc'<\/code><\/td>Algoritmo di cifratura OpenSSL<\/td><\/tr>\n <\/tbody>\n <\/table>\n <\/div>\n <\/div>\n<\/section>\n\n
                  \n
                  \n

                  Tutte le costanti di configurazione<\/h2>\n\n

                  Configurazione generale<\/h3>\n

                  Definite in core\/src\/cache\/config-cache.php<\/code>:<\/p>\n

                  \n \n \n \n
                  Costante<\/th>Predefinito<\/th>Descrizione<\/th><\/tr>\n <\/thead>\n
                  CACHE_ENABLED<\/code><\/td>false<\/code><\/td>Switch principale. Deve essere true<\/code> perché il caching funzioni<\/td><\/tr>\n
                  CACHE_DRIVER<\/code><\/td>'file'<\/code><\/td>Driver backend: 'file'<\/code> o 'redis'<\/code><\/td><\/tr>\n
                  CACHE_MAX_SIZE_PER_ELEMENT<\/code><\/td>65536<\/code> (64 KB)<\/td>Dimensione massima in byte per elemento. Gli elementi più grandi vengono ignorati<\/td><\/tr>\n
                  DOMAIN_NAME<\/code><\/td>'dressapi'<\/code><\/td>Prefisso\/namespace per isolamento tra domini<\/td><\/tr>\n
                  APP_NAME<\/code><\/td>'core'<\/code><\/td>Prefisso\/namespace per isolamento tra applicazioni<\/td><\/tr>\n
                  DB_ENC_ALGORITHM<\/code><\/td>'tiger192,4'<\/code><\/td>Algoritmo hash per generare le chiavi di cache dalle query SQL<\/td><\/tr>\n <\/tbody>\n <\/table>\n <\/div>\n\n

                  Impostazioni cache su file<\/h3>\n

                  Definite in core\/src\/cache\/config-file-cache.php<\/code>:<\/p>\n

                  \n \n \n \n
                  Costante<\/th>Predefinito<\/th>Descrizione<\/th><\/tr>\n <\/thead>\n
                  CACHE_PATH<\/code><\/td>'\/dev\/shm\/'<\/code><\/td>Directory base per i file di cache. \/dev\/shm\/<\/code> è un filesystem RAM per prestazioni massime<\/td><\/tr>\n
                  CACHE_ENCRYPTION_ENABLED<\/code><\/td>true<\/code><\/td>Crittografia dei dati a riposo<\/td><\/tr>\n
                  CACHE_ENCRYPTION_KEY<\/code><\/td>'change-this-...'<\/code><\/td>Chiave crittografia AES<\/td><\/tr>\n
                  CACHE_ENCRYPTION_CIPHER<\/code><\/td>'aes-256-cbc'<\/code><\/td>Algoritmo OpenSSL<\/td><\/tr>\n <\/tbody>\n <\/table>\n <\/div>\n\n

                  Impostazioni Redis<\/h3>\n

                  Definite in core\/src\/cache\/config-redis-cache.php<\/code>:<\/p>\n

                  \n \n \n \n
                  Costante<\/th>Predefinito<\/th>Descrizione<\/th><\/tr>\n <\/thead>\n
                  REDIS_SCHEME<\/code><\/td>'tcp'<\/code><\/td>Schema di connessione<\/td><\/tr>\n
                  REDIS_HOST<\/code><\/td>'127.0.0.1'<\/code><\/td>Hostname del server Redis<\/td><\/tr>\n
                  REDIS_PORT<\/code><\/td>6379<\/code><\/td>Porta del server Redis<\/td><\/tr>\n
                  REDIS_USERNAME<\/code><\/td>null<\/code><\/td>Username Redis opzionale (ACL Redis 6+)<\/td><\/tr>\n
                  REDIS_PASSWORD<\/code><\/td>null<\/code><\/td>Password Redis opzionale<\/td><\/tr>\n
                  REDIS_DATABASE<\/code><\/td>0<\/code><\/td>Indice database Redis (0-15)<\/td><\/tr>\n <\/tbody>\n <\/table>\n <\/div>\n <\/div>\n<\/section>\n\n
                  \n
                  \n

                  Punti di integrazione nel bootstrap<\/h2>\n

                  L'istanza di cache viene creata una volta in bootstrap.php<\/code> e iniettata in ogni componente principale:<\/p>\n

                  \n
                  bootstrap.php<\/div>\n$cache<\/span> = CCache<\/span>::CreateInstance<\/span>();\n$request<\/span> = CRequest<\/span>::CreateInstance<\/span>($connection_manager<\/span>, $cache<\/span>, $logger<\/span>);\n$user<\/span> = CUser<\/span>::CreateInstance<\/span>($request<\/span>, $connection_manager<\/span>, $cache<\/span>, $logger<\/span>);\n$response<\/span> = CHtmlResponse<\/span>::CreateInstance<\/span>($request<\/span>, $cache<\/span>, $user<\/span>, $logger<\/span>);\nCTranslator<\/span>::Init<\/span>($connection_manager<\/span>, $cache<\/span>, $logger<\/span>);\n <\/div>\n\n

                  Componenti che usano la cache<\/h3>\n
                  \n \n \n \n
                  Componente<\/th>Cosa viene cachato<\/th><\/tr>\n <\/thead>\n
                  CDB<\/code><\/td>Tutti i risultati GetCached*()<\/code>; strutture tabelle; liste moduli<\/td><\/tr>\n
                  CBaseModel<\/code><\/td>Definizioni colonne; mappature picklist; risultati per viste lista\/dettaglio<\/td><\/tr>\n
                  CBaseController<\/code><\/td>Risposte OPTIONS (strutture moduli)<\/td><\/tr>\n
                  CUser<\/code><\/td>Permessi ACL, dati ruolo utente<\/td><\/tr>\n
                  CRoutes<\/code><\/td>Mappature tabella rotte (percorsi origine\/destinazione)<\/td><\/tr>\n
                  CTranslator<\/code><\/td>Stringhe di traduzione per lingua<\/td><\/tr>\n <\/tbody>\n <\/table>\n <\/div>\n

                  Nota:<\/strong> HTTP_CACHE_TIMEOUT<\/code> (predefinito: 0<\/code>) controlla il caching HTTP lato browser tramite l'header Cache-Control<\/code>. Questo è indipendente dal sistema cache lato server descritto qui.<\/p>\n <\/div>\n<\/section>\n\n

                  \n
                  \n

                  Buone pratiche<\/h2>\n
                    \n
                  1. Usare \/dev\/shm\/<\/code> per la cache su file<\/strong> – Il percorso predefinito memorizza i file in un filesystem RAM. Fornisce latenza prossima a zero. Al riavvio \/dev\/shm\/<\/code> viene svuotato automaticamente.<\/li>\n
                  2. Cambiare la chiave di crittografia<\/strong> – La chiave predefinita è un segnaposto. Sostituirla con una stringa casuale crittograficamente sicura: openssl rand -base64 32<\/code><\/li>\n
                  3. Attenzione al limite di 64 KB<\/strong> – CACHE_MAX_SIZE_PER_ELEMENT<\/code> è 65536 byte. I dati più grandi non vengono cachati silenziosamente. Aumentare il limite o paginare le query.<\/li>\n
                  4. Redis per distribuzioni multi-server<\/strong> – CFileCache<\/code> memorizza sul filesystem locale. Per deploy bilanciati o clusterizzati, usare CRedisCache<\/code> per coerenza della cache.<\/li>\n
                  5. Debug con file di log<\/strong> – File cache: core\/logs\/dressapi-cache.log<\/code>, Redis cache: core\/logs\/dressapi-redis-cache.log<\/code><\/li>\n
                  6. Abilitare in produzione<\/strong> – La cache è disabilitata per default. Abilitarla in staging e produzione per guadagni significativi di prestazioni.<\/li>\n <\/ol>\n <\/div>\n<\/section>\n\n
                    \n ← Torna ai Tutorial<\/a>\n<\/section>","description":"Cache su filesystem e Redis con connessione lazy","meta_keywords":"","visible":"yes","status":"public","creation_date":"0000-00-00","id__user":1,"priority":0,"groupname":"TUTORIAL"}],"module":"pages","permissions":{"can_read":true},"main_item_title":"title","related_tables":[{"name":"Newsonpage","module":"newsonpage","FK":"id_cmspage","permissions":[]}],"page_info":{"table":"","key":"id","url":"\/pages","url_list":"\/pages","filters":{"id":["=","7008"]},"pagination":{"total_items":23,"page":1,"total_pages":2,"step":1,"items_per_page":20,"url_prev":"\/pages","url_next":"\/pages\/p\/2","url_tmpl":"\/pages\/p\/[[p]]","url_tmpl_with_order":"\/pages\/p\/[[p]]\/ob\/[[ob]]"},"order":{"field":"id","type":"DESC","url_tmpl":"\/pages\/p\/[[p]]"},"module":{"title":"Pages","description":"List of pages","name":"pages"},"current":{"title":"Pages","description":"List of pages","name":"pages","url":"\/tutorials\/cache"}},"components":{"alert":{"alert1":[{"type":"warning","message":"OK COMPONENT!"},{"type":"danger","message":"ERROR COMPONENT!"}]}},"messages":[]}