Firebase and Cloud FirestoreFirebase و ⁦Cloud Firestore⁩

$ firebase login
$ dart pub global activate flutterfire_cli
$ flutterfire configure
$ flutter pub add firebase_core cloud_firestore

import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';

import 'firebase_options.dart'; // written by `flutterfire configure`

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  runApp(const MaterialApp(home: Scaffold(body: Center(child: Text('Ready')))));
}

// A SHORTENED example of the file `flutterfire configure` writes.
// The values below are placeholders, not a real project.
import 'package:firebase_core/firebase_core.dart' show FirebaseOptions;
import 'package:flutter/foundation.dart'
    show defaultTargetPlatform, kIsWeb, TargetPlatform;

class DefaultFirebaseOptions {
  static FirebaseOptions get currentPlatform {
    if (kIsWeb) return web;
    switch (defaultTargetPlatform) {
      case TargetPlatform.android:
        return android;
      case TargetPlatform.iOS:
        return ios;
      default:
        throw UnsupportedError('This platform is not configured.');
    }
  }

  static const FirebaseOptions android = FirebaseOptions(
    apiKey: 'YOUR-ANDROID-API-KEY',
    appId: '1:000000000000:android:0000000000000000',
    messagingSenderId: '000000000000',
    projectId: 'your-project-id',
  );

  static const FirebaseOptions ios = FirebaseOptions(
    apiKey: 'YOUR-IOS-API-KEY',
    appId: '1:000000000000:ios:0000000000000000',
    messagingSenderId: '000000000000',
    projectId: 'your-project-id',
    iosBundleId: 'com.example.students',
  );

  static const FirebaseOptions web = FirebaseOptions(
    apiKey: 'YOUR-WEB-API-KEY',
    appId: '1:000000000000:web:0000000000000000',
    messagingSenderId: '000000000000',
    projectId: 'your-project-id',
  );
}

import 'package:cloud_firestore/cloud_firestore.dart';

class Student {
  final String id; // the document id (not stored inside the document)
  final int studentId; // the university number, e.g. 1021
  final String name;
  final int stage;

  const Student({
    required this.id,
    required this.studentId,
    required this.name,
    required this.stage,
  });

  // A Firestore document -> a Student
  factory Student.fromDoc(DocumentSnapshot<Map<String, dynamic>> doc) {
    final data = doc.data()!;
    return Student(
      id: doc.id,
      studentId: data['studentId'] as int,
      name: data['name'] as String,
      stage: data['stage'] as int,
    );
  }

  // A Student -> the fields of a document
  Map<String, dynamic> toMap() =>
      {'studentId': studentId, 'name': name, 'stage': stage};
}

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:flutter/material.dart';

import 'student.dart';

class StudentList extends StatefulWidget {
  const StudentList({super.key});

  @override
  State<StudentList> createState() => _StudentListState();
}

class _StudentListState extends State<StudentList> {
  // Make the stream once, not in build().
  final Stream<QuerySnapshot<Map<String, dynamic>>> _students =
      FirebaseFirestore.instance
          .collection('students')
          .orderBy('name')
          .snapshots();

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<QuerySnapshot<Map<String, dynamic>>>(
      stream: _students,
      builder: (context, snapshot) {
        if (snapshot.hasError) {
          return Center(child: Text('Could not load: ${snapshot.error}'));
        }
        if (!snapshot.hasData) {
          return const Center(child: CircularProgressIndicator());
        }
        final docs = snapshot.data!.docs;
        if (docs.isEmpty) {
          return const Center(child: Text('No students yet.'));
        }
        return ListView.builder(
          itemCount: docs.length,
          itemBuilder: (context, index) {
            final student = Student.fromDoc(docs[index]);
            return ListTile(
              leading: CircleAvatar(child: Text('${student.stage}')),
              title: Text(student.name),
              subtitle: Text('ID ${student.studentId}'),
            );
          },
        );
      },
    );
  }
}

Future<List<Student>> loadOnce() async {
  final query = await FirebaseFirestore.instance
      .collection('students')
      .orderBy('name')
      .get(); // one answer, no listener
  return query.docs.map(Student.fromDoc).toList();
}

import 'package:cloud_firestore/cloud_firestore.dart';

import 'student.dart';

class StudentService {
  final _students = FirebaseFirestore.instance.collection('students');

  // CREATE with a generated id (the usual way)
  Future<String> add(Student s) async {
    final ref = await _students.add(s.toMap());
    return ref.id;
  }

  // CREATE or REPLACE a document whose id you choose
  Future<void> putWithId(String id, Student s) =>
      _students.doc(id).set(s.toMap());

  // UPDATE some fields; fails if the document does not exist
  Future<void> moveToStage(String id, int stage) =>
      _students.doc(id).update({'stage': stage});

  // MERGE: change some fields, create the document if it is missing
  Future<void> saveStage(String id, int stage) =>
      _students.doc(id).set({'stage': stage}, SetOptions(merge: true));

  // DELETE one field from a document
  Future<void> removeStage(String id) =>
      _students.doc(id).update({'stage': FieldValue.delete()});

  // DELETE the whole document
  Future<void> delete(String id) => _students.doc(id).delete();

  // READ once (no live updates)
  Future<List<Student>> loadOnce() async {
    final query = await _students.orderBy('name').get();
    return query.docs.map(Student.fromDoc).toList();
  }
}

import 'package:cloud_firestore/cloud_firestore.dart';

Future<String> deleteStudent(String id) async {
  try {
    await FirebaseFirestore.instance.collection('students').doc(id).delete();
    return 'Deleted';
  } on FirebaseException catch (e) {
    // e.code is a short name such as 'permission-denied' or 'unavailable'
    return 'Could not delete (${e.code})';
  }
}

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';

import 'firebase_options.dart';
import 'student.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
  runApp(const MaterialApp(home: StudentsScreen()));
}

class StudentsScreen extends StatefulWidget {
  const StudentsScreen({super.key});

  @override
  State<StudentsScreen> createState() => _StudentsScreenState();
}

class _StudentsScreenState extends State<StudentsScreen> {
  final _students = FirebaseFirestore.instance.collection('students');
  late final Stream<QuerySnapshot<Map<String, dynamic>>> _stream =
      _students.orderBy('name').snapshots();

  final _idField = TextEditingController();
  final _nameField = TextEditingController();
  final _stageField = TextEditingController();
  String? _editingId; // null: the form adds a new student

  @override
  void dispose() {
    _idField.dispose();
    _nameField.dispose();
    _stageField.dispose();
    super.dispose();
  }

  Future<void> _save() async {
    final studentId = int.tryParse(_idField.text);
    final stage = int.tryParse(_stageField.text);
    final name = _nameField.text.trim();
    if (studentId == null || stage == null || name.isEmpty) {
      _show('Fill in all three fields correctly.');
      return;
    }
    final data = {'studentId': studentId, 'name': name, 'stage': stage};
    final id = _editingId;
    try {
      if (id == null) {
        await _students.add(data); // Create: Firestore makes the id
      } else {
        await _students.doc(id).update(data); // Update: only these fields
      }
      _clearForm();
    } on FirebaseException catch (e) {
      _show('Could not save (${e.code})');
    }
  }

  Future<void> _delete(String id) async {
    try {
      await _students.doc(id).delete(); // Delete the whole document
    } on FirebaseException catch (e) {
      _show('Could not delete (${e.code})');
    }
  }

  void _startEditing(Student s) {
    setState(() => _editingId = s.id);
    _idField.text = '${s.studentId}';
    _nameField.text = s.name;
    _stageField.text = '${s.stage}';
  }

  void _clearForm() {
    setState(() => _editingId = null);
    _idField.clear();
    _nameField.clear();
    _stageField.clear();
  }

  void _show(String message) {
    if (!mounted) return;
    ScaffoldMessenger.of(context)
        .showSnackBar(SnackBar(content: Text(message)));
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Students')),
      body: Column(
        children: [
          Padding(
            padding: const EdgeInsets.all(12),
            child: Column(
              children: [
                TextField(
                  controller: _idField,
                  keyboardType: TextInputType.number,
                  decoration: const InputDecoration(labelText: 'Student ID'),
                ),
                TextField(
                  controller: _nameField,
                  decoration: const InputDecoration(labelText: 'Name'),
                ),
                TextField(
                  controller: _stageField,
                  keyboardType: TextInputType.number,
                  decoration: const InputDecoration(labelText: 'Stage'),
                ),
                const SizedBox(height: 8),
                Row(
                  children: [
                    FilledButton(
                      onPressed: _save,
                      child: Text(_editingId == null ? 'Add' : 'Update'),
                    ),
                    if (_editingId != null)
                      TextButton(onPressed: _clearForm, child: const Text('Cancel')),
                  ],
                ),
              ],
            ),
          ),
          const Divider(),
          Expanded(
            child: StreamBuilder<QuerySnapshot<Map<String, dynamic>>>(
              stream: _stream, // Read: live, rebuilt on every change
              builder: (context, snapshot) {
                if (snapshot.hasError) {
                  return Center(child: Text('Error: ${snapshot.error}'));
                }
                if (!snapshot.hasData) {
                  return const Center(child: CircularProgressIndicator());
                }
                final students =
                    snapshot.data!.docs.map(Student.fromDoc).toList();
                if (students.isEmpty) {
                  return const Center(child: Text('No students yet.'));
                }
                return ListView(
                  children: [
                    for (final s in students)
                      ListTile(
                        leading: CircleAvatar(child: Text('${s.stage}')),
                        title: Text(s.name),
                        subtitle: Text('ID ${s.studentId}'),
                        onTap: () => _startEditing(s),
                        trailing: IconButton(
                          icon: const Icon(Icons.delete_outline),
                          tooltip: 'Delete',
                          onPressed: () => _delete(s.id),
                        ),
                      ),
                  ],
                );
              },
            ),
          ),
        ],
      ),
    );
  }
}

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {

    // Any signed-in user may read and write students
    match /students/{studentId} {
      allow read, write: if request.auth != null;
    }

    // Each user may read and write only their own profile
    match /users/{userId} {
      allow read, write: if request.auth != null
                         && request.auth.uid == userId;
    }
  }
}