How I Created An Instagram Clone With Flutter And Firebase

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:equatable/equatable.dart';
import 'package:hochzeit/models/guest.dart';
import 'package:hochzeit/models/post_comment.dart';

class Post extends Equatable {
  final String id;
  final String text;
  final String imageId;
  final Guest author;
  final DateTime createdAt;
  final DateTime updatedAt;
  final List<PostComment> comments;
  final List<Guest> likes;
  final bool isDeleted;

  const Post(
      {required this.id,
      required this.text,
      required this.author,
      required this.createdAt,
      required this.updatedAt,
      required this.comments,
      required this.likes,
      required this.isDeleted,
      required this.imageId});

  Post update() => Post(
      id: id,
      createdAt: createdAt,
      text: text,
      author: author,
      comments: comments,
      likes: likes,
      imageId: imageId,
      isDeleted: isDeleted,
      updatedAt: DateTime.now());

  factory Post.fromJson(Map<String, dynamic> json) {
    return Post(
        id: json.containsKey("id") ? json["id"] : "",
        text: json.containsKey("text") ? json["text"] : "",
        createdAt: json.containsKey("createdAt")
            ? (json["createdAt"] as Timestamp).toDate()
            : DateTime(1970),
        updatedAt: json.containsKey("updatedAt")
            ? (json["updatedAt"] as Timestamp).toDate()
            : DateTime(1970),
        author: json.containsKey("author")
            ? Guest.fromJson(json["author"])
            : Guest.empty(),
        imageId: json.containsKey("imageId") ? json["imageId"] : "",
        isDeleted: json["isDeleted"],
        comments: json.containsKey("comments")
            ? (json["comments"] as List)
                .map((item) => PostComment.fromJson(item))
                .toList()
            : <PostComment>[],
        likes: json.containsKey("likes")
            ? (json["likes"] as List)
                .map((item) => Guest.fromJson(item))
                .toList()
            : <Guest>[]);
  }

  Map<String, dynamic> toJson() {
    return <String, dynamic>{
      "id": id,
      "text": text,
      "createdAt": Timestamp.fromDate(createdAt),
      "updatedAt": Timestamp.fromDate(updatedAt),          
      "author": author.toJson(),
      "imageId": imageId,
      "isDeleted": isDeleted,
      "comments": comments
          .map((comment) => comment.toJson())
          .toList(),
      "likes": likes.map((like) => like.toJson()).toList()
    };
  }

  @override
  List<Object?> get props => [id];
}

import 'package:equatable/equatable.dart';

class Guest extends Equatable {
  final String id;
  final String uid;
  final String firstName;
  final String lastName;
  final String displayName;
  final String profilePicture;

  const Guest(
      {required this.id,
      required this.uid,
      required this.firstName,
      required this.lastName,
      required this.displayName,
      required this.profilePicture});
      
  Guest.empty()
      : this(
            id: "",
            uid: "",
            firstName: "",
            lastName: "",
            displayName: "",
            profilePicture: "");

  factory Guest.fromJson(Map<String, dynamic> json) {
    return Guest(
        id: json.containsKey("id") ? json["id"] : "",
        uid: json.containsKey("uid") ? json["uid"] : "",
        firstName: json.containsKey("firstName") ? json["firstName"] : "",
        lastName: json.containsKey("lastName") ? json["lastName"] : "",
        displayName: json.containsKey("displayName") ? json["displayName"] : "",
        profilePicture:
            json.containsKey("profilePicture") ? json["profilePicture"] : "");
  }

  Map<String, dynamic> toJson() {
    return <String, dynamic>{
      "id": id,
      "uid": uid,
      "firstName": firstName,
      "lastName": lastName,
      "displayName": displayName,
      "profilePicture": profilePicture,
    };
  }

  @override
  List<Object?> get props => [id, uid];
}

Stream<QuerySnapshot> _getPostsStream() {
  return FirebaseFirestore.instance
          .collection('posts')
          .where("isDeleted", isNotEqualTo: true)
          .orderBy("isDeleted", descending: true)
          .orderBy("createdAt", descending: true)
          .snapshots();
}

StreamBuilder(
    stream: _getPostsStream(),
    builder: (context, snapshot) {
      if (snapshot.hasError) {
        // handle error
      }

      if (snapshot.connectionState == ConnectionState.waiting) {
        return const Center(child: CircularProgressIndicator());
      }

      List<Widget> postCards = [];
      for (int index = 0;
          index < snapshot.data!.docs.length;
          index++) {
        final post = Post.fromJson(snapshot.data!.docs[index]
            .data() as Map<String, dynamic>);
        posts.add(post);
        postCards.add(PostCard(
          item: post,
        ));
      }

      postCards.add(_buildLoadingButton(snapshot.data));

      return ListView(
          padding: const EdgeInsets.fromLTRB(0, 0, 0, 80),
          physics: const AlwaysScrollableScrollPhysics(),
          children: postCards);
    })

    final image = await ImagePicker().pickImage(source: ImageSource.gallery);

    if (image != null) {
      final imageFile = await image.readAsBytes();
      
      ...
    } 

// select an image
final image = await ImagePicker().pickImage(source: source);

if (image != null) {
  final imageFile = await image.readAsBytes();

	// upload the image
  final task = uploadFile(imageFile, image.name);

  task.snapshotEvents.listen((event) async {
    if (event.state == TaskState.success) {
	    // get the download url of the uploaded image
      _imagePath = await event.ref.getDownloadURL();
    } else if (event.state == TaskState.error) {
			// Handle error
    }
  });
}

// upload an image to Firebase Storage
// you need to pass in the file content and the name like "myImage.jpg"
UploadTask uploadFile(Uint8List file, String fileName) {
  final ref = FirebaseStorage.instance.ref();

  final child = ref.child("images/$fileName");
  return child.putData(file);
}

// add a new post to a Firebase Firestore collection
Future<Post> addPost(String text, String imageId, Guest author) async {
  final docRef = FirebaseFirestore.instance.collection("posts").doc();
  final newPost = Post(
      id: docRef.id,
      author: author,
      comments: const <PostComment>[],
      likes: const <Guest>[],
      updatedAt: DateTime.now(),
      createdAt: DateTime.now(),
      text: text,
      isDeleted: false,
      imageId: imageId);

  await FirebaseFirestore.instance
      .collection("posts")
      .doc(docRef.id)
      .set(newPost.toJson());

  return newPost;
}

Future addComment(Post post, PostComment comment) async {
  post.comments.add(comment);

	// this creates a new copy with the last updated timestamp set to now
  final postCopy = post.update();

  await FirebaseFirestore.instance
      .collection("posts")
      .doc(postCopy.id)
      .update(postCopy.toJson());
}

Future likePost(Post post, Guest guest) async {
  post.likes.add(guest);

	// this creates a new copy with the last updated timestamp set to now
  final postCopy = post.update();

  await FirebaseFirestore.instance
      .collection("posts")
      .doc(postCopy.id)
      .update(postCopy.toJson());
}

Future deletePost(Post post) async {
  final newPost = Post(
      id: post.id,
      author: post.author,
      comments: post.comments,
      likes: post.likes,
      updatedAt: DateTime.now(),
      createdAt: post.createdAt,
      text: post.text,
      isDeleted: true, // <-- here is the relevant flag
      imageId: post.imageId);

  await FirebaseFirestore.instance
      .collection("posts")
      .doc(post.id)
      .set(newPost.toJson());
}

// find all posts where the user is author, has liked, or has commented
// then we update the author information, the like information, or the comment 
// information if our user matches
Future updateGuestInPosts(
    List<Post> allPosts, Guest oldGuest, Guest newGuest) async {
  final postsToUpdate = allPosts
      .where((post) =>
          post.author == oldGuest ||
          post.comments.any((comment) => comment.author == oldGuest) ||
          post.likes.any((like) => like == oldGuest))
      .toList();

  for (var post in postsToUpdate) {
    final newPost = Post(
        id: post.id,
        text: post.text,
        author: post.author == oldGuest ? newGuest : oldGuest,
        createdAt: post.createdAt,
        updatedAt: DateTime.now(),
        isDeleted: post.isDeleted,
        imageId: post.imageId,
        likes: _replaceLikes(post, oldGuest, newGuest),
        comments: _replaceComments(post.comments, oldGuest, newGuest));

    await FirebaseFirestore.instance
        .collection("posts")
        .doc(newPost.id)
        .set(newPost.toJson());
  }
}

List<Guest> _replaceLikes(Post post, Guest oldGuest, Guest newGuest) {
  final index = post.likes.indexOf(oldGuest);

  if (index == -1) return post.likes;

  post.likes.removeAt(index);
  post.likes.insert(index, newGuest);

  return post.likes;
}

List<PostComment> _replaceComments(
    List<PostComment> comments, Guest oldGuest, Guest newGuest) {
  return comments
      .map((comment) => PostComment(
          id: comment.id,
          text: comment.text,
          createdAt: comment.createdAt,
          author: comment.author == oldGuest ? newGuest : oldGuest))
      .toList();
}