NotesService.js

/**
 * SPDX-FileCopyrightText: 2019 Nextcloud GmbH and Nextcloud contributors
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */

import axios from '@nextcloud/axios'
import { generateUrl } from '@nextcloud/router'
import { showError } from '@nextcloud/dialogs'

import store from './store.js'
import { copyNote } from './Util.js'

function url(url) {
	url = `apps/notes${url}`
	return generateUrl(url)
}

function handleSyncError(message, err = null) {
	if (err?.response) {
		const statusCode = err.response?.status
		switch (statusCode) {
		case 404:
			showError(message + ' ' + t('notes', 'Note not found.'))
			break
		case 423:
			showError(message + ' ' + t('notes', 'Note is locked.'))
			break
		case 507:
			showError(message + ' ' + t('notes', 'Insufficient storage.'))
			break
		default:
			showError(message + ' HTTP ' + statusCode + ' (' + err.response.data?.errorType + ')')
		}
	} else {
		showError(message + ' ' + t('notes', 'See JavaScript console and server log for details.'))
	}
}

export const setSettings = settings => {
	return axios
		.put(url('/settings'), settings)
		.then(response => {
			const settings = response.data
			store.commit('setSettings', settings)
			return settings
		})
		.catch(err => {
			console.error(err)
			handleSyncError(t('notes', 'Updating settings has failed.'), err)
			throw err
		})
}

export const deleteEditorMode = () => {
	return axios
		.post(url('/settings/migrate'))
		.catch(err => {
			console.error(err)
			throw err
		})
}

export const getDashboardData = () => {
	return axios
		.get(url('/notes/dashboard'))
		.then(response => {
			return response.data
		})
		.catch(err => {
			console.error(err)
			handleSyncError(t('notes', 'Fetching notes for dashboard has failed.'), err)
			throw err
		})
}

export const fetchNotes = async (chunkSize = 50, chunkCursor = null) => {
	console.log('[fetchNotes] Called with chunkSize:', chunkSize, 'cursor:', chunkCursor)
	const lastETag = store.state.sync.etag
	const lastModified = store.state.sync.lastModified
	const headers = {}
	if (lastETag) {
		headers['If-None-Match'] = lastETag
	}

	try {
		// Signal start of loading
		store.commit('setNotesLoadingInProgress', true)

		// Fetch settings first (only on first load)
		if (!store.state.app.settings || Object.keys(store.state.app.settings).length === 0) {
			try {
				const settingsResponse = await axios.get(generateUrl('/apps/notes/api/v1/settings'))
				store.commit('setSettings', settingsResponse.data)
			} catch (err) {
				console.warn('Failed to fetch settings, will continue with defaults', err)
			}
		}

		// Load notes metadata in chunks excluding content for performance
		// Content is loaded on-demand when user selects a note
		const params = new URLSearchParams()
		if (lastModified) {
			params.append('pruneBefore', lastModified)
		}
		params.append('exclude', 'content') // Exclude heavy content field
		params.append('chunkSize', chunkSize.toString()) // Request chunked data
		if (chunkCursor) {
			params.append('chunkCursor', chunkCursor) // Continue from previous chunk
		}

		const url = generateUrl('/apps/notes/api/v1/notes' + (params.toString() ? '?' + params.toString() : ''))
		console.log('[fetchNotes] Requesting:', url)

		const response = await axios.get(url, { headers })

		console.log('[fetchNotes] Response received, status:', response.status)
		console.log('[fetchNotes] Response data type:', Array.isArray(response.data) ? 'array' : typeof response.data)
		console.log('[fetchNotes] Response headers:', response.headers)

		// Backend returns array of notes directly
		const notes = Array.isArray(response.data) ? response.data : []
		const noteIds = notes.map(note => note.id)

		// Cursor is in response headers, not body
		const nextCursor = response.headers['x-notes-chunk-cursor'] || null
		const pendingCount = response.headers['x-notes-chunk-pending'] ? parseInt(response.headers['x-notes-chunk-pending']) : 0
		const isLastChunk = !nextCursor

		// Category statistics and total count from first chunk (if available)
		const categoryStats = response.headers['x-notes-category-stats']
		if (categoryStats) {
			try {
				const stats = JSON.parse(categoryStats)
				console.log('[fetchNotes] Received category stats:', Object.keys(stats).length, 'categories')
				store.commit('setCategoryStats', stats)
			} catch (e) {
				console.warn('[fetchNotes] Failed to parse category stats:', e)
			}
		}
		const totalCount = response.headers['x-notes-total-count']
		if (totalCount) {
			const count = parseInt(totalCount)
			console.log('[fetchNotes] Total notes count:', count)
			store.commit('setTotalNotesCount', count)
		}

		console.log('[fetchNotes] Processed:', notes.length, 'notes, noteIds:', noteIds.length)
		console.log('[fetchNotes] Cursor:', nextCursor, 'Pending:', pendingCount, 'isLastChunk:', isLastChunk)

		// Update notes incrementally
		if (chunkCursor) {
			// Subsequent chunk - use incremental update
			console.log('[fetchNotes] Using incremental update for subsequent chunk')
			store.dispatch('updateNotesIncremental', { notes, isLastChunk })
			if (isLastChunk) {
				// Final chunk - clean up deleted notes
				console.log('[fetchNotes] Final chunk - cleaning up deleted notes')
				store.dispatch('finalizeNotesUpdate', noteIds)
			}
		} else {
			// First chunk - use full update
			console.log('[fetchNotes] Using full update for first chunk')
			store.dispatch('updateNotes', { noteIds, notes })
		}

		// Update ETag and last modified
		store.commit('setSyncETag', response.headers.etag)
		store.commit('setSyncLastModified', response.headers['last-modified'])
		store.commit('setNotesLoadingInProgress', false)

		console.log('[fetchNotes] Completed successfully')
		return {
			noteIds,
			chunkCursor: nextCursor,
			isLastChunk,
		}
	} catch (err) {
		store.commit('setNotesLoadingInProgress', false)
		if (err?.response?.status === 304) {
			console.log('[fetchNotes] 304 Not Modified - no changes')
			store.commit('setSyncLastModified', err.response.headers['last-modified'])
			return null
		} else {
			console.error('[fetchNotes] Error:', err)
			handleSyncError(t('notes', 'Fetching notes has failed.'), err)
			throw err
		}
	}
}

export const searchNotes = async (searchQuery, chunkSize = 50, chunkCursor = null) => {
	console.log('[searchNotes] Called with query:', searchQuery, 'chunkSize:', chunkSize, 'cursor:', chunkCursor)

	try {
		// Signal start of loading
		store.commit('setNotesLoadingInProgress', true)

		// Build search parameters
		const params = new URLSearchParams()
		params.append('search', searchQuery)
		params.append('exclude', 'content') // Exclude heavy content field
		params.append('chunkSize', chunkSize.toString())
		if (chunkCursor) {
			params.append('chunkCursor', chunkCursor)
		}

		const url = generateUrl('/apps/notes/api/v1/notes' + (params.toString() ? '?' + params.toString() : ''))
		console.log('[searchNotes] Requesting:', url)

		const response = await axios.get(url)

		console.log('[searchNotes] Response received, status:', response.status)

		// Backend returns array of notes directly
		const notes = Array.isArray(response.data) ? response.data : []
		const noteIds = notes.map(note => note.id)

		// Cursor is in response headers, not body
		const nextCursor = response.headers['x-notes-chunk-cursor'] || null
		const isLastChunk = !nextCursor

		console.log('[searchNotes] Processed:', notes.length, 'notes, cursor:', nextCursor)

		// For search, we want to replace notes on first chunk, then append on subsequent chunks
		if (chunkCursor) {
			// Subsequent chunk - use incremental update
			console.log('[searchNotes] Using incremental update for subsequent chunk')
			store.dispatch('updateNotesIncremental', { notes, isLastChunk })
		} else {
			// First chunk - replace with search results
			console.log('[searchNotes] Using full update for first chunk')
			store.dispatch('updateNotes', { noteIds, notes })
		}

		store.commit('setNotesLoadingInProgress', false)

		console.log('[searchNotes] Completed successfully')
		return {
			noteIds,
			chunkCursor: nextCursor,
			isLastChunk,
		}
	} catch (err) {
		store.commit('setNotesLoadingInProgress', false)
		console.error('[searchNotes] Error:', err)
		handleSyncError(t('notes', 'Searching notes has failed.'), err)
		throw err
	}
}

export const fetchNote = noteId => {
	return axios
		.get(url('/notes/' + noteId))
		.then(response => {
			const localNote = store.getters.getNote(parseInt(noteId))
			// only overwrite if there are no unsaved changes
			if (!localNote || !localNote.unsaved) {
				_updateLocalNote(response.data)
			}
			return response.data
		})
		.catch(err => {
			if (err?.response?.status === 404) {
				throw err
			} else {
				console.error(err)
				const msg = t('notes', 'Fetching note {id} has failed.', { id: noteId })
				store.commit('setNoteAttribute', { noteId, attribute: 'error', value: true })
				store.commit('setNoteAttribute', { noteId, attribute: 'errorType', value: msg })
				return store.getter.getNote(noteId)
			}
		})
}

export const refreshNote = (noteId, lastETag) => {
	const headers = {}
	if (lastETag) {
		headers['If-None-Match'] = lastETag
	}
	const note = store.getters.getNote(noteId)
	const oldContent = note.content
	return axios
		.get(
			url('/notes/' + noteId),
			{ headers },
		)
		.then(response => {
			if (note.conflict) {
				store.commit('setNoteAttribute', { noteId, attribute: 'conflict', value: response.data })
				return response.headers.etag
			}
			const currentContent = store.getters.getNote(noteId).content
			store.commit('setNoteAttribute', { noteId, attribute: 'internalPath', value: response.data.internalPath })
			// only update if local content has not changed
			if (oldContent === currentContent) {
				_updateLocalNote(response.data)
				return response.headers.etag
			}
			return null
		})
		.catch(err => {
			if (err?.response?.status === 304 || note.deleting) {
				// ignore error if note is deleting or not changed
				return null
			} else if (err?.code === 'ECONNABORTED') {
				// ignore cancelled request
				console.debug('Refresh Note request was cancelled.')
				return null
			} else {
				console.error(err)
				handleSyncError(t('notes', 'Refreshing note {id} has failed.', { id: noteId }), err)
			}
			return null
		})
}

export const setTitle = (noteId, title) => {
	return axios
		.put(url('/notes/' + noteId + '/title'), { title })
		.then(response => {
			store.commit('setNoteAttribute', { noteId, attribute: 'title', value: response.data.title })
			// need to update the internal path as well since sharing sidebar uses it
			store.commit('setNoteAttribute', { noteId, attribute: 'internalPath', value: response.data?.internalPath })
		})
		.catch(err => {
			console.error(err)
			handleSyncError(t('notes', 'Renaming note {id} has failed.', { id: noteId }), err)
			throw err
		})
}

export const createNote = (category, title, content) => {
	return axios
		.post(url('/notes'), {
			category: category || '',
			content: content || '',
			title: title || '',
		})
		.then(response => {
			_updateLocalNote(response.data)
			return response.data
		})
		.catch(err => {
			console.error(err)
			handleSyncError(t('notes', 'Creating new note has failed.'), err)
			throw err
		})
}

function _updateLocalNote(note, reference) {
	if (reference === undefined) {
		reference = copyNote(note, {})
	}
	store.commit('updateNote', note)
	store.commit('setNoteAttribute', { noteId: note.id, attribute: 'reference', value: reference })
}

function _updateNote(note) {
	const requestOptions = { headers: { 'If-Match': '"' + note.etag + '"' } }
	return axios
		.put(url('/notes/' + note.id), { content: note.content }, requestOptions)
		.then(response => {
			note.saveError = false
			store.commit('setNoteAttribute', { noteId: note.id, attribute: 'conflict', value: undefined })
			const updated = response.data
			if (updated.content === note.content) {
				// everything is fine
				// => update note with remote data
				_updateLocalNote(
					{ ...updated, unsaved: false },
				)
			} else {
				// content has changed locally in the meanwhile
				// => merge note, but exclude content
				_updateLocalNote(
					copyNote(updated, note, ['content']),
					copyNote(updated, {}),
				)
			}
		})
		.catch(err => {
			if (err?.response?.status === 412) {
				// ETag does not match, try to merge changes
				note.saveError = false
				store.commit('setNoteAttribute', { noteId: note.id, attribute: 'conflict', value: undefined })
				const reference = note.reference
				const remote = err.response.data
				if (remote.content === note.content) {
					// content is already up-to-date
					// => update note with remote data
					_updateLocalNote(
						{ ...remote, unsaved: false },
					)
				} else if (remote.content === reference.content) {
					// remote content has not changed
					// => use all other attributes and sync again
					_updateLocalNote(
						copyNote(remote, note, ['content']),
						copyNote(remote, {}),
					)
					queueCommand(note.id, 'content')
				} else {
					console.info('Note update conflict. Manual resolution required.')
					store.commit('setNoteAttribute', { noteId: note.id, attribute: 'conflict', value: remote })
				}
			} else {
				store.commit('setNoteAttribute', { noteId: note.id, attribute: 'saveError', value: true })
				console.error(err)
				handleSyncError(t('notes', 'Saving note {id} has failed.', { id: note.id }), err)
			}
		})
}

export const conflictSolutionLocal = note => {
	note.etag = note.conflict.etag
	_updateLocalNote(
		copyNote(note.conflict, note, ['content']),
		copyNote(note.conflict, {}),
	)
	store.commit('setNoteAttribute', { noteId: note.id, attribute: 'conflict', value: undefined })
	queueCommand(note.id, 'content')
}

export const conflictSolutionRemote = note => {
	_updateLocalNote(
		{ ...note.conflict, unsaved: false },
	)
	store.commit('setNoteAttribute', { noteId: note.id, attribute: 'conflict', value: undefined })
}

export const autotitleNote = noteId => {
	return axios
		.put(url('/notes/' + noteId + '/autotitle'))
		.then((response) => {
			store.commit('setNoteAttribute', { noteId, attribute: 'title', value: response.data })
			refreshNote(noteId)
		})
		.catch(err => {
			console.error(err)
			handleSyncError(t('notes', 'Updating title for note {id} has failed.', { id: noteId }), err)
		})
}

export const undoDeleteNote = (note) => {
	return axios
		.post(url('/notes/undo'), note)
		.then(response => {
			_updateLocalNote(response.data)
			return response.data
		})
		.catch(err => {
			console.error(err)
			handleSyncError(t('notes', 'Undo delete has failed for note {title}.', { title: note.title }), err)
			throw err
		})
}

export const deleteNote = async (noteId, onNoteDeleted) => {
	store.commit('setNoteAttribute', { noteId, attribute: 'deleting', value: 'deleting' })
	try {
		await axios.delete(url('/notes/' + noteId))
	} catch (err) {
		console.error(err)
		handleSyncError(t('notes', 'Deleting note {id} has failed.', { id: noteId }), err)
	}
	// remove note always since we don't know when exactly the error happened
	// (note could be deleted on server even if an error was thrown)
	onNoteDeleted()
	store.commit('removeNote', noteId)
}

export const setFavorite = (noteId, favorite) => {
	return axios
		.put(url('/notes/' + noteId + '/favorite'), { favorite })
		.then(response => {
			store.commit('setNoteAttribute', { noteId, attribute: 'favorite', value: response.data })
		})
		.catch(err => {
			console.error(err)
			handleSyncError(t('notes', 'Toggling favorite for note {id} has failed.', { id: noteId }), err)
			throw err
		})
}

export const setCategory = (noteId, category) => {
	return axios
		.put(url('/notes/' + noteId + '/category'), { category })
		.then(response => {
			const realCategory = response.data
			if (category !== realCategory) {
				handleSyncError(t('notes', 'Updating the note\'s category has failed. Is the target directory writable?'))
			}
			store.commit('setNoteAttribute', { noteId, attribute: 'category', value: realCategory })
		})
		.catch(err => {
			console.error(err)
			handleSyncError(t('notes', 'Updating the category for note {id} has failed.', { id: noteId }), err)
			throw err
		})
}

export const queueCommand = (noteId, type) => {
	store.commit('addToQueue', { noteId, type })
	_processQueue()
}

function _processQueue() {
	const queue = Object.values(store.state.sync.queue)
	if (store.state.app.isSaving || queue.length === 0) {
		return
	}
	store.commit('setSaving', true)
	store.commit('clearQueue')

	async function _executeQueueCommands() {
		for (const cmd of queue) {
			try {
				switch (cmd.type) {
				case 'content':
					await _updateNote(store.state.notes.notesIds[cmd.noteId])
					break
				case 'autotitle':
					await autotitleNote(cmd.noteId)
					break
				default:
					console.error('Unknown queue command: ' + cmd.type)
				}

			} catch (e) {
				console.error('Command has failed with error:')
				console.error(e)
			}
		}
		store.commit('setSaving', false)
		store.commit('setManualSave', false)
		_processQueue()
	}
	_executeQueueCommands()
}

export const saveNoteManually = (noteId) => {
	store.commit('setNoteAttribute', { noteId, attribute: 'saveError', value: false })
	store.commit('setManualSave', true)
	queueCommand(noteId, 'content')
}

export const noteExists = (noteId) => {
	return store.getters.noteExists(noteId)
}

export const getCategories = (maxLevel, details) => {
	const categories = store.getters.getCategories(maxLevel, details)
	if (maxLevel === 0) {
		return [...new Set([...categories, ...store.state.notes.categories])]
	} else {
		return categories
	}
}