Crea un blog in Swift con Oracle Content Management headless

Introduzione

Un ambiente di sviluppo iOS che utilizza Swift e SwiftUI può essere un potente strumento per creare applicazioni che utilizzano contenuti di Oracle Content Management. Armati del giusto modello di contenuto, è possibile creare rapidamente l'interfaccia utente che costituisce una tipica applicazione di blog.

In questa esercitazione, creeremo una semplice applicazione di blog per iOS in Swift utilizzando Oracle Content Management come CMS headless nonché il kit SDK (Software Development Kit) per la distribuzione dei contenuti. Questo esempio per iOS è disponibile all'indirizzo GitHub.

L'esercitazione prevede tre passi:

1. Preparare Oracle Content Management
2. Creare l'applicazione di blog in Xcode
3. Eseguire l'applicazione

Prerequisiti

Prima di procedere con questa esercitazione, si consiglia di leggere le seguenti informazioni:

• Concetti chiave
• Repository di asset

Per seguire questa esercitazione, è necessario:

• una sottoscrizione a Oracle Content Management
• un account di Oracle Content Management con ruolo Amministratore contenuto;
• un computer Mac con Xcode versione 14.2 o successiva

Quello che stiamo costruendo

La nostra applicazione di blog è composta da tre pagine separate che consentono ai visitatori di esplorare articoli di blog organizzati in argomenti.

La prima pagina, la home page, è costituita dal branding (nome e logo dell'azienda), da alcuni collegamenti e da un elenco di argomenti di blog.

La seconda pagina, la pagina di elenco degli articoli, mostra le anteprime di ogni articolo di blog che appartiene all'argomento.

Infine, la pagina dell'articolo visualizza l'articolo del blog finale, incluse informazioni sull'autore del blog.

Per continuare, sarà necessario disporre di una sottoscrizione attiva a Oracle Content Management e accedere con il ruolo Amministratore contenuto.

Passo 1: Preparare Oracle Content Management

Se non si dispone già di un'istanza di Oracle Content Management, vedere Avvio rapido per informazioni su come registrarsi per Oracle Cloud, eseguire il provisioning di un'istanza di Oracle Content Management e configurare Oracle Content Management come CMS headless.

Per questa esercitazione è necessario creare un modello di contenuto in due modi. È disponibile un packing di asset scaricabile che riempirà il repository vuoto con tipi di contenuto e contenuto associato oppure è possibile creare modelli di contenuto e contenuto personalizzati.

Per preparare Oracle Content Management:

1. Creare un canale e un repository degli asset.
2. Creare un modello di contenuto utilizzando uno dei due metodi riportati di seguito.
   • Metodo 1: Importazione del pacchetto asset di campioni di Oracle Content Management
   • Metodo 2: creare un modello di contenuto personale

Creare un canale e un repository degli asset

È innanzitutto necessario creare un canale e un repository di asset in Oracle Content Management in modo da poter pubblicare il contenuto.

Per creare un canale e un repository di asset in Oracle Content Management, effettuare le operazioni riportate di seguito.

1. Accedere all'interfaccia Web di Oracle Content Management come amministratore.

2. Scegliere Contenuto nel menu di navigazione a sinistra, quindi scegliere Canali di pubblicazione dall'elenco di selezione nell'intestazione della pagina.

   

3. Nell'angolo in alto a destra fare clic su Crea per creare un nuovo canale. Assegnare un nome al canale 'OCEGettingStartedChannel' ai fini di questa esercitazione e mantenere pubblico l'accesso. Fare clic su Salva per creare il canale.

   

4. Scegliere Contenuto nel menu di navigazione a sinistra, quindi scegliere Repositori dall'elenco di selezione nell'intestazione della pagina.

   

5. Nell'angolo in alto a destra fare clic su Crea per creare un nuovo repository di asset. Assegnare un nome al repository degli asset 'OCEGettingStartedRepository' ai fini di questa esercitazione.

   

6. Nel campo Canali di pubblicazione selezionare il canale OCEGettingStartedChannel per indicare a Oracle Content Management che il contenuto del repository OCEGettingStartedRepository può essere pubblicato nel canale OCEGettingStartedChannel. Al termine, fare clic su Salva.

   

Crea un modello di contenuto

Il passo successivo consiste nel creare un modello di contenuto. Sono disponibili due metodi:

• Metodo 1: Importazione del pacchetto asset di campioni di Oracle Content Management
• Metodo 2: creare un modello di contenuto personale

Importa il pacchetto asset di campioni di Oracle Content Management

È possibile scaricare un pacchetto di asset campione preconfigurato di Oracle Content Management contenente tutti i tipi di contenuto e gli asset richiesti per questa esercitazione. Se si preferisce, è inoltre possibile creare un modello di contenuto personalizzato anziché scaricare il pacchetto di asset campione.

È possibile caricare una copia del contenuto in questa esercitazione da Oracle Content Management Samples Asset Pack. In questo modo sarà possibile sperimentare i tipi di contenuto e modificare il contenuto. Se si desidera importare il pacchetto asset di esempio di Oracle Content Management, scaricare l'archivio del pacchetto asset OCESamplesAssetPack.zip ed estrarlo in una directory a scelta:

1. Scaricare Oracle Content Management Samples Asset Pack (OCESamplesAssetPack.zip) dalla pagina download di Oracle Content Management. Estrarre il file zip scaricato in una posizione sul computer. Dopo l'estrazione, questa posizione includerà un file denominato OCEGettingStarted_data.zip.

2. Accedere all'interfaccia Web di Oracle Content Management come amministratore.

3. Scegliere Contenuto nel menu di navigazione a sinistra, quindi scegliere Repositori dall'elenco di selezione nell'intestazione della pagina. Selezionare OCEGettingStartedRepository e fare clic sul pulsante Importa contenuto nella barra delle azioni superiore.

   

4. Caricare OCEGettingStarted_data.zip dal computer locale nella cartella Documenti.

   

5. Dopo il caricamento, selezionare OCEGettingStarted_data.zip e fare clic su OK per importare il contenuto nel repository degli asset.

   

6. Dopo aver importato correttamente il contenuto, passare alla pagina Asset e aprire il repository OCEGettingStartedRepository. Tutte le immagini e gli elementi di contenuto correlati sono stati aggiunti al repository degli asset.

   

7. Fare clic su Seleziona tutto in alto a sinistra, quindi su Pubblica per aggiungere tutti gli asset importati al canale di pubblicazione creato in precedenza, OCEGettingStartedChannel.

   

8. Prima della pubblicazione, è necessario convalidare tutti gli asset. Aggiungere prima OCEGettingStartedChannel come canale selezionato, quindi fare clic sul pulsante Convalida.

   

9. Dopo la convalida degli asset, è possibile pubblicare tutti gli asset nel canale selezionato facendo clic sul pulsante Pubblica nell'angolo superiore destro.

   

Al termine, è possibile visualizzare nella pagina Asset la pubblicazione di tutti gli asset. (È possibile indicare l'icona sopra il nome dell'asset).

Dopo aver importato Oracle Content Management Samples Asset Pack, è possibile avviare la creazione del blog in Xcode.

Crea un modello di contenuto personale

Anziché importare il pacchetto asset di campioni di Oracle Content Management, è inoltre possibile creare un modello di contenuto personalizzato.

Per questa esercitazione viene utilizzato un tipo di contenuto denominato 'OCEGettingStartedHomePage' per creare la home page per il nostro blog. Questa home page è costituita dal branding (nome e logo dell'azienda), da alcuni URL per i collegamenti e da un elenco di argomenti di blog che devono essere inclusi nella pagina.

Per creare tipi di contenuto per il modello di contenuto:

1. Accedere all'interfaccia Web di Oracle Content Management come amministratore.
2. Scegliere Contenuto nel menu di navigazione a sinistra, quindi scegliere Tipi di asset dall'elenco di selezione nell'intestazione della pagina.
3. Fare clic su Crea nell'angolo superiore destro.
4. Scegliere di creare un tipo di contenuto (non un tipo di asset digitale). Ripetere questa operazione per tutti i tipi di contenuto richiesti.

Creeremo quattro tipi di contenuto, ciascuno con il proprio set di campi:

• OCEGettingStartedHomePage
• OCEGettingStartedTopic
• OCEGettingStartedAuthor
• OCEGettingStartedArticle

Il primo tipo di contenuto, OCEGettingStartedHomePage, deve contenere i campi riportati di seguito.

Nome visualizzato	Tipo di campo	Obbligatorio.	Nome computer
Nome società	Campo di testo a singolo valore	X	company_name
Logo società	Campo di testo a singolo valore	X	company_logo
Argomenti	Campo di riferimento a più valori	X	argomenti
URL contatto	Campo di testo a singolo valore	X	contact_url
Informazioni su URL	Campo di testo a singolo valore	X	about_url

Di seguito è riportato l'aspetto della definizione del tipo di contenuto OCEGettingStartedHomePage.

Il secondo tipo di contenuto, OCEGettingStartedTopic, deve avere il seguente campo:

Nome visualizzato	Tipo di campo	Obbligatorio.	Nome computer
Anteprima	Campo immagine a singolo valore	X	anteprima

Di seguito è riportato l'aspetto del tipo di contenuto OCEGettingStartedTopic.

Il terzo tipo di contenuto, OCEGettingStartedAuthor, deve contenere i seguenti campi:

Nome visualizzato	Tipo di campo	Obbligatorio.	Nome computer
Avatar	Campo immagine a singolo valore	X	avatar

Di seguito è riportato l'aspetto del tipo di contenuto OCEGettingStartedAuthor.

Il quarto e ultimo tipo di contenuto, OCEGettingStartedArticle, devono avere i seguenti campi:

Nome visualizzato	Tipo di campo	Obbligatorio.	Nome computer
Data pubblicazione	Campo data a valore singolo	X	published_name
Autore	Campo di riferimento a un solo valore	X	creare
Immagine	Campo immagine a singolo valore	X	immagine
Didascalia immagine	Campo di testo a singolo valore	X	image_caption
Contenuto articolo	Campo di testo grande a singolo valore	X	article_content
Argomento	Campo di riferimento a un solo valore	X	argomento

Di seguito è riportato l'aspetto del tipo di contenuto OCEGettingStartedArticle.

Dopo aver creato i tipi di contenuto, è possibile aggiungere questi tipi di contenuto al repository creato in precedenza, OCEGettingStartedRepository:

1. Accedere all'interfaccia Web di Oracle Content Management come amministratore.
2. Passare a OCEGettingStartedRepository.
3. Modificare il repository e, in Tipi di asset, specificare tutti e quattro i tipi di contenuto appena creati. Fare clic sul pulsante Salva per salvare le modifiche.

Dopo aver aggiunto i tipi di contenuto al repository, è possibile aprire il repository OCEGettingStartedRepository nella pagina Asset e iniziare a creare gli elementi di contenuto per tutti i tipi di contenuto.

Passo 2: Creare l'applicazione di blog in Xcode

Per utilizzare i contenuti di Oracle Content Management in un'applicazione iOS, è possibile utilizzare l'esempio di blog di iOS, disponibile come repository open source su GitHub.

Nota: tenere presente che l'uso dell'esempio iOS è facoltativo e che viene utilizzato in questa esercitazione per iniziare rapidamente. Puoi anche creare la tua applicazione iOS.

Per costruire il blog in Swift:

1. Duplica il repository di esempio
2. Configurare l'applicazione iOS
3. Utilizzare Content SDK per recuperare il contenuto

Duplica repository di esempio

L'esempio di blog di iOS è disponibile come repository open source su GitHub.

Sarà innanzitutto necessario clonare l'esempio da GitHub al computer locale:

git clone https://github.com/oracle-samples/oce-ios-blog-sample.git

Dopo aver duplicato l'esempio, aprire il file di progetto Xcode, BlogDemo.xcodeproj.

Quando apri il progetto di esempio in Xcode, si estrarrà automaticamente la dipendenza per content-management-swift, il pacchetto Swift che implementa Oracle Content Delivery SDK.

Non esistono altre dipendenze di terze parti per questa applicazione, pertanto non sono necessarie altre installazioni manuali. Prima di eseguire l'applicazione, tuttavia, è necessaria una configurazione aggiuntiva.

Configurare l'applicazione iOS

In questo esempio di blog di iOS, è necessario configurare alcune informazioni in modo che Oracle Content Management Content SDK possa indirizzare l'URL dell'istanza corretto con il token canale corretto. Questi valori vengono utilizzati ogni volta che l'applicazione richiede dati dall'istanza di Oracle Content Management.

Aprire il file credentials.json e modificare entrambe le coppie chiave-valore per riflettere l'URL dell'istanza e il token del canale associato al canale di pubblicazione. Il canale di questa esercitazione è OCEGettingStartedChannel.

{
    "url": "https://samples.mycontentdemo.com",
    "channelToken": "47c9fb78774d4485bc7090bf7b955632"
}

Utilizzare Content SDK per recuperare il contenuto

Oracle Content Management offre un pacchetto Swift (content-management-swift) costituito dalle librerie OracleContentCore e OracleContentDelivery per consentire la ricerca e l'uso dei contenuti nelle applicazioni. Il pacchetto è ospitato su GitHub.

Ulteriori informazioni su Content SDK per Swift nella libreria della documentazione di Oracle Content Management:

• OracleContentDelivery
• OracleContentCore

È possibile utilizzare queste librerie di Content SDK per recuperare i contenuti in modo da renderli disponibili nella nostra applicazione iOS.

Inserimento dell'applicazione

Per richiedere i dati, è necessario fornire alcune informazioni necessarie alla libreria, denominata inserimento dell'applicazione. È possibile assegnare particolari informazioni in modo che la forma delle richieste sia corretta e puntare all'URL dell'istanza corretto.

In questa demo, quando l'applicazione viene avviata per la prima volta, Onboarding.urlProvider viene assegnato come istanza della propria classe, MyURLProvider. In questo modo vengono stabiliti l'URL dell'istanza e il token del canale utilizzati dalla libreria dei contenuti per ogni richiesta effettuata.

Quando si specifica un provider di URL non è strettamente necessario (poiché le informazioni su URL e token possono essere specificate per ogni richiesta), l'assegnazione riduce la quantità di codice necessario per ogni sito di chiamata.

@main
struct BlogDemo: App {
    init() {
        // ... 

        // The sample code expects the URL and channel token to be provided by ``OracleContentCore.Onboarding``
        // Assign your ``OracleContentCore.URLProvider`` implementation to the ``OracleContentCore.Onboarding.urlProvider`` property
        Onboarding.urlProvider = MyURLProvider()
        
        // ...
        
    }
}

L'implementazione MyURLProvider legge i dati da credentials.json per ottenere l'URL e il token del canale.

{
    "url": "https://samples.mycontentdemo.com",
    "channelToken": "47c9fb78774d4485bc7090bf7b955632"
}

Ogni volta che la libreria di contenuti Oracle deve creare una richiesta, recupera la proprietà seguente:

/// This function provides the URL to be used for each OracleContentCore request
///
/// Services which implement ``OracleContentCore.ImplementsOverrides`` may provide a different URL and
/// authorization headers (if required) on a call-by-call basis
public var url: () -> URL? = {
  return URL(string: MyURLProvider.credentials.url)
}

Ogni volta che la libreria deve creare una richiesta, recupererà anche il token di consegna:

/// This function provides the delivery channel token to be used for each OracleContentCore request
///
/// Services which implement ``OracleContentCore.ImplementsChannelToken`` may override this value
/// on a call-by-call basis
public var deliveryChannelToken: () -> String? = {
  
  return MyURLProvider.credentials.channelToken
}

Inoltre, l'assegnazione a Onboarding.logger offre l'opportunità di definire la propria implementazione di log. Per questa demo, l'implementazione di MyLogger consiste semplicemente nella "stampa" della console. Negli ambienti di produzione, il logger potrebbe utilizzare la registrazione universale, i dati core o qualsiasi tecnologia scelta.

@main
struct BlogDemo: App {
    init() {
        // ... 

         Onboarding.logger = MyLogger()
        
        // ...
        
    }
}

Richiesta di dati mediante la libreria di Oracle Content

Nota: il codice di richiesta per questa demo è disponibile in BlogNetworking.swift.

Ora possiamo sfruttare Content SDK per recuperare i contenuti in modo da renderli disponibili nell'applicazione iOS.

Il file BlogNetworking.swift contiene tutto il codice per ottenere i dati per l'applicazione. L'oggetto modello associato a ciascuna pagina includerà vari metodi per recuperare i dati di Oracle Content Management.

Dati della home page

La home page dell'applicazione è BlogDemoMain.swift, un file SwiftUI con un oggetto modello associato. L'oggetto modello è responsabile della gestione dello stato della pagina e dell'emissione delle chiamate di funzione necessarie per avviare il processo di recupero dati. Alla ricezione dei dati, lo stato della pagina cambia e SwiftUI aggiornerà l'interfaccia utente di conseguenza.

Inizialmente, la pagina principale richiede due diversi dati:

1. In primo luogo, viene eseguita una query per l'elemento di contenuto che rappresenta la home page del blog.
2. Quindi scaricare il logo a cui fa riferimento l'elemento di contenuto.

Aprire BlogNetworking.swift e trovare la funzione fetchHomePage(), che esegue la richiesta iniziale.

/// Retrieve the content item which represents the home page of the blog
/// - returns: Asset
public func fetchHomePage() async throws -> Asset {
    let typeNode = QueryNode.equal(field: "type", value: "OCEGettingStartedHomePage")
    let nameNode = QueryNode.equal(field: "name", value: "HomePage")
    let q = QueryBuilder(node: typeNode).and(nameNode)
    
    let result = try await DeliveryAPI
        .listAssets()
        .query(q)
        .fields(.all)
        .limit(1)
        .fetchNextAsync()
        .items
        .first
       
    guard let foundResult = result else {
        throw BlogNetworkingError.homePageNotFound
    }
    
    return foundResult
}

Questa funzione utilizza la concorrenza Swift per richiedere i dati. Tenere presente che lo spazio di nomi di tutti gli oggetti o servizi di richiesta è DeliveryAPI. In questo esempio, l'oggetto richiesta è listAssets().

Seguire l'oggetto richiesta sono una serie di componenti del costruttore che ci consentono di ottimizzare la richiesta. Qui sono stati specificati alcuni dettagli della query, è stato richiesto di recuperare tutti i campi e i dati di risposta sono stati limitati a un solo oggetto.

La richiesta a Oracle Content Management viene sottomessa mediante il verbo di richiamo fetchNextAsync().

Nota: poiché l'oggetto di richiesta inizia con "list", il verbo di richiamo inizierà con "fetchNext".

Le richieste di tipo "Elenco" restituiscono dati che indicano il numero di record restituiti, se esistono più dati e una raccolta di risultati (nella proprietà "items").

La nostra funzione recupera il primo valore dalla proprietà "items" e lo restituisce. Questo è l'asset che rappresenta il nostro blog e contiene l'ID del logo, il nome dell'azienda, gli URL delle informazioni e dei contatti e un elenco di argomenti.

Con l'ID del logo disponibile, possiamo emettere la nostra seconda richiesta per scaricare il logo:

/// Download the logo for display on the home page
/// - parameter logoId: The identifier of the logo to download
/// - returns: BlogImageState 
public func fetchLogo(logoId: String?) async throws -> BlogImageState {
    
    do {
        guard let logoID = logoId else { 
          throw BlogNetworkingError.missingLogoId 
        }
        
        let result = try await DeliveryAPI
            .downloadNative(identifier: logoID)
            .downloadAsync(progress: nil)
        
        guard let image = UIImage(contentsOfFile: result.result.path) else {
            throw OracleContentError.couldNotCreateImageFromURL(URL(string: result.result.path))
        }
        
        return .image(image)
        
    } catch {
        return .error(error)
    }

}

La nostra richiesta e invocazione sono molto più semplici in questa funzione. L'oggetto richiesta viene creato utilizzando downloadNative(identifier: logoID) e sottomesso utilizzando il verbo di richiamo downloadAsync.

Quando l'oggetto è stato scaricato, i dati vengono convertiti in UIImage e restituiti come enumerazione BlogImageState con l'immagine stessa come valore associato.

Nota: questo esempio utilizza l'enumerazione BlogImageState perché consente di rappresentare i vari stati dell'immagine senza dover utilizzare valori facoltativi. Ciò rende l'utilizzo in SwiftUI molto facile.

Dati argomento

Quando il nostro modello ha richiesto i dati della home page, ha eseguito una chiamata simile alla seguente:

self.home = try await self.networking.fetchHomePage()   

Dopo il recupero della home page, è necessario trovare la raccolta dei valori degli asset che rappresentano gli argomenti nel nostro blog. Per fare questo, chiediamo il campo denominato "topics" il cui tipo è una serie di asset.

self.topics = try self.home.customField("topics") as [Asset]

BlogDemoMain.swift esegue l'iterazione su questa raccolta di argomenti e rappresenta ognuno come elemento in una vista griglia. La rappresentazione dell'interfaccia utente viene definita in Topic.swift e l'oggetto modello associato, TopicModel.swift.

Per visualizzare le informazioni su un singolo argomento, è necessario eseguire due task:

1. Dobbiamo recuperare le informazioni dettagliate su ogni argomento.
2. È necessario scaricare l'immagine a cui fa riferimento ciascun argomento.

In TopicModel.swift, ci rivolgiamo al codice di rete per ottenere l'intero asset:

let fullAsset = try await self.networking.readAsset(assetId: self.topic.identifier)

Ottenere informazioni dettagliate sull'argomento è un processo semplice. Crea una richiesta di lettura utilizzando l'identificativo specificato, quindi recupera i dati.

/// Obtain detailed information about an Asset
/// - parameter assetId: The identifier of the asset to read
/// - returns: Asset
public func readAsset(assetId: String) async throws -> Asset {
    let result = try await DeliveryAPI
        .readAsset(assetId: assetId)
        .fetchAsync()
    
    return result
}

Nota: tutte le richieste di lettura restituiscono un singolo oggetto e vengono sottomesse mediante un verbo di richiamo che inizia con "fetch".

Una volta recuperate le informazioni dettagliate sul nostro argomento, è necessario estrarre i dati che definiscono la miniatura e quindi scaricarla.

In TopicModel.swift, otteniamo le informazioni di anteprima chiedendo il campo personalizzato denominato "thumbnail". Poiché i campi personalizzati possono essere di molti tipi diversi, è necessario specificare in modo esplicito che questo campo è un tipo di asset. Una volta trovato con successo l'asset, possiamo afferrarne l'identificativo.

imageIdentifier = (try fullAsset.customField("thumbnail") as Asset).identifier

Con l'identificativo disponibile, TopicModel.swift può ora chiedere al codice di rete di recuperare la condizione media dell'immagine di anteprima ridotta.

let imageState = await self.networking.downloadMediumRendition(identifier: imageIdentifier)
return imageState

Il codice di rete per ottenere l'immagine crea un oggetto di richiesta "downloadRendition" per recuperare una rendition denominata 'Medium' in formato jpg. Il verbo di richiamo utilizzato per sottomettere la richiesta è "downloadAsync".

Quando l'oggetto è stato scaricato, i dati vengono convertiti in UIImage e restituiti come enumerazione BlogImageState con l'immagine stessa come valore associato.

/// Downloads the "Medium" rendition of an asset and returns the value as a `BlogImageState`
/// Note that any error while downloading the image will result in a placeholder image
public func downloadMediumRendition(identifier: String) async -> BlogImageState {
    
    do {
        let result = try await DeliveryAPI
                                .downloadRendition(identifier: identifier,
                                                   renditionName: "Medium",
                                                   format: "jpg")
                                .downloadAsync(progress: nil)
        
        guard let uiImage = UIImage(contentsOfFile: result.result.path()) else {
            throw OracleContentError.couldNotCreateImageFromURL(result.result)
        }
        
        return .image(uiImage)
        
    } catch {
        return .image(UIImage(systemName: "questionmark.circle")!)
    }

}

Ora che sono disponibili le informazioni dettagliate sull'argomento e l'immagine di anteprima ridotta, SwiftUI può creare la rappresentazione visiva di un argomento.

Dati elenco articoli

Se si passa a un argomento, l'utente accede a una nuova pagina contenente un elenco di articoli assegnati all'argomento selezionato.

La creazione delle pagine degli articoli è molto simile al processo utilizzato per creare la lista degli argomenti. Dato un identificativo di argomento, è necessario:

1. Recupera la lista degli articoli per l'argomento e
2. Per ogni articolo, recupera la rendition di anteprima dell'asset contenuto nel relativo campo "immagine".

Quando si recupera l'elenco degli asset, l'oggetto di richiesta è .listAssets().

In assenza di altri componenti del builder, tutti gli asset pubblicati verranno recuperati dal canale di pubblicazione specificato in credentials.json. Ciò che tuttavia vogliamo è recuperare solo gli asset il cui tipo è OCEGettingStartedArticle e la cui proprietà dell'argomento corrisponde all'identificativo dell'argomento passato.

/// Obtain the collection of articles for a given topic. Limited to a maximum of 50 articles for demo purposes.
/// - parameter topic: Asset
/// - returns: [Asset] representing the articles for the specified topic
public func fetchArticles(for topic: Asset) async throws -> [Asset] {

    let typeNode = QueryNode.equal(field: "type", value: "OCEGettingStartedArticle")
    let fieldsTopicNode = QueryNode.equal(field: "fields.topic", value: topic.identifier)
    let fullQuery = QueryBuilder(node: typeNode).and(fieldsTopicNode)
    
    let result = try await DeliveryAPI
        .listAssets()
        .query(fullQuery)
        .order(.field("fields.published_date", .desc))
        .limit(50)
        .fetchNextAsync()
    
    return result.items
}

Per ciascuno degli articoli recuperati, dobbiamo determinare quale immagine scaricare. Riceviamo l'identificativo dell'asset a cui viene fatto riferimento nel campo "immagine" e lo utilizziamo per inviare una richiesta di download della relativa anteprima.

let identifier = (try article.customField("image") as Asset).identifier
let image = await self.networking.downloadThumbnail(identifier: identifier, fileGroup: article.fileGroup)

Il codice di rete per richiedere il download è simile al seguente:

/// Downloads the thumbnail rendition of an asset and returns the values as a ``BlogImageState``
/// Note that any error while downloading the image will result in a placeholder image
/// - parameter identifier: The identifier of the asset
/// - parameter fileGroup: The file group of the asset - used to differentiate thumbnails for digital assets, videos and "advanced videos"
public func downloadThumbnail(identifier: String, fileGroup: String) async -> BlogImageState {
    do {
        let result = try await DeliveryAPI
            .downloadThumbnail(identifier: identifier, fileGroup: fileGroup)
            .downloadAsync(progress: nil)
        
        guard let uiImage = UIImage(contentsOfFile: result.result.path()) else {
           throw OracleContentError.couldNotCreateImageFromURL(result.result)
        }
        
        return .image(uiImage)
    } catch {
        Onboarding.logError(error.localizedDescription)
        return .image(UIImage(systemName: "questionmark.circle")!)
    }
}

Ora possiamo visualizzare un'anteprima di ogni articolo:

Dati articolo

Se si seleziona l'anteprima di un articolo, viene visualizzata la pagina finale dell'applicazione di esempio, ovvero l'articolo stesso. Come in precedenza, è necessario eseguire diverse richieste di dati:

1. Dato l'identificativo dell'articolo selezionato, dobbiamo recuperare le sue informazioni dettagliate.
2. Scarica l'avatar dell'autore.
3. Scaricare l'immagine dell'articolo da visualizzare.

@MainActor
func fetchArticle() async throws {

    self.article = try await self.networking.readArticle(assetId: article.identifier)
    
    let author: Asset = try self.article.customField("author")
    let authorAvatar: Asset = try author.customField("avatar")

    Task {
        self.avatar = await self.networking.downloadNative(identifier: authorAvatar.identifier)
    }
    
    Task {
        let hero: Asset = try self.article.customField("image_16x9")
        self.heroImage = await self.networking.downloadNative(identifier: hero.identifier)
    }
}

La lettura delle informazioni dettagliate per un asset è un processo semplice:

/// Obtain detailed information about an Asset
/// - parameter assetId: The identifier of the asset to read
/// - returns: Asset
public func readAsset(assetId: String) async throws -> Asset {
    let result = try await DeliveryAPI
        .readAsset(assetId: assetId)
        .fetchAsync()
    
    return result
}

Scaricare l'avatar e le immagini degli articoli seguendo entrambi lo stesso pattern generale utilizzato per ottenere altre immagini:

/// Downloads the native rendition of an asset and returns the values as a ``BlogImageState``
/// Note that any error while downloading the image will result in a placeholder image
public func downloadNative(identifier: String) async -> BlogImageState {
    do {
        let result = try await DeliveryAPI
            .downloadNative(identifier: identifier)
            .downloadAsync(progress: nil)
        
        guard let uiImage = UIImage(contentsOfFile: result.result.path()) else {
           throw OracleContentError.couldNotCreateImageFromURL(result.result)
        }
        
        return .image(uiImage)
    } catch {
        Onboarding.logError(error.localizedDescription)
        return .image(UIImage(systemName: "questionmark.circle")!)
    }
    
}

Il risultato è un articolo di blog completamente formattato:

Passo 3: eseguire l'applicazione

Con l'applicazione completata, è possibile eseguirla nel simulatore o distribuirla in qualsiasi iPhone o iPad su cui è in esecuzione iOS o iPadOS 16.0 o versione successiva.

Conclusione

In questa esercitazione è stato creato un sito di applicazioni di blog per iOS, disponibile all'indirizzo GitHub. Questa applicazione utilizza Oracle Content Management come CMS headless. Dopo aver impostato e configurato Oracle Content Management con un canale di contenuto pubblicato per l'esercitazione sul blog, l'applicazione è stata eseguita per recuperare il contenuto richiesto.

Per ulteriori informazioni su Swift, visitare il sito Web di Swift.

Scopri i concetti importanti di Oracle Content Management nella documentazione.

Nella pagina Esempi di Oracle Content Management di Oracle Help Center è possibile trovare altri esempi come questo.

---

Titolo e informazioni sul copyright

Crea un'applicazione di blog in Swift per iOS con Oracle Content Management headless

F82145-01

Maggio 2023

Copyright © 2021, 2023, Oracle and/or its affiliates.

Autore principale: Oracle Corporation