Modello Flutter

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

Un backend per elenco immobili Flutter 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.

Punti Chiave

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

  1. Distribuisci in pochi minutiIncolla 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'usoProperty.location (GeoPoint) supporta $nearSphere per "proprietà vicino a me" e ricerca basata su mappa.
  3. SDK Flutter-nativoOggetti tipizzati, async/await, pinning offline opzionale e Live Queries per nuove inserzioni.
  4. REST + GraphQLEntrambi 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 Flutter?

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 Flutter è 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 Flutter 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 Flutter, 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 Flutter e distribuisca — tutto da un'unica richiesta.

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

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 Flutter comunica con Back4app — accesso, query delle proprietà (con geo), crea lead, gestisci preferiti.

Visualizza sorgente del diagramma
Mermaid
sequenceDiagram
  participant User
  participant App as Flutter 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.

Usa Flutter per il frontend con il Back4app Flutter SDK. Includi schermate per lista immobili (geo/mappa), dettaglio, modulo lead e preferiti; supporto pinning offline per listaggi salvati.

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 Flutter Passo dopo Passo

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

  1. Passo 1: Installa il SDK Back4app Flutter

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

    YAML
    dependencies:
      flutter:
        sdk: flutter
      parse_server_sdk_flutter: ^7.0.0
  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.

    Dart
    import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
    
    void main() async {
      WidgetsFlutterBinding.ensureInitialized();
    
      await Parse().initialize(
        'YOUR_APP_ID',
        'https://parseapi.back4app.com',
        clientKey: 'YOUR_CLIENT_KEY',
        autoSendSessionId: true,
      );
    
      runApp(const MyApp());
    }
  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.

    Dart
    Future<List<ParseObject>> getProperties({String status = 'for_sale'}) async {
      final query = QueryBuilder<ParseObject>(ParseObject('Property'))
        ..whereEqualTo('status', status)
        ..orderByDescending('createdAt');
      final response = await query.query();
      if (response.success && response.results != null) {
        return response.results as List<ParseObject>;
      }
      return [];
    }
    
    // Geo query: properties near a point
    Future<List<ParseObject>> getPropertiesNear(double lat, double lng, {int limit = 20}) async {
      final query = QueryBuilder<ParseObject>(ParseObject('Property'))
        ..setLocationConstraint('location', ParseGeoPoint(latitude: lat, longitude: lng), 50)
        ..setLimit(limit);
      final response = await query.query();
      return response.success && response.results != null
          ? response.results as List<ParseObject>
          : [];
    }
  4. Passo 4: Crea un lead (richiesta)

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

    Dart
    Future<void> createLead(String name, String email, String propertyId, {String? phone, String? message}) async {
      final lead = ParseObject('Lead')
        ..set('name', name)
        ..set('email', email)
        ..set('property', ParseObject('Property')..objectId = propertyId);
      if (phone != null) lead.set('phone', phone);
      if (message != null) lead.set('message', message);
      final response = await lead.save();
      if (response.success) {
        print('Lead created: ${response.result.objectId}');
      }
    }
  5. Passo 5: Gestisci i preferiti

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

    Dart
    // Add favorite (user + property)
    Future<void> addFavorite(ParseUser user, String propertyId) async {
      final favorite = ParseObject('Favorite')
        ..set('user', user)
        ..set('property', ParseObject('Property')..objectId = propertyId);
      await favorite.save();
    }
    
    // Remove favorite
    Future<void> removeFavorite(String favoriteId) async {
      final favorite = ParseObject('Favorite')..objectId = favoriteId;
      await favorite.delete();
    }
    
    // List favorites for current user
    Future<List<ParseObject>> getMyFavorites(ParseUser user) async {
      final query = QueryBuilder<ParseObject>(ParseObject('Favorite'))
        ..whereEqualTo('user', user);
      final response = await query.query();
      return response.success && response.results != null
          ? response.results as List<ParseObject>
          : [];
    }

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

Dart
class Property {
  final String? objectId;
  final String title;
  final String? description;
  final double? price;
  final String? address;
  final ParseGeoPoint? location;
  final int? beds;
  final int? baths;
  final double? area;
  final String? propertyType;
  final String? status;
  final String? listedById;
  final DateTime? createdAt;
  final DateTime? updatedAt;

  Property({
    this.objectId,
    required this.title,
    this.description,
    this.price,
    this.address,
    this.location,
    this.beds,
    this.baths,
    this.area,
    this.propertyType,
    this.status = 'for_sale',
    this.listedById,
    this.createdAt,
    this.updatedAt,
  });

  factory Property.fromJson(Map<String, dynamic> json) {
    return Property(
      objectId: json['objectId'] as String?,
      title: json['title'] as String,
      description: json['description'] as String?,
      price: (json['price'] as num?)?.toDouble(),
      address: json['address'] as String?,
      location: json['location'] != null ? ParseGeoPoint.fromJson(json['location']) : null,
      beds: json['beds'] as int?,
      baths: json['baths'] as int?,
      area: (json['area'] as num?)?.toDouble(),
      propertyType: json['propertyType'] as String?,
      status: json['status'] as String? ?? 'for_sale',
      listedById: json['listedBy'] is Map ? (json['listedBy'] as Map)['objectId'] as String? : null,
      createdAt: json['createdAt'] != null ? DateTime.parse(json['createdAt']) : null,
      updatedAt: json['updatedAt'] != null ? DateTime.parse(json['updatedAt']) : null,
    );
  }
}

class Lead {
  final String? objectId;
  final String name;
  final String email;
  final String? phone;
  final String? message;
  final String? propertyId;
  final DateTime? createdAt;
  final DateTime? updatedAt;

  Lead({
    this.objectId,
    required this.name,
    required this.email,
    this.phone,
    this.message,
    this.propertyId,
    this.createdAt,
    this.updatedAt,
  });

  factory Lead.fromJson(Map<String, dynamic> json) {
    return Lead(
      objectId: json['objectId'] as String?,
      name: json['name'] as String,
      email: json['email'] as String,
      phone: json['phone'] as String?,
      message: json['message'] as String?,
      propertyId: json['property'] is Map ? (json['property'] as Map)['objectId'] as String? : null,
      createdAt: json['createdAt'] != null ? DateTime.parse(json['createdAt']) : null,
      updatedAt: json['updatedAt'] != null ? DateTime.parse(json['updatedAt']) : null,
    );
  }
}

class Favorite {
  final String? objectId;
  final String? userId;
  final String? propertyId;
  final DateTime? createdAt;
  final DateTime? updatedAt;

  Favorite({
    this.objectId,
    this.userId,
    this.propertyId,
    this.createdAt,
    this.updatedAt,
  });

  factory Favorite.fromJson(Map<String, dynamic> json) {
    return Favorite(
      objectId: json['objectId'] as String?,
      userId: json['user'] is Map ? (json['user'] as Map)['objectId'] as String? : null,
      propertyId: json['property'] is Map ? (json['property'] as Map)['objectId'] as String? : null,
      createdAt: json['createdAt'] != null ? DateTime.parse(json['createdAt']) : null,
      updatedAt: json['updatedAt'] != null ? DateTime.parse(json['updatedAt']) : null,
    );
  }
}

Offline-First & Datastore Locale

Usa pin() e unpin() affinché le proprietà e i preferiti siano disponibili offline e si sincronizzino quando tornano online.

Gli SDK supportati includono un datastore locale. Fissa gli oggetti Proprietà e Preferito per mantenerli sul dispositivo; interroga i dati fissati quando sei offline. Quando l'app torna online, sincronizza con il server.

Di seguito: fissa i risultati dopo il recupero e rimuovi il pin quando non hai più bisogno di copie locali.

Dart
// Pin properties after fetch (offline-first)
Future<void> fetchAndPinProperties() async {
  final query = QueryBuilder<ParseObject>(ParseObject('Property'))
    ..whereEqualTo('status', 'for_sale')
    ..orderByDescending('createdAt');
  final response = await query.query();
  if (response.success && response.results != null) {
    final results = response.results!.cast<ParseObject>();
    await ParseObject.pinAllObjects(results);
    // Query from local store when offline:
    // QueryBuilder<ParseObject>(ParseObject('Property')).fromLocalDatastore();
  }
}

// Unpin when no longer needed
Future<void> unpinAllProperties() async {
  await ParseObject.unpinAll('Property');
}

Domande Frequenti

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

Che cos'è Back4app?
Perché usare Back4app per un'app di listing immobiliare Flutter?
Che cos'è la classe Property in un'app immobiliare Flutter?
Come funzionano le geo-queries con il Flutter SDK?
Come posso creare un lead da Flutter?
Posso aggiungere campi a Property in seguito nella mia app Flutter?
Il SDK di Flutter supporta l'uso offline per le proprietà?

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 Flutter in pochi minuti. Nessuna carta di credito richiesta.

Costruisci con AI Agent