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

# Connettori condivisi

> Collega un unico account di servizio condiviso da tutti gli utenti dell'app

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Stai visualizzando la documentazione per sviluppatori
    </div>

    <div className="dev-docs-banner-text">
      Questa documentazione è rivolta agli sviluppatori che lavorano con la piattaforma
      per sviluppatori Base44. Per informazioni sui connettori nell'editor dell'app, consulta{" "}
      <a href="/Integrations/Connectors">Uso dei connettori</a>.
    </div>
  </div>
</div>

Un connettore condiviso collega un unico account per l'intera app. Tutti gli utenti dell'app condividono lo stesso token OAuth. Usalo per account di servizio, come pubblicare in un canale Slack aziendale, leggere da un Google Calendar condiviso o interrogare uno spazio di lavoro Notion condiviso.

**Per configurare un connettore condiviso:**

1. [**Configura**](#configure) un file JSONC per ciascun servizio necessario
2. [**Distribuisci e autorizza**](#deploy-and-authorize) tramite la CLI
3. [**Usa nelle funzioni backend**](#use-in-backend-functions) chiamando [`getConnection()`](/developers/references/sdk/docs/interfaces/connectors#getconnection) per i connettori OAuth, oppure usando direttamente l'[API REST di Stripe](#stripe) per i pagamenti

## Configura

Ogni connettore è un file JSONC nella directory dei connettori del progetto. Il file definisce il tipo di integrazione e gli scope necessari alla tua app. Per impostazione predefinita la directory è `base44/connectors/`, ma puoi personalizzare il percorso nella [configurazione del progetto](/developers/backend/overview/project-structure#config-jsonc).

<Tree>
  <Tree.Folder name="connectors" defaultOpen>
    <Tree.File name="googlecalendar.jsonc" />

    <Tree.File name="slack.jsonc" />

    <Tree.File name="slackbot.jsonc" />

    <Tree.File name="notion.jsonc" />
  </Tree.Folder>
</Tree>

### Esempio

Questo esempio configura un connettore Google Calendar con scope di lettura e gestione degli eventi:

```jsonc theme={null}
{
  "type": "googlecalendar",
  "scopes": [
    "https://www.googleapis.com/auth/calendar.readonly",
    "https://www.googleapis.com/auth/calendar.events",
  ],
}
```

### Riferimento dei campi

<ResponseField name="type" type="string" required>
  L'identificatore del tipo di integrazione. Consulta la tabella dei [servizi supportati](/developers/backend/resources/connectors#supported-services) per l'elenco completo dei valori accettati.

  Ogni tipo di connettore può essere definito una sola volta nel progetto.
</ResponseField>

<ResponseField name="scopes" type="array" required>
  Array di scope OAuth richiesti dall'integrazione. Gli scope specifici
  dipendono dal servizio esterno e dalle operazioni che la tua app deve eseguire.
  Consulta la documentazione [permessi e scope dei
  connettori](/Integrations/Connectors#connector-permissions) per gli scope
  disponibili per ciascun servizio.
</ResponseField>

## Distribuisci e autorizza

Distribuisci i connettori con [`connectors push`](/developers/references/cli/commands/connectors-push) o [`deploy`](/developers/references/cli/commands/deploy). Per scaricare i connettori esistenti da Base44, usa [`connectors pull`](/developers/references/cli/commands/connectors-pull).

Quando esegui il push, la CLI gestisce ciascun connettore in base al suo tipo:

* **Connettori OAuth:** la CLI ti chiede di autorizzare ciascun connettore uno alla volta. Suggerisce di aprire il browser automaticamente e, se accetti, itera in sequenza attraverso la pagina di autorizzazione di ogni integrazione. Dopo il completamento dell'autorizzazione, i token OAuth vengono memorizzati in modo sicuro e puoi recuperarli tramite l'SDK.
* **Stripe:** la CLI predispone una sandbox Stripe per la tua app e restituisce un URL di rivendicazione per completare l'onboarding. Non è necessario alcun flusso OAuth.

## Usa nelle funzioni backend

Una volta distribuito e autorizzato, usa il connettore nelle tue [funzioni backend](/developers/backend/resources/backend-functions/overview). L'approccio dipende dal modello di autenticazione del connettore:

<Tabs>
  <Tab title="Connettori OAuth">
    Chiama [`connectors.getConnection()`](/developers/references/sdk/docs/interfaces/connectors#getconnection) con il tipo del connettore per recuperare un `accessToken` da usare per chiamate API autenticate. Alcuni connettori restituiscono anche una `connectionConfig` con parametri aggiuntivi (ad esempio un sottodominio o un ID account).

    Questo esempio recupera una connessione Google Calendar e ottiene i prossimi eventi:

    ```typescript theme={null}
    const { accessToken } =
      await base44.asServiceRole.connectors.getConnection("googlecalendar");

    const timeMin = new Date().toISOString();
    const url = `https://www.googleapis.com/calendar/v3/calendars/primary/events?maxResults=10&orderBy=startTime&singleEvents=true&timeMin=${timeMin}`;

    const response = await fetch(url, {
      headers: { Authorization: `Bearer ${accessToken}` },
    });

    const events = await response.json();
    ```
  </Tab>

  <Tab title="Stripe">
    Stripe non usa `getConnection()`. La piattaforma memorizza invece le chiavi API di Stripe come app secrets quando esegui il provisioning del connettore. Nelle tue funzioni backend, leggi `STRIPE_SECRET_KEY` dall'ambiente e chiama direttamente l'[API REST di Stripe](https://docs.stripe.com/api).

    Questo esempio crea una sessione Stripe Checkout e restituisce l'URL di pagamento:

    ```typescript theme={null}
    const STRIPE_SECRET_KEY = Deno.env.get("STRIPE_SECRET_KEY");

    Deno.serve(async (req) => {
      const { priceId, successUrl, cancelUrl } = await req.json();

      const response = await fetch("https://api.stripe.com/v1/checkout/sessions", {
        method: "POST",
        headers: {
          Authorization: `Bearer ${STRIPE_SECRET_KEY}`,
          "Content-Type": "application/x-www-form-urlencoded",
        },
        body: new URLSearchParams({
          "payment_method_types[]": "card",
          "line_items[0][price]": priceId,
          "line_items[0][quantity]": "1",
          mode: "payment",
          success_url: successUrl || `${req.headers.get("origin")}?success=true`,
          cancel_url: cancelUrl || `${req.headers.get("origin")}?canceled=true`,
        }),
      });

      const session = await response.json();
      return Response.json({ url: session.url });
    });
    ```
  </Tab>
</Tabs>

## Automazioni dei connettori

Le automazioni dei connettori consentono alle funzioni backend di rispondere in tempo reale agli eventi dei servizi collegati. Ad esempio, puoi eseguire una funzione quando arriva una nuova email in Gmail o quando cambia un file in Google Drive.

Configura le automazioni dei connettori nel file `function.jsonc` insieme alle altre automazioni. Consulta [Automazioni dei connettori](/developers/backend/resources/backend-functions/automations#connector-automations) per il riferimento completo dei campi, gli eventi supportati e la documentazione dei payload.

## Vedi anche

* [Panoramica dei connettori](/developers/backend/resources/connectors)
* [Connettori per utente dell'app](/developers/backend/resources/connectors/app-user-connectors)
* [Riferimento SDK dei connettori](/developers/references/sdk/docs/interfaces/connectors#getconnection)
* [connectors push](/developers/references/cli/commands/connectors-push)
* [connectors pull](/developers/references/cli/commands/connectors-pull)
* [deploy](/developers/references/cli/commands/deploy)
* [Funzioni backend](/developers/backend/resources/backend-functions/overview)
* [Automazioni](/developers/backend/resources/backend-functions/automations)

<Note>Questa pagina è stata tradotta utilizzando l'IA. Per informazioni più accurate e aggiornate, consulta la [versione inglese](/). </Note>