> ## 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.

# Schema utente

> Estendi l'entità User integrata con campi aggiuntivi per la tua 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 è per sviluppatori che lavorano con la piattaforma per sviluppatori di Base44. Per informazioni sulla gestione dei dati della tua app usando l'editor, consulta <a href="/Building-your-app/Managing-your-app-data">Gestire i dati dell'app</a>.
    </div>
  </div>
</div>

L'entità User esiste in ogni progetto Base44 per impostazione predefinita e memorizza informazioni sugli utenti della tua app. Puoi aggiungere campi per memorizzare dati utente aggiuntivi, poi usare quei campi nelle [regole di sicurezza](/developers/backend/resources/entities/security) per controllare l'accesso ai dati o nella tua app per personalizzare l'esperienza.

## Campi integrati

Ogni entità User include un insieme di campi integrati per impostazione predefinita.

| Campo       | Tipo   | Descrizione                   |
| ----------- | ------ | ----------------------------- |
| `full_name` | string | Nome visualizzato dell'utente |
| `email`     | string | Indirizzo email dell'utente   |
| `role`      | string | `admin` oppure `user`         |

L'entità User ha anche i [campi integrati generali](/developers/backend/resources/entities/entity-schemas#built-in-fields) che esistono su tutte le entità, come `id` e `created_date`.

Questi campi sono gestiti dal sistema e non possono essere ridefiniti nel tuo schema.

## Campi personalizzati

Per aggiungere campi personalizzati, definisci uno schema User contenente solo i tuoi campi aggiuntivi. Tentare di ridefinire i campi integrati causerà un errore di validazione.

Crea un file `User.json` o `User.jsonc` nella directory delle entità del tuo progetto. Per impostazione predefinita è `base44/entities/`, ma puoi personalizzare il percorso nella [configurazione del progetto](/developers/backend/overview/project-structure#configjsonc).

```json entities/User.json theme={null}
{
  "type": "object",
  "properties": {
    "company": { "type": "string" },
    "phone": { "type": "string" },
    "job_title": { "type": "string" },
    "bio": { 
      "type": "string",
      "maxLength": 500
    }
  },
  "required": ["company"]
}
```

Poi invia le tue entità a Base44 usando [`entities push`](/developers/references/cli/commands/entities-push) o [`deploy`](/developers/references/cli/commands/deploy).

## Esempio completo

Ecco uno schema User completo con vari tipi di campo:

```json theme={null}
{
  "type": "object",
  "properties": {
    "company": {
      "type": "string"
    },
    "phone": {
      "type": "string"
    },
    "job_title": {
      "type": "string",
      "maxLength": 100
    },
    "bio": {
      "type": "string",
      "maxLength": 500
    },
    "website": {
      "type": "string",
      "format": "uri"
    },
    "preferences": {
      "type": "object",
      "properties": {
        "theme": {
          "type": "string",
          "enum": ["light", "dark"],
          "default": "light"
        },
        "notifications": {
          "type": "boolean",
          "default": true
        }
      }
    }
  },
  "required": ["company"]
}
```

## Usare i tuoi campi

Una volta definito e inviato il tuo schema User, puoi referenziare i tuoi campi nelle regole di sicurezza e accedervi nel codice della tua app.

### Nelle regole di sicurezza

Puoi usare i campi utente per controllare l'accesso ad altre entità. Ad esempio, potresti limitare gli utenti a vedere solo i record che appartengono alla loro azienda.

Per referenziare i campi utente nelle [regole di sicurezza](/developers/backend/resources/entities/security), usa la sintassi template `{{user.data.*}}`:

```json theme={null}
{
  "rls": {
    "read": {"data.company": "{{user.data.company}}"},
    "update": {"data.company": "{{user.data.company}}"}
  }
}
```

Questa regola garantisce che gli utenti possano leggere e aggiornare solo i record in cui il campo `company` del record corrisponde al proprio.

### Nel codice

Accedi ai campi utente tramite l'[SDK](/developers/references/sdk/getting-started/overview):

```typescript theme={null}
// Get current user's fields
const currentUser = await base44.auth.me();
console.log(currentUser.company); // "Acme Inc"

// Update current user's fields
await base44.auth.updateMe({
  phone: "+1-555-0123",
  job_title: "Senior Developer"
});

// List all users with service role (backend functions only)
const allUsers = await base44.asServiceRole.entities.User.list();
```

<Info>
  Questo esempio usa un client `base44`. Consulta [Configurare il client](/developers/references/sdk/getting-started/client) per le istruzioni di configurazione.
</Info>

## Vedi anche

* [Panoramica delle entità](/developers/backend/resources/entities/overview): scopri la configurazione dello schema del database
* [Schemi delle entità](/developers/backend/resources/entities/entity-schemas): definisci la struttura delle tue entità
* [Sicurezza](/developers/backend/resources/entities/security): configura regole di sicurezza a livello di riga
* [Struttura del progetto](/developers/backend/overview/project-structure): come gli schemi delle entità si inseriscono nel tuo progetto

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