thunderstrike/plane
thunderstrike/plane
2
0
Fork 0
forked from github/plane
Code Pull Requests Activity

fix: deleting old issue store

Browse Source
This commit is contained in:
sriram veeraghanta 2024-01-22 13:58:34 +05:30
parent e32a50fba6
commit 24442ccc9c
1 changed files with 0 additions and 396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

396
web/store/issues/project-issues/cycle/issue.store.ts
View File

@ -1,396 +0,0 @@
import { action, observable, makeObservable, computed, runInAction, autorun } from "mobx";
// base class
import { IssueBaseStore } from "store/issues";
// services
import { IssueService } from "services/issue";
import { CycleService } from "services/cycle.service";
// types
import { TIssueGroupByOptions } from "types";
import { IIssue } from "types/issues";
import { IIssueResponse, TLoader, IGroupedIssues, ISubGroupedIssues, TUnGroupedIssues, ViewFlags } from "../../types";
import { RootStore } from "store/root";
export interface ICycleIssuesStore {
// observable
loader: TLoader;
issues: { [cycle_id: string]: IIssueResponse } | undefined;
// computed
getIssues: IIssueResponse | undefined;
getIssuesIds: IGroupedIssues | ISubGroupedIssues | TUnGroupedIssues | undefined;
// actions
fetchIssues: (
workspaceSlug: string,
projectId: string,
loadType: TLoader,
cycleId?: string | undefined
) => Promise<IIssueResponse | undefined>;
createIssue: (
workspaceSlug: string,
projectId: string,
data: Partial<IIssue>,
cycleId?: string | undefined
) => Promise<IIssue | undefined>;
updateIssue: (
workspaceSlug: string,
projectId: string,
issueId: string,
data: Partial<IIssue>,
cycleId?: string | undefined
) => Promise<IIssue | undefined>;
removeIssue: (
workspaceSlug: string,
projectId: string,
issueId: string,
cycleId?: string | undefined
) => Promise<IIssue | undefined>;
quickAddIssue: (
workspaceSlug: string,
projectId: string,
data: IIssue,
cycleId?: string | undefined
) => Promise<IIssue | undefined>;
addIssueToCycle: (
workspaceSlug: string,
cycleId: string,
issueIds: string[],
fetchAfterAddition?: boolean,
projectId?: string
) => Promise<IIssue>;
removeIssueFromCycle: (
workspaceSlug: string,
projectId: string,
cycleId: string,
issueId: string,
issueBridgeId: string
) => Promise<IIssue>;
transferIssuesFromCycle: (
workspaceSlug: string,
projectId: string,
cycleId: string,
payload: {
new_cycle_id: string;
}
) => Promise<IIssue>;
viewFlags: ViewFlags;
}
export class CycleIssuesStore extends IssueBaseStore implements ICycleIssuesStore {
loader: TLoader = "init-loader";
issues: { [cycle_id: string]: IIssueResponse } | undefined = undefined;
// root store
rootStore;
// service
cycleService;
issueService;
//viewData
viewFlags = {
enableQuickAdd: true,
enableIssueCreation: true,
enableInlineEditing: true,
};
constructor(_rootStore: RootStore) {
super(_rootStore);
makeObservable(this, {
// observable
loader: observable.ref,
issues: observable.ref,
// computed
getIssues: computed,
getIssuesIds: computed,
// action
fetchIssues: action,
createIssue: action,
updateIssue: action,
removeIssue: action,
quickAddIssue: action,
addIssueToCycle: action,
removeIssueFromCycle: action,
transferIssuesFromCycle: action,
});
this.rootStore = _rootStore;
this.issueService = new IssueService();
this.cycleService = new CycleService();
autorun(() => {
const workspaceSlug = this.rootStore.workspace.workspaceSlug;
const projectId = this.rootStore.project.projectId;
const cycleId = this.rootStore.cycle.cycleId;
const hasPermissionToCurrentProject = this.rootStore.user.hasPermissionToCurrentProject;
if (!workspaceSlug || !projectId || !hasPermissionToCurrentProject || !cycleId) return;
const userFilters = this.rootStore?.cycleIssuesFilter?.issueFilters?.filters;
if (userFilters) this.fetchIssues(workspaceSlug, projectId, "mutation", cycleId);
});
}
get getIssues() {
const cycleId = this.rootStore?.cycle?.cycleId;
if (!cycleId || !this.issues || !this.issues[cycleId]) return undefined;
return this.issues[cycleId];
}
get getIssuesIds() {
const cycleId = this.rootStore?.cycle?.cycleId;
const displayFilters = this.rootStore?.cycleIssuesFilter?.issueFilters?.displayFilters;
const subGroupBy = displayFilters?.sub_group_by;
const groupBy = displayFilters?.group_by;
const orderBy = displayFilters?.order_by;
const layout = displayFilters?.layout;
if (!cycleId || !this.issues || !this.issues[cycleId]) return undefined;
let issues: IIssueResponse | IGroupedIssues | ISubGroupedIssues | TUnGroupedIssues | undefined = undefined;
if (layout === "list" && orderBy) {
if (groupBy) issues = this.groupedIssues(groupBy, orderBy, this.issues[cycleId]);
else issues = this.unGroupedIssues(orderBy, this.issues[cycleId]);
} else if (layout === "kanban" && groupBy && orderBy) {
if (subGroupBy) issues = this.subGroupedIssues(subGroupBy, groupBy, orderBy, this.issues[cycleId]);
else issues = this.groupedIssues(groupBy, orderBy, this.issues[cycleId]);
} else if (layout === "calendar")
issues = this.groupedIssues("target_date" as TIssueGroupByOptions, "target_date", this.issues[cycleId], true);
else if (layout === "spreadsheet") issues = this.unGroupedIssues(orderBy ?? "-created_at", this.issues[cycleId]);
else if (layout === "gantt_chart") issues = this.unGroupedIssues(orderBy ?? "sort_order", this.issues[cycleId]);
return issues;
}
fetchIssues = async (
workspaceSlug: string,
projectId: string,
loadType: TLoader = "init-loader",
cycleId: string | undefined = undefined
) => {
if (!cycleId) return undefined;
try {
this.loader = loadType;
const params = this.rootStore?.cycleIssuesFilter?.appliedFilters;
const response = await this.cycleService.getCycleIssuesWithParams(workspaceSlug, projectId, cycleId, params);
const _issues = { ...this.issues, [cycleId]: { ...response } };
runInAction(() => {
this.issues = _issues;
this.loader = undefined;
});
return response;
} catch (error) {
console.error(error);
this.loader = undefined;
throw error;
}
};
createIssue = async (
workspaceSlug: string,
projectId: string,
data: Partial<IIssue>,
cycleId: string | undefined = undefined
) => {
if (!cycleId) return undefined;
try {
const response = await this.rootStore.projectIssues.createIssue(workspaceSlug, projectId, data);
await this.addIssueToCycle(workspaceSlug, cycleId, [response.id], false);
let _issues = this.issues;
if (!_issues) _issues = {};
if (!_issues[cycleId]) _issues[cycleId] = {};
_issues[cycleId] = { ..._issues[cycleId], ...{ [response.id]: response } };
runInAction(() => {
this.issues = _issues;
});
return response;
} catch (error) {
this.fetchIssues(workspaceSlug, projectId, "mutation", cycleId);
throw error;
}
};
updateIssue = async (
workspaceSlug: string,
projectId: string,
issueId: string,
data: Partial<IIssue>,
cycleId: string | undefined = undefined
) => {
if (!cycleId) return undefined;
try {
let _issues = { ...this.issues };
if (!_issues) _issues = {};
if (!_issues[cycleId]) _issues[cycleId] = {};
_issues[cycleId][issueId] = { ..._issues[cycleId][issueId], ...data };
runInAction(() => {
this.issues = _issues;
});
const response = await this.rootStore.projectIssues.updateIssue(workspaceSlug, projectId, issueId, data);
runInAction(() => {
_issues = { ...this.issues };
_issues[cycleId][issueId] = { ..._issues[cycleId][issueId], ...response };
this.issues = _issues;
});
return response;
} catch (error) {
this.fetchIssues(workspaceSlug, projectId, "mutation", cycleId);
throw error;
}
};
removeIssue = async (
workspaceSlug: string,
projectId: string,
issueId: string,
cycleId: string | undefined = undefined
) => {
if (!cycleId) return undefined;
try {
let _issues = { ...this.issues };
if (!_issues) _issues = {};
if (!_issues[cycleId]) _issues[cycleId] = {};
delete _issues?.[cycleId]?.[issueId];
_issues[cycleId] = { ..._issues[cycleId] };
runInAction(() => {
this.issues = _issues;
});
const response = await this.rootStore.projectIssues.removeIssue(workspaceSlug, projectId, issueId);
return response;
} catch (error) {
this.fetchIssues(workspaceSlug, projectId, "mutation", cycleId);
throw error;
}
};
quickAddIssue = async (
workspaceSlug: string,
projectId: string,
data: IIssue,
cycleId: string | undefined = undefined
) => {
if (!cycleId) return;
try {
let _issues = { ...this.issues };
if (!_issues) _issues = {};
if (!_issues[cycleId]) _issues[cycleId] = {};
_issues[cycleId] = { ..._issues[cycleId], ...{ [data.id as keyof IIssue]: data } };
runInAction(() => {
this.issues = _issues;
});
const response = await this.createIssue(workspaceSlug, projectId, data, cycleId);
if (this.issues && response) {
delete this.issues[cycleId][data.id as keyof IIssue];
let _issues = { ...this.issues };
if (!_issues) _issues = {};
if (!_issues[cycleId]) _issues[cycleId] = {};
_issues[cycleId] = { ..._issues[cycleId], ...{ [response.id as keyof IIssue]: response } };
runInAction(() => {
this.issues = _issues;
});
}
return response;
} catch (error) {
this.fetchIssues(workspaceSlug, projectId, "mutation", cycleId);
throw error;
}
};
addIssueToCycle = async (
workspaceSlug: string,
cycleId: string,
issueIds: string[],
fetchAfterAddition = true,
projectId?: string
) => {
const activeProjectId = this.rootStore.project.projectId;
if (!activeProjectId && !projectId) return;
const projectIdToUpdate: string = projectId || activeProjectId || "";
try {
const issueToCycle = await this.issueService.addIssueToCycle(workspaceSlug, projectIdToUpdate, cycleId, {
issues: issueIds,
});
if (fetchAfterAddition) this.fetchIssues(workspaceSlug, projectIdToUpdate, "mutation", cycleId);
return issueToCycle;
} catch (error) {
this.fetchIssues(workspaceSlug, projectIdToUpdate, "mutation", cycleId);
throw error;
}
};
removeIssueFromCycle = async (
workspaceSlug: string,
projectId: string,
cycleId: string,
issueId: string,
issueBridgeId: string
) => {
try {
let _issues = { ...this.issues };
if (!_issues) _issues = {};
if (!_issues[cycleId]) _issues[cycleId] = {};
delete _issues?.[cycleId]?.[issueId];
runInAction(() => {
this.issues = _issues;
});
const response = await this.issueService.removeIssueFromCycle(workspaceSlug, projectId, cycleId, issueBridgeId);
return response;
} catch (error) {
this.fetchIssues(workspaceSlug, projectId, "mutation", cycleId);
throw error;
}
};
transferIssuesFromCycle = async (
workspaceSlug: string,
projectId: string,
cycleId: string,
payload: {
new_cycle_id: string;
}
) => {
try {
const response = await this.cycleService.transferIssues(
workspaceSlug as string,
projectId as string,
cycleId as string,
payload
);
await this.fetchIssues(workspaceSlug, projectId, "mutation", cycleId);
return response;
} catch (error) {
this.fetchIssues(workspaceSlug, projectId, "mutation", cycleId);
throw error;
}
};
}