/packages/react_ui/src/pages/:workspace/calendar/useActions.ts at fc159b1517d0ed184bcd00d32cd926d153aa64ee

// SPDX-FileCopyrightText: 2024 Shota FUJI <pockawoooh@gmail.com>
// SPDX-License-Identifier: AGPL-3.0-only

import * as proto from "@bufbuild/protobuf";
import { NotFoundSchema } from "@yamori/proto/yamori/error/v1/not_found_pb.js";
import { DateSchema } from "@yamori/proto/yamori/type/v1/date_pb.js";
import { type LeaveSchema } from "@yamori/proto/yamori/work_record/v1/leave_pb.js";
import { type WorkerSchema } from "@yamori/proto/yamori/worker/v1/worker_pb.js";
import { type WorkspaceSchema } from "@yamori/proto/yamori/workspace/v1/workspace_pb.js";
import { WriteWorkRecordRequestSchema } from "@yamori/proto/yamori/worker/v1/write_work_record_request_pb.js";
import { WriteWorkRecordResponseSchema } from "@yamori/proto/yamori/worker/v1/write_work_record_response_pb.js";
import { isBefore } from "date-fns";

import { useMethodMutation } from "../../../contexts/Service.tsx";
import { useToast } from "../../../contexts/Toast.tsx";
import { IllegalMessageError } from "../../../errors/IllegalMessageError.ts";
import { fromProtoDate, toProtoDate } from "../../../helpers.ts";

import type * as Spreadsheet from "./Spreadsheet.ts";

export interface Actions {
	isPending: boolean;

	/**
	 * 選択されたセルを出勤として設定する。
	 */
	markAsWorked(): Promise<void>;

	/**
	 * 選択されたセルを欠勤として設定する。
	 */
	markAsAbsent(): Promise<void>;

	/**
	 * 選択されたセルを休日として設定する。
	 */
	markAsDayOff(): Promise<void>;

	/**
	 * 選択されたセルを法定・特別休暇として設定する。
	 */
	markAsWorkspaceDefinedLeave(
		leave: proto.MessageShape<typeof LeaveSchema>,
	): Promise<void>;

	/**
	 * 選択されたセルを年次有給休暇として設定する。
	 */
	markAsPaidLeave(): Promise<void>;
}

export interface UseActionsInput {
	workspace: proto.MessageShape<typeof WorkspaceSchema>;

	selection: Spreadsheet.Selection;

	workers: readonly proto.MessageShape<typeof WorkerSchema>[];

	dates: readonly Date[];

	onWorkRecordUpdated?(): void;
}

export function useActions({
	workspace,
	selection,
	workers,
	dates,
	onWorkRecordUpdated,
}: UseActionsInput): Actions {
	const toast = useToast();

	const mutation = useMethodMutation({
		service: "yamori.worker.v1.WorkerService",
		method: "WriteWorkRecord",
		request: {
			schema: WriteWorkRecordRequestSchema,
		},
		response: {
			schema: WriteWorkRecordResponseSchema,
		},
		mapResponse(resp) {
			if (resp.result.case === "ok") {
				return resp.result.value.workRecords;
			}

			if (typeof resp.result.case === "undefined") {
				throw new IllegalMessageError(resp);
			}

			throw resp.result.value;
		},
		options: {
			onError(error) {
				if (
					proto.isMessage(error, NotFoundSchema) &&
					error.typeName === "yamori.worker.v1.PaidLeaveProvision"
				) {
					toast.open({
						severity: "warn",
						title: "年次有給休暇の残り日数がありません",
					});
					return;
				}

				toast.open({
					severity: "danger",
					title: "勤怠記録の更新に失敗しました",
				});
			},
		},
	});

	const runForWorkers = async (
		callback: (
			worker: proto.MessageShape<typeof WorkerSchema>,
			dates: proto.MessageShape<typeof DateSchema>[],
		) => Promise<void>,
	) => {
		try {
			for (let i = 0, l = workers.length; i < l; i++) {
				const cells = selection.cells
					.filter((cell) => cell.row === i)
					.map((cell) => {
						const date = dates[cell.column];
						if (!date) {
							return null;
						}

						return toProtoDate(date);
					})
					.filter((d): d is proto.MessageShape<typeof DateSchema> => !!d);
				const worker = workers[i];

				if (!worker || !cells.length) {
					continue;
				}

				if (!worker.writeWorkRecordKey) {
					toast.open({
						severity: "warn",
						title: "書き込み権限がありません",
						description: `労働者「${worker.displayName}」への書き込み権限がありません。`,
					});
					continue;
				}

				await callback(worker, cells);
			}
		} finally {
			onWorkRecordUpdated?.();
		}
	};

	return {
		isPending: mutation.isPending,
		markAsDayOff() {
			return runForWorkers(async (worker, dates) => {
				await mutation.mutateAsync({
					workspaceId: workspace.id,
					workerId: worker.id,
					writeWorkRecordKey: worker.writeWorkRecordKey,
					workRecord: {
						dates,
						record: {
							case: "dayOff",
							value: {},
						},
					},
				});
			});
		},
		markAsWorked() {
			return runForWorkers(async (worker, dates) => {
				await mutation.mutateAsync({
					workspaceId: workspace.id,
					workerId: worker.id,
					writeWorkRecordKey: worker.writeWorkRecordKey,
					workRecord: {
						dates,
						kind: {
							case: "dayWhole",
							value: {
								kind: {
									case: "worked",
									value: {},
								},
							},
						},
					},
				});
			});
		},
		markAsAbsent() {
			return runForWorkers(async (worker, dates) => {
				await mutation.mutateAsync({
					workspaceId: workspace.id,
					workerId: worker.id,
					writeWorkRecordKey: worker.writeWorkRecordKey,
					workRecord: {
						dates,
						kind: {
							case: "dayWhole",
							value: {
								kind: {
									case: "skipped",
									value: {},
								},
							},
						},
					},
				});
			});
		},
		markAsPaidLeave() {
			return runForWorkers(async (worker, dates) => {
				await mutation.mutateAsync({
					workspaceId: workspace.id,
					workerId: worker.id,
					writeWorkRecordKey: worker.writeWorkRecordKey,
					workRecord: {
						dates,
						kind: {
							case: "dayWhole",
							value: {
								kind: {
									case: "paidLeave",
									value: {},
								},
							},
						},
					},
				});
			});
		},
		markAsWorkspaceDefinedLeave(leave) {
			return runForWorkers(async (worker, dates) => {
				const firstAvailableAt =
					leave.revisions[0]?.startAt && fromProtoDate(leave.revisions[0].startAt);

				const datesTheLeaveNotAvailableFor = firstAvailableAt
					? dates.filter((date) => isBefore(fromProtoDate(date), firstAvailableAt))
					: [];

				if (firstAvailableAt && datesTheLeaveNotAvailableFor.length > 0) {
					toast.open({
						severity: "warn",
						title: `${leave.displayName}は利用できません`,
						description: `対象範囲に${leave.displayName}の運用開始日以前の日付が含まれているため${worker.displayName}への書き込みをスキップします。`,
					});
					return;
				}

				await mutation.mutateAsync({
					workspaceId: workspace.id,
					workerId: worker.id,
					writeWorkRecordKey: worker.writeWorkRecordKey,
					workRecord: {
						dates,
						kind: {
							case: "dayWhole",
							value: {
								kind: {
									case: "workspaceDefinedLeaveId",
									value: leave.id!,
								},
							},
						},
					},
				});
			});
		},
	};
}