feat: scaffold complete danable frontend architecture with all pages, layouts, stores, and 3 annotator modes

This commit is contained in:
quanganh2k4 2026-10-30 00:33:07 +07:00
commit 78848dd7d1
173 changed files with 18649 additions and 0 deletions

128
src/hooks/useAnnotation.ts Normal file
View file

@ -0,0 +1,128 @@
import { useEffect } from 'react'
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import * as annotationService from '@/services/annotationService'
import * as exportService from '@/services/exportService'
import * as imageService from '@/services/imageService'
import { useAnnotationStore } from '@/stores/annotationStore'
export function useAnnotation(projectId?: string, imageId?: string) {
const queryClient = useQueryClient()
const resolvedProjectId = projectId || 'proj-traffic-det'
const resolvedImageId = imageId || `${resolvedProjectId}-img-42`
const store = useAnnotationStore()
const imageQuery = useQuery({
queryKey: ['image', resolvedProjectId, resolvedImageId],
queryFn: () => imageService.getImageById(resolvedProjectId, resolvedImageId),
enabled: Boolean(resolvedProjectId && resolvedImageId),
})
const annotationQuery = useQuery({
queryKey: ['annotation', resolvedProjectId, resolvedImageId],
queryFn: () => annotationService.getAnnotation(resolvedProjectId, resolvedImageId),
enabled: Boolean(resolvedProjectId && resolvedImageId),
})
useEffect(() => {
if (annotationQuery.data && annotationQuery.data.imageId !== store.currentImageId) {
store.setAnnotationData(annotationQuery.data)
}
}, [annotationQuery.data, store])
const saveMutation = useMutation({
mutationFn: () =>
annotationService.saveAnnotation(resolvedProjectId, resolvedImageId, {
classificationLabelId: store.classificationLabelId,
flags: store.flags,
shapes: store.shapes,
}),
onSuccess: (saved) => {
store.markSaved(saved.updatedAt)
queryClient.invalidateQueries({ queryKey: ['project-images', resolvedProjectId] })
},
})
const submitMutation = useMutation({
mutationFn: async () => {
await annotationService.saveAnnotation(resolvedProjectId, resolvedImageId, {
classificationLabelId: store.classificationLabelId,
flags: store.flags,
shapes: store.shapes,
})
return annotationService.submitForReview(resolvedProjectId, resolvedImageId)
},
onSuccess: () => {
store.markSaved('Đã gửi duyệt')
queryClient.invalidateQueries({ queryKey: ['image', resolvedProjectId, resolvedImageId] })
queryClient.invalidateQueries({ queryKey: ['project-images', resolvedProjectId] })
queryClient.invalidateQueries({ queryKey: ['project', resolvedProjectId] })
},
})
const approveMutation = useMutation({
mutationFn: () => annotationService.approveAnnotation(resolvedProjectId, resolvedImageId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['image', resolvedProjectId, resolvedImageId] })
queryClient.invalidateQueries({ queryKey: ['project-images', resolvedProjectId] })
queryClient.invalidateQueries({ queryKey: ['project', resolvedProjectId] })
},
})
const rejectMutation = useMutation({
mutationFn: (reason?: string) =>
annotationService.rejectAnnotation(resolvedProjectId, resolvedImageId, reason),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['image', resolvedProjectId, resolvedImageId] })
queryClient.invalidateQueries({ queryKey: ['project-images', resolvedProjectId] })
queryClient.invalidateQueries({ queryKey: ['project', resolvedProjectId] })
},
})
const exportLabelMe = () => {
if (!imageQuery.data) return
exportService.downloadImageLabelMeJSON(imageQuery.data, store.shapes)
}
const exportMask = () => {
if (!imageQuery.data) return
exportService.downloadImageMaskPNG(imageQuery.data, store.shapes)
}
const selectedShape = store.shapes.find((s) => s.id === store.selectedShapeId) ?? null
return {
image: imageQuery.data,
isLoading: imageQuery.isLoading || annotationQuery.isLoading,
shapes: store.shapes,
selectedShapeId: store.selectedShapeId,
selectedShape,
classificationLabelId: store.classificationLabelId,
flags: store.flags,
activeLabelId: store.activeLabelId,
activeGroupId: store.activeGroupId,
lastSavedAt: store.lastSavedAt,
isDirty: store.isDirty,
canUndo: store.history.past.length > 0,
canRedo: store.history.future.length > 0,
addShape: store.addShape,
updateShape: store.updateShape,
deleteShape: store.deleteShape,
toggleShapeVisibility: store.toggleShapeVisibility,
selectShape: store.selectShape,
setClassificationLabel: store.setClassificationLabel,
toggleFlag: store.toggleFlag,
setActiveLabelId: store.setActiveLabelId,
setActiveGroupId: store.setActiveGroupId,
undo: store.undo,
redo: store.redo,
saveAnnotation: saveMutation.mutateAsync,
isSaving: saveMutation.isPending,
submitForReview: submitMutation.mutateAsync,
isSubmitting: submitMutation.isPending,
approveAnnotation: approveMutation.mutateAsync,
rejectAnnotation: rejectMutation.mutateAsync,
exportLabelMe,
exportMask,
}
}

67
src/hooks/useAuth.ts Normal file
View file

@ -0,0 +1,67 @@
import { useState } from 'react'
import * as authService from '@/services/authService'
import { useAuthStore } from '@/stores/authStore'
import { LoginRequest, UserRole } from '@/types'
import { canApproveLabels, canCreateProject, canManageUsers } from '@/utils/permissions'
export function useAuth() {
const { user, isAuthenticated, login: storeLogin, logout: storeLogout, setUser, setRole } = useAuthStore()
const [isLoading, setIsLoading] = useState(false)
const [error, setError] = useState<string | null>(null)
const login = async (payload: LoginRequest) => {
setIsLoading(true)
setError(null)
try {
const response = await authService.login(payload)
storeLogin(response.user, response.accessToken)
return response
} catch (err) {
const message = err instanceof Error ? err.message : 'Đăng nhập thất bại'
setError(message)
throw err
} finally {
setIsLoading(false)
}
}
const loginWithSSO = async (provider: 'google' | 'microsoft' | 'sso' = 'sso') => {
setIsLoading(true)
setError(null)
try {
const response = await authService.loginWithSSO(provider)
storeLogin(response.user, response.accessToken)
return response
} finally {
setIsLoading(false)
}
}
const logout = async () => {
await authService.logout()
storeLogout()
}
const switchRole = async (role: UserRole) => {
const updated = await authService.switchUserRole(role)
setRole(role)
setUser(updated)
}
const role: UserRole = user?.role ?? 'admin'
return {
user,
role,
isAuthenticated,
isLoading,
error,
login,
loginWithSSO,
logout,
switchRole,
canManageUsers: canManageUsers(role),
canApproveLabels: canApproveLabels(role),
canCreateProject: canCreateProject(role),
}
}

36
src/hooks/useAutoSave.ts Normal file
View file

@ -0,0 +1,36 @@
import { useEffect } from 'react'
import * as annotationService from '@/services/annotationService'
import { useAnnotationStore } from '@/stores/annotationStore'
export function useAutoSave(projectId?: string, imageId?: string, intervalMs = 2500) {
const isDirty = useAnnotationStore((s) => s.isDirty)
const shapes = useAnnotationStore((s) => s.shapes)
const classificationLabelId = useAnnotationStore((s) => s.classificationLabelId)
const flags = useAnnotationStore((s) => s.flags)
const markSaved = useAnnotationStore((s) => s.markSaved)
const lastSavedAt = useAnnotationStore((s) => s.lastSavedAt)
useEffect(() => {
if (!projectId || !imageId || !isDirty) return
const timer = window.setTimeout(async () => {
try {
await annotationService.saveAnnotation(projectId, imageId, {
classificationLabelId,
flags,
shapes,
})
markSaved('Vừa lưu 1 giây trước')
} catch {
// Bỏ qua lỗi tự động lưu tạm thời
}
}, intervalMs)
return () => window.clearTimeout(timer)
}, [projectId, imageId, isDirty, shapes, classificationLabelId, flags, intervalMs, markSaved])
return {
isDirty,
lastSavedAt,
}
}

29
src/hooks/useCanvas.ts Normal file
View file

@ -0,0 +1,29 @@
import { useCanvasStore } from '@/stores/canvasStore'
export function useCanvas() {
const store = useCanvasStore()
return {
activeTool: store.activeTool,
zoom: store.zoom,
zoomPercent: Math.round(store.zoom * 100),
pan: store.pan,
showBoxes: store.showBoxes,
showMask: store.showMask,
maskOpacity: store.maskOpacity,
vertexEditMode: store.vertexEditMode,
setActiveTool: store.setActiveTool,
setZoom: store.setZoom,
setPan: store.setPan,
setShowBoxes: store.setShowBoxes,
toggleShowBoxes: store.toggleShowBoxes,
setShowMask: store.setShowMask,
toggleShowMask: store.toggleShowMask,
setMaskOpacity: store.setMaskOpacity,
setVertexEditMode: store.setVertexEditMode,
toggleVertexEditMode: store.toggleVertexEditMode,
zoomIn: store.zoomIn,
zoomOut: store.zoomOut,
resetZoom: store.resetZoom,
}
}

17
src/hooks/useDebounce.ts Normal file
View file

@ -0,0 +1,17 @@
import { useEffect, useState } from 'react'
export function useDebounce<T>(value: T, delayMs = 250): T {
const [debouncedValue, setDebouncedValue] = useState<T>(value)
useEffect(() => {
const timer = window.setTimeout(() => {
setDebouncedValue(value)
}, delayMs)
return () => {
window.clearTimeout(timer)
}
}, [value, delayMs])
return debouncedValue
}

View file

@ -0,0 +1,47 @@
import { useNavigate } from 'react-router-dom'
import { ImageItem } from '@/types'
export function useImageNavigation(
projectId: string,
images: ImageItem[],
currentImageId?: string
) {
const navigate = useNavigate()
const currentIndex = images.findIndex((img) => img.id === currentImageId)
const resolvedIndex = currentIndex >= 0 ? currentIndex : 0
const currentImage = images[resolvedIndex] ?? null
const prevImage = resolvedIndex > 0 ? (images[resolvedIndex - 1] ?? null) : null
const nextImage =
resolvedIndex < images.length - 1 ? (images[resolvedIndex + 1] ?? null) : null
const goToImage = (imageId: string) => {
navigate(`/projects/${projectId}/annotate/${imageId}`)
}
const goToPrev = () => {
if (prevImage) {
goToImage(prevImage.id)
}
}
const goToNext = () => {
if (nextImage) {
goToImage(nextImage.id)
}
}
return {
currentImage,
currentIndex: resolvedIndex,
totalCount: images.length,
hasPrev: Boolean(prevImage),
hasNext: Boolean(nextImage),
prevImage,
nextImage,
goToImage,
goToPrev,
goToNext,
}
}

62
src/hooks/useImages.ts Normal file
View file

@ -0,0 +1,62 @@
import { useState } from 'react'
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import * as imageService from '@/services/imageService'
import { ImageAnnotationStatus } from '@/types'
export function useImages(projectId?: string) {
const queryClient = useQueryClient()
const resolvedProjectId = projectId || 'proj-traffic-det'
const [statusFilter, setStatusFilter] = useState<ImageAnnotationStatus | 'all'>('all')
const [assigneeFilter, setAssigneeFilter] = useState<string>('all')
const [search, setSearch] = useState<string>('')
const imagesQuery = useQuery({
queryKey: [
'project-images',
resolvedProjectId,
{ status: statusFilter, assigneeId: assigneeFilter, search },
],
queryFn: () =>
imageService.getProjectImages(resolvedProjectId, {
status: statusFilter,
assigneeId: assigneeFilter,
search,
}),
enabled: Boolean(resolvedProjectId),
})
const uploadMutation = useMutation({
mutationFn: (files: { fileName: string; url?: string; width?: number; height?: number }[]) =>
imageService.uploadImages(resolvedProjectId, files),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['project-images', resolvedProjectId] })
queryClient.invalidateQueries({ queryKey: ['project', resolvedProjectId] })
queryClient.invalidateQueries({ queryKey: ['projects'] })
},
})
const updateStatusMutation = useMutation({
mutationFn: ({ imageId, status }: { imageId: string; status: ImageAnnotationStatus }) =>
imageService.updateImageStatus(resolvedProjectId, imageId, status),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['project-images', resolvedProjectId] })
queryClient.invalidateQueries({ queryKey: ['project', resolvedProjectId] })
queryClient.invalidateQueries({ queryKey: ['projects'] })
},
})
return {
images: imagesQuery.data ?? [],
isLoading: imagesQuery.isLoading,
statusFilter,
assigneeFilter,
search,
setStatusFilter,
setAssigneeFilter,
setSearch,
uploadImages: uploadMutation.mutateAsync,
isUploading: uploadMutation.isPending,
updateImageStatus: updateStatusMutation.mutateAsync,
}
}

View file

@ -0,0 +1,147 @@
import { useEffect } from 'react'
import { useAnnotationStore } from '@/stores/annotationStore'
import { useCanvasStore } from '@/stores/canvasStore'
import { LabelClass } from '@/types'
export interface KeyboardShortcutsOptions {
classes?: LabelClass[]
onSave?: () => void
onSubmit?: () => void
onPrevImage?: () => void
onNextImage?: () => void
isClassification?: boolean
enabled?: boolean
}
export function useKeyboardShortcuts({
classes = [],
onSave,
onSubmit,
onPrevImage,
onNextImage,
isClassification = false,
enabled = true,
}: KeyboardShortcutsOptions = {}) {
const setActiveTool = useCanvasStore((s) => s.setActiveTool)
const selectedShapeId = useAnnotationStore((s) => s.selectedShapeId)
const deleteShape = useAnnotationStore((s) => s.deleteShape)
const updateShape = useAnnotationStore((s) => s.updateShape)
const setActiveLabelId = useAnnotationStore((s) => s.setActiveLabelId)
const setClassificationLabel = useAnnotationStore((s) => s.setClassificationLabel)
const undo = useAnnotationStore((s) => s.undo)
const redo = useAnnotationStore((s) => s.redo)
useEffect(() => {
if (!enabled) return
const handleKeyDown = (event: KeyboardEvent) => {
const target = event.target as HTMLElement | null
if (
target &&
(target.tagName === 'INPUT' ||
target.tagName === 'TEXTAREA' ||
target.tagName === 'SELECT' ||
target.isContentEditable)
) {
return
}
const key = event.key.toLowerCase()
// Ctrl+S / Cmd+S: Lưu
if ((event.ctrlKey || event.metaKey) && key === 's') {
event.preventDefault()
onSave?.()
return
}
// Ctrl+Z / Cmd+Z: Undo / Redo
if ((event.ctrlKey || event.metaKey) && key === 'z') {
event.preventDefault()
if (event.shiftKey) {
redo()
} else {
undo()
}
return
}
// Phím tắt công cụ: V (Select), R/W (BBox), P (Polygon)
if (!event.ctrlKey && !event.metaKey && !event.altKey) {
if (key === 'v') {
setActiveTool('select')
return
}
if (key === 'r' || key === 'w') {
setActiveTool('bbox')
return
}
if (key === 'p') {
setActiveTool('polygon')
return
}
// A / ArrowLeft: Ảnh trước, D / ArrowRight: Ảnh tiếp
if (key === 'a' || event.key === 'ArrowLeft') {
onPrevImage?.()
return
}
if (key === 'd' || event.key === 'ArrowRight') {
onNextImage?.()
return
}
// Enter: Nộp duyệt hoặc xác nhận
if (event.key === 'Enter' && onSubmit) {
event.preventDefault()
onSubmit()
return
}
// Delete / Backspace: Xóa shape đang chọn
if ((event.key === 'Delete' || event.key === 'Backspace') && selectedShapeId) {
event.preventDefault()
deleteShape(selectedShapeId)
return
}
// Phím số 1-9: Chọn lớp nhãn
if (/^[1-9]$/.test(key)) {
const idx = parseInt(key, 10) - 1
const targetClass = classes[idx]
if (targetClass) {
setActiveLabelId(targetClass.id)
if (isClassification) {
setClassificationLabel(targetClass.id)
} else if (selectedShapeId) {
updateShape(selectedShapeId, {
labelId: targetClass.id,
labelName: targetClass.name,
color: targetClass.color,
})
}
}
}
}
}
window.addEventListener('keydown', handleKeyDown)
return () => window.removeEventListener('keydown', handleKeyDown)
}, [
enabled,
classes,
isClassification,
selectedShapeId,
setActiveTool,
deleteShape,
updateShape,
setActiveLabelId,
setClassificationLabel,
undo,
redo,
onSave,
onSubmit,
onPrevImage,
onNextImage,
])
}

View file

@ -0,0 +1,48 @@
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import * as exportService from '@/services/exportService'
import * as labelService from '@/services/labelService'
import * as projectService from '@/services/projectService'
export function useProjectDetail(projectId?: string) {
const queryClient = useQueryClient()
const resolvedId = projectId || 'proj-traffic-det'
const projectQuery = useQuery({
queryKey: ['project', resolvedId],
queryFn: () => projectService.getProjectById(resolvedId),
enabled: Boolean(resolvedId),
})
const createLabelMutation = useMutation({
mutationFn: (input: { name: string; color?: string }) =>
labelService.createLabel(resolvedId, input),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['project', resolvedId] })
queryClient.invalidateQueries({ queryKey: ['projects'] })
},
})
const deleteLabelMutation = useMutation({
mutationFn: (labelId: string) => labelService.deleteLabel(resolvedId, labelId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['project', resolvedId] })
queryClient.invalidateQueries({ queryKey: ['projects'] })
},
})
const exportMutation = useMutation({
mutationFn: (format: exportService.ExportFormat = 'coco_json') =>
exportService.exportProjectLabels(resolvedId, format),
})
return {
project: projectQuery.data,
isLoading: projectQuery.isLoading,
isError: projectQuery.isError,
refetch: projectQuery.refetch,
createLabel: createLabelMutation.mutateAsync,
deleteLabel: deleteLabelMutation.mutateAsync,
exportDataset: exportMutation.mutateAsync,
isExporting: exportMutation.isPending,
}
}

97
src/hooks/useProjects.ts Normal file
View file

@ -0,0 +1,97 @@
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import * as projectService from '@/services/projectService'
import { useProjectStore } from '@/stores/projectStore'
import { CreateProjectInput, Project } from '@/types'
export function useProjects() {
const queryClient = useQueryClient()
const {
searchQuery,
taskTypeFilter,
statusFilter,
selectedProjectId,
setSearchQuery,
setTaskTypeFilter,
setStatusFilter,
setSelectedProjectId,
resetFilters,
} = useProjectStore()
const projectsQuery = useQuery({
queryKey: ['projects', { search: searchQuery, taskType: taskTypeFilter, status: statusFilter }],
queryFn: () =>
projectService.getProjects({
search: searchQuery,
taskType: taskTypeFilter,
status: statusFilter,
}),
})
const allProjectsQuery = useQuery({
queryKey: ['projects', 'all'],
queryFn: () => projectService.getProjects(),
})
const activitiesQuery = useQuery({
queryKey: ['activities'],
queryFn: () => projectService.getRecentActivities(),
})
const createProjectMutation = useMutation({
mutationFn: (input: CreateProjectInput) => projectService.createProject(input),
onSuccess: (created) => {
setSelectedProjectId(created.id)
queryClient.invalidateQueries({ queryKey: ['projects'] })
queryClient.invalidateQueries({ queryKey: ['activities'] })
},
})
const updateProjectMutation = useMutation({
mutationFn: ({ projectId, updates }: { projectId: string; updates: Partial<Project> }) =>
projectService.updateProject(projectId, updates),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['projects'] })
},
})
const deleteProjectMutation = useMutation({
mutationFn: (projectId: string) => projectService.deleteProject(projectId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['projects'] })
},
})
const projects = projectsQuery.data ?? []
const allProjects = allProjectsQuery.data ?? projects
const totalImages = allProjects.reduce((acc, p) => acc + p.stats.totalImages, 0)
const completedImages = allProjects.reduce((acc, p) => acc + p.stats.completed, 0)
const pendingReviewImages = allProjects.reduce((acc, p) => acc + p.stats.pendingReview, 0)
return {
projects,
allProjects,
activities: activitiesQuery.data ?? [],
isLoading: projectsQuery.isLoading,
isError: projectsQuery.isError,
searchQuery,
taskTypeFilter,
statusFilter,
selectedProjectId,
setSearchQuery,
setTaskTypeFilter,
setStatusFilter,
setSelectedProjectId,
resetFilters,
createProject: createProjectMutation.mutateAsync,
isCreating: createProjectMutation.isPending,
updateProject: updateProjectMutation.mutateAsync,
deleteProject: deleteProjectMutation.mutateAsync,
summaryStats: {
totalProjects: allProjects.length,
totalImages,
completedImages,
pendingReviewImages,
},
}
}

79
src/hooks/useUsers.ts Normal file
View file

@ -0,0 +1,79 @@
import { useState } from 'react'
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import * as userService from '@/services/userService'
import { InviteMemberInput, UserRole, UserStatus } from '@/types'
export function useUsers() {
const queryClient = useQueryClient()
const [search, setSearch] = useState('')
const [roleFilter, setRoleFilter] = useState<UserRole | 'all'>('all')
const [statusFilter, setStatusFilter] = useState<UserStatus | 'all'>('all')
const membersQuery = useQuery({
queryKey: ['members', { search, role: roleFilter, status: statusFilter }],
queryFn: () =>
userService.getMembers({
search,
role: roleFilter,
status: statusFilter,
}),
})
const allMembersQuery = useQuery({
queryKey: ['members', 'all'],
queryFn: () => userService.getMembers(),
})
const permissionsQuery = useQuery({
queryKey: ['role-permissions'],
queryFn: () => userService.getRolePermissions(),
})
const inviteMutation = useMutation({
mutationFn: (input: InviteMemberInput) => userService.inviteMember(input),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['members'] })
},
})
const updateRoleMutation = useMutation({
mutationFn: ({ memberId, role }: { memberId: string; role: UserRole }) =>
userService.updateMemberRole(memberId, role),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['members'] })
},
})
const toggleStatusMutation = useMutation({
mutationFn: (memberId: string) => userService.toggleMemberStatus(memberId),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['members'] })
},
})
const allMembers = allMembersQuery.data ?? []
return {
members: membersQuery.data ?? [],
allMembers,
rolePermissions: permissionsQuery.data ?? [],
isLoading: membersQuery.isLoading,
search,
roleFilter,
statusFilter,
setSearch,
setRoleFilter,
setStatusFilter,
inviteMember: inviteMutation.mutateAsync,
isInviting: inviteMutation.isPending,
updateMemberRole: updateRoleMutation.mutateAsync,
toggleMemberStatus: toggleStatusMutation.mutateAsync,
counts: {
total: allMembers.length,
admins: allMembers.filter((m) => m.role === 'admin').length,
managers: allMembers.filter((m) => m.role === 'manager').length,
annotators: allMembers.filter((m) => m.role === 'annotator').length,
reviewers: allMembers.filter((m) => m.role === 'reviewer').length,
},
}
}