gengitkan/client/src/store/sagas/kanboards.ts

import { select, put } from 'redux-saga/effects';
import { fetchIssues, addLabel, removeLabel } from '../actions/issues';
import { fetchIssuesSaga } from './issues';
import { BUILD_KANBOARD_SUCCESS, buildKanboard, BUILD_KANBOARD_FAILURE } from '../actions/kanboards';
import { Project, Issue } from '../../types/gitea';
import { Board, BoardLane } from '../../types/board';
import { KanboardLane, Kanboard, KanboardCard } from '../../types/kanboard';

export function* moveCardSaga(action: any) {
  const {
    boardID, fromLaneID,
    fromPosition, toLaneID,
    toPosition,
  } = action;

  if (fromLaneID === toLaneID) return;

  const { board, kanboard } = yield select(state => {
    return {
      kanboard: state.kanboards.byID[boardID],
      board: state.boards.byID[boardID]
    }
  });

  const toLane = kanboard.columns[toLaneID];
  const card = toLane.cards[toPosition];

  if (!card) return;

  yield put(addLabel(card.project, card.issue.number, board.lanes[toLaneID].issueLabel));
  yield put(removeLabel(card.project, card.issue.number, board.lanes[fromLaneID].issueLabel));

}

export function* buildKanboardSaga(action: any) {
  const { board, milestones } = action;
  console.log("milestones", milestones);
  let kanboard;
  try {

    for (let p, i = 0; (p = board.projects[i]); i++) {
      const { project } = yield fetchIssues(p, milestones);
      yield fetchIssuesSaga({ project: project, milestones: milestones });
    }

    const issues = yield select(state => state.issues);

    kanboard = createKanboard(board, issues);

  } catch (error) {
    yield put({ type: BUILD_KANBOARD_FAILURE, error });
    return
  }

  yield put({ type: BUILD_KANBOARD_SUCCESS, kanboard });
}

export function* refreshKanboardSaga(action: any) {
  const { project, milestones } = action;
  const boards = yield select(state => state.boards);
  const boardValues = Object.values(boards.byID);

  for (let b: any, i = 0; (b = boardValues[i]); i++) {
    const hasProject = b.projects.indexOf(project) !== -1;
    if (!hasProject) continue;
    yield put(buildKanboard(b, milestones));
  }
}

function createCards(projects: Project[], issues: any, lane: BoardLane, rest: Set<KanboardCard>) {
  const cards: KanboardCard[] = projects.reduce((laneCards, p) => {

    const projectIssues = p in issues.byProject ? issues.byProject[p] : [];

    return projectIssues.reduce((projectCards: KanboardCard[], issue: any) => {

      const hasLabel = issue.labels.some((l: any) => l.name === lane.issueLabel);
      const { card, memoized } = getMemoizedKanboardCard(issue.id, issue.title, p, issue);

      if (hasLabel) {
        projectCards.push(card);
        rest.delete(card);
      } else {
        if (!memoized) rest.add(card);
      }

      return projectCards;

    }, laneCards);

  }, []);

  return cards;
}

const kanboardCardMemo: { [key: string]: KanboardCard } = {};

function getKanboardCardMemoizationKey(id: number, project: Project, issue: Issue) {
  return `${project.id}-${issue.id}-${id}`;
}

function isKanboardCardMemoized(key: string) {
  return kanboardCardMemo.hasOwnProperty(key)
}

function getMemoizedKanboardCard(id: number, title: string, project: Project, issue: Issue) {
  const key = getKanboardCardMemoizationKey(id, project, issue);
  if (isKanboardCardMemoized(key)) return { card: kanboardCardMemo[key], memoized: true };
  kanboardCardMemo[key] = { id, title, project, issue };
  return { card: kanboardCardMemo[key], memoized: false };
}

function resetKandboarCardMemo() {
  Object.keys(kanboardCardMemo).forEach(k => delete kanboardCardMemo[k]);
}

function createKanboardLanes(board: Board, issues: any): KanboardLane[] {
  const lanes: KanboardLane[] = [];
  const rest = new Set<KanboardCard>();

  resetKandboarCardMemo();

  board.lanes.forEach((l: BoardLane, i: number) => {
    const cards = createCards(board.projects, issues, l, rest);
    lanes.push({
      id: i,
      title: l.title,
      cards,
    });
  });

  // Assign remaining issues
  board.lanes.forEach((l: BoardLane, i: number) => {
    if (!l.collectRemainingIssues) return;
    lanes[i].cards.push(...Array.from(rest.values()));
  });

  resetKandboarCardMemo();

  return lanes;
}

function createKanboard(board: Board, issues: any) {
  if (!board) return null;

  const kanboard = {
    id: board.id,
    columns: createKanboardLanes(board, issues),
  };

  return kanboard;
}