guesstimate/client/src/hooks/useProjectReducer.sagas.ts

import { all, select, takeLatest, put, delay } from "redux-saga/effects";
import { client } from '../gql/client';
import { 
  MUTATION_CREATE_PROJECT, MUTATION_UPDATE_PROJECT_TITLE, 
  MUTATION_ADD_PROJECT_TASK, MUTATION_REMOVE_PROJECT_TASK, 
  MUTATION_UPDATE_PROJECT_TASK, MUTATION_UPDATE_PROJECT_PARAMS, 
  MUTATION_ADD_PROJECT_TASK_CATEGORY, 
  MUTATION_UPDATE_PROJECT_TASK_CATEGORY,
  MUTATION_REMOVE_PROJECT_TASK_CATEGORY
} from "../gql/mutations/project";
import { 
  UPDATE_PROJECT_TITLE, resetProject, 
  ADD_TASK, taskSaved, AddTask, 
  taskRemoved, RemoveTask, REMOVE_TASK, 
  UPDATE_TASK_ESTIMATION, UpdateTaskEstimation, 
  UpdateTaskLabel, UPDATE_TASK_LABEL, UpdateParam, 
  paramsSaved, UPDATE_PARAM, AddTaskCategory, 
  ADD_TASK_CATEGORY, taskCategorySaved, UpdateTaskCategoryLabel, UPDATE_TASK_CATEGORY_LABEL, UPDATE_TASK_CATEGORY_COST, updateTaskCategoryCost, UpdateTaskCategoryCost, RemoveTaskCategory, taskCategoryRemoved, REMOVE_TASK_CATEGORY, backendError 
} from "./useProjectReducer";
import { Project } from "../types/project";

export function* rootSaga() {
  yield all([
    createProjectSaga(),
    takeLatest(UPDATE_PROJECT_TITLE, updateProjectTitleSaga),
    takeLatest(UPDATE_TASK_ESTIMATION, updateTaskEstimationSaga),
    takeLatest(UPDATE_TASK_LABEL, updateTaskLabelSaga),
    takeLatest(UPDATE_PARAM, updateProjectParamsSaga),
    takeLatest(ADD_TASK, addTaskSaga),
    takeLatest(REMOVE_TASK, removeTaskSaga),
    takeLatest(ADD_TASK_CATEGORY, addProjectTaskCategorySaga),
    takeLatest(UPDATE_TASK_CATEGORY_LABEL, updateProjectTaskCategoryLabelSaga),
    takeLatest(UPDATE_TASK_CATEGORY_COST, updateProjectTaskCategoryCostSaga),
    takeLatest(REMOVE_TASK_CATEGORY, removeProjectTaskCategorySaga),
  ]);
}

export function* updateProjectTitleSaga() {
  let project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }

  yield client.mutate({
    mutation: MUTATION_UPDATE_PROJECT_TITLE,
    variables: {
      projectId: project.id,
      title: project.title,
    }
  });
}

export function* createProjectSaga() {
  const project: Project = yield select();

  if (project.id !== undefined) return;
  
  const { data } = yield client.mutate({
    mutation: MUTATION_CREATE_PROJECT,
    variables: {
      changes: {
        title: project.title,
      }
    }
  });

  yield put(resetProject(data.createProject));

  return yield select();
}

export function* addTaskSaga({ task }: AddTask) {
  let project: Project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }
  
  const { data } = yield client.mutate({
    mutation: MUTATION_ADD_PROJECT_TASK,
    variables: {
      projectId: project.id,
      changes: {
        label: task.label,
        categoryId: task.category ? task.category.id : -1,
        estimations: {
          optimistic: task.estimations.optimistic,
          likely: task.estimations.likely,
          pessimistic: task.estimations.pessimistic,
        }
      }
    }
  });

  yield put(taskSaved({ ...task, ...data.addProjectTask }));
}

export function* removeTaskSaga({ id }: RemoveTask) {
  let project: Project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }
  
  yield client.mutate({
    mutation: MUTATION_REMOVE_PROJECT_TASK,
    variables: {
      projectId: project.id,
      taskId: id,
    }
  });

  yield put(taskRemoved(id));
}

export function* updateTaskEstimationSaga({ id, confidence, value }: UpdateTaskEstimation) {
  let project: Project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }
  
  const { data } = yield client.mutate({
    mutation: MUTATION_UPDATE_PROJECT_TASK,
    variables: {
      projectId: project.id,
      taskId: id,
      changes: {
        estimations: {
          [confidence]: value,
        }
      }
    }
  });

  yield put(taskSaved({ ...data.updateProjectTask }));
}

export function* updateTaskLabelSaga({ id, label }: UpdateTaskLabel) {
  let project: Project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }
  
  const { data } = yield client.mutate({
    mutation: MUTATION_UPDATE_PROJECT_TASK,
    variables: {
      projectId: project.id,
      taskId: id,
      changes: {
        label,
      }
    }
  });

  yield put(taskSaved({ ...data.updateProjectTask }));
}

export function* updateProjectParamsSaga({ name, value }: UpdateParam) {
  yield delay(500);
  
  let project: Project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }

  if (typeof value === 'object') {
    delete value.__typename;
  }
  
  const { data } = yield client.mutate({
    mutation: MUTATION_UPDATE_PROJECT_PARAMS,
    variables: {
      projectId: project.id,
      changes: {
        [name]: value,
      }
    }
  });

  yield put(paramsSaved({ ...data.updateProjectParams }));
}

export function* addProjectTaskCategorySaga({ taskCategory }: AddTaskCategory) {
  let project: Project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }
  
  const { data } = yield client.mutate({
    mutation: MUTATION_ADD_PROJECT_TASK_CATEGORY,
    variables: {
      projectId: project.id,
      changes: {
        label: taskCategory.label,
        costPerTimeUnit: taskCategory.costPerTimeUnit,
      }
    }
  });

  yield put(taskCategorySaved({ ...data.addProjectTaskCategory }));
}

export function* updateProjectTaskCategoryLabelSaga({ categoryId, label }: UpdateTaskCategoryLabel) {
  let project: Project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }
  
  const { data } = yield client.mutate({
    mutation: MUTATION_UPDATE_PROJECT_TASK_CATEGORY,
    variables: {
      projectId: project.id,
      taskCategoryId: categoryId,
      changes: {
        label,
      }
    }
  });

  yield put(taskCategorySaved({ ...data.updateProjectTaskCategory }));
}

export function* updateProjectTaskCategoryCostSaga({ categoryId, costPerTimeUnit }: UpdateTaskCategoryCost) {
  let project: Project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }
  
  const { data } = yield client.mutate({
    mutation: MUTATION_UPDATE_PROJECT_TASK_CATEGORY,
    variables: {
      projectId: project.id,
      taskCategoryId: categoryId,
      changes: {
        costPerTimeUnit,
      }
    }
  });

  yield put(taskCategorySaved({ ...data.updateProjectTaskCategory }));
}

export function* removeProjectTaskCategorySaga({ taskCategoryId }: RemoveTaskCategory) {
  let project: Project = yield select();

  if (project.id === undefined) {
    project = yield createProjectSaga();
  }
  
  try {
    yield client.mutate({
      mutation: MUTATION_REMOVE_PROJECT_TASK_CATEGORY,
      variables: {
        projectId: project.id,
        taskCategoryId,
      }
    });
  } catch(err) {
    yield put(backendError(err));
    return
  }
  

  yield put(taskCategoryRemoved(taskCategoryId));
}