Function updateTask

models/tasks.js:71–122

(taskData, taskId = null)

 * @return {Promise<{taskId: string}>}
 */
const updateTask = async (taskData, taskId = null) => {
  try {
    taskData = await toFirestoreData(taskData);
    if (taskId) {
      const task = await tasksModel.doc(taskId).get();
      if (taskData?.assignee && task.data().status === TASK_STATUS.AVAILABLE) {
        taskData = { ...taskData, status: TASK_STATUS.ASSIGNED };
      }
      if (taskData.status === "VERIFIED") {
        taskData = { ...taskData, endsOn: Math.floor(Date.now() / 1000) };
      }
      const { dependsOn, ...taskWithoutDependsOn } = taskData;
      await tasksModel.doc(taskId).set({
        ...task.data(),
        ...taskWithoutDependsOn,
      });
      if (dependsOn) {
        await firestore.runTransaction(async (transaction) => {
          const dependencyQuery = dependencyModel.where("taskId", "==", taskId);
          const existingDependenciesSnapshot = await transaction.get(dependencyQuery);
          const existingDependsOnIds = existingDependenciesSnapshot.docs.map((doc) => doc.data().dependsOn);
          const newDependencies = dependsOn.filter((dependency) => !existingDependsOnIds.includes(dependency));
          if (newDependencies.length > 0) {
            for (const dependency of newDependencies) {
              const dependencyDoc = await tasksModel.doc(dependency).get();
              if (dependencyDoc.exists) {
                const taskDependsOn = {
                  taskId: taskId,
                  dependsOn: dependency,
                };
                const docRef = dependencyModel.doc();
                transaction.set(docRef, taskDependsOn);
              } else {
                throw new Error("Invalid dependency passed");
              }
            }
          }
        });
      }
      return { taskId };
    }
    const taskInfo = await tasksModel.add(taskData);
    const result = {
      taskId: taskInfo.id,
      taskDetails: await fromFirestoreData(taskData),
    };
    return result;
  } catch (err) {
    logger.error("Error in updating task", err);
    throw err;
  }
};
const addDependency = async (data) => {
  try {
    const { taskId, dependsOn } = data;