Connect Ajou

Text.defaultProps = Text.defaultProps || {};
Text.defaultProps.allowFontScaling = false;

async function registerForPushNotification() {
let token;
if (Constants.isDevice) {
    const { status: existingStatus } =
    await Notifications.getPermissionsAsync();
    let finalStatus = existingStatus;
    if (existingStatus !== "granted") {
    const { status } = await Notifications.requestPermissionsAsync();
    finalStatus = status;
    }
    if (finalStatus !== "granted") {
    alert("Failed to get push token for push notification!");
    return;
    }
    token = (await Notifications.getExpoPushTokenAsync()).data;
    console.log(token);
} else {
    alert("Must use physical device for Push Notifications");
}

firebase
   .auth()
   .createUserWithEmailAndPassword(email, password)
   .then((response) => {
     const uid = response.user.uid;
     const data = {
       email,
       fullName,
       picture,
       url,
       myCourses,
     };

const usersRef = firebase.firestore().collection("users");
usersRef
  .doc(email)
  .set(data)
  .then(() => {
    setReRendering(isReRendering + 1);
  })
  .catch((error) => {
    console.error("Error: ", error);
  });

const favoritesRef = firebase.firestore().collection("favorites");
favoritesRef.doc(email).set(
  {
    selectedItemsArray: [],
  },
  { merge: true }
);

allCommunities.forEach((element) => {
  favoritesRef
    .doc(email)
    .collection("all")
    .doc(element)
    .set({}, { merge: true });
});

favoritesRef.doc(email).collection("selectedItems").add({});

const curUserEmail = firebase.auth().currentUser.providerData[0].email;
const unsubscribe = firebase
  .firestore()
  .collection("users")
  .doc(curUserEmail)
  .onSnapshot((snapshot) => {
    const getUser = snapshot.data();
    setUser(getUser);
    if (!getUser.myCourses.length) {
      return () => {
        unsubscribe();
      };
    }

getUser.myCourses.forEach((course) => {
  let background = randomHex();
  const courseRef = firebase.firestore().collection("courses").doc(course);
  courseRef.get().then((doc) => {
    const getMyCourse = doc.data();
    let array_of_schedules = splitSchedule(getMyCourse.schedule);
    for (var i = 0; i < array_of_schedules.length; i++) {
      let day = array_of_schedules[i].substr(0, 3);
      let time = array_of_schedules[i].substr(4, 1);
      let row = matchTime(time);
      let column = matchDays(day);
      if (isSelected[row][column] == "#FFFFFF") {
        isSelected[row][column] = background;
        courseName[row][column] = getMyCourse.name;
      }
    }
  });
});

const getSelectedItems = firebase
  .firestore()
  .collection("favorites")
  .doc(curUserEmail)
  .collection("selectedItems")
  .orderBy("createdAt", "desc")
  .onSnapshot((querySnapshot) => {
    const selectedItems = querySnapshot.docs.map((docSnapshot) => {
      const selectedItem = {
        _id: docSnapshot.id,
        ...docSnapshot.data(),
      };
      return selectedItem;
    });
    setSelectedItems(selectedItems);
  });

const pick = (community) => {
  let tempSelectedItems = selectedItemsArray;
  const index = tempSelectedItems.indexOf(community._id);
  if (index > -1) {
    tempSelectedItems.splice(index, 1);
  } else {
    tempSelectedItems.push(community._id);
  }
  setSelectedItemsArray(tempSelectedItems);
  setReRendering(isReRendering + 1);
};

{
  selectedItemsArray.includes(item._id) ? (
    <MaterialIcons
      name="check-box"
      size={24}
      color="black"
      style={style.communityIcon}
    />
  ) : (
    <MaterialIcons
      name="check-box-outline-blank"
      size={24}
      color="black"
      style={style.communityIcon}
    />
  );
}

selectedItemsArray.forEach((item) => {
  selectedItemsRef
    .doc(item)
    .set(
      {
        createdAt: new Date().getTime(),
      },
      { merge: true }
    )
    .catch(function (error) {
      console.error("Error: ", error);
    });
});

firebase
  .firestore()
  .collection("favorites")
  .doc(user.email)
  .set(
    {
      selectedItemsArray: selectedItemsArray,
    },
    { merge: true }
  )
  .catch(function (error) {
    console.error("Error: ", error);
  });

function getHeaderTitle(route) {
  const routeName = getFocusedRouteNameFromRoute(route) ?? "All";

  switch (routeName) {
    case "All":
      return "All";
    case "Info":
      return "Info";
    case "Campus":
      return "Campus";
    case "Friends":
      return "Friends";
  }
}

const getData = db.onSnapshot((querySnapshot) => {
  const writings = querySnapshot.docs.map((docSnapshot) => {
    const data = {
      _id: docSnapshot.id,
      ...docSnapshot.data(),
    };
    return data;
  });
  setWriting(writings);
});

<ScrollView style={style.container}>
    {writing.map((writing) => (
      <TouchableOpacity
        onPress={() => {
          navigation.push("See", {
            extraData: user,
            data: writing,
            listName: listName,
          });
        }}
        key={writing._id}
      >
        <Card style={style.box}>

const onSubmit = async (event) => {
  firebase
    .firestore()
    .collection(listName)
    .doc(title)
    .set({
      _id: Math.random().toString(36).slice(2),
      title: title,
      content: content,
      creator: user,
      createdAt: Date.now(),
      like: [],
      comments: [],
    })
    .then(() => {
      navigation.goBack();
    });
  setTitle("");
  setContent("");
};

const fetchWriting = () => {
  if (writing) {
    setWriting([]);
  }
  listRf
    .where("title", "<=", search)
    .get()
    .then((querySnapshot) => {
      querySnapshot.forEach((doc) => {
        const data = doc.data();
        setWriting((prev) => [data, ...prev]);
      });
    });

  setisSearch(false);
};

<Right>
        <TouchableOpacity
          onPress={() => {
            fetchWriting();
            setisSearch(true);
          }}
        >
          <Feather name="search" size={30} />
        </TouchableOpacity>
      </Right>
};

function getData() {
  const dbCom = firebase.firestore().collection(listName).doc(writing.title);
  dbCom.onSnapshot((doc) => {
    if (doc.data() !== undefined) {
      const data = doc.data().comments;
      setAllComment(data);
      const likeList = doc.data().like;
      setCurrentLike(likeList);
    }
  });
}

const reWritingUpdate = () => {
  firebase
    .firestore()
    .collection(listName)
    .doc(writing.title)
    .get()
    .then((doc) => {
      firebase.firestore().collection(listName).doc(reTitle).set(
        {
          title: reTitle,
          content: reContent,
          comments: doc.data().comments,
          createdAt: doc.data().createdAt,
          creator: doc.data().creator,
          like: doc.data().like,
        },
        { merge: true }
      );
    });
  firebase.firestore().collection(listName).doc(writing.title).delete();
  setReModal(false);
  setModalVisible(false);
  navigation.goBack();
};

onPress: () => {
            firebase
              .firestore()
              .collection(listName)
              .doc(writing.title)
              .update({
                comments: firebase.firestore.FieldValue.arrayRemove(comment),
              });
          },

const handleClickCourse = (courseName, row, col) => {
  Alert.alert("Do you want to remove this course?", courseName, [
    {
      text: "No",
      onPress: () => console.log("No"),
    },
    {
      text: "Yes",
      onPress: () => {
        console.log("Yes");
        removeBackground(isSelected[row][col]);
        let selected_code = getCourseCode(courseName);
        update_array = myCourses.filter(
          (element) => element !== selected_code
        );
        userRef
          .set(
            {
              myCourses: update_array,
            },
            { merge: true }
          )
          .catch(function (error) {
            console.error("Error: ", error);
          });
      },
      style: "destructive",
    },
  ]);
};

const handlePickCourse = (schedule, code, name) => {
  console.log("handling");
  let array_of_schedules = splitSchedule(schedule);
  setBackground(randomHex());
  for (var i = 0; i < array_of_schedules.length; i++) {
    let day = array_of_schedules[i].substr(0, 3);
    let time = array_of_schedules[i].substr(4, 1);
    if (isSelected[matchTime(time)][matchDays(day)] != "#FFFFFF") {
      Alert.alert("Duplicate Entry");
      return;
    }
    isSelected[matchTime(time)][matchDays(day)] = background;
    courseName[matchTime(time)][matchDays(day)] = name;
  }
  let update_array = myCourses;
  update_array.push(code);
  userRef
    .set(
      {
        myCourses: update_array,
      },
      { merge: true }
    )
    .catch(function (error) {
      console.error("Error: ", error);
    });
};

<ScrollView>
  {courses.map((course) => (
    <TouchableOpacity
      onPress={() =>
        handlePickCourse(course.schedule, course.code, course.name)
      }
      key={course.code}
    >
      <CourseItem
        name={course.name}
        prof={course.prof}
        schedule={course.schedule}
        credits={course.credits}
        code={course.code}
      />
    </TouchableOpacity>
  ))}
</ScrollView>

const unsubscribe = firebase
  .firestore()
  .collection("notification")
  .orderBy("createdAt", "desc")
  .onSnapshot((querySnapshot) => {
    if (querySnapshot.size) {
      const notices = querySnapshot.docs.map((docSnapshot) => {
        return {
          ...docSnapshot.data(),
        };
      });
      setData(notices);
    } else {
      console.log("No such document!");
    }
  });

const noticeClick = async (item) => {
  Linking.canOpenURL(item.url).then((supported) => {
    if (supported) {
      Linking.openURL(item.url);
    } else {
      Linking.openURL(
        "https://www.ajou.ac.kr/oia/notice/notice.do?mode=list&srCategoryId=108&srSearchKey=&srSearchVal="
      );
    }
  });

return (
  <View style={style.container}>
    <FlatList
      data={data}
      renderItem={renderItem}
      keyExtractor={(item) => item.id.toString()}
      contentContainerStyle={style.list}
    />
  </View>
);

const renderItem = ({ item }) => {
  const isRead = item.isRead;

  return (
    <TouchableOpacity
      style={[style.box, isRead ? style.boxRead : style.boxUnRead]}
      onPress={() => noticeClick(item)}
    >
      <View style=>
        <Text style={style.title}>{item.title}</Text>
        <Text style={style.time}>{calculateTime(item.createdAt)}</Text>
      </View>
      <Text style={style.content}>{item.content}</Text>
    </TouchableOpacity>
  );
};

const unsubscribe = firebase
  .firestore()
  .collection("chat")
  .orderBy("latestMessage.createdAt", "desc")
  .onSnapshot((snapshot) => {
    const threads = [];
    snapshot.docs.map((docSnapshot) => {
      if (
        docSnapshot.data().user.email == user.email ||
        docSnapshot.data().target.email == user.email
      ) {
        let thread = {
          _id: docSnapshot.data().target.email,
          ...docSnapshot.data(),
        };
        threads.push(thread);
      }
    });

    setThreads(threads);
    setReRendering(isReRendering + 1);
  });

const moveToChat = (item) => {
  navigation.navigate("Chat", { thread: item, user: user });
};

const unsubscribe = firebase
  .firestore()
  .collection("chat")
  .doc(thread._id)
  .collection("messages")
  .orderBy("createdAt", "desc")
  .onSnapshot((snapshot) => {
    const messages = snapshot.docs.map((docSnapshot) => {
      const data = {
        _id: docSnapshot.id,
        text: "",
        createdAt: new Date().getTime(),
        ...docSnapshot.data(),
      };
      if (!docSnapshot.data().system) {
        data.user = {
          ...docSnapshot.data().user,
          name: docSnapshot.data().user.fullName,
        };
      }
      return data;
    });

    setMessages(messages);
  });

return (
  <GiftedChat
    messages={messages}
    onSend={onSend}
    user=
    renderAvatar={null}
    showAvatarForEveryMessage={true}
    alwaysShowSend={true}
    renderBubble={renderBubble}
  />
);

async function onSend(messages) {
  const text = messages[0].text;

  firebase
    .firestore()
    .collection("chat")
    .doc(thread._id)
    .collection("messages")
    .add({
      text,
      createdAt: new Date().getTime(),
      user: {
        _id: user.email,
        name: user.fullName,
      },
    });

  await firebase
    .firestore()
    .collection("chat")
    .doc(thread._id)
    .set(
      {
        latestMessage: {
          text,
          createdAt: new Date().getTime(),
        },
      },
      { merge: true }
    );
}

usersRef.get().then((doc) => {
  const getuser = doc.data();
  if (getuser.picture) {
    setPicture(true);
    const storageRef = firebase.storage().ref(`${user.email}`);
    storageRef
      .getDownloadURL()
      .then((url) => {
        setUrl(url);
      })
      .catch((error) => {
        console.error("Error updating document: ", error);
      });
  }
});

const uploadImageToStorage = async (path, imageName) => {
  const response = await fetch(path);
  const blob = await response.blob();
  const ref = firebase.storage().ref().child(imageName);
  return ref.put(blob);
};

onPress: () => {
         console.log("Yes");
         setPicture(false);
         setUrl("");
         const storageRef = firebase.storage().ref(`${user.email}`);
         storageRef
           .delete()
           .then(() => {
             console.log("Your profile has been reset");
           })
           .catch((error) => {
             console.error("Error updating document: ", error);
           });

         usersRef
           .set({ picture: false, url: "" }, { merge: true })
           .then(() => {
             console.log("Document successfully updated!");
             setReRendering(isReRendering + 1);
           })
           .catch((error) => {
             console.error("Error updating document: ", error);
           });
       },

firebase
  .auth()
  .signOut()
  .then(() => {
    console.log("Sign-out successful");
    Update.reloadAsync();
  })
  .catch((error) => {
    console.log("Error: ", error);
  });