> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aftersell.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Azioni

> Tutte le azioni dell'SDK di Aftersell Cart per leggere e modificare il carrello: aprire, chiudere, aggiungere, rimuovere, aggiornare la quantità, cambiare variante, leggere lo stato e formattare gli importi.

Le azioni **leggono e modificano il carrello**. Vivono sotto `window.aftersell.cart.actions`.

<Note>
  Le azioni vanno eseguite **dopo che il carrello è pronto**, dentro `ready()` o un handler di [evento](/it/aftersell/cart/sdk-events).
</Note>

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.aftersell.cart.ready().then(() => {
  const state = window.aftersell.cart.actions.getCart();
  console.log(state.itemCount, 'items');
});
```

<Note>
  **Prima che il carrello si carichi, le azioni sono stub.** Ognuna registra un avviso in console che nomina l'azione, per esempio `cart.actions.addItem() called before the cart loaded`, e non fa nulla. Le azioni async risolvono comunque una Promise, quindi una catena `.then()` viene eseguita normalmente invece di generare un errore; `getCart()` restituisce `null` e `formatMoney()` restituisce una stringa vuota.

  Non si rompe nulla se ne chiami una troppo presto, ma non succede nemmeno nulla. Controlla la console per quell'avviso quando un'azione sembra non fare nulla.
</Note>

<div id="every-action">
  ## Tutte le azioni
</div>

| Azione                                                   | Firma                                | Restituisce             | Cosa fa                                     |
| -------------------------------------------------------- | ------------------------------------ | ----------------------- | ------------------------------------------- |
| [`open`](#open-and-close)                                | `open()`                             | Nulla                   | Apre il drawer.                             |
| [`close`](#open-and-close)                               | `close()`                            | Nulla                   | Chiude il drawer.                           |
| [`getCart`](#getcart)                                    | `getCart()`                          | `AftersellCart \| null` | Legge il carrello corrente.                 |
| [`formatMoney`](#formatmoneycents)                       | `formatMoney(cents)`                 | `string`                | Formatta un importo per la visualizzazione. |
| [`addItem`](#additemvariantid-quantity)                  | `addItem(variantId, quantity?)`      | `Promise`               | Aggiunge una variante.                      |
| [`removeItem`](#removeitemkey)                           | `removeItem(key)`                    | `Promise`               | Rimuove una riga.                           |
| [`updateItemQuantity`](#updateitemquantitykey-quantity)  | `updateItemQuantity(key, quantity)`  | `Promise`               | Imposta la quantità di una riga.            |
| [`replaceLineVariant`](#replacelinevariantkey-variantid) | `replaceLineVariant(key, variantId)` | `Promise`               | Sostituisce la variante di una riga.        |
| [`refresh`](#refresh)                                    | `refresh()`                          | `Promise`               | Ricarica il carrello da Shopify.            |
| [`visualRefresh`](#visualrefresh)                        | `visualRefresh()`                    | Nulla                   | Ridisegna senza ricaricare.                 |

<Warning>
  Chiamare un'azione da un handler `cart_updated` può creare un loop. Leggi prima [le due regole](/it/aftersell/cart/sdk-events#the-two-rules).
</Warning>

***

<div id="drawer">
  ## Drawer
</div>

<div id="open-and-close">
  ### open e close
</div>

Aprono o chiudono il drawer del carrello. Entrambe sono sincrone e non richiedono argomenti.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// Open the drawer from your own cart link.
document.querySelector('#my-cart-link').addEventListener('click', (event) => {
  event.preventDefault();
  window.aftersell.cart.actions.open();
});
```

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// Close it after the shopper does something in a custom block.
window.aftersell.cart.actions.close();
```

***

<div id="reading">
  ## Lettura
</div>

<div id="getcart">
  ### getCart()
</div>

Restituisce l'[oggetto cart](/it/aftersell/cart/sdk-cart-object) corrente, oppure `null` prima che sia stato caricato. Il risultato è una **copia**, quindi modificarlo non cambia il carrello reale.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.aftersell.cart.ready().then(() => {
  const state = window.aftersell.cart.actions.getCart();
  if (!state) return; // the initial load failed

  console.log(state.itemCount, 'items,', state.items.length, 'lines');
  console.log('Total:', window.aftersell.cart.actions.formatMoney(state.totalPrice));
});
```

Poiché è uno snapshot, non conservare il risultato; rileggilo ogni volta che ti servono dati aggiornati. In un handler di evento hai già il carrello aggiornato come payload, quindi lì `getCart()` è ridondante.

<div id="formatmoneycents">
  ### formatMoney(cents)
</div>

Formatta un importo in unità minori usando il formato monetario del tuo store. Ogni prezzo nell'SDK è in centesimi, quindi è così che ne trasformi uno in qualcosa da mostrare.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.aftersell.cart.actions.formatMoney(5779);  // "$57.79"
window.aftersell.cart.actions.formatMoney(0);     // "$0.00"
```

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// Show the cart total in your own header element.
window.aftersell.cart.events.on('cart_updated', (state) => {
  document.querySelector('#header-total').textContent =
    window.aftersell.cart.actions.formatMoney(state.totalPrice);
});
```

Sovrascrivi il formato con [`configure({ money_format })`](/it/aftersell/cart/sdk-configure#money_format).

***

<div id="changing-the-cart">
  ## Modificare il carrello
</div>

<Note>
  Le azioni sugli articoli identificano una riga tramite la sua **`key`** di Shopify, non tramite l'ID della variante, perché un carrello può contenere la stessa variante su più righe con proprietà diverse. Leggila da `getCart().items[n].key`.
</Note>

<div id="additemvariantid-quantity">
  ### addItem(variantId, quantity?)
</div>

Aggiunge una variante al carrello. `quantity` è `1` per impostazione predefinita. Si risolve una volta che il carrello si è assestato.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// Add one, then show the shopper.
window.aftersell.cart.actions.addItem(41720671830082).then(() => {
  window.aftersell.cart.actions.open();
});
```

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// Add a specific quantity.
window.aftersell.cart.actions.addItem(41720671830082, 3);
```

Aggiungere una variante già presente nel carrello aumenta la quantità di quella riga invece di creare una seconda riga, purché la riga esistente non abbia line item properties. Una riga con proprietà è una riga distinta, quindi ne ottieni una nuova.

<div id="removeitemkey">
  ### removeItem(key)
</div>

Rimuove completamente una riga.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// Remove any free line from the cart.
const gift = window.aftersell.cart.actions
  .getCart()
  .items.find((line) => line.finalLinePrice === 0);
if (gift) window.aftersell.cart.actions.removeItem(gift.key);
```

<div id="updateitemquantitykey-quantity">
  ### updateItemQuantity(key, quantity)
</div>

Imposta la quantità di una riga. Passare `0` rimuove la riga.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
const line = window.aftersell.cart.actions.getCart().items[0];
if (line) window.aftersell.cart.actions.updateItemQuantity(line.key, 3);
```

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// Cap a line at one unit.
window.aftersell.cart.events.on('cart_updated', (state) => {
  state.items.forEach((line) => {
    if (line.variantId === LIMITED_VARIANT_ID && line.quantity > 1) {
      window.aftersell.cart.actions.updateItemQuantity(line.key, 1);
    }
  });
});
```

Quel secondo esempio è sicuro da eseguire da `cart_updated` perché il controllo `> 1` è falso al secondo passaggio. Vedi [le due regole](/it/aftersell/cart/sdk-events#the-two-rules).

<div id="replacelinevariantkey-variantid">
  ### replaceLineVariant(key, variantId)
</div>

Sostituisce la variante di una riga mantenendone la quantità e le proprietà. Utile per un selettore di taglia o gusto dentro il carrello.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
const line = window.aftersell.cart.actions.getCart().items[0];
window.aftersell.cart.actions.replaceLineVariant(line.key, 41720671862850);
```

<Warning>
  Il **selling plan della riga si reimposta** durante uno scambio. Una riga di abbonamento diventa un acquisto singolo a meno che tu non riapplichi un piano.
</Warning>

Lo scambio è un'aggiunta seguita da una rimozione, non una modifica in loco, quindi il risultato è una **nuova riga**: ottiene una nuova `key` e finisce alla fine del carrello. Rileggi `getCart()` dopo, invece di riutilizzare la key che hai passato.

***

<div id="refreshing">
  ## Aggiornamento
</div>

<div id="refresh">
  ### refresh()
</div>

Ricarica il carrello da Shopify. Usalo dopo che qualcosa al di fuori dell'SDK ha modificato il carrello e il drawer non se ne è accorto.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// After a raw Ajax API call of your own.
fetch('/cart/add.js', { method: 'POST', /* … */ })
  .then(() => window.aftersell.cart.actions.refresh())
  .then(() => { window.aftersell.cart.actions.open(); });
```

Nella maggior parte dei casi non ti serve, dato che Aftersell è già in ascolto degli eventi standard del carrello di Shopify e ricarica da solo. Ricorri a questa azione quando un'integrazione personalizzata li bypassa.

<div id="visualrefresh">
  ### visualRefresh()
</div>

Riesegue le trasformazioni di rendering senza ricaricare il carrello da Shopify. Ti serve raramente: registrare (o annullare la registrazione di) una [line transform](/it/aftersell/cart/sdk-hooks#registerlinetransform), un [comparator](/it/aftersell/cart/sdk-hooks#registerlinecomparator), un [enricher](/it/aftersell/cart/sdk-hooks#registercartenricher) o uno dei due [hook di abbonamento](/it/aftersell/cart/sdk-hooks#registersubscriptionoptionstransform) ne attiva uno per te. Solo i due hook di add-to-cart non lo fanno, dato che non cambiano nulla di quanto già a schermo.

Ricorri a questa azione quando qualcosa da cui una trasformazione *dipende* cambia ma il carrello in sé no:

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// A currency switcher changed the format: repaint prices already on screen.
window.myTheme.onCurrencyChange((currency) => {
  window.aftersell.cart.configure({ money_format: FORMATS[currency] });
  window.aftersell.cart.actions.visualRefresh();
});
```

***

<div id="notes-and-edge-cases">
  ## Note e casi limite
</div>

* **Le azioni async si risolvono quando la modifica si è assestata.** Attenderne una ti permette di sequenziare il lavoro dopo che il carrello si è effettivamente aggiornato.
* **`getCart()` restituisce una copia.** Modificarla non ha alcun effetto sul carrello reale.
* **Non c'è un'azione per i codici sconto.** I codici applicati sono leggibili sul carrello (`discountCodes`, `totalDiscount`) e per riga (`discountAllocations`); gli acquirenti li applicano tramite il blocco [Discount code](/it/aftersell/cart/discount-code-block).
* **Non c'è un'azione per gli attributi del carrello o le note.** Gli attributi sono leggibili sull'oggetto cart; gli acquirenti scrivono le note tramite il blocco [Notes](/it/aftersell/cart/notes-block).
* **Per nascondere una riga invece di rimuoverla**, usa [`registerLineTransform`](/it/aftersell/cart/sdk-hooks#registerlinetransform). Rimuovere cambia il totale dell'acquirente; nascondere no.

<div id="where-to-go-next">
  ## Dove andare adesso
</div>

* **[Oggetto cart](/it/aftersell/cart/sdk-cart-object)**: cosa restituisce `getCart()`.
* **[Eventi](/it/aftersell/cart/sdk-events)**: quando eseguire queste azioni.
* **[Hook](/it/aftersell/cart/sdk-hooks)**: cambia come una riga viene renderizzata invece di cambiare il carrello.
* **[Casi d'uso](/it/aftersell/cart/sdk-use-cases)**: soluzioni complete alle richieste più comuni.