6 posts tagged with "Database"

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  runApp(MyApp());
}

Future<UserCredential> signUpWithEmail(String email, String password) async {
  try {
    return await FirebaseAuth.instance.createUserWithEmailAndPassword(
      email: email,
      password: password,
    );
  } on FirebaseAuthException catch (e) {
    throw _handleAuthError(e);
  }
}

Future<UserCredential> signInWithEmail(String email, String password) async {
  try {
    return await FirebaseAuth.instance.signInWithEmailAndPassword(
      email: email,
      password: password,
    );
  } on FirebaseAuthException catch (e) {
    throw _handleAuthError(e);
  }
}

// Thêm dữ liệu
Future<void> addUser(String userId, Map<String, dynamic> userData) async {
  await FirebaseFirestore.instance
      .collection('users')
      .doc(userId)
      .set(userData);
}

// Đọc dữ liệu
Future<DocumentSnapshot> getUser(String userId) async {
  return await FirebaseFirestore.instance
      .collection('users')
      .doc(userId)
      .get();
}

// Cập nhật dữ liệu
Future<void> updateUser(String userId, Map<String, dynamic> newData) async {
  await FirebaseFirestore.instance
      .collection('users')
      .doc(userId)
      .update(newData);
}

// Xóa dữ liệu
Future<void> deleteUser(String userId) async {
  await FirebaseFirestore.instance
      .collection('users')
      .doc(userId)
      .delete();
}

Stream<QuerySnapshot> getUsersStream() {
  return FirebaseFirestore.instance
      .collection('users')
      .snapshots();
}

// Sử dụng trong Widget
StreamBuilder<QuerySnapshot>(
  stream: getUsersStream(),
  builder: (context, snapshot) {
    if (snapshot.hasError) {
      return Text('Có lỗi xảy ra');
    }
    if (snapshot.connectionState == ConnectionState.waiting) {
      return CircularProgressIndicator();
    }
    return ListView(
      children: snapshot.data!.docs.map((doc) {
        return ListTile(
          title: Text(doc['name']),
        );
      }).toList(),
    );
  },
)

Future<String> uploadFile(File file, String path) async {
  try {
    final ref = FirebaseStorage.instance.ref().child(path);
    final uploadTask = ref.putFile(file);
    final snapshot = await uploadTask.whenComplete(() {});
    return await snapshot.ref.getDownloadURL();
  } catch (e) {
    throw Exception('Lỗi khi upload file: $e');
  }
}

Future<void> downloadFile(String url, String localPath) async {
  try {
    final ref = FirebaseStorage.instance.refFromURL(url);
    final file = File(localPath);
    await ref.writeToFile(file);
  } catch (e) {
    throw Exception('Lỗi khi download file: $e');
  }
}

import 'package:firebase_core/firebase_core.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'firebase_options.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  runApp(MyApp());
}

class User {
  final String? id;
  final String name;
  final String email;
  final int age;
  final DateTime createdAt;

  User({
    this.id,
    required this.name,
    required this.email,
    required this.age,
    DateTime? createdAt,
  }) : createdAt = createdAt ?? DateTime.now();

  // Convert to Map for Firestore
  Map<String, dynamic> toMap() {
    return {
      'name': name,
      'email': email,
      'age': age,
      'createdAt': Timestamp.fromDate(createdAt),
    };
  }

  // Create from Firestore document
  factory User.fromMap(String id, Map<String, dynamic> map) {
    return User(
      id: id,
      name: map['name'] as String,
      email: map['email'] as String,
      age: map['age'] as int,
      createdAt: (map['createdAt'] as Timestamp).toDate(),
    );
  }

  // Create from Firestore document snapshot
  factory User.fromDocument(DocumentSnapshot doc) {
    return User.fromMap(doc.id, doc.data() as Map<String, dynamic>);
  }
}

import 'package:cloud_firestore/cloud_firestore.dart';

class FirestoreService {
  final FirebaseFirestore _firestore = FirebaseFirestore.instance;

  // Thêm document với auto-generated ID
  Future<String> addUser(User user) async {
    try {
      final docRef = await _firestore
          .collection('users')
          .add(user.toMap());
      
      return docRef.id;
    } catch (e) {
      throw Exception('Error adding user: $e');
    }
  }
}

// Thêm document với ID tùy chỉnh
Future<void> addUserWithId(String userId, User user) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .set(user.toMap());
  } catch (e) {
    throw Exception('Error adding user: $e');
  }
}

// Merge: Nếu document đã tồn tại, chỉ update các field được chỉ định
Future<void> addUserWithMerge(String userId, Map<String, dynamic> data) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .set(data, SetOptions(merge: true));
  } catch (e) {
    throw Exception('Error adding user: $e');
  }
}

// Thêm document vào subcollection
Future<void> addPostToUser(String userId, Post post) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .collection('posts')
        .add(post.toMap());
  } catch (e) {
    throw Exception('Error adding post: $e');
  }
}

// Đọc một document
Future<User?> getUser(String userId) async {
  try {
    final doc = await _firestore
        .collection('users')
        .doc(userId)
        .get();

    if (doc.exists) {
      return User.fromDocument(doc);
    }
    return null;
  } catch (e) {
    throw Exception('Error getting user: $e');
  }
}

// Đọc tất cả documents trong collection
Future<List<User>> getAllUsers() async {
  try {
    final snapshot = await _firestore
        .collection('users')
        .get();

    return snapshot.docs
        .map((doc) => User.fromDocument(doc))
        .toList();
  } catch (e) {
    throw Exception('Error getting users: $e');
  }
}

// Query với where
Future<List<User>> getUsersByAge(int minAge) async {
  try {
    final snapshot = await _firestore
        .collection('users')
        .where('age', isGreaterThanOrEqualTo: minAge)
        .get();

    return snapshot.docs
        .map((doc) => User.fromDocument(doc))
        .toList();
  } catch (e) {
    throw Exception('Error getting users: $e');
  }
}

// Multiple conditions
Future<List<User>> getUsersByAgeAndName(int age, String name) async {
  try {
    final snapshot = await _firestore
        .collection('users')
        .where('age', isEqualTo: age)
        .where('name', isEqualTo: name)
        .get();

    return snapshot.docs
        .map((doc) => User.fromDocument(doc))
        .toList();
  } catch (e) {
    throw Exception('Error getting users: $e');
  }
}

// Sort và limit
Future<List<User>> getUsersSortedByAge({int limit = 10}) async {
  try {
    final snapshot = await _firestore
        .collection('users')
        .orderBy('age', descending: false)
        .limit(limit)
        .get();

    return snapshot.docs
        .map((doc) => User.fromDocument(doc))
        .toList();
  } catch (e) {
    throw Exception('Error getting users: $e');
  }
}

// Pagination
Future<List<User>> getUsersPaginated({
  required int limit,
  DocumentSnapshot? startAfter,
}) async {
  try {
    Query query = _firestore
        .collection('users')
        .orderBy('createdAt', descending: true)
        .limit(limit);

    if (startAfter != null) {
      query = query.startAfterDocument(startAfter);
    }

    final snapshot = await query.get();

    return snapshot.docs
        .map((doc) => User.fromDocument(doc))
        .toList();
  } catch (e) {
    throw Exception('Error getting users: $e');
  }
}

// Stream để lắng nghe thay đổi real-time
Stream<List<User>> getUsersStream() {
  return _firestore
      .collection('users')
      .snapshots()
      .map((snapshot) => snapshot.docs
          .map((doc) => User.fromDocument(doc))
          .toList());
}

// Stream cho single document
Stream<User?> getUserStream(String userId) {
  return _firestore
      .collection('users')
      .doc(userId)
      .snapshots()
      .map((doc) => doc.exists ? User.fromDocument(doc) : null);
}

// Update toàn bộ document
Future<void> updateUser(String userId, User user) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .set(user.toMap());
  } catch (e) {
    throw Exception('Error updating user: $e');
  }
}

// Update chỉ một số fields
Future<void> updateUserFields(
  String userId,
  Map<String, dynamic> fields,
) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .update(fields);
  } catch (e) {
    throw Exception('Error updating user: $e');
  }
}

// Ví dụ sử dụng
await updateUserFields('user123', {
  'name': 'Tên mới',
  'age': 26,
});

// Tăng/giảm giá trị số
Future<void> incrementUserAge(String userId) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .update({
      'age': FieldValue.increment(1),
    });
  } catch (e) {
    throw Exception('Error incrementing age: $e');
  }
}

// Thêm vào array
Future<void> addToArray(String userId, String item) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .update({
      'tags': FieldValue.arrayUnion([item]),
    });
  } catch (e) {
    throw Exception('Error adding to array: $e');
  }
}

// Xóa khỏi array
Future<void> removeFromArray(String userId, String item) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .update({
      'tags': FieldValue.arrayRemove([item]),
    });
  } catch (e) {
    throw Exception('Error removing from array: $e');
  }
}

// Xóa document
Future<void> deleteUser(String userId) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .delete();
  } catch (e) {
    throw Exception('Error deleting user: $e');
  }
}

// Xóa một field
Future<void> deleteUserField(String userId, String fieldName) async {
  try {
    await _firestore
        .collection('users')
        .doc(userId)
        .update({
      fieldName: FieldValue.delete(),
    });
  } catch (e) {
    throw Exception('Error deleting field: $e');
  }
}

// Xóa tất cả documents trong subcollection
Future<void> deleteUserPosts(String userId) async {
  try {
    final snapshot = await _firestore
        .collection('users')
        .doc(userId)
        .collection('posts')
        .get();

    final batch = _firestore.batch();
    for (var doc in snapshot.docs) {
      batch.delete(doc.reference);
    }
    await batch.commit();
  } catch (e) {
    throw Exception('Error deleting posts: $e');
  }
}

// Transaction: Đảm bảo atomic operations
Future<void> transferPoints(
  String fromUserId,
  String toUserId,
  int points,
) async {
  try {
    await _firestore.runTransaction((transaction) async {
      // Đọc documents
      final fromDoc = await transaction.get(
        _firestore.collection('users').doc(fromUserId),
      );
      final toDoc = await transaction.get(
        _firestore.collection('users').doc(toUserId),
      );

      if (!fromDoc.exists || !toDoc.exists) {
        throw Exception('User not found');
      }

      final fromPoints = fromDoc.data()!['points'] as int;
      if (fromPoints < points) {
        throw Exception('Insufficient points');
      }

      // Update
      transaction.update(fromDoc.reference, {
        'points': FieldValue.increment(-points),
      });
      transaction.update(toDoc.reference, {
        'points': FieldValue.increment(points),
      });
    });
  } catch (e) {
    throw Exception('Error transferring points: $e');
  }
}

// Batch write: Thực hiện nhiều operations cùng lúc
Future<void> batchUpdateUsers(List<String> userIds, Map<String, dynamic> data) async {
  try {
    final batch = _firestore.batch();

    for (var userId in userIds) {
      final docRef = _firestore.collection('users').doc(userId);
      batch.update(docRef, data);
    }

    await batch.commit();
  } catch (e) {
    throw Exception('Error batch updating users: $e');
  }
}

import 'package:cloud_firestore/cloud_firestore.dart';

class FirestoreService {
  final FirebaseFirestore _firestore = FirebaseFirestore.instance;

  // CREATE
  Future<String> createUser(User user) async {
    try {
      final docRef = await _firestore
          .collection('users')
          .add(user.toMap());
      return docRef.id;
    } catch (e) {
      throw Exception('Error creating user: $e');
    }
  }

  // READ - Single
  Future<User?> getUser(String userId) async {
    try {
      final doc = await _firestore
          .collection('users')
          .doc(userId)
          .get();
      return doc.exists ? User.fromDocument(doc) : null;
    } catch (e) {
      throw Exception('Error getting user: $e');
    }
  }

  // READ - All
  Future<List<User>> getAllUsers() async {
    try {
      final snapshot = await _firestore
          .collection('users')
          .get();
      return snapshot.docs
          .map((doc) => User.fromDocument(doc))
          .toList();
    } catch (e) {
      throw Exception('Error getting users: $e');
    }
  }

  // READ - Query
  Future<List<User>> getUsersByAge(int minAge) async {
    try {
      final snapshot = await _firestore
          .collection('users')
          .where('age', isGreaterThanOrEqualTo: minAge)
          .orderBy('age')
          .get();
      return snapshot.docs
          .map((doc) => User.fromDocument(doc))
          .toList();
    } catch (e) {
      throw Exception('Error getting users: $e');
    }
  }

  // READ - Stream
  Stream<List<User>> getUsersStream() {
    return _firestore
        .collection('users')
        .snapshots()
        .map((snapshot) => snapshot.docs
            .map((doc) => User.fromDocument(doc))
            .toList());
  }

  // UPDATE
  Future<void> updateUser(String userId, Map<String, dynamic> data) async {
    try {
      await _firestore
          .collection('users')
          .doc(userId)
          .update(data);
    } catch (e) {
      throw Exception('Error updating user: $e');
    }
  }

  // DELETE
  Future<void> deleteUser(String userId) async {
    try {
      await _firestore
          .collection('users')
          .doc(userId)
          .delete();
    } catch (e) {
      throw Exception('Error deleting user: $e');
    }
  }
}

class UsersListWidget extends StatelessWidget {
  final FirestoreService _service = FirestoreService();

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<List<User>>(
      stream: _service.getUsersStream(),
      builder: (context, snapshot) {
        if (snapshot.connectionState == ConnectionState.waiting) {
          return Center(child: CircularProgressIndicator());
        }

        if (snapshot.hasError) {
          return Center(child: Text('Error: ${snapshot.error}'));
        }

        if (!snapshot.hasData || snapshot.data!.isEmpty) {
          return Center(child: Text('No users found'));
        }

        final users = snapshot.data!;
        return ListView.builder(
          itemCount: users.length,
          itemBuilder: (context, index) {
            final user = users[index];
            return ListTile(
              title: Text(user.name),
              subtitle: Text(user.email),
              trailing: Text('Age: ${user.age}'),
            );
          },
        );
      },
    );
  }
}