feat: 添加 Anki APKG 导入/导出功能
- 添加 APKG 解析器 (src/lib/anki/apkg-parser.ts) - 添加 APKG 导出器 (src/lib/anki/apkg-exporter.ts) - 添加导入/导出 Server Actions - 添加导入/导出 UI 组件 - 集成到牌组页面 - 添加 i18n 翻译 同时修复断链: - /folders → /decks (Navbar, signup, profile)
This commit is contained in:
@@ -9,5 +9,5 @@ export default async function ProfilePage() {
|
||||
redirect("/login?redirect=/profile");
|
||||
}
|
||||
|
||||
redirect(session.user.username ? `/users/${session.user.username}` : "/folders");
|
||||
redirect(session.user.username ? `/users/${session.user.username}` : "/decks");
|
||||
}
|
||||
|
||||
@@ -28,7 +28,7 @@ export default function SignUpPage() {
|
||||
|
||||
useEffect(() => {
|
||||
if (!isPending && session?.user?.username && !redirectTo && !verificationSent) {
|
||||
router.push("/folders");
|
||||
router.push("/decks");
|
||||
}
|
||||
}, [session, isPending, router, redirectTo, verificationSent]);
|
||||
|
||||
|
||||
@@ -25,6 +25,7 @@ import {
|
||||
actionGetDeckById,
|
||||
} from "@/modules/deck/deck-action";
|
||||
import type { ActionOutputDeck } from "@/modules/deck/deck-action-dto";
|
||||
import { ImportButton, ExportButton } from "@/components/deck/ImportExport";
|
||||
|
||||
interface DeckCardProps {
|
||||
deck: ActionOutputDeck;
|
||||
@@ -149,25 +150,17 @@ export function DecksClient({ userId }: DecksClientProps) {
|
||||
const [decks, setDecks] = useState<ActionOutputDeck[]>([]);
|
||||
const [loading, setLoading] = useState(true);
|
||||
|
||||
const loadDecks = async () => {
|
||||
setLoading(true);
|
||||
const result = await actionGetDecksByUserId(userId);
|
||||
if (result.success && result.data) {
|
||||
setDecks(result.data);
|
||||
}
|
||||
setLoading(false);
|
||||
};
|
||||
|
||||
useEffect(() => {
|
||||
let ignore = false;
|
||||
|
||||
const loadDecks = async () => {
|
||||
setLoading(true);
|
||||
const result = await actionGetDecksByUserId(userId);
|
||||
if (!ignore) {
|
||||
if (result.success && result.data) {
|
||||
setDecks(result.data);
|
||||
}
|
||||
setLoading(false);
|
||||
}
|
||||
};
|
||||
|
||||
loadDecks();
|
||||
|
||||
return () => {
|
||||
ignore = true;
|
||||
};
|
||||
}, [userId]);
|
||||
|
||||
const handleUpdateDeck = (deckId: number, updates: Partial<ActionOutputDeck>) => {
|
||||
@@ -199,11 +192,12 @@ export function DecksClient({ userId }: DecksClientProps) {
|
||||
<PageLayout>
|
||||
<PageHeader title={t("title")} subtitle={t("subtitle")} />
|
||||
|
||||
<div className="mb-4">
|
||||
<div className="mb-4 flex gap-2">
|
||||
<LightButton onClick={handleCreateDeck}>
|
||||
<Plus size={18} />
|
||||
{t("newDeck")}
|
||||
</LightButton>
|
||||
<ImportButton onImportComplete={loadDecks} />
|
||||
</div>
|
||||
|
||||
<CardList>
|
||||
|
||||
254
src/components/deck/ImportExport.tsx
Normal file
254
src/components/deck/ImportExport.tsx
Normal file
@@ -0,0 +1,254 @@
|
||||
"use client";
|
||||
|
||||
import { useState, useRef } from "react";
|
||||
import { Upload, Download, FileUp, X, Check, Loader2 } from "lucide-react";
|
||||
import { LightButton, PrimaryButton } from "@/design-system/base/button";
|
||||
import { Modal } from "@/design-system/overlay/modal";
|
||||
import { actionPreviewApkg, actionImportApkg } from "@/modules/import/import-action";
|
||||
import { actionExportApkg } from "@/modules/export/export-action";
|
||||
import { toast } from "sonner";
|
||||
import { useTranslations } from "next-intl";
|
||||
|
||||
interface ImportExportProps {
|
||||
deckId?: number;
|
||||
deckName?: string;
|
||||
onImportComplete?: () => void;
|
||||
}
|
||||
|
||||
interface PreviewDeck {
|
||||
id: number;
|
||||
name: string;
|
||||
cardCount: number;
|
||||
}
|
||||
|
||||
export function ImportButton({ onImportComplete }: ImportExportProps) {
|
||||
const t = useTranslations("decks");
|
||||
const [isModalOpen, setIsModalOpen] = useState(false);
|
||||
const [step, setStep] = useState<"upload" | "select" | "importing">("upload");
|
||||
const [file, setFile] = useState<File | null>(null);
|
||||
const [decks, setDecks] = useState<PreviewDeck[]>([]);
|
||||
const [selectedDeckId, setSelectedDeckId] = useState<number | null>(null);
|
||||
const [deckName, setDeckName] = useState("");
|
||||
const [loading, setLoading] = useState(false);
|
||||
const fileInputRef = useRef<HTMLInputElement>(null);
|
||||
|
||||
const handleFileSelect = async (e: React.ChangeEvent<HTMLInputElement>) => {
|
||||
const selectedFile = e.target.files?.[0];
|
||||
if (!selectedFile) return;
|
||||
|
||||
if (!selectedFile.name.endsWith(".apkg")) {
|
||||
toast.error("Please select an .apkg file");
|
||||
return;
|
||||
}
|
||||
|
||||
setFile(selectedFile);
|
||||
setLoading(true);
|
||||
|
||||
const formData = new FormData();
|
||||
formData.append("file", selectedFile);
|
||||
|
||||
const result = await actionPreviewApkg(formData);
|
||||
|
||||
setLoading(false);
|
||||
|
||||
if (result.success && result.decks) {
|
||||
setDecks(result.decks);
|
||||
setStep("select");
|
||||
if (result.decks.length === 1) {
|
||||
setSelectedDeckId(result.decks[0].id);
|
||||
setDeckName(result.decks[0].name);
|
||||
}
|
||||
} else {
|
||||
toast.error(result.message);
|
||||
}
|
||||
};
|
||||
|
||||
const handleImport = async () => {
|
||||
if (!file || selectedDeckId === null) {
|
||||
toast.error("Please select a deck to import");
|
||||
return;
|
||||
}
|
||||
|
||||
setStep("importing");
|
||||
|
||||
const formData = new FormData();
|
||||
formData.append("file", file);
|
||||
formData.append("deckId", selectedDeckId.toString());
|
||||
if (deckName) {
|
||||
formData.append("deckName", deckName);
|
||||
}
|
||||
|
||||
const result = await actionImportApkg(formData);
|
||||
|
||||
if (result.success) {
|
||||
toast.success(result.message);
|
||||
setIsModalOpen(false);
|
||||
resetState();
|
||||
onImportComplete?.();
|
||||
} else {
|
||||
toast.error(result.message);
|
||||
setStep("select");
|
||||
}
|
||||
};
|
||||
|
||||
const resetState = () => {
|
||||
setStep("upload");
|
||||
setFile(null);
|
||||
setDecks([]);
|
||||
setSelectedDeckId(null);
|
||||
setDeckName("");
|
||||
setLoading(false);
|
||||
if (fileInputRef.current) {
|
||||
fileInputRef.current.value = "";
|
||||
}
|
||||
};
|
||||
|
||||
const handleClose = () => {
|
||||
setIsModalOpen(false);
|
||||
resetState();
|
||||
};
|
||||
|
||||
return (
|
||||
<>
|
||||
<LightButton onClick={() => setIsModalOpen(true)}>
|
||||
<Upload size={18} />
|
||||
{t("importApkg")}
|
||||
</LightButton>
|
||||
|
||||
<Modal open={isModalOpen} onClose={handleClose}>
|
||||
<div className="p-6 w-full max-w-md">
|
||||
<div className="flex justify-between items-center mb-4">
|
||||
<h2 className="text-xl font-bold">{t("importApkg")}</h2>
|
||||
<button onClick={handleClose} className="text-gray-400 hover:text-gray-600">
|
||||
<X size={20} />
|
||||
</button>
|
||||
</div>
|
||||
|
||||
{step === "upload" && (
|
||||
<div className="space-y-4">
|
||||
<div
|
||||
className="border-2 border-dashed border-gray-300 rounded-lg p-8 text-center cursor-pointer hover:border-primary-500 transition-colors"
|
||||
onClick={() => fileInputRef.current?.click()}
|
||||
>
|
||||
<FileUp size={40} className="mx-auto text-gray-400 mb-2" />
|
||||
<p className="text-gray-600">{t("clickToUpload")}</p>
|
||||
<p className="text-sm text-gray-400">{t("apkgFilesOnly")}</p>
|
||||
</div>
|
||||
<input
|
||||
ref={fileInputRef}
|
||||
type="file"
|
||||
accept=".apkg"
|
||||
className="hidden"
|
||||
onChange={handleFileSelect}
|
||||
/>
|
||||
{loading && (
|
||||
<div className="flex items-center justify-center gap-2 text-gray-500">
|
||||
<Loader2 size={20} className="animate-spin" />
|
||||
<span>{t("parsing")}</span>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{step === "select" && (
|
||||
<div className="space-y-4">
|
||||
<p className="text-sm text-gray-600">{t("foundDecks", { count: decks.length })}</p>
|
||||
|
||||
<div className="space-y-2 max-h-48 overflow-y-auto">
|
||||
{decks.map((deck) => (
|
||||
<div
|
||||
key={deck.id}
|
||||
className={`p-3 border rounded-lg cursor-pointer transition-colors ${
|
||||
selectedDeckId === deck.id
|
||||
? "border-primary-500 bg-primary-50"
|
||||
: "border-gray-200 hover:border-gray-300"
|
||||
}`}
|
||||
onClick={() => {
|
||||
setSelectedDeckId(deck.id);
|
||||
setDeckName(deck.name);
|
||||
}}
|
||||
>
|
||||
<div className="flex items-center justify-between">
|
||||
<span className="font-medium">{deck.name}</span>
|
||||
<span className="text-sm text-gray-500">{deck.cardCount} cards</span>
|
||||
</div>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<label className="block text-sm font-medium text-gray-700 mb-1">
|
||||
{t("deckName")}
|
||||
</label>
|
||||
<input
|
||||
type="text"
|
||||
value={deckName}
|
||||
onChange={(e) => setDeckName(e.target.value)}
|
||||
className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-primary-500"
|
||||
placeholder={t("enterDeckName")}
|
||||
/>
|
||||
</div>
|
||||
|
||||
<div className="flex gap-2">
|
||||
<LightButton onClick={() => setStep("upload")} className="flex-1">
|
||||
{t("back")}
|
||||
</LightButton>
|
||||
<PrimaryButton
|
||||
onClick={handleImport}
|
||||
disabled={selectedDeckId === null}
|
||||
className="flex-1"
|
||||
>
|
||||
{t("import")}
|
||||
</PrimaryButton>
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{step === "importing" && (
|
||||
<div className="flex flex-col items-center justify-center py-8">
|
||||
<Loader2 size={40} className="animate-spin text-primary-500 mb-4" />
|
||||
<p className="text-gray-600">{t("importing")}</p>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
</Modal>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
export function ExportButton({ deckId, deckName }: ImportExportProps) {
|
||||
const t = useTranslations("decks");
|
||||
const [loading, setLoading] = useState(false);
|
||||
|
||||
const handleExport = async () => {
|
||||
if (!deckId) return;
|
||||
|
||||
setLoading(true);
|
||||
|
||||
const result = await actionExportApkg(deckId);
|
||||
|
||||
setLoading(false);
|
||||
|
||||
if (result.success && result.data && result.filename) {
|
||||
const blob = new Blob([result.data], { type: "application/octet-stream" });
|
||||
const url = URL.createObjectURL(blob);
|
||||
const a = document.createElement("a");
|
||||
a.href = url;
|
||||
a.download = result.filename;
|
||||
document.body.appendChild(a);
|
||||
a.click();
|
||||
document.body.removeChild(a);
|
||||
URL.revokeObjectURL(url);
|
||||
toast.success(t("exportSuccess"));
|
||||
} else {
|
||||
toast.error(result.message);
|
||||
}
|
||||
};
|
||||
|
||||
return (
|
||||
<LightButton onClick={handleExport} disabled={loading}>
|
||||
{loading ? <Loader2 size={18} className="animate-spin" /> : <Download size={18} />}
|
||||
{t("exportApkg")}
|
||||
</LightButton>
|
||||
);
|
||||
}
|
||||
@@ -21,7 +21,7 @@ export async function Navbar() {
|
||||
});
|
||||
|
||||
const mobileMenuItems: NavigationItem[] = [
|
||||
{ label: t("folders"), href: "/folders", icon: <Folder size={18} /> },
|
||||
{ label: t("folders"), href: "/decks", icon: <Folder size={18} /> },
|
||||
{ label: t("explore"), href: "/explore", icon: <Compass size={18} /> },
|
||||
...(session ? [{ label: t("favorites"), href: "/favorites", icon: <Heart size={18} /> }] : []),
|
||||
{ label: t("sourceCode"), href: "https://github.com/GoddoNebianU/learn-languages", icon: <Github size={18} />, external: true },
|
||||
@@ -42,7 +42,7 @@ export async function Navbar() {
|
||||
</GhostLightButton>
|
||||
<div className="flex gap-0.5 justify-center items-center">
|
||||
<LanguageSettings />
|
||||
<GhostLightButton href="/folders" className="md:block! hidden!" size="md">
|
||||
<GhostLightButton href="/decks" className="md:block! hidden!" size="md">
|
||||
{t("folders")}
|
||||
</GhostLightButton>
|
||||
<GhostLightButton href="/explore" className="md:block! hidden!" size="md">
|
||||
|
||||
419
src/lib/anki/apkg-exporter.ts
Normal file
419
src/lib/anki/apkg-exporter.ts
Normal file
@@ -0,0 +1,419 @@
|
||||
import JSZip from "jszip";
|
||||
import initSqlJs from "sql.js";
|
||||
import type { Database } from "sql.js";
|
||||
import type {
|
||||
AnkiDeck,
|
||||
AnkiNoteType,
|
||||
AnkiDeckConfig,
|
||||
AnkiNoteRow,
|
||||
AnkiCardRow,
|
||||
AnkiRevlogRow,
|
||||
} from "./types";
|
||||
|
||||
const FIELD_SEPARATOR = "\x1f";
|
||||
const BASE91_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!#$%&()*+,-./:;<=>?@[]^_`{|}~";
|
||||
|
||||
function generateGuid(): string {
|
||||
let result = "";
|
||||
const id = Date.now() ^ (Math.random() * 0xffffffff);
|
||||
let num = BigInt(id);
|
||||
|
||||
for (let i = 0; i < 10; i++) {
|
||||
result = BASE91_CHARS[Number(num % 91n)] + result;
|
||||
num = num / 91n;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
function checksum(str: string): number {
|
||||
let hash = 0;
|
||||
for (let i = 0; i < str.length; i++) {
|
||||
const char = str.charCodeAt(i);
|
||||
hash = ((hash << 5) - hash) + char;
|
||||
hash = hash & hash;
|
||||
}
|
||||
return Math.abs(hash) % 100000000;
|
||||
}
|
||||
|
||||
function createCollectionSql(): string {
|
||||
return `
|
||||
CREATE TABLE col (
|
||||
id INTEGER PRIMARY KEY,
|
||||
crt INTEGER NOT NULL,
|
||||
mod INTEGER NOT NULL,
|
||||
scm INTEGER NOT NULL,
|
||||
ver INTEGER NOT NULL DEFAULT 11,
|
||||
dty INTEGER NOT NULL DEFAULT 0,
|
||||
usn INTEGER NOT NULL DEFAULT 0,
|
||||
ls INTEGER NOT NULL DEFAULT 0,
|
||||
conf TEXT NOT NULL,
|
||||
models TEXT NOT NULL,
|
||||
decks TEXT NOT NULL,
|
||||
dconf TEXT NOT NULL,
|
||||
tags TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE notes (
|
||||
id INTEGER PRIMARY KEY,
|
||||
guid TEXT NOT NULL,
|
||||
mid INTEGER NOT NULL,
|
||||
mod INTEGER NOT NULL,
|
||||
usn INTEGER NOT NULL,
|
||||
tags TEXT NOT NULL,
|
||||
flds TEXT NOT NULL,
|
||||
sfld TEXT NOT NULL,
|
||||
csum INTEGER NOT NULL,
|
||||
flags INTEGER NOT NULL DEFAULT 0,
|
||||
data TEXT NOT NULL DEFAULT ''
|
||||
);
|
||||
|
||||
CREATE TABLE cards (
|
||||
id INTEGER PRIMARY KEY,
|
||||
nid INTEGER NOT NULL,
|
||||
did INTEGER NOT NULL,
|
||||
ord INTEGER NOT NULL,
|
||||
mod INTEGER NOT NULL,
|
||||
usn INTEGER NOT NULL,
|
||||
type INTEGER NOT NULL,
|
||||
queue INTEGER NOT NULL,
|
||||
due INTEGER NOT NULL,
|
||||
ivl INTEGER NOT NULL,
|
||||
factor INTEGER NOT NULL,
|
||||
reps INTEGER NOT NULL,
|
||||
lapses INTEGER NOT NULL,
|
||||
left INTEGER NOT NULL,
|
||||
odue INTEGER NOT NULL DEFAULT 0,
|
||||
odid INTEGER NOT NULL DEFAULT 0,
|
||||
flags INTEGER NOT NULL DEFAULT 0,
|
||||
data TEXT NOT NULL DEFAULT ''
|
||||
);
|
||||
|
||||
CREATE TABLE revlog (
|
||||
id INTEGER PRIMARY KEY,
|
||||
cid INTEGER NOT NULL,
|
||||
usn INTEGER NOT NULL,
|
||||
ease INTEGER NOT NULL,
|
||||
ivl INTEGER NOT NULL,
|
||||
lastIvl INTEGER NOT NULL,
|
||||
factor INTEGER NOT NULL,
|
||||
time INTEGER NOT NULL,
|
||||
type INTEGER NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE graves (
|
||||
usn INTEGER NOT NULL,
|
||||
oid INTEGER NOT NULL,
|
||||
type INTEGER NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX ix_cards_nid ON cards (nid);
|
||||
CREATE INDEX ix_cards_sched ON cards (did, queue, due);
|
||||
CREATE INDEX ix_cards_usn ON cards (usn);
|
||||
CREATE INDEX ix_notes_csum ON notes (csum);
|
||||
CREATE INDEX ix_notes_usn ON notes (usn);
|
||||
CREATE INDEX ix_revlog_cid ON revlog (cid);
|
||||
CREATE INDEX ix_revlog_usn ON revlog (usn);
|
||||
`;
|
||||
}
|
||||
|
||||
function mapCardType(type: string): number {
|
||||
switch (type) {
|
||||
case "NEW": return 0;
|
||||
case "LEARNING": return 1;
|
||||
case "REVIEW": return 2;
|
||||
case "RELEARNING": return 3;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
function mapCardQueue(queue: string): number {
|
||||
switch (queue) {
|
||||
case "USER_BURIED": return -3;
|
||||
case "SCHED_BURIED": return -2;
|
||||
case "SUSPENDED": return -1;
|
||||
case "NEW": return 0;
|
||||
case "LEARNING": return 1;
|
||||
case "REVIEW": return 2;
|
||||
case "IN_LEARNING": return 3;
|
||||
case "PREVIEW": return 4;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
export interface ExportDeckData {
|
||||
deck: {
|
||||
id: number;
|
||||
name: string;
|
||||
desc: string;
|
||||
collapsed: boolean;
|
||||
conf: Record<string, unknown>;
|
||||
};
|
||||
noteType: {
|
||||
id: number;
|
||||
name: string;
|
||||
kind: "STANDARD" | "CLOZE";
|
||||
css: string;
|
||||
fields: { name: string; ord: number }[];
|
||||
templates: { name: string; ord: number; qfmt: string; afmt: string }[];
|
||||
};
|
||||
notes: {
|
||||
id: bigint;
|
||||
guid: string;
|
||||
tags: string;
|
||||
flds: string;
|
||||
sfld: string;
|
||||
csum: number;
|
||||
}[];
|
||||
cards: {
|
||||
id: bigint;
|
||||
noteId: bigint;
|
||||
ord: number;
|
||||
type: string;
|
||||
queue: string;
|
||||
due: number;
|
||||
ivl: number;
|
||||
factor: number;
|
||||
reps: number;
|
||||
lapses: number;
|
||||
left: number;
|
||||
}[];
|
||||
revlogs: {
|
||||
id: bigint;
|
||||
cardId: bigint;
|
||||
ease: number;
|
||||
ivl: number;
|
||||
lastIvl: number;
|
||||
factor: number;
|
||||
time: number;
|
||||
type: number;
|
||||
}[];
|
||||
media: Map<string, Buffer>;
|
||||
}
|
||||
|
||||
async function createDatabase(data: ExportDeckData): Promise<Uint8Array> {
|
||||
const SQL = await initSqlJs({
|
||||
locateFile: (file: string) => `https://sql.js.org/dist/${file}`,
|
||||
});
|
||||
|
||||
const db = new SQL.Database();
|
||||
|
||||
db.run(createCollectionSql());
|
||||
|
||||
const now = Date.now();
|
||||
const nowSeconds = Math.floor(now / 1000);
|
||||
|
||||
const defaultConfig = {
|
||||
dueCounts: true,
|
||||
estTimes: true,
|
||||
newSpread: 0,
|
||||
curDeck: data.deck.id,
|
||||
curModel: data.noteType.id,
|
||||
};
|
||||
|
||||
const deckJson: Record<string, AnkiDeck> = {
|
||||
[data.deck.id.toString()]: {
|
||||
id: data.deck.id,
|
||||
mod: nowSeconds,
|
||||
name: data.deck.name,
|
||||
usn: -1,
|
||||
lrnToday: [0, 0],
|
||||
revToday: [0, 0],
|
||||
newToday: [0, 0],
|
||||
timeToday: [0, 0],
|
||||
collapsed: data.deck.collapsed,
|
||||
browserCollapsed: false,
|
||||
desc: data.deck.desc,
|
||||
dyn: 0,
|
||||
conf: 1,
|
||||
extendNew: 0,
|
||||
extendRev: 0,
|
||||
},
|
||||
"1": {
|
||||
id: 1,
|
||||
mod: nowSeconds,
|
||||
name: "Default",
|
||||
usn: -1,
|
||||
lrnToday: [0, 0],
|
||||
revToday: [0, 0],
|
||||
newToday: [0, 0],
|
||||
timeToday: [0, 0],
|
||||
collapsed: false,
|
||||
browserCollapsed: false,
|
||||
desc: "",
|
||||
dyn: 0,
|
||||
conf: 1,
|
||||
extendNew: 0,
|
||||
extendRev: 0,
|
||||
},
|
||||
};
|
||||
|
||||
const noteTypeJson: Record<string, AnkiNoteType> = {
|
||||
[data.noteType.id.toString()]: {
|
||||
id: data.noteType.id,
|
||||
name: data.noteType.name,
|
||||
type: data.noteType.kind === "CLOZE" ? 1 : 0,
|
||||
mod: nowSeconds,
|
||||
usn: -1,
|
||||
sortf: 0,
|
||||
did: data.deck.id,
|
||||
flds: data.noteType.fields.map((f, i) => ({
|
||||
id: now + i,
|
||||
name: f.name,
|
||||
ord: f.ord,
|
||||
sticky: false,
|
||||
rtl: false,
|
||||
font: "Arial",
|
||||
size: 20,
|
||||
media: [],
|
||||
})),
|
||||
tmpls: data.noteType.templates.map((t, i) => ({
|
||||
id: now + i + 100,
|
||||
name: t.name,
|
||||
ord: t.ord,
|
||||
qfmt: t.qfmt,
|
||||
afmt: t.afmt,
|
||||
did: null,
|
||||
})),
|
||||
css: data.noteType.css,
|
||||
latexPre: "\\documentclass[12pt]{article}\n\\special{papersize=3in,5in}\n\\usepackage{amssymb,amsmath}\n\\pagestyle{empty}\n\\setlength{\\parindent}{0in}\n\\begin{document}\n",
|
||||
latexPost: "\\end{document}",
|
||||
latexsvg: false,
|
||||
req: [],
|
||||
},
|
||||
};
|
||||
|
||||
const deckConfigJson: Record<string, AnkiDeckConfig> = {
|
||||
"1": {
|
||||
id: 1,
|
||||
mod: nowSeconds,
|
||||
name: "Default",
|
||||
usn: -1,
|
||||
maxTaken: 60,
|
||||
autoplay: true,
|
||||
timer: 0,
|
||||
replayq: true,
|
||||
new: {
|
||||
bury: true,
|
||||
delays: [1, 10],
|
||||
initialFactor: 2500,
|
||||
ints: [1, 4, 7],
|
||||
order: 1,
|
||||
perDay: 20,
|
||||
},
|
||||
rev: {
|
||||
bury: true,
|
||||
ease4: 1.3,
|
||||
ivlFct: 1,
|
||||
maxIvl: 36500,
|
||||
perDay: 200,
|
||||
hardFactor: 1.2,
|
||||
},
|
||||
lapse: {
|
||||
delays: [10],
|
||||
leechAction: 0,
|
||||
leechFails: 8,
|
||||
minInt: 1,
|
||||
mult: 0,
|
||||
},
|
||||
dyn: false,
|
||||
},
|
||||
};
|
||||
|
||||
db.run(
|
||||
`INSERT INTO col (id, crt, mod, scm, ver, dty, usn, ls, conf, models, decks, dconf, tags)
|
||||
VALUES (1, ?, ?, ?, 11, 0, 0, 0, ?, ?, ?, ?, '{}')`,
|
||||
[
|
||||
nowSeconds,
|
||||
now,
|
||||
now,
|
||||
JSON.stringify(defaultConfig),
|
||||
JSON.stringify(noteTypeJson),
|
||||
JSON.stringify(deckJson),
|
||||
JSON.stringify(deckConfigJson),
|
||||
]
|
||||
);
|
||||
|
||||
for (const note of data.notes) {
|
||||
db.run(
|
||||
`INSERT INTO notes (id, guid, mid, mod, usn, tags, flds, sfld, csum, flags, data)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, '')`,
|
||||
[
|
||||
Number(note.id),
|
||||
note.guid || generateGuid(),
|
||||
data.noteType.id,
|
||||
nowSeconds,
|
||||
-1,
|
||||
note.tags || " ",
|
||||
note.flds,
|
||||
note.sfld,
|
||||
note.csum || checksum(note.sfld),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
for (const card of data.cards) {
|
||||
db.run(
|
||||
`INSERT INTO cards (id, nid, did, ord, mod, usn, type, queue, due, ivl, factor, reps, lapses, left, odue, odid, flags, data)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, 0, '')`,
|
||||
[
|
||||
Number(card.id),
|
||||
Number(card.noteId),
|
||||
data.deck.id,
|
||||
card.ord,
|
||||
nowSeconds,
|
||||
-1,
|
||||
mapCardType(card.type),
|
||||
mapCardQueue(card.queue),
|
||||
card.due,
|
||||
card.ivl,
|
||||
card.factor,
|
||||
card.reps,
|
||||
card.lapses,
|
||||
card.left,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
for (const revlog of data.revlogs) {
|
||||
db.run(
|
||||
`INSERT INTO revlog (id, cid, usn, ease, ivl, lastIvl, factor, time, type)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
[
|
||||
Number(revlog.id),
|
||||
Number(revlog.cardId),
|
||||
-1,
|
||||
revlog.ease,
|
||||
revlog.ivl,
|
||||
revlog.lastIvl,
|
||||
revlog.factor,
|
||||
revlog.time,
|
||||
revlog.type,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
const dbData = db.export();
|
||||
db.close();
|
||||
|
||||
return dbData;
|
||||
}
|
||||
|
||||
export async function exportApkg(data: ExportDeckData): Promise<Buffer> {
|
||||
const zip = new JSZip();
|
||||
|
||||
const dbData = await createDatabase(data);
|
||||
zip.file("collection.anki21", dbData);
|
||||
|
||||
const mediaMapping: Record<string, string> = {};
|
||||
const mediaEntries = Array.from(data.media.entries());
|
||||
|
||||
mediaEntries.forEach(([filename, buffer], index) => {
|
||||
mediaMapping[index.toString()] = filename;
|
||||
zip.file(index.toString(), buffer);
|
||||
});
|
||||
|
||||
zip.file("media", JSON.stringify(mediaMapping));
|
||||
|
||||
return zip.generateAsync({ type: "nodebuffer" });
|
||||
}
|
||||
174
src/lib/anki/apkg-parser.ts
Normal file
174
src/lib/anki/apkg-parser.ts
Normal file
@@ -0,0 +1,174 @@
|
||||
import JSZip from "jszip";
|
||||
import initSqlJs from "sql.js";
|
||||
import type { Database, SqlValue } from "sql.js";
|
||||
import {
|
||||
type AnkiDeck,
|
||||
type AnkiNoteType,
|
||||
type AnkiDeckConfig,
|
||||
type AnkiNoteRow,
|
||||
type AnkiCardRow,
|
||||
type AnkiRevlogRow,
|
||||
type ParsedApkg,
|
||||
} from "./types";
|
||||
|
||||
async function openDatabase(zip: JSZip): Promise<Database | null> {
|
||||
const SQL = await initSqlJs({
|
||||
locateFile: (file: string) => `https://sql.js.org/dist/${file}`,
|
||||
});
|
||||
|
||||
const anki21b = zip.file("collection.anki21b");
|
||||
const anki21 = zip.file("collection.anki21");
|
||||
const anki2 = zip.file("collection.anki2");
|
||||
|
||||
let dbFile = anki21b || anki21 || anki2;
|
||||
if (!dbFile) return null;
|
||||
|
||||
const dbData = await dbFile.async("uint8array");
|
||||
return new SQL.Database(dbData);
|
||||
}
|
||||
|
||||
function parseJsonField<T>(jsonStr: string): T {
|
||||
try {
|
||||
return JSON.parse(jsonStr);
|
||||
} catch {
|
||||
return {} as T;
|
||||
}
|
||||
}
|
||||
|
||||
function queryAll<T>(db: Database, sql: string, params: SqlValue[] = []): T[] {
|
||||
const results: T[] = [];
|
||||
const stmt = db.prepare(sql);
|
||||
stmt.bind(params);
|
||||
|
||||
while (stmt.step()) {
|
||||
const row = stmt.getAsObject();
|
||||
results.push(row as T);
|
||||
}
|
||||
|
||||
stmt.free();
|
||||
return results;
|
||||
}
|
||||
|
||||
function queryOne<T>(db: Database, sql: string, params: SqlValue[] = []): T | null {
|
||||
const results = queryAll<T>(db, sql, params);
|
||||
return results[0] ?? null;
|
||||
}
|
||||
|
||||
export async function parseApkg(buffer: Buffer): Promise<ParsedApkg> {
|
||||
const zip = await JSZip.loadAsync(buffer);
|
||||
const db = await openDatabase(zip);
|
||||
|
||||
if (!db) {
|
||||
throw new Error("No valid Anki database found in APKG file");
|
||||
}
|
||||
|
||||
const col = queryOne<{
|
||||
crt: number;
|
||||
mod: number;
|
||||
ver: number;
|
||||
conf: string;
|
||||
models: string;
|
||||
decks: string;
|
||||
dconf: string;
|
||||
tags: string;
|
||||
}>(db, "SELECT crt, mod, ver, conf, models, decks, dconf, tags FROM col WHERE id = 1");
|
||||
|
||||
if (!col) {
|
||||
db.close();
|
||||
throw new Error("Invalid APKG: no collection row found");
|
||||
}
|
||||
|
||||
const decksMap = new Map<number, AnkiDeck>();
|
||||
const decksJson = parseJsonField<Record<string, AnkiDeck>>(col.decks);
|
||||
for (const [id, deck] of Object.entries(decksJson)) {
|
||||
decksMap.set(parseInt(id, 10), deck);
|
||||
}
|
||||
|
||||
const noteTypesMap = new Map<number, AnkiNoteType>();
|
||||
const modelsJson = parseJsonField<Record<string, AnkiNoteType>>(col.models);
|
||||
for (const [id, model] of Object.entries(modelsJson)) {
|
||||
noteTypesMap.set(parseInt(id, 10), model);
|
||||
}
|
||||
|
||||
const deckConfigsMap = new Map<number, AnkiDeckConfig>();
|
||||
const dconfJson = parseJsonField<Record<string, AnkiDeckConfig>>(col.dconf);
|
||||
for (const [id, config] of Object.entries(dconfJson)) {
|
||||
deckConfigsMap.set(parseInt(id, 10), config);
|
||||
}
|
||||
|
||||
const notes = queryAll<AnkiNoteRow>(
|
||||
db,
|
||||
"SELECT id, guid, mid, mod, usn, tags, flds, sfld, csum, flags, data FROM notes"
|
||||
);
|
||||
|
||||
const cards = queryAll<AnkiCardRow>(
|
||||
db,
|
||||
"SELECT id, nid, did, ord, mod, usn, type, queue, due, ivl, factor, reps, lapses, left, odue, odid, flags, data FROM cards"
|
||||
);
|
||||
|
||||
const revlogs = queryAll<AnkiRevlogRow>(
|
||||
db,
|
||||
"SELECT id, cid, usn, ease, ivl, lastIvl, factor, time, type FROM revlog"
|
||||
);
|
||||
|
||||
const mediaMap = new Map<string, Buffer>();
|
||||
const mediaFile = zip.file("media");
|
||||
if (mediaFile) {
|
||||
const mediaJson = parseJsonField<Record<string, string>>(await mediaFile.async("text"));
|
||||
for (const [num, filename] of Object.entries(mediaJson)) {
|
||||
const mediaData = zip.file(num);
|
||||
if (mediaData) {
|
||||
const data = await mediaData.async("nodebuffer");
|
||||
mediaMap.set(filename, data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
db.close();
|
||||
|
||||
return {
|
||||
decks: decksMap,
|
||||
noteTypes: noteTypesMap,
|
||||
deckConfigs: deckConfigsMap,
|
||||
notes,
|
||||
cards,
|
||||
revlogs,
|
||||
media: mediaMap,
|
||||
collectionMeta: {
|
||||
crt: col.crt,
|
||||
mod: col.mod,
|
||||
ver: col.ver,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function getDeckNotesAndCards(
|
||||
parsed: ParsedApkg,
|
||||
deckId: number
|
||||
): { notes: AnkiNoteRow[]; cards: AnkiCardRow[] } {
|
||||
const deckCards = parsed.cards.filter(c => c.did === deckId);
|
||||
const noteIds = new Set(deckCards.map(c => c.nid));
|
||||
const deckNotes = parsed.notes.filter(n => noteIds.has(n.id));
|
||||
|
||||
return { notes: deckNotes, cards: deckCards };
|
||||
}
|
||||
|
||||
export function getDeckNames(parsed: ParsedApkg): { id: number; name: string; cardCount: number }[] {
|
||||
const cardCounts = new Map<number, number>();
|
||||
for (const card of parsed.cards) {
|
||||
cardCounts.set(card.did, (cardCounts.get(card.did) ?? 0) + 1);
|
||||
}
|
||||
|
||||
const result: { id: number; name: string; cardCount: number }[] = [];
|
||||
for (const [id, deck] of parsed.decks) {
|
||||
if (deck.dyn === 0) {
|
||||
result.push({
|
||||
id,
|
||||
name: deck.name,
|
||||
cardCount: cardCounts.get(id) ?? 0,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return result.sort((a, b) => a.name.localeCompare(b.name));
|
||||
}
|
||||
193
src/lib/anki/types.ts
Normal file
193
src/lib/anki/types.ts
Normal file
@@ -0,0 +1,193 @@
|
||||
/**
|
||||
* Anki APKG format types
|
||||
* Based on Anki's official database schema
|
||||
*/
|
||||
|
||||
// ============================================
|
||||
// APKG JSON Configuration Types
|
||||
// ============================================
|
||||
|
||||
export interface AnkiField {
|
||||
id: number;
|
||||
name: string;
|
||||
ord: number;
|
||||
sticky: boolean;
|
||||
rtl: boolean;
|
||||
font: string;
|
||||
size: number;
|
||||
media: string[];
|
||||
description?: string;
|
||||
plainText?: boolean;
|
||||
collapsed?: boolean;
|
||||
excludeFromSearch?: boolean;
|
||||
tag?: number;
|
||||
preventDeletion?: boolean;
|
||||
}
|
||||
|
||||
export interface AnkiTemplate {
|
||||
id: number | null;
|
||||
name: string;
|
||||
ord: number;
|
||||
qfmt: string;
|
||||
afmt: string;
|
||||
bqfmt?: string;
|
||||
bafmt?: string;
|
||||
did?: number | null;
|
||||
bfont?: string;
|
||||
bsize?: number;
|
||||
}
|
||||
|
||||
export interface AnkiNoteType {
|
||||
id: number;
|
||||
name: string;
|
||||
type: 0 | 1; // 0=standard, 1=cloze
|
||||
mod: number;
|
||||
usn: number;
|
||||
sortf: number;
|
||||
did: number | null;
|
||||
tmpls: AnkiTemplate[];
|
||||
flds: AnkiField[];
|
||||
css: string;
|
||||
latexPre: string;
|
||||
latexPost: string;
|
||||
latexsvg: boolean | null;
|
||||
req: [number, string, number[]][];
|
||||
originalStockKind?: number;
|
||||
}
|
||||
|
||||
export interface AnkiDeckConfig {
|
||||
id: number;
|
||||
mod: number;
|
||||
name: string;
|
||||
usn: number;
|
||||
maxTaken: number;
|
||||
autoplay: boolean;
|
||||
timer: 0 | 1;
|
||||
replayq: boolean;
|
||||
new: {
|
||||
bury: boolean;
|
||||
delays: number[];
|
||||
initialFactor: number;
|
||||
ints: [number, number, number];
|
||||
order: number;
|
||||
perDay: number;
|
||||
};
|
||||
rev: {
|
||||
bury: boolean;
|
||||
ease4: number;
|
||||
ivlFct: number;
|
||||
maxIvl: number;
|
||||
perDay: number;
|
||||
hardFactor: number;
|
||||
};
|
||||
lapse: {
|
||||
delays: number[];
|
||||
leechAction: 0 | 1;
|
||||
leechFails: number;
|
||||
minInt: number;
|
||||
mult: number;
|
||||
};
|
||||
dyn: boolean;
|
||||
}
|
||||
|
||||
export interface AnkiDeck {
|
||||
id: number;
|
||||
mod: number;
|
||||
name: string;
|
||||
usn: number;
|
||||
lrnToday: [number, number];
|
||||
revToday: [number, number];
|
||||
newToday: [number, number];
|
||||
timeToday: [number, number];
|
||||
collapsed: boolean;
|
||||
browserCollapsed: boolean;
|
||||
desc: string;
|
||||
dyn: 0 | 1;
|
||||
conf: number;
|
||||
extendNew: number;
|
||||
extendRev: number;
|
||||
reviewLimit?: number | null;
|
||||
newLimit?: number | null;
|
||||
reviewLimitToday?: number | null;
|
||||
newLimitToday?: number | null;
|
||||
md?: boolean;
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// APKG Database Row Types
|
||||
// ============================================
|
||||
|
||||
export interface AnkiNoteRow {
|
||||
id: number;
|
||||
guid: string;
|
||||
mid: number;
|
||||
mod: number;
|
||||
usn: number;
|
||||
tags: string;
|
||||
flds: string;
|
||||
sfld: string;
|
||||
csum: number;
|
||||
flags: number;
|
||||
data: string;
|
||||
}
|
||||
|
||||
export interface AnkiCardRow {
|
||||
id: number;
|
||||
nid: number;
|
||||
did: number;
|
||||
ord: number;
|
||||
mod: number;
|
||||
usn: number;
|
||||
type: number; // 0=new, 1=learning, 2=review, 3=relearning
|
||||
queue: number; // -3=buried(user), -2=buried(sched), -1=suspended, 0=new, 1=learning, 2=review, 3=day learning, 4=preview
|
||||
due: number;
|
||||
ivl: number;
|
||||
factor: number;
|
||||
reps: number;
|
||||
lapses: number;
|
||||
left: number;
|
||||
odue: number;
|
||||
odid: number;
|
||||
flags: number;
|
||||
data: string;
|
||||
}
|
||||
|
||||
export interface AnkiRevlogRow {
|
||||
id: number;
|
||||
cid: number;
|
||||
usn: number;
|
||||
ease: number;
|
||||
ivl: number;
|
||||
lastIvl: number;
|
||||
factor: number;
|
||||
time: number;
|
||||
type: number;
|
||||
}
|
||||
|
||||
// ============================================
|
||||
// Parsed APKG Types
|
||||
// ============================================
|
||||
|
||||
export interface ParsedApkg {
|
||||
decks: Map<number, AnkiDeck>;
|
||||
noteTypes: Map<number, AnkiNoteType>;
|
||||
deckConfigs: Map<number, AnkiDeckConfig>;
|
||||
notes: AnkiNoteRow[];
|
||||
cards: AnkiCardRow[];
|
||||
revlogs: AnkiRevlogRow[];
|
||||
media: Map<string, Buffer>;
|
||||
collectionMeta: {
|
||||
crt: number;
|
||||
mod: number;
|
||||
ver: number;
|
||||
};
|
||||
}
|
||||
|
||||
export interface ApkgImportResult {
|
||||
success: boolean;
|
||||
deckName: string;
|
||||
noteCount: number;
|
||||
cardCount: number;
|
||||
mediaCount: number;
|
||||
errors: string[];
|
||||
}
|
||||
134
src/modules/export/export-action.ts
Normal file
134
src/modules/export/export-action.ts
Normal file
@@ -0,0 +1,134 @@
|
||||
"use server";
|
||||
|
||||
import { auth } from "@/auth";
|
||||
import { headers } from "next/headers";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { exportApkg, type ExportDeckData } from "@/lib/anki/apkg-exporter";
|
||||
import { createLogger } from "@/lib/logger";
|
||||
|
||||
const log = createLogger("export-action");
|
||||
|
||||
export interface ActionOutputExportApkg {
|
||||
success: boolean;
|
||||
message: string;
|
||||
data?: ArrayBuffer;
|
||||
filename?: string;
|
||||
}
|
||||
|
||||
export async function actionExportApkg(deckId: number): Promise<ActionOutputExportApkg> {
|
||||
const session = await auth.api.getSession({ headers: await headers() });
|
||||
if (!session?.user?.id) {
|
||||
return { success: false, message: "Unauthorized" };
|
||||
}
|
||||
|
||||
try {
|
||||
const deck = await prisma.deck.findFirst({
|
||||
where: { id: deckId, userId: session.user.id },
|
||||
include: {
|
||||
cards: {
|
||||
include: {
|
||||
note: {
|
||||
include: {
|
||||
noteType: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
if (!deck) {
|
||||
return { success: false, message: "Deck not found or access denied" };
|
||||
}
|
||||
|
||||
if (deck.cards.length === 0) {
|
||||
return { success: false, message: "Deck has no cards to export" };
|
||||
}
|
||||
|
||||
const firstCard = deck.cards[0];
|
||||
if (!firstCard?.note?.noteType) {
|
||||
return { success: false, message: "Deck has invalid card data" };
|
||||
}
|
||||
|
||||
const noteType = firstCard.note.noteType;
|
||||
|
||||
const revlogs = await prisma.revlog.findMany({
|
||||
where: {
|
||||
cardId: { in: deck.cards.map(c => c.id) },
|
||||
},
|
||||
});
|
||||
|
||||
const exportData: ExportDeckData = {
|
||||
deck: {
|
||||
id: deck.id,
|
||||
name: deck.name,
|
||||
desc: deck.desc,
|
||||
collapsed: deck.collapsed,
|
||||
conf: deck.conf as Record<string, unknown>,
|
||||
},
|
||||
noteType: {
|
||||
id: noteType.id,
|
||||
name: noteType.name,
|
||||
kind: noteType.kind,
|
||||
css: noteType.css,
|
||||
fields: (noteType.fields as { name: string; ord: number }[]) ?? [],
|
||||
templates: (noteType.templates as { name: string; ord: number; qfmt: string; afmt: string }[]) ?? [],
|
||||
},
|
||||
notes: deck.cards.map((card) => ({
|
||||
id: card.note.id,
|
||||
guid: card.note.guid,
|
||||
tags: card.note.tags,
|
||||
flds: card.note.flds,
|
||||
sfld: card.note.sfld,
|
||||
csum: card.note.csum,
|
||||
})),
|
||||
cards: deck.cards.map((card) => ({
|
||||
id: card.id,
|
||||
noteId: card.noteId,
|
||||
ord: card.ord,
|
||||
type: card.type,
|
||||
queue: card.queue,
|
||||
due: card.due,
|
||||
ivl: card.ivl,
|
||||
factor: card.factor,
|
||||
reps: card.reps,
|
||||
lapses: card.lapses,
|
||||
left: card.left,
|
||||
})),
|
||||
revlogs: revlogs.map((r) => ({
|
||||
id: r.id,
|
||||
cardId: r.cardId,
|
||||
ease: r.ease,
|
||||
ivl: r.ivl,
|
||||
lastIvl: r.lastIvl,
|
||||
factor: r.factor,
|
||||
time: r.time,
|
||||
type: r.type,
|
||||
})),
|
||||
media: new Map(),
|
||||
};
|
||||
|
||||
const apkgBuffer = await exportApkg(exportData);
|
||||
|
||||
log.info("APKG exported successfully", {
|
||||
userId: session.user.id,
|
||||
deckId: deck.id,
|
||||
cardCount: deck.cards.length,
|
||||
});
|
||||
|
||||
const safeDeckName = deck.name.replace(/[^a-zA-Z0-9\u4e00-\u9fff_-]/g, "_");
|
||||
|
||||
return {
|
||||
success: true,
|
||||
message: "Deck exported successfully",
|
||||
data: apkgBuffer.buffer.slice(apkgBuffer.byteOffset, apkgBuffer.byteOffset + apkgBuffer.byteLength) as ArrayBuffer,
|
||||
filename: `${safeDeckName}.apkg`,
|
||||
};
|
||||
} catch (error) {
|
||||
log.error("Failed to export APKG", { error, deckId });
|
||||
return {
|
||||
success: false,
|
||||
message: error instanceof Error ? error.message : "Failed to export deck",
|
||||
};
|
||||
}
|
||||
}
|
||||
296
src/modules/import/import-action.ts
Normal file
296
src/modules/import/import-action.ts
Normal file
@@ -0,0 +1,296 @@
|
||||
"use server";
|
||||
|
||||
import { auth } from "@/auth";
|
||||
import { headers } from "next/headers";
|
||||
import { validate } from "@/utils/validate";
|
||||
import { z } from "zod";
|
||||
import { parseApkg, getDeckNames, getDeckNotesAndCards } from "@/lib/anki/apkg-parser";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { CardType, CardQueue, NoteKind } from "../../../generated/prisma/enums";
|
||||
import { createLogger } from "@/lib/logger";
|
||||
import type { ParsedApkg } from "@/lib/anki/types";
|
||||
|
||||
const log = createLogger("import-action");
|
||||
|
||||
const schemaImportApkg = z.object({
|
||||
deckName: z.string().min(1).optional(),
|
||||
});
|
||||
|
||||
export type ActionInputImportApkg = z.infer<typeof schemaImportApkg>;
|
||||
|
||||
export interface ActionOutputImportApkg {
|
||||
success: boolean;
|
||||
message: string;
|
||||
deckId?: number;
|
||||
noteCount?: number;
|
||||
cardCount?: number;
|
||||
}
|
||||
|
||||
export interface ActionOutputPreviewApkg {
|
||||
success: boolean;
|
||||
message: string;
|
||||
decks?: { id: number; name: string; cardCount: number }[];
|
||||
}
|
||||
|
||||
async function importNoteType(
|
||||
parsed: ParsedApkg,
|
||||
ankiNoteTypeId: number,
|
||||
userId: string
|
||||
): Promise<number> {
|
||||
const ankiNoteType = parsed.noteTypes.get(ankiNoteTypeId);
|
||||
if (!ankiNoteType) {
|
||||
throw new Error(`Note type ${ankiNoteTypeId} not found in APKG`);
|
||||
}
|
||||
|
||||
const existing = await prisma.noteType.findFirst({
|
||||
where: { name: ankiNoteType.name, userId },
|
||||
});
|
||||
|
||||
if (existing) {
|
||||
return existing.id;
|
||||
}
|
||||
|
||||
const fields = ankiNoteType.flds.map((f) => ({
|
||||
name: f.name,
|
||||
ord: f.ord,
|
||||
sticky: f.sticky,
|
||||
rtl: f.rtl,
|
||||
font: f.font,
|
||||
size: f.size,
|
||||
media: f.media,
|
||||
}));
|
||||
|
||||
const templates = ankiNoteType.tmpls.map((t) => ({
|
||||
name: t.name,
|
||||
ord: t.ord,
|
||||
qfmt: t.qfmt,
|
||||
afmt: t.afmt,
|
||||
bqfmt: t.bqfmt,
|
||||
bafmt: t.bafmt,
|
||||
did: t.did,
|
||||
}));
|
||||
|
||||
const noteType = await prisma.noteType.create({
|
||||
data: {
|
||||
name: ankiNoteType.name,
|
||||
kind: ankiNoteType.type === 1 ? NoteKind.CLOZE : NoteKind.STANDARD,
|
||||
css: ankiNoteType.css,
|
||||
fields: fields as unknown as object,
|
||||
templates: templates as unknown as object,
|
||||
userId,
|
||||
},
|
||||
});
|
||||
|
||||
return noteType.id;
|
||||
}
|
||||
|
||||
function mapAnkiCardType(type: number): CardType {
|
||||
switch (type) {
|
||||
case 0: return CardType.NEW;
|
||||
case 1: return CardType.LEARNING;
|
||||
case 2: return CardType.REVIEW;
|
||||
case 3: return CardType.RELEARNING;
|
||||
default: return CardType.NEW;
|
||||
}
|
||||
}
|
||||
|
||||
function mapAnkiCardQueue(queue: number): CardQueue {
|
||||
switch (queue) {
|
||||
case -3: return CardQueue.USER_BURIED;
|
||||
case -2: return CardQueue.SCHED_BURIED;
|
||||
case -1: return CardQueue.SUSPENDED;
|
||||
case 0: return CardQueue.NEW;
|
||||
case 1: return CardQueue.LEARNING;
|
||||
case 2: return CardQueue.REVIEW;
|
||||
case 3: return CardQueue.IN_LEARNING;
|
||||
case 4: return CardQueue.PREVIEW;
|
||||
default: return CardQueue.NEW;
|
||||
}
|
||||
}
|
||||
|
||||
async function importDeck(
|
||||
parsed: ParsedApkg,
|
||||
deckId: number,
|
||||
userId: string,
|
||||
deckNameOverride?: string
|
||||
): Promise<{ deckId: number; noteCount: number; cardCount: number }> {
|
||||
const ankiDeck = parsed.decks.get(deckId);
|
||||
if (!ankiDeck) {
|
||||
throw new Error(`Deck ${deckId} not found in APKG`);
|
||||
}
|
||||
|
||||
const deck = await prisma.deck.create({
|
||||
data: {
|
||||
name: deckNameOverride || ankiDeck.name,
|
||||
desc: ankiDeck.desc || "",
|
||||
visibility: "PRIVATE",
|
||||
collapsed: ankiDeck.collapsed,
|
||||
conf: JSON.parse(JSON.stringify(ankiDeck)),
|
||||
userId,
|
||||
},
|
||||
});
|
||||
|
||||
const { notes: ankiNotes, cards: ankiCards } = getDeckNotesAndCards(parsed, deckId);
|
||||
|
||||
if (ankiNotes.length === 0) {
|
||||
return { deckId: deck.id, noteCount: 0, cardCount: 0 };
|
||||
}
|
||||
|
||||
const noteTypeIdMap = new Map<number, number>();
|
||||
const firstNote = ankiNotes[0];
|
||||
if (firstNote) {
|
||||
const importedNoteTypeId = await importNoteType(parsed, firstNote.mid, userId);
|
||||
noteTypeIdMap.set(firstNote.mid, importedNoteTypeId);
|
||||
}
|
||||
|
||||
const noteIdMap = new Map<number, bigint>();
|
||||
|
||||
for (const ankiNote of ankiNotes) {
|
||||
let noteTypeId = noteTypeIdMap.get(ankiNote.mid);
|
||||
if (!noteTypeId) {
|
||||
noteTypeId = await importNoteType(parsed, ankiNote.mid, userId);
|
||||
noteTypeIdMap.set(ankiNote.mid, noteTypeId);
|
||||
}
|
||||
|
||||
const noteId = BigInt(Date.now() + Math.floor(Math.random() * 1000));
|
||||
noteIdMap.set(ankiNote.id, noteId);
|
||||
|
||||
await prisma.note.create({
|
||||
data: {
|
||||
id: noteId,
|
||||
guid: ankiNote.guid,
|
||||
noteTypeId,
|
||||
mod: ankiNote.mod,
|
||||
usn: ankiNote.usn,
|
||||
tags: ankiNote.tags,
|
||||
flds: ankiNote.flds,
|
||||
sfld: ankiNote.sfld,
|
||||
csum: ankiNote.csum,
|
||||
flags: ankiNote.flags,
|
||||
data: ankiNote.data,
|
||||
userId,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
for (const ankiCard of ankiCards) {
|
||||
const noteId = noteIdMap.get(ankiCard.nid);
|
||||
if (!noteId) {
|
||||
log.warn("Card references non-existent note", { cardId: ankiCard.id, noteId: ankiCard.nid });
|
||||
continue;
|
||||
}
|
||||
|
||||
await prisma.card.create({
|
||||
data: {
|
||||
id: BigInt(ankiCard.id),
|
||||
noteId,
|
||||
deckId: deck.id,
|
||||
ord: ankiCard.ord,
|
||||
mod: ankiCard.mod,
|
||||
usn: ankiCard.usn,
|
||||
type: mapAnkiCardType(ankiCard.type),
|
||||
queue: mapAnkiCardQueue(ankiCard.queue),
|
||||
due: ankiCard.due,
|
||||
ivl: ankiCard.ivl,
|
||||
factor: ankiCard.factor,
|
||||
reps: ankiCard.reps,
|
||||
lapses: ankiCard.lapses,
|
||||
left: ankiCard.left,
|
||||
odue: ankiCard.odue,
|
||||
odid: ankiCard.odid,
|
||||
flags: ankiCard.flags,
|
||||
data: ankiCard.data,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
return { deckId: deck.id, noteCount: ankiNotes.length, cardCount: ankiCards.length };
|
||||
}
|
||||
|
||||
export async function actionPreviewApkg(formData: FormData): Promise<ActionOutputPreviewApkg> {
|
||||
const session = await auth.api.getSession({ headers: await headers() });
|
||||
if (!session?.user?.id) {
|
||||
return { success: false, message: "Unauthorized" };
|
||||
}
|
||||
|
||||
const file = formData.get("file") as File | null;
|
||||
if (!file) {
|
||||
return { success: false, message: "No file provided" };
|
||||
}
|
||||
|
||||
if (!file.name.endsWith(".apkg")) {
|
||||
return { success: false, message: "Invalid file type. Please upload an .apkg file" };
|
||||
}
|
||||
|
||||
try {
|
||||
const buffer = Buffer.from(await file.arrayBuffer());
|
||||
const parsed = await parseApkg(buffer);
|
||||
const decks = getDeckNames(parsed);
|
||||
|
||||
return {
|
||||
success: true,
|
||||
message: "APKG parsed successfully",
|
||||
decks: decks.filter(d => d.cardCount > 0)
|
||||
};
|
||||
} catch (error) {
|
||||
log.error("Failed to parse APKG", { error });
|
||||
return {
|
||||
success: false,
|
||||
message: error instanceof Error ? error.message : "Failed to parse APKG file"
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
export async function actionImportApkg(
|
||||
formData: FormData
|
||||
): Promise<ActionOutputImportApkg> {
|
||||
const session = await auth.api.getSession({ headers: await headers() });
|
||||
if (!session?.user?.id) {
|
||||
return { success: false, message: "Unauthorized" };
|
||||
}
|
||||
|
||||
const file = formData.get("file") as File | null;
|
||||
const deckIdStr = formData.get("deckId") as string | null;
|
||||
const deckName = formData.get("deckName") as string | null;
|
||||
|
||||
if (!file) {
|
||||
return { success: false, message: "No file provided" };
|
||||
}
|
||||
|
||||
if (!deckIdStr) {
|
||||
return { success: false, message: "No deck selected" };
|
||||
}
|
||||
|
||||
const deckId = parseInt(deckIdStr, 10);
|
||||
if (isNaN(deckId)) {
|
||||
return { success: false, message: "Invalid deck ID" };
|
||||
}
|
||||
|
||||
try {
|
||||
const buffer = Buffer.from(await file.arrayBuffer());
|
||||
const parsed = await parseApkg(buffer);
|
||||
|
||||
const result = await importDeck(parsed, deckId, session.user.id, deckName || undefined);
|
||||
|
||||
log.info("APKG imported successfully", {
|
||||
userId: session.user.id,
|
||||
deckId: result.deckId,
|
||||
noteCount: result.noteCount,
|
||||
cardCount: result.cardCount
|
||||
});
|
||||
|
||||
return {
|
||||
success: true,
|
||||
message: `Imported ${result.cardCount} cards from ${result.noteCount} notes`,
|
||||
deckId: result.deckId,
|
||||
noteCount: result.noteCount,
|
||||
cardCount: result.cardCount,
|
||||
};
|
||||
} catch (error) {
|
||||
log.error("Failed to import APKG", { error });
|
||||
return {
|
||||
success: false,
|
||||
message: error instanceof Error ? error.message : "Failed to import APKG file"
|
||||
};
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user