890 lines
25 KiB
JavaScript
890 lines
25 KiB
JavaScript
import * as Sentry from '@sentry/browser';
|
|
import { sortBy } from 'lodash';
|
|
import {
|
|
BoardType,
|
|
ListType,
|
|
inactiveId,
|
|
flashAnimationDuration,
|
|
ISSUABLE,
|
|
titleQueries,
|
|
subscriptionQueries,
|
|
deleteListQueries,
|
|
listsQuery,
|
|
updateListQueries,
|
|
issuableTypes,
|
|
FilterFields,
|
|
ListTypeTitles,
|
|
DraggableItemTypes,
|
|
} from 'ee_else_ce/boards/constants';
|
|
import {
|
|
formatIssueInput,
|
|
formatBoardLists,
|
|
formatListIssues,
|
|
formatListsPageInfo,
|
|
formatIssue,
|
|
updateListPosition,
|
|
moveItemListHelper,
|
|
getMoveData,
|
|
FiltersInfo,
|
|
filterVariables,
|
|
} from 'ee_else_ce/boards/boards_util';
|
|
import createBoardListMutation from 'ee_else_ce/boards/graphql/board_list_create.mutation.graphql';
|
|
import issueMoveListMutation from 'ee_else_ce/boards/graphql/issue_move_list.mutation.graphql';
|
|
import totalCountAndWeightQuery from 'ee_else_ce/boards/graphql/board_lists_deferred.query.graphql';
|
|
import { getIdFromGraphQLId } from '~/graphql_shared/utils';
|
|
import { convertObjectPropsToCamelCase } from '~/lib/utils/common_utils';
|
|
import { queryToObject } from '~/lib/utils/url_utility';
|
|
import { s__ } from '~/locale';
|
|
import { gqlClient } from '../graphql';
|
|
import projectBoardQuery from '../graphql/project_board.query.graphql';
|
|
import groupBoardQuery from '../graphql/group_board.query.graphql';
|
|
import boardLabelsQuery from '../graphql/board_labels.query.graphql';
|
|
import groupBoardMilestonesQuery from '../graphql/group_board_milestones.query.graphql';
|
|
import groupProjectsQuery from '../graphql/group_projects.query.graphql';
|
|
import issueCreateMutation from '../graphql/issue_create.mutation.graphql';
|
|
import listsIssuesQuery from '../graphql/lists_issues.query.graphql';
|
|
import projectBoardMilestonesQuery from '../graphql/project_board_milestones.query.graphql';
|
|
|
|
import * as types from './mutation_types';
|
|
|
|
export default {
|
|
fetchBoard: ({ commit, dispatch }, { fullPath, fullBoardId, boardType }) => {
|
|
const variables = {
|
|
fullPath,
|
|
boardId: fullBoardId,
|
|
};
|
|
|
|
return gqlClient
|
|
.query({
|
|
query: boardType === BoardType.group ? groupBoardQuery : projectBoardQuery,
|
|
variables,
|
|
})
|
|
.then(({ data }) => {
|
|
const board = data.workspace?.board;
|
|
commit(types.RECEIVE_BOARD_SUCCESS, board);
|
|
dispatch('setBoardConfig', board);
|
|
})
|
|
.catch(() => commit(types.RECEIVE_BOARD_FAILURE));
|
|
},
|
|
|
|
setInitialBoardData: ({ commit }, data) => {
|
|
commit(types.SET_INITIAL_BOARD_DATA, data);
|
|
},
|
|
|
|
setBoardConfig: ({ commit }, board) => {
|
|
const config = {
|
|
milestoneId: board.milestone?.id || null,
|
|
milestoneTitle: board.milestone?.title || null,
|
|
iterationId: board.iteration?.id || null,
|
|
iterationTitle: board.iteration?.title || null,
|
|
assigneeId: board.assignee?.id || null,
|
|
assigneeUsername: board.assignee?.username || null,
|
|
labels: board.labels?.nodes || [],
|
|
labelIds: board.labels?.nodes?.map((label) => label.id) || [],
|
|
weight: board.weight,
|
|
};
|
|
commit(types.SET_BOARD_CONFIG, config);
|
|
},
|
|
|
|
setActiveId({ commit }, { id, sidebarType }) {
|
|
commit(types.SET_ACTIVE_ID, { id, sidebarType });
|
|
},
|
|
|
|
unsetActiveId({ dispatch }) {
|
|
dispatch('setActiveId', { id: inactiveId, sidebarType: '' });
|
|
},
|
|
|
|
setFilters: ({ commit, state: { issuableType } }, filters) => {
|
|
commit(
|
|
types.SET_FILTERS,
|
|
filterVariables({
|
|
filters,
|
|
issuableType,
|
|
filterInfo: FiltersInfo,
|
|
filterFields: FilterFields,
|
|
}),
|
|
);
|
|
},
|
|
|
|
performSearch({ dispatch }) {
|
|
dispatch(
|
|
'setFilters',
|
|
convertObjectPropsToCamelCase(queryToObject(window.location.search, { gatherArrays: true })),
|
|
);
|
|
dispatch('fetchLists');
|
|
dispatch('resetIssues');
|
|
},
|
|
|
|
fetchLists: ({ commit, state, dispatch }) => {
|
|
const { boardType, filterParams, fullPath, fullBoardId, issuableType } = state;
|
|
|
|
const variables = {
|
|
fullPath,
|
|
boardId: fullBoardId,
|
|
filters: filterParams,
|
|
...(issuableType === issuableTypes.issue && {
|
|
isGroup: boardType === BoardType.group,
|
|
isProject: boardType === BoardType.project,
|
|
}),
|
|
};
|
|
|
|
return gqlClient
|
|
.query({
|
|
query: listsQuery[issuableType].query,
|
|
variables,
|
|
})
|
|
.then(({ data }) => {
|
|
const { lists, hideBacklogList } = data[boardType]?.board;
|
|
commit(types.RECEIVE_BOARD_LISTS_SUCCESS, formatBoardLists(lists));
|
|
// Backlog list needs to be created if it doesn't exist and it's not hidden
|
|
if (!lists.nodes.find((l) => l.listType === ListType.backlog) && !hideBacklogList) {
|
|
dispatch('createList', { backlog: true });
|
|
}
|
|
})
|
|
.catch(() => commit(types.RECEIVE_BOARD_LISTS_FAILURE));
|
|
},
|
|
|
|
highlightList: ({ commit, state }, listId) => {
|
|
if ([ListType.backlog, ListType.closed].includes(state.boardLists[listId].listType)) {
|
|
return;
|
|
}
|
|
|
|
commit(types.ADD_LIST_TO_HIGHLIGHTED_LISTS, listId);
|
|
|
|
setTimeout(() => {
|
|
commit(types.REMOVE_LIST_FROM_HIGHLIGHTED_LISTS, listId);
|
|
}, flashAnimationDuration);
|
|
},
|
|
|
|
createList: ({ dispatch }, { backlog, labelId, milestoneId, assigneeId }) => {
|
|
dispatch('createIssueList', { backlog, labelId, milestoneId, assigneeId });
|
|
},
|
|
|
|
createIssueList: (
|
|
{ state, commit, dispatch, getters },
|
|
{ backlog, labelId, milestoneId, assigneeId, iterationId },
|
|
) => {
|
|
const { fullBoardId } = state;
|
|
|
|
const existingList = getters.getListByLabelId(labelId);
|
|
|
|
if (existingList) {
|
|
dispatch('highlightList', existingList.id);
|
|
return;
|
|
}
|
|
|
|
gqlClient
|
|
.mutate({
|
|
mutation: createBoardListMutation,
|
|
variables: {
|
|
boardId: fullBoardId,
|
|
backlog,
|
|
labelId,
|
|
milestoneId,
|
|
assigneeId,
|
|
iterationId,
|
|
},
|
|
})
|
|
.then(({ data }) => {
|
|
if (data.boardListCreate?.errors.length) {
|
|
commit(types.CREATE_LIST_FAILURE, data.boardListCreate.errors[0]);
|
|
} else {
|
|
const list = data.boardListCreate?.list;
|
|
dispatch('addList', list);
|
|
dispatch('highlightList', list.id);
|
|
}
|
|
})
|
|
.catch((e) => {
|
|
commit(types.CREATE_LIST_FAILURE);
|
|
throw e;
|
|
});
|
|
},
|
|
|
|
addList: ({ commit, dispatch, getters }, list) => {
|
|
commit(types.RECEIVE_ADD_LIST_SUCCESS, updateListPosition(list));
|
|
|
|
dispatch('fetchItemsForList', {
|
|
listId: getters.getListByTitle(ListTypeTitles.backlog)?.id,
|
|
});
|
|
},
|
|
|
|
fetchLabels: ({ state, commit }, searchTerm) => {
|
|
const { fullPath, boardType } = state;
|
|
|
|
const variables = {
|
|
fullPath,
|
|
searchTerm,
|
|
isGroup: boardType === BoardType.group,
|
|
isProject: boardType === BoardType.project,
|
|
};
|
|
|
|
commit(types.RECEIVE_LABELS_REQUEST);
|
|
|
|
return gqlClient
|
|
.query({
|
|
query: boardLabelsQuery,
|
|
variables,
|
|
})
|
|
.then(({ data }) => {
|
|
const labels = data[boardType]?.labels.nodes;
|
|
|
|
commit(types.RECEIVE_LABELS_SUCCESS, labels);
|
|
return labels;
|
|
})
|
|
.catch((e) => {
|
|
commit(types.RECEIVE_LABELS_FAILURE);
|
|
throw e;
|
|
});
|
|
},
|
|
|
|
fetchMilestones({ state, commit }, searchTerm) {
|
|
commit(types.RECEIVE_MILESTONES_REQUEST);
|
|
|
|
const { fullPath, boardType } = state;
|
|
|
|
const variables = {
|
|
fullPath,
|
|
searchTerm,
|
|
};
|
|
|
|
let query;
|
|
if (boardType === BoardType.project) {
|
|
query = projectBoardMilestonesQuery;
|
|
}
|
|
if (boardType === BoardType.group) {
|
|
query = groupBoardMilestonesQuery;
|
|
}
|
|
|
|
if (!query) {
|
|
// eslint-disable-next-line @gitlab/require-i18n-strings
|
|
throw new Error('Unknown board type');
|
|
}
|
|
|
|
return gqlClient
|
|
.query({
|
|
query,
|
|
variables,
|
|
})
|
|
.then(({ data }) => {
|
|
const errors = data[boardType]?.errors;
|
|
const milestones = data[boardType]?.milestones.nodes;
|
|
|
|
if (errors?.[0]) {
|
|
throw new Error(errors[0]);
|
|
}
|
|
|
|
commit(types.RECEIVE_MILESTONES_SUCCESS, milestones);
|
|
|
|
return milestones;
|
|
})
|
|
.catch((e) => {
|
|
commit(types.RECEIVE_MILESTONES_FAILURE);
|
|
throw e;
|
|
});
|
|
},
|
|
|
|
moveList: (
|
|
{ state: { boardLists }, commit, dispatch },
|
|
{
|
|
item: {
|
|
dataset: { listId: movedListId, draggableItemType },
|
|
},
|
|
newIndex,
|
|
to: { children },
|
|
},
|
|
) => {
|
|
if (draggableItemType !== DraggableItemTypes.list) {
|
|
return;
|
|
}
|
|
|
|
const displacedListId = children[newIndex].dataset.listId;
|
|
if (movedListId === displacedListId) {
|
|
return;
|
|
}
|
|
|
|
const listIds = sortBy(
|
|
Object.keys(boardLists).filter(
|
|
(listId) =>
|
|
listId !== movedListId &&
|
|
boardLists[listId].listType !== ListType.backlog &&
|
|
boardLists[listId].listType !== ListType.closed,
|
|
),
|
|
(i) => boardLists[i].position,
|
|
);
|
|
|
|
const targetPosition = boardLists[displacedListId].position;
|
|
// When the dragged list moves left, displaced list should shift right.
|
|
const shiftOffset = Number(boardLists[movedListId].position < targetPosition);
|
|
const displacedListIndex = listIds.findIndex((listId) => listId === displacedListId);
|
|
|
|
commit(
|
|
types.MOVE_LISTS,
|
|
listIds
|
|
.slice(0, displacedListIndex + shiftOffset)
|
|
.concat([movedListId], listIds.slice(displacedListIndex + shiftOffset))
|
|
.map((listId, index) => ({ listId, position: index })),
|
|
);
|
|
dispatch('updateList', { listId: movedListId, position: targetPosition });
|
|
},
|
|
|
|
updateList: (
|
|
{ state: { issuableType, boardItemsByListId = {} }, dispatch },
|
|
{ listId, position, collapsed },
|
|
) => {
|
|
gqlClient
|
|
.mutate({
|
|
mutation: updateListQueries[issuableType].mutation,
|
|
variables: {
|
|
listId,
|
|
position,
|
|
collapsed,
|
|
},
|
|
})
|
|
.then(({ data }) => {
|
|
if (data?.updateBoardList?.errors.length) {
|
|
throw new Error();
|
|
}
|
|
|
|
// Only fetch when board items havent been fetched on a collapsed list
|
|
if (!boardItemsByListId[listId]) {
|
|
dispatch('fetchItemsForList', { listId });
|
|
}
|
|
})
|
|
.catch(() => {
|
|
dispatch('handleUpdateListFailure');
|
|
});
|
|
},
|
|
|
|
handleUpdateListFailure: ({ dispatch, commit }) => {
|
|
dispatch('fetchLists');
|
|
|
|
commit(
|
|
types.SET_ERROR,
|
|
s__('Boards|An error occurred while updating the board list. Please try again.'),
|
|
);
|
|
},
|
|
|
|
toggleListCollapsed: ({ commit }, { listId, collapsed }) => {
|
|
commit(types.TOGGLE_LIST_COLLAPSED, { listId, collapsed });
|
|
},
|
|
|
|
removeList: ({ state: { issuableType, boardLists }, commit, dispatch, getters }, listId) => {
|
|
const listsBackup = { ...boardLists };
|
|
|
|
commit(types.REMOVE_LIST, listId);
|
|
|
|
return gqlClient
|
|
.mutate({
|
|
mutation: deleteListQueries[issuableType].mutation,
|
|
variables: {
|
|
listId,
|
|
},
|
|
})
|
|
.then(
|
|
({
|
|
data: {
|
|
destroyBoardList: { errors },
|
|
},
|
|
}) => {
|
|
if (errors.length > 0) {
|
|
commit(types.REMOVE_LIST_FAILURE, listsBackup);
|
|
} else {
|
|
dispatch('fetchItemsForList', {
|
|
listId: getters.getListByTitle(ListTypeTitles.backlog)?.id,
|
|
});
|
|
}
|
|
},
|
|
)
|
|
.catch(() => {
|
|
commit(types.REMOVE_LIST_FAILURE, listsBackup);
|
|
});
|
|
},
|
|
|
|
fetchItemsForList: ({ state, commit }, { listId, fetchNext = false }) => {
|
|
if (!listId) return null;
|
|
|
|
if (!fetchNext) {
|
|
commit(types.RESET_ITEMS_FOR_LIST, listId);
|
|
}
|
|
commit(types.REQUEST_ITEMS_FOR_LIST, { listId, fetchNext });
|
|
|
|
const { fullPath, fullBoardId, boardType, filterParams } = state;
|
|
const variables = {
|
|
fullPath,
|
|
boardId: fullBoardId,
|
|
id: listId,
|
|
filters: filterParams,
|
|
isGroup: boardType === BoardType.group,
|
|
isProject: boardType === BoardType.project,
|
|
first: 10,
|
|
after: fetchNext ? state.pageInfoByListId[listId].endCursor : undefined,
|
|
};
|
|
|
|
return gqlClient
|
|
.query({
|
|
query: listsIssuesQuery,
|
|
context: {
|
|
isSingleRequest: true,
|
|
},
|
|
variables,
|
|
})
|
|
.then(({ data }) => {
|
|
const { lists } = data[boardType]?.board;
|
|
const listItems = formatListIssues(lists);
|
|
const listPageInfo = formatListsPageInfo(lists);
|
|
commit(types.RECEIVE_ITEMS_FOR_LIST_SUCCESS, { listItems, listPageInfo, listId });
|
|
})
|
|
.catch(() => commit(types.RECEIVE_ITEMS_FOR_LIST_FAILURE, listId));
|
|
},
|
|
|
|
resetIssues: ({ commit }) => {
|
|
commit(types.RESET_ISSUES);
|
|
},
|
|
|
|
moveItem: ({ dispatch }, payload) => {
|
|
dispatch('moveIssue', payload);
|
|
},
|
|
|
|
moveIssue: ({ dispatch, state }, params) => {
|
|
const moveData = getMoveData(state, params);
|
|
|
|
dispatch('moveIssueCard', moveData);
|
|
dispatch('updateMovedIssue', moveData);
|
|
dispatch('updateIssueOrder', { moveData });
|
|
},
|
|
|
|
moveIssueCard: ({ commit }, moveData) => {
|
|
const {
|
|
reordering,
|
|
shouldClone,
|
|
itemNotInToList,
|
|
originalIndex,
|
|
itemId,
|
|
fromListId,
|
|
toListId,
|
|
moveBeforeId,
|
|
moveAfterId,
|
|
} = moveData;
|
|
|
|
commit(types.REMOVE_BOARD_ITEM_FROM_LIST, { itemId, listId: fromListId });
|
|
|
|
if (reordering) {
|
|
commit(types.ADD_BOARD_ITEM_TO_LIST, {
|
|
itemId,
|
|
listId: toListId,
|
|
moveBeforeId,
|
|
moveAfterId,
|
|
});
|
|
|
|
return;
|
|
}
|
|
|
|
if (itemNotInToList) {
|
|
commit(types.ADD_BOARD_ITEM_TO_LIST, {
|
|
itemId,
|
|
listId: toListId,
|
|
moveBeforeId,
|
|
moveAfterId,
|
|
});
|
|
}
|
|
|
|
if (shouldClone) {
|
|
commit(types.ADD_BOARD_ITEM_TO_LIST, { itemId, listId: fromListId, atIndex: originalIndex });
|
|
}
|
|
},
|
|
|
|
updateMovedIssue: (
|
|
{ commit, state: { boardItems, boardLists } },
|
|
{ itemId, fromListId, toListId },
|
|
) => {
|
|
const updatedIssue = moveItemListHelper(
|
|
boardItems[itemId],
|
|
boardLists[fromListId],
|
|
boardLists[toListId],
|
|
);
|
|
|
|
commit(types.UPDATE_BOARD_ITEM, updatedIssue);
|
|
},
|
|
|
|
undoMoveIssueCard: ({ commit }, moveData) => {
|
|
const {
|
|
reordering,
|
|
shouldClone,
|
|
itemNotInToList,
|
|
itemId,
|
|
fromListId,
|
|
toListId,
|
|
originalIssue,
|
|
originalIndex,
|
|
} = moveData;
|
|
|
|
commit(types.UPDATE_BOARD_ITEM, originalIssue);
|
|
|
|
if (reordering) {
|
|
commit(types.REMOVE_BOARD_ITEM_FROM_LIST, { itemId, listId: fromListId });
|
|
commit(types.ADD_BOARD_ITEM_TO_LIST, { itemId, listId: fromListId, atIndex: originalIndex });
|
|
return;
|
|
}
|
|
|
|
if (shouldClone) {
|
|
commit(types.REMOVE_BOARD_ITEM_FROM_LIST, { itemId, listId: fromListId });
|
|
}
|
|
if (itemNotInToList) {
|
|
commit(types.REMOVE_BOARD_ITEM_FROM_LIST, { itemId, listId: toListId });
|
|
}
|
|
|
|
commit(types.ADD_BOARD_ITEM_TO_LIST, { itemId, listId: fromListId, atIndex: originalIndex });
|
|
},
|
|
|
|
updateIssueOrder: async ({ commit, dispatch, state }, { moveData, mutationVariables = {} }) => {
|
|
try {
|
|
const { itemId, fromListId, toListId, moveBeforeId, moveAfterId, itemNotInToList } = moveData;
|
|
const {
|
|
fullBoardId,
|
|
filterParams,
|
|
boardItems: {
|
|
[itemId]: { iid, referencePath },
|
|
},
|
|
} = state;
|
|
|
|
const { data } = await gqlClient.mutate({
|
|
mutation: issueMoveListMutation,
|
|
variables: {
|
|
iid,
|
|
projectPath: referencePath.split(/[#]/)[0],
|
|
boardId: fullBoardId,
|
|
fromListId: getIdFromGraphQLId(fromListId),
|
|
toListId: getIdFromGraphQLId(toListId),
|
|
moveBeforeId: moveBeforeId ? getIdFromGraphQLId(moveBeforeId) : undefined,
|
|
moveAfterId: moveAfterId ? getIdFromGraphQLId(moveAfterId) : undefined,
|
|
// 'mutationVariables' allows EE code to pass in extra parameters.
|
|
...mutationVariables,
|
|
},
|
|
update(
|
|
cache,
|
|
{
|
|
data: {
|
|
issueMoveList: {
|
|
issue: { weight },
|
|
},
|
|
},
|
|
},
|
|
) {
|
|
if (fromListId === toListId) return;
|
|
|
|
const updateFromList = () => {
|
|
const fromList = cache.readQuery({
|
|
query: totalCountAndWeightQuery,
|
|
variables: { id: fromListId, filters: filterParams },
|
|
});
|
|
|
|
const updatedFromList = {
|
|
boardList: {
|
|
__typename: 'BoardList',
|
|
id: fromList.boardList.id,
|
|
issuesCount: fromList.boardList.issuesCount - 1,
|
|
totalWeight: fromList.boardList.totalWeight - Number(weight),
|
|
},
|
|
};
|
|
|
|
cache.writeQuery({
|
|
query: totalCountAndWeightQuery,
|
|
variables: { id: fromListId, filters: filterParams },
|
|
data: updatedFromList,
|
|
});
|
|
};
|
|
|
|
const updateToList = () => {
|
|
if (!itemNotInToList) return;
|
|
|
|
const toList = cache.readQuery({
|
|
query: totalCountAndWeightQuery,
|
|
variables: { id: toListId, filters: filterParams },
|
|
});
|
|
|
|
const updatedToList = {
|
|
boardList: {
|
|
__typename: 'BoardList',
|
|
id: toList.boardList.id,
|
|
issuesCount: toList.boardList.issuesCount + 1,
|
|
totalWeight: toList.boardList.totalWeight + Number(weight),
|
|
},
|
|
};
|
|
|
|
cache.writeQuery({
|
|
query: totalCountAndWeightQuery,
|
|
variables: { id: toListId, filters: filterParams },
|
|
data: updatedToList,
|
|
});
|
|
};
|
|
|
|
updateFromList();
|
|
updateToList();
|
|
},
|
|
});
|
|
|
|
if (data?.issueMoveList?.errors.length || !data.issueMoveList) {
|
|
throw new Error('issueMoveList empty');
|
|
}
|
|
|
|
commit(types.MUTATE_ISSUE_SUCCESS, { issue: data.issueMoveList.issue });
|
|
} catch {
|
|
commit(
|
|
types.SET_ERROR,
|
|
s__('Boards|An error occurred while moving the issue. Please try again.'),
|
|
);
|
|
dispatch('undoMoveIssueCard', moveData);
|
|
}
|
|
},
|
|
|
|
setAssignees: ({ commit }, { id, assignees }) => {
|
|
commit('UPDATE_BOARD_ITEM_BY_ID', {
|
|
itemId: id,
|
|
prop: 'assignees',
|
|
value: assignees,
|
|
});
|
|
},
|
|
|
|
addListItem: ({ commit, dispatch }, { list, item, position, inProgress = false }) => {
|
|
commit(types.ADD_BOARD_ITEM_TO_LIST, {
|
|
listId: list.id,
|
|
itemId: item.id,
|
|
atIndex: position,
|
|
inProgress,
|
|
});
|
|
commit(types.UPDATE_BOARD_ITEM, item);
|
|
if (!inProgress) {
|
|
dispatch('setActiveId', { id: item.id, sidebarType: ISSUABLE });
|
|
}
|
|
},
|
|
|
|
removeListItem: ({ commit }, { listId, itemId }) => {
|
|
commit(types.REMOVE_BOARD_ITEM_FROM_LIST, { listId, itemId });
|
|
commit(types.REMOVE_BOARD_ITEM, itemId);
|
|
},
|
|
|
|
addListNewIssue: (
|
|
{ state: { boardConfig, boardType, fullPath, filterParams }, dispatch, commit },
|
|
{ issueInput, list, placeholderId = `tmp-${new Date().getTime()}` },
|
|
) => {
|
|
const input = formatIssueInput(issueInput, boardConfig);
|
|
|
|
if (boardType === BoardType.project) {
|
|
input.projectPath = fullPath;
|
|
}
|
|
|
|
const placeholderIssue = formatIssue({ ...issueInput, id: placeholderId, isLoading: true });
|
|
dispatch('addListItem', { list, item: placeholderIssue, position: 0, inProgress: true });
|
|
|
|
gqlClient
|
|
.mutate({
|
|
mutation: issueCreateMutation,
|
|
variables: { input },
|
|
update(cache) {
|
|
const fromList = cache.readQuery({
|
|
query: totalCountAndWeightQuery,
|
|
variables: { id: list.id, filters: filterParams },
|
|
});
|
|
|
|
const updatedList = {
|
|
boardList: {
|
|
__typename: 'BoardList',
|
|
id: fromList.boardList.id,
|
|
issuesCount: fromList.boardList.issuesCount + 1,
|
|
totalWeight: fromList.boardList.totalWeight,
|
|
},
|
|
};
|
|
|
|
cache.writeQuery({
|
|
query: totalCountAndWeightQuery,
|
|
variables: { id: list.id, filters: filterParams },
|
|
data: updatedList,
|
|
});
|
|
},
|
|
})
|
|
.then(({ data }) => {
|
|
if (data.createIssue.errors.length) {
|
|
throw new Error();
|
|
}
|
|
|
|
const rawIssue = data.createIssue?.issue;
|
|
const formattedIssue = formatIssue(rawIssue);
|
|
dispatch('removeListItem', { listId: list.id, itemId: placeholderId });
|
|
dispatch('addListItem', { list, item: formattedIssue, position: 0 });
|
|
})
|
|
.catch(() => {
|
|
dispatch('removeListItem', { listId: list.id, itemId: placeholderId });
|
|
commit(
|
|
types.SET_ERROR,
|
|
s__('Boards|An error occurred while creating the issue. Please try again.'),
|
|
);
|
|
});
|
|
},
|
|
|
|
setActiveBoardItemLabels: ({ dispatch }, params) => {
|
|
dispatch('setActiveIssueLabels', params);
|
|
},
|
|
|
|
setActiveIssueLabels: async ({ commit, getters }, input) => {
|
|
const { activeBoardItem } = getters;
|
|
|
|
let labels = input?.labels || [];
|
|
if (input.removeLabelIds) {
|
|
labels = activeBoardItem.labels.filter(
|
|
(label) => input.removeLabelIds[0] !== getIdFromGraphQLId(label.id),
|
|
);
|
|
}
|
|
commit(types.UPDATE_BOARD_ITEM_BY_ID, {
|
|
itemId: input.id || activeBoardItem.id,
|
|
prop: 'labels',
|
|
value: labels,
|
|
});
|
|
},
|
|
|
|
setActiveItemSubscribed: async ({ commit, getters, state }, input) => {
|
|
const { activeBoardItem, isEpicBoard } = getters;
|
|
const { fullPath, issuableType } = state;
|
|
const workspacePath = isEpicBoard
|
|
? { groupPath: fullPath }
|
|
: { projectPath: input.projectPath };
|
|
const { data } = await gqlClient.mutate({
|
|
mutation: subscriptionQueries[issuableType].mutation,
|
|
variables: {
|
|
input: {
|
|
...workspacePath,
|
|
iid: String(activeBoardItem.iid),
|
|
subscribedState: input.subscribed,
|
|
},
|
|
},
|
|
});
|
|
|
|
if (data.updateIssuableSubscription?.errors?.length > 0) {
|
|
throw new Error(data.updateIssuableSubscription[issuableType].errors);
|
|
}
|
|
|
|
commit(types.UPDATE_BOARD_ITEM_BY_ID, {
|
|
itemId: activeBoardItem.id,
|
|
prop: 'subscribed',
|
|
value: data.updateIssuableSubscription[issuableType].subscribed,
|
|
});
|
|
},
|
|
|
|
setActiveItemTitle: async ({ commit, getters, state }, input) => {
|
|
const { activeBoardItem, isEpicBoard } = getters;
|
|
const { fullPath, issuableType } = state;
|
|
const workspacePath = isEpicBoard
|
|
? { groupPath: fullPath }
|
|
: { projectPath: input.projectPath };
|
|
const { data } = await gqlClient.mutate({
|
|
mutation: titleQueries[issuableType].mutation,
|
|
variables: {
|
|
input: {
|
|
...workspacePath,
|
|
iid: String(activeBoardItem.iid),
|
|
title: input.title,
|
|
},
|
|
},
|
|
});
|
|
|
|
if (data.updateIssuableTitle?.errors?.length > 0) {
|
|
throw new Error(data.updateIssuableTitle.errors);
|
|
}
|
|
|
|
commit(types.UPDATE_BOARD_ITEM_BY_ID, {
|
|
itemId: activeBoardItem.id,
|
|
prop: 'title',
|
|
value: data.updateIssuableTitle[issuableType].title,
|
|
});
|
|
},
|
|
|
|
setActiveItemConfidential: ({ commit, getters }, confidential) => {
|
|
const { activeBoardItem } = getters;
|
|
commit(types.UPDATE_BOARD_ITEM_BY_ID, {
|
|
itemId: activeBoardItem.id,
|
|
prop: 'confidential',
|
|
value: confidential,
|
|
});
|
|
},
|
|
|
|
fetchGroupProjects: ({ commit, state }, { search = '', fetchNext = false }) => {
|
|
commit(types.REQUEST_GROUP_PROJECTS, fetchNext);
|
|
|
|
const { fullPath } = state;
|
|
|
|
const variables = {
|
|
fullPath,
|
|
search: search !== '' ? search : undefined,
|
|
after: fetchNext ? state.groupProjectsFlags.pageInfo.endCursor : undefined,
|
|
};
|
|
|
|
return gqlClient
|
|
.query({
|
|
query: groupProjectsQuery,
|
|
variables,
|
|
})
|
|
.then(({ data }) => {
|
|
const { projects } = data.group;
|
|
commit(types.RECEIVE_GROUP_PROJECTS_SUCCESS, {
|
|
projects: projects.nodes,
|
|
pageInfo: projects.pageInfo,
|
|
fetchNext,
|
|
});
|
|
})
|
|
.catch(() => commit(types.RECEIVE_GROUP_PROJECTS_FAILURE));
|
|
},
|
|
|
|
setSelectedProject: ({ commit }, project) => {
|
|
commit(types.SET_SELECTED_PROJECT, project);
|
|
},
|
|
|
|
toggleBoardItemMultiSelection: ({ commit, state, dispatch, getters }, boardItem) => {
|
|
const { selectedBoardItems } = state;
|
|
const index = selectedBoardItems.indexOf(boardItem);
|
|
|
|
// If user already selected an item (activeBoardItem) without using mult-select,
|
|
// include that item in the selection and unset state.ActiveId to hide the sidebar.
|
|
if (getters.activeBoardItem) {
|
|
commit(types.ADD_BOARD_ITEM_TO_SELECTION, getters.activeBoardItem);
|
|
dispatch('unsetActiveId');
|
|
}
|
|
|
|
if (index === -1) {
|
|
commit(types.ADD_BOARD_ITEM_TO_SELECTION, boardItem);
|
|
} else {
|
|
commit(types.REMOVE_BOARD_ITEM_FROM_SELECTION, boardItem);
|
|
}
|
|
},
|
|
|
|
setAddColumnFormVisibility: ({ commit }, visible) => {
|
|
commit(types.SET_ADD_COLUMN_FORM_VISIBLE, visible);
|
|
},
|
|
|
|
resetBoardItemMultiSelection: ({ commit }) => {
|
|
commit(types.RESET_BOARD_ITEM_SELECTION);
|
|
},
|
|
|
|
toggleBoardItem: ({ state, dispatch }, { boardItem, sidebarType = ISSUABLE }) => {
|
|
dispatch('resetBoardItemMultiSelection');
|
|
|
|
if (boardItem.id === state.activeId) {
|
|
dispatch('unsetActiveId');
|
|
} else {
|
|
dispatch('setActiveId', { id: boardItem.id, sidebarType });
|
|
}
|
|
},
|
|
|
|
setError: ({ commit }, { message, error, captureError = true }) => {
|
|
commit(types.SET_ERROR, message);
|
|
|
|
if (captureError) {
|
|
Sentry.captureException(error);
|
|
}
|
|
},
|
|
|
|
unsetError: ({ commit }) => {
|
|
commit(types.SET_ERROR, undefined);
|
|
},
|
|
|
|
// EE action needs CE empty equivalent
|
|
setActiveItemWeight: () => {},
|
|
};
|