Inserzione Immobiliare
Costruito con AI Agent
Modello GraphQL

Modello Backend per Elenco Immobili
GraphQL — Schema, Geo-Query & Guida AI

Un backend per elenco immobili GraphQL pronto per la produzione su Back4app: elenchi, contatti, preferiti, geo-query, diagramma ER, dizionario dei dati, schema JSON, playground API e un prompt AI Agent con un clic per il deploy in pochi minuti.

Costruito con AI Agent

Punti Chiave

In questa pagina ottieni uno schema immobiliare pronto per la produzione, un prompt AI con un clic e codice passo-passo GraphQL — così puoi lanciare un'app per la lista delle proprietà senza costruire il backend.

  1. Distribuisci in pochi minuti — Incolla il prompt dell'agente AI e ottieni un'app funzionante con lista di proprietà, ricerca geografica, acquisizione di lead e preferiti.
  2. Query geografiche pronte all'uso — Property.location (GeoPoint) supporta $nearSphere per "proprietà vicino a me" e ricerca basata su mappa.
  3. SDK GraphQL-nativo — Oggetti tipizzati, async/await, pinning offline opzionale e Live Queries per nuove inserzioni.
  4. REST + GraphQL — Entrambi gli API generati automaticamente; filtra per stato, letti, prezzo; ordina per distanza o data.
  5. Quattro classi — _User (integrato), Property, Lead (richieste), Favorite (inserzioni salvate).

Cos'è il template backend per la lista immobiliare GraphQL?

Back4app è un backend-as-a-service (BaaS) ideale per app di lista immobiliare: backend gestito, autenticazione, query geografiche e SDK per oltre 13 tecnologie. Il template backend per la lista immobiliare GraphQL è uno schema pre-costruito su Back4app con autenticazione (User), inserzioni (Property), richieste (Lead) e proprietà salvate (Favorite). Ottieni query geografiche, acquisizione di lead e un prompt AI Agent con un clic — collega un frontend GraphQL e lancia un'app per la lista delle proprietà funzionante in pochi minuti.

Migliore per:

App di listing immobiliarePortali immobiliariAcquisizione leadRicerca basata su mappaLanci MVPTeam che scelgono un BaaS per il settore immobiliare

Panoramica

Un'app di listing immobiliare ha bisogno di CRUD per le proprietà, geo-query per la ricerca su mappa, acquisizione lead (richieste per proprietà) e preferiti degli utenti. Sotto il cofano ha bisogno di autenticazione, Proprietà con posizione (GeoPoint), Lead collegato a Proprietà e Preferito che collega Utente a Proprietà.

Lo schema (vedi diagramma ER qui sotto) copre utenti, proprietà, lead e preferiti. Con l'SDK Back4app GraphQL, puoi interrogare le proprietà (incluso geo), creare lead e gestire i preferiti — senza scrivere uno strato API personalizzato.

Caratteristiche principali delle inserzioni immobiliari

Questo modello di backend include le seguenti funzionalità pronte all'uso.

Inserzioni immobiliari

Proprietà con titolo, prezzo, indirizzo, posizione (GeoPoint), letti, bagni, stato. Elenca e filtra per stato, prezzo o geo.

Cattura lead

Collegare i lead a nome, email, telefono, messaggio a una Proprietà. Cattura le richieste dalle pagine di dettaglio degli annunci.

Proprietà salvate

Collegamenti preferiti utente e proprietà. Elenca i preferiti per l'utente corrente; aggiungi o rimuovi dal dettaglio dell'annuncio.

Geo-query

Property.location (GeoPoint) supporta $nearSphere. Trova proprietà vicino a un punto; ordina per distanza.

Utente e permessi

_User integrato; limita la creazione/aggiornamento della Proprietà agli agenti; lettura pubblica per elenco e dettaglio.

Perché costruire il tuo backend di listing immobiliare con Back4app?

Back4app ti offre un backend pronto con geo-query e acquisizione lead così puoi costruire la tua app di listing immobiliare senza scrivere codice di collegamento REST o gestire l'autenticazione da solo.

  • •Geo-query e SDK: Property.location (GeoPoint) supporta $nearSphere; l'SDK mantiene Property e Lead di tipo sicuro.
  • •Cattura lead e preferiti: La classe Lead memorizza le richieste per proprietà; i link Preferiti collegano l'utente e la proprietà per le inserzioni salvate.
  • •Live Queries: Iscriviti alle modifiche di Property o Favorite in modo che l'interfaccia utente si aggiorni in tempo reale.

Stessa schema e API per ogni stack — cambia client in seguito senza modificare il backend.

Vantaggi principali

Un backend immobiliare pronto per la produzione così puoi spedire più velocemente e concentrarti sulla tua app.

Spedisci più velocemente, senza codice backend

API REST e GraphQL e uno schema pronto — collega la tua app e vai.

Geo-Query pronte all'uso

Trova proprietà vicino a un punto con $nearSphere; ordina per distanza.

Cattura Lead

La classe Lead memorizza nome, email, telefono, messaggio e puntatore alla proprietà.

Autenticazione integrata

Registrazione utente, accesso e gestione delle sessioni; limita i preferiti e la gestione degli annunci.

Funziona offline

Il pinning locale mantiene le proprietà e i preferiti disponibili offline e si sincronizza quando ti riconnetti.

Distribuisci in pochi minuti

Usa l'AI Agent per creare e distribuire la tua app immobiliare da questo template.

Pronto per provarlo?

Lascia che l'agente AI di Back4app crei il backend per il tuo annuncio immobiliare, colleghi il frontend GraphQL e distribuisca — tutto da un'unica richiesta.

Costruisci con l'agente AIProva il Playground API

Gratis per iniziare — 50 richieste dell'agente AI/mese, senza carta di credito richiesta

Stack Tecnico

Tutto ciò che alimenta questo modello di annuncio immobiliare a colpo d'occhio.

Frontend
GraphQL
Backend
Back4app
Database
MongoDB
Auth
Autenticazione e Controllo Accessi
API
REST & GraphQL
Distribuzione
Agente AI / Dashboard

Diagramma ER

Diagramma Entità-Relazione per il modello di dati delle inserzioni immobiliari GraphQL.

Visualizza sorgente del diagramma
Mermaid
erDiagram
    _User {
        String objectId PK
        String username
        String email
        String password
        Date createdAt
        Date updatedAt
    }

    Property {
        String objectId PK
        String title
        String description
        Number price
        String address
        GeoPoint location
        Number beds
        Number baths
        Number area
        String propertyType
        String status
        Pointer listedBy FK
        Date createdAt
        Date updatedAt
    }

    Lead {
        String objectId PK
        String name
        String email
        String phone
        String message
        Pointer property FK
        Date createdAt
        Date updatedAt
    }

    Favorite {
        String objectId PK
        Pointer user FK
        Pointer property FK
        Date createdAt
        Date updatedAt
    }

    _User ||--o{ Property : "listedBy"
    _User ||--o{ Favorite : "user"
    Property ||--o{ Lead : "property"
    Property ||--o{ Favorite : "property"

Flusso di integrazione

Sequenza Auth-to-CRUD: come la tua app GraphQL comunica con Back4app — accesso, query delle proprietà (con geo), crea lead, gestisci preferiti.

Visualizza sorgente del diagramma
Mermaid
sequenceDiagram
  participant User
  participant App as GraphQL App
  participant Back4app as Back4app Cloud

  User->>App: Login
  App->>Back4app: Authenticate (username, password)
  Back4app-->>App: Session token
  App-->>User: Logged in

  User->>App: Load data
  App->>Back4app: Query Property and Lead
  Back4app-->>App: List of Property / Lead
  App-->>User: Show list

  User->>App: Create or update
  App->>Back4app: Save Property
  Back4app-->>App: Property (objectId)
  App-->>User: Updated list

Dizionario dei Dati

Riferimento completo ai campi per ogni classe nello schema.

CampoTipoDescrizioneRichiesto
objectIdStringAuto-generated unique identifierauto
titleStringListing title
descriptionStringFull listing description—
priceNumberAsking or rental price—
addressStringStreet address—
locationGeoPointLat/lng for geo-queries and map display—
bedsNumberNumber of bedrooms—
bathsNumberNumber of bathrooms—
areaNumberArea in sq ft or sq m—
propertyTypeStringe.g. house, apartment, land—
statusStringe.g. for_sale, for_rent, sold—
listedByPointer<_User>User who created the listing—
createdAtDateAuto-generated creation timestampauto
updatedAtDateAuto-generated last-update timestampauto

14 campi in Property

Sicurezza e Permessi

Come le ACL e i permessi a livello di classe proteggono i dati in questo schema immobiliare.

Proprietà e lettura pubblica

Consenti lettura pubblica per l'elenco e i dettagli delle Proprietà; limita creazione/aggiornamento/eliminazione agli utenti autenticati (ad es. agenti di vendita).

Permessi a Livello di Classe

Le CLP limitano creazione/lettura/aggiornamento/eliminazione per classe. La creazione di lead può essere pubblica; le scritture di Preferiti e Proprietà richiedono tipicamente autenticazione.

Relazioni basate su puntatori

listedBy collega la proprietà a _User; Favorite collega utente e proprietà. Usa il Cloud Code per far rispettare la proprietà dove necessario.

Schema (JSON)

Definizione dello schema JSON grezzo — copia e usa nella tua app Back4app o importa tramite l'API.

JSON
{
  "classes": [
    {
      "className": "Property",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "description": {
          "type": "String",
          "required": false
        },
        "price": {
          "type": "Number",
          "required": false
        },
        "address": {
          "type": "String",
          "required": false
        },
        "location": {
          "type": "GeoPoint",
          "required": false
        },
        "beds": {
          "type": "Number",
          "required": false
        },
        "baths": {
          "type": "Number",
          "required": false
        },
        "area": {
          "type": "Number",
          "required": false
        },
        "propertyType": {
          "type": "String",
          "required": false
        },
        "status": {
          "type": "String",
          "required": false
        },
        "listedBy": {
          "type": "Pointer",
          "targetClass": "_User",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Lead",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "name": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "phone": {
          "type": "String",
          "required": false
        },
        "message": {
          "type": "String",
          "required": false
        },
        "property": {
          "type": "Pointer",
          "targetClass": "Property",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Favorite",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "user": {
          "type": "Pointer",
          "targetClass": "_User",
          "required": false
        },
        "property": {
          "type": "Pointer",
          "targetClass": "Property",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "_User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Costruisci con AI Agent

Usa l'AI Agent di Back4app per costruire un'app di annunci immobiliari reale da questo modello: creerà il frontend, il backend (questo schema, autenticazione, geo-query e API) e lo distribuirà — senza configurazione manuale.

Back4app AI Agent
Pronto per costruire
Crea un'app di listaggio immobiliare su Back4app con questo schema e comportamento esatti.

Schema:
1. _User (integrato Back4app): username (String, obbligatorio), email (String, obbligatorio), password (String, obbligatorio); objectId, createdAt, updatedAt (sistema).
2. Property: title (String, obbligatorio), description (String), price (Number), address (String), location (GeoPoint), beds (Number), baths (Number), area (Number), propertyType (String), status (String; es. for_sale, for_rent, sold), listedBy (Pointer a _User); objectId, createdAt, updatedAt (sistema).
3. Lead: name (String, obbligatorio), email (String, obbligatorio), phone (String), message (String), property (Pointer a Property); objectId, createdAt, updatedAt (sistema).
4. Favorite: user (Pointer a _User), property (Pointer a Property); objectId, createdAt, updatedAt (sistema).

Sicurezza:
- Impostare ACL in modo che solo utenti autenticati possano creare/aggiornare/eliminare Property e Favorite; consentire lettura pubblica per lista e dettaglio Property. La creazione Lead può essere pubblica o richiedere auth.
- Usare Class-Level Permissions per cui solo utenti autenticati gestiscono Favorite; Property e Lead secondo necessità.

Auth:
- Registrazione (username, email, password) e login; supporto logout/sessione.

Comportamento:
- CRUD completo per Property (agenti di listaggio) e Favorite.
- Creare Lead (richiesta) collegato a un Property; elencare lead per proprietà o per listaggi dell'utente corrente.
- Query geo: trovare proprietà vicine a un punto con location (GeoPoint), $nearSphere e limit.
- Filtrare proprietà per status, beds, baths, fascia di prezzo, propertyType.
- Opzionale: Live Queries in tempo reale per nuovi listaggi o modifiche ai preferiti.

Consegnare:
- Creare l'app Back4app con lo schema sopra, ACL e eventuale Cloud Code.
- Generare il frontend e collegarlo a questo backend; distribuire per un'app eseguibile end-to-end.

Esponi il backend tramite API GraphQL. Fornisci esempi di query (properties, property per id, geo) e mutation (createLead, add/remove Favorite).

Premi il pulsante qui sotto per aprire l'Agent con il prompt di questo modello già compilato.

Distribuisci in pochi minuti50 prompt gratuiti / meseNessuna carta di credito richiesta

API Playground

Prova gli endpoint REST e GraphQL per lo schema immobiliare. Le risposte dai dati di esempio sopra — nessun account Back4app necessario.

Caricamento playground…

Utilizza lo stesso schema di questo modello.

Integrazione GraphQL Passo dopo Passo

Collegati al tuo backend Back4app da un'app GraphQL utilizzando il SDK Back4app GraphQL.

  1. Passo 1: Installa il SDK Back4app GraphQL

    Aggiungi il SDK di Back4app per il tuo stack (ad es. npm, pubspec o gestore di pacchetti).

    text
    # Use any GraphQL client (Apollo, urql, fetch)

  2. Passo 2: Inizializza Back4app nella tua app

    Inizializza il SDK di Back4app all'avvio dell'app con il tuo App ID e l'URL del server.

    text
    # Endpoint: https://parseapi.back4app.com/graphql
# Headers: X-Parse-Application-Id, X-Parse-JavaScript-Key (or Master Key)

  3. Passo 3: Interroga le proprietà (con geo opzionale)

    Usa il SDK per recuperare oggetti Property; usa la query geo per "vicino a me" o risultati mappa.

    GraphQL
    query GetProperties($status: String) {
  properties(where: { status: { equalTo: $status } }, order: createdAt_DESC) {
    results { objectId title price address location { latitude longitude } status }
  }
}

query GetPropertiesNear($lat: Float!, $lng: Float!) {
  properties(where: { location: { nearSphere: { latitude: $lat, longitude: $lng } } }, limit: 20) {
    results { objectId title price }
  }
}

  4. Passo 4: Crea un lead (richiesta)

    Crea un Lead con nome, email, telefono, messaggio e puntatore alla proprietà.

    GraphQL
    mutation CreateLead($name: String!, $email: String!, $propertyId: ID!) {
  createLead(input: { name: $name, email: $email, property: { link: $propertyId } }) {
    lead { objectId }
  }
}

  5. Passo 5: Gestisci i preferiti

    Aggiungi o rimuovi Preferito (utente + proprietà); elenca i preferiti per l'utente corrente.

    GraphQL
    query GetMyFavorites {
  favorites(where: { user: { equalTo: "current" } }) {
    results { objectId property { ... on Property { objectId title } } }
  }
}

Integrazione della Gestione dello Stato

Integra il SDK di Back4app con il layer di stato della tua app (ad es. contesto, store o servizi).

Modello Dati Completo

Copia un modello completo di Proprietà/Contatto/Preferito per una serializzazione sicura per tipo (ad es. classe, interfaccia o definizione di tipo).

text
type Property {
  objectId: ID!
  title: String!
  description: String
  price: Float
  address: String
  location: GeoPoint
  beds: Int
  baths: Int
  area: Float
  propertyType: String
  status: String
  createdAt: Date
  updatedAt: Date
}

type Lead {
  objectId: ID!
  name: String!
  email: String!
  phone: String
  message: String
  property: Property
  createdAt: Date
  updatedAt: Date
}

type Favorite {
  objectId: ID!
  user: User
  property: Property
  createdAt: Date
  updatedAt: Date
}

Domande Frequenti

Domande comuni sul modello di backend per l'elenco immobiliare.

Che cos'è Back4app?
Qual è il tipo Property nell'API di GraphQL?
Come posso eseguire una geo query in GraphQL?
Come posso creare un lead tramite GraphQL?
Posso aggiungere campi al tipo Property in seguito?
È disponibile il tempo reale tramite GraphQL?

Fidato da sviluppatori in tutto il mondo

Unisciti alla comunità che costruisce il futuro delle app

G2 Users Love Us Badge

Pronto per costruire la tua app di listing immobiliare?

Inizia il tuo progetto GraphQL in pochi minuti. Nessuna carta di credito richiesta.

Costruisci con AI Agent