302 lines
8.3 KiB
TypeScript
302 lines
8.3 KiB
TypeScript
'use server'
|
|
|
|
import { revalidatePath } from 'next/cache'
|
|
import prisma from '@/lib/prisma'
|
|
import { Note, CheckItem } from '@/lib/types'
|
|
|
|
// Helper function to parse JSON strings from database
|
|
function parseNote(dbNote: any): Note {
|
|
return {
|
|
...dbNote,
|
|
checkItems: dbNote.checkItems ? JSON.parse(dbNote.checkItems) : null,
|
|
labels: dbNote.labels ? JSON.parse(dbNote.labels) : null,
|
|
images: dbNote.images ? JSON.parse(dbNote.images) : null,
|
|
}
|
|
}
|
|
|
|
// Get all notes (non-archived by default)
|
|
export async function getNotes(includeArchived = false) {
|
|
try {
|
|
const notes = await prisma.note.findMany({
|
|
where: includeArchived ? {} : { isArchived: false },
|
|
orderBy: [
|
|
{ isPinned: 'desc' },
|
|
{ order: 'asc' },
|
|
{ updatedAt: 'desc' }
|
|
]
|
|
})
|
|
|
|
return notes.map(parseNote)
|
|
} catch (error) {
|
|
console.error('Error fetching notes:', error)
|
|
return []
|
|
}
|
|
}
|
|
|
|
// Get archived notes only
|
|
export async function getArchivedNotes() {
|
|
try {
|
|
const notes = await prisma.note.findMany({
|
|
where: { isArchived: true },
|
|
orderBy: { updatedAt: 'desc' }
|
|
})
|
|
|
|
return notes.map(parseNote)
|
|
} catch (error) {
|
|
console.error('Error fetching archived notes:', error)
|
|
return []
|
|
}
|
|
}
|
|
|
|
// Search notes
|
|
export async function searchNotes(query: string) {
|
|
try {
|
|
if (!query.trim()) {
|
|
return await getNotes()
|
|
}
|
|
|
|
const notes = await prisma.note.findMany({
|
|
where: {
|
|
isArchived: false,
|
|
OR: [
|
|
{ title: { contains: query } },
|
|
{ content: { contains: query } },
|
|
{ labels: { contains: query } },
|
|
{ checkItems: { contains: query } }
|
|
]
|
|
},
|
|
orderBy: [
|
|
{ isPinned: 'desc' },
|
|
{ updatedAt: 'desc' }
|
|
]
|
|
})
|
|
|
|
// Enhanced ranking: prioritize title matches
|
|
const rankedNotes = notes.map(note => {
|
|
const parsedNote = parseNote(note)
|
|
let score = 0
|
|
|
|
// Title match gets highest score
|
|
if (parsedNote.title?.toLowerCase().includes(query.toLowerCase())) {
|
|
score += 10
|
|
}
|
|
|
|
// Content match
|
|
if (parsedNote.content.toLowerCase().includes(query.toLowerCase())) {
|
|
score += 5
|
|
}
|
|
|
|
// Label match
|
|
if (parsedNote.labels?.some(label => label.toLowerCase().includes(query.toLowerCase()))) {
|
|
score += 3
|
|
}
|
|
|
|
// CheckItems match
|
|
if (parsedNote.checkItems?.some(item => item.text.toLowerCase().includes(query.toLowerCase()))) {
|
|
score += 2
|
|
}
|
|
|
|
return { note: parsedNote, score }
|
|
})
|
|
|
|
// Sort by score descending, then by existing order (pinned/updated)
|
|
return rankedNotes
|
|
.sort((a, b) => b.score - a.score)
|
|
.map(item => item.note)
|
|
} catch (error) {
|
|
console.error('Error searching notes:', error)
|
|
return []
|
|
}
|
|
}
|
|
|
|
// Create a new note
|
|
export async function createNote(data: {
|
|
title?: string
|
|
content: string
|
|
color?: string
|
|
type?: 'text' | 'checklist'
|
|
checkItems?: CheckItem[]
|
|
labels?: string[]
|
|
images?: string[]
|
|
isArchived?: boolean
|
|
reminder?: Date | null
|
|
isMarkdown?: boolean
|
|
}) {
|
|
try {
|
|
const note = await prisma.note.create({
|
|
data: {
|
|
title: data.title || null,
|
|
content: data.content,
|
|
color: data.color || 'default',
|
|
type: data.type || 'text',
|
|
checkItems: data.checkItems ? JSON.stringify(data.checkItems) : null,
|
|
labels: data.labels ? JSON.stringify(data.labels) : null,
|
|
images: data.images ? JSON.stringify(data.images) : null,
|
|
isArchived: data.isArchived || false,
|
|
reminder: data.reminder || null,
|
|
isMarkdown: data.isMarkdown || false,
|
|
}
|
|
})
|
|
|
|
revalidatePath('/')
|
|
return parseNote(note)
|
|
} catch (error) {
|
|
console.error('Error creating note:', error)
|
|
throw new Error('Failed to create note')
|
|
}
|
|
}
|
|
|
|
// Update a note
|
|
export async function updateNote(id: string, data: {
|
|
title?: string | null
|
|
content?: string
|
|
color?: string
|
|
isPinned?: boolean
|
|
isArchived?: boolean
|
|
type?: 'text' | 'checklist'
|
|
checkItems?: CheckItem[] | null
|
|
labels?: string[] | null
|
|
images?: string[] | null
|
|
reminder?: Date | null
|
|
isMarkdown?: boolean
|
|
}) {
|
|
try {
|
|
// Stringify JSON fields if they exist
|
|
const updateData: any = { ...data }
|
|
if ('checkItems' in data) {
|
|
updateData.checkItems = data.checkItems ? JSON.stringify(data.checkItems) : null
|
|
}
|
|
if ('labels' in data) {
|
|
updateData.labels = data.labels ? JSON.stringify(data.labels) : null
|
|
}
|
|
if ('images' in data) {
|
|
updateData.images = data.images ? JSON.stringify(data.images) : null
|
|
}
|
|
updateData.updatedAt = new Date()
|
|
|
|
const note = await prisma.note.update({
|
|
where: { id },
|
|
data: updateData
|
|
})
|
|
|
|
revalidatePath('/')
|
|
return parseNote(note)
|
|
} catch (error) {
|
|
console.error('Error updating note:', error)
|
|
throw new Error('Failed to update note')
|
|
}
|
|
}
|
|
|
|
// Delete a note
|
|
export async function deleteNote(id: string) {
|
|
try {
|
|
await prisma.note.delete({
|
|
where: { id }
|
|
})
|
|
|
|
revalidatePath('/')
|
|
return { success: true }
|
|
} catch (error) {
|
|
console.error('Error deleting note:', error)
|
|
throw new Error('Failed to delete note')
|
|
}
|
|
}
|
|
|
|
// Toggle pin status
|
|
export async function togglePin(id: string, isPinned: boolean) {
|
|
return updateNote(id, { isPinned })
|
|
}
|
|
|
|
// Toggle archive status
|
|
export async function toggleArchive(id: string, isArchived: boolean) {
|
|
return updateNote(id, { isArchived })
|
|
}
|
|
|
|
// Update note color
|
|
export async function updateColor(id: string, color: string) {
|
|
return updateNote(id, { color })
|
|
}
|
|
|
|
// Update note labels
|
|
export async function updateLabels(id: string, labels: string[]) {
|
|
return updateNote(id, { labels })
|
|
}
|
|
|
|
// Get all unique labels
|
|
export async function getAllLabels() {
|
|
try {
|
|
const notes = await prisma.note.findMany({
|
|
select: { labels: true }
|
|
})
|
|
|
|
const labelsSet = new Set<string>()
|
|
notes.forEach(note => {
|
|
const labels = note.labels ? JSON.parse(note.labels) : null
|
|
if (labels) {
|
|
labels.forEach((label: string) => labelsSet.add(label))
|
|
}
|
|
})
|
|
|
|
return Array.from(labelsSet).sort()
|
|
} catch (error) {
|
|
console.error('Error fetching labels:', error)
|
|
return []
|
|
}
|
|
}
|
|
|
|
// Reorder notes (drag and drop)
|
|
export async function reorderNotes(draggedId: string, targetId: string) {
|
|
console.log('[REORDER-DEBUG] reorderNotes called:', { draggedId, targetId })
|
|
|
|
try {
|
|
const draggedNote = await prisma.note.findUnique({ where: { id: draggedId } })
|
|
const targetNote = await prisma.note.findUnique({ where: { id: targetId } })
|
|
|
|
console.log('[REORDER-DEBUG] Notes found:', {
|
|
draggedNote: draggedNote ? { id: draggedNote.id, title: draggedNote.title, isPinned: draggedNote.isPinned, order: draggedNote.order } : null,
|
|
targetNote: targetNote ? { id: targetNote.id, title: targetNote.title, isPinned: targetNote.isPinned, order: targetNote.order } : null
|
|
})
|
|
|
|
if (!draggedNote || !targetNote) {
|
|
console.error('[REORDER-DEBUG] Notes not found')
|
|
throw new Error('Notes not found')
|
|
}
|
|
|
|
// Get all notes in the same category (pinned or unpinned)
|
|
const allNotes = await prisma.note.findMany({
|
|
where: {
|
|
isPinned: draggedNote.isPinned,
|
|
isArchived: false
|
|
},
|
|
orderBy: { order: 'asc' }
|
|
})
|
|
|
|
console.log('[REORDER-DEBUG] All notes in category:', allNotes.map(n => ({ id: n.id, title: n.title, order: n.order })))
|
|
|
|
// Create new order array
|
|
const reorderedNotes = allNotes.filter(n => n.id !== draggedId)
|
|
const targetIndex = reorderedNotes.findIndex(n => n.id === targetId)
|
|
reorderedNotes.splice(targetIndex, 0, draggedNote)
|
|
|
|
console.log('[REORDER-DEBUG] New order:', reorderedNotes.map((n, i) => ({ id: n.id, title: n.title, newOrder: i })))
|
|
|
|
// Update all notes with new order
|
|
const updates = reorderedNotes.map((note, index) =>
|
|
prisma.note.update({
|
|
where: { id: note.id },
|
|
data: { order: index }
|
|
})
|
|
)
|
|
|
|
console.log('[REORDER-DEBUG] Executing transaction with', updates.length, 'updates')
|
|
await prisma.$transaction(updates)
|
|
console.log('[REORDER-DEBUG] Transaction completed successfully')
|
|
|
|
revalidatePath('/')
|
|
return { success: true }
|
|
} catch (error) {
|
|
console.error('[REORDER-DEBUG] Error reordering notes:', error)
|
|
throw new Error('Failed to reorder notes')
|
|
}
|
|
}
|