mirror of
https://github.com/BoostIo/Boostnote
synced 2025-12-13 17:56:25 +00:00
566 lines
15 KiB
JavaScript
566 lines
15 KiB
JavaScript
const keygen = require('browser/lib/keygen')
|
|
const CSON = require('season')
|
|
const path = require('path')
|
|
const _ = require('lodash')
|
|
const sander = require('sander')
|
|
const consts = require('browser/lib/consts')
|
|
|
|
let storages = []
|
|
let notes = []
|
|
|
|
let queuedTasks = []
|
|
|
|
function queueSaveFolder (storageKey, folderKey) {
|
|
let storage = _.find(storages, {key: storageKey})
|
|
if (storage == null) throw new Error('Failed to queue: Storage doesn\'t exist.')
|
|
|
|
let targetTasks = queuedTasks.filter((task) => task.storage === storageKey && task.folder === folderKey)
|
|
targetTasks.forEach((task) => {
|
|
clearTimeout(task.timer)
|
|
})
|
|
queuedTasks = queuedTasks.filter((task) => task.storage !== storageKey || task.folder !== folderKey)
|
|
let newTimer = setTimeout(() => {
|
|
let folderNotes = notes.filter((note) => note.storage === storageKey && note.folder === folderKey)
|
|
sander
|
|
.writeFile(path.join(storage.cache.path, folderKey, 'data.json'), JSON.stringify({
|
|
notes: folderNotes.map((note) => {
|
|
let json = note.toJSON()
|
|
delete json.storage
|
|
return json
|
|
})
|
|
}))
|
|
}, 1500)
|
|
|
|
queuedTasks.push({
|
|
storage: storageKey,
|
|
folder: folderKey,
|
|
timer: newTimer
|
|
})
|
|
}
|
|
|
|
class Storage {
|
|
constructor (cache) {
|
|
this.key = cache.key
|
|
this.cache = cache
|
|
}
|
|
|
|
loadJSONData () {
|
|
return new Promise((resolve, reject) => {
|
|
try {
|
|
let data = CSON.readFileSync(path.join(this.cache.path, 'boostnote.json'))
|
|
this.data = data
|
|
resolve(this)
|
|
} catch (err) {
|
|
reject(err)
|
|
}
|
|
})
|
|
}
|
|
|
|
toJSON () {
|
|
return Object.assign({}, this.cache, this.data)
|
|
}
|
|
|
|
initStorage () {
|
|
return this.loadJSONData()
|
|
.catch((err) => {
|
|
console.error(err.code)
|
|
if (err.code === 'ENOENT') {
|
|
let initialStorage = {
|
|
folders: []
|
|
}
|
|
|
|
return sander.writeFile(path.join(this.cache.path, 'boostnote.json'), JSON.stringify(initialStorage))
|
|
} else throw err
|
|
})
|
|
.then(() => this.loadJSONData())
|
|
}
|
|
|
|
saveData () {
|
|
return sander
|
|
.writeFile(path.join(this.cache.path, 'boostnote.json'), JSON.stringify(this.data))
|
|
.then(() => this)
|
|
}
|
|
|
|
saveCache () {
|
|
_saveCaches()
|
|
}
|
|
|
|
static forge (cache) {
|
|
let instance = new this(cache)
|
|
return instance
|
|
}
|
|
}
|
|
|
|
class Note {
|
|
constructor (note) {
|
|
this.storage = note.storage
|
|
this.folder = note.folder
|
|
this.key = note.key
|
|
this.uniqueKey = `${note.storage}-${note.folder}-${note.key}`
|
|
this.data = note
|
|
}
|
|
|
|
toJSON () {
|
|
return Object.assign({}, this.data, {
|
|
uniqueKey: this.uniqueKey
|
|
})
|
|
}
|
|
|
|
save () {
|
|
let storage = _.find(storages, {key: this.storage})
|
|
if (storage == null) return Promise.reject(new Error('Storage doesn\'t exist.'))
|
|
let folder = _.find(storage.data.folders, {key: this.folder})
|
|
if (folder == null) return Promise.reject(new Error('Storage doesn\'t exist.'))
|
|
|
|
// FS MUST BE MANIPULATED BY ASYNC METHOD
|
|
queueSaveFolder(storage.key, folder.key)
|
|
return Promise.resolve(this)
|
|
}
|
|
|
|
static forge (note) {
|
|
let instance = new this(note)
|
|
|
|
return Promise.resolve(instance)
|
|
}
|
|
}
|
|
|
|
function init () {
|
|
let fetchStorages = function () {
|
|
let caches
|
|
try {
|
|
caches = JSON.parse(localStorage.getItem('storages'))
|
|
if (!_.isArray(caches)) throw new Error('Cached data is not valid.')
|
|
} catch (e) {
|
|
console.error(e)
|
|
caches = []
|
|
localStorage.setItem('storages', JSON.stringify(caches))
|
|
}
|
|
|
|
return caches.map((cache) => {
|
|
return Storage
|
|
.forge(cache)
|
|
.loadJSONData()
|
|
.catch((err) => {
|
|
console.error(err)
|
|
console.error('Failed to load a storage JSON File: %s', cache)
|
|
return null
|
|
})
|
|
})
|
|
}
|
|
|
|
let fetchNotes = function (storages) {
|
|
let notes = []
|
|
let modifiedStorages = []
|
|
storages
|
|
.forEach((storage) => {
|
|
storage.data.folders.forEach((folder) => {
|
|
let dataPath = path.join(storage.cache.path, folder.key, 'data.json')
|
|
let data
|
|
try {
|
|
data = CSON.readFileSync(dataPath)
|
|
} catch (e) {
|
|
// Remove folder if fetching failed.
|
|
console.error('Failed to load data: %s', dataPath)
|
|
storage.data.folders = storage.data.folders.filter((_folder) => _folder.key !== folder.key)
|
|
if (modifiedStorages.some((modified) => modified.key === storage.key)) modifiedStorages.push(storage)
|
|
return
|
|
}
|
|
data.notes.forEach((note) => {
|
|
note.storage = storage.key
|
|
note.folder = folder.key
|
|
notes.push(Note.forge(note))
|
|
})
|
|
})
|
|
}, [])
|
|
return Promise
|
|
.all(modifiedStorages.map((storage) => storage.saveData()))
|
|
.then(() => Promise.all(notes))
|
|
}
|
|
|
|
return Promise.all(fetchStorages())
|
|
.then((_storages) => {
|
|
storages = _storages.filter((storage) => {
|
|
if (!_.isObject(storage)) return false
|
|
return true
|
|
})
|
|
_saveCaches()
|
|
|
|
return storages
|
|
})
|
|
.then(fetchNotes)
|
|
.then((_notes) => {
|
|
notes = _notes
|
|
return {
|
|
storages: storages.map((storage) => storage.toJSON()),
|
|
notes: notes.map((note) => note.toJSON())
|
|
}
|
|
})
|
|
}
|
|
|
|
function _saveCaches () {
|
|
localStorage.setItem('storages', JSON.stringify(storages.map((storage) => storage.cache)))
|
|
}
|
|
|
|
function addStorage (input) {
|
|
if (!_.isString(input.path) || !input.path.match(/^\//)) {
|
|
return Promise.reject(new Error('Path must be absolute.'))
|
|
}
|
|
|
|
let key = keygen()
|
|
while (storages.some((storage) => storage.key === key)) {
|
|
key = keygen()
|
|
}
|
|
|
|
return Storage
|
|
.forge({
|
|
name: input.name,
|
|
key: key,
|
|
type: input.type,
|
|
path: input.path
|
|
})
|
|
.initStorage()
|
|
.then((storage) => {
|
|
let _notes = []
|
|
let isFolderRemoved = false
|
|
storage.data.folders.forEach((folder) => {
|
|
let dataPath = path.join(storage.cache.path, folder.key, 'data.json')
|
|
let data
|
|
try {
|
|
data = CSON.readFileSync(dataPath)
|
|
} catch (e) {
|
|
// Remove folder if fetching failed.
|
|
console.error('Failed to load data: %s', dataPath)
|
|
storage.data.folders = storage.data.folders.filter((_folder) => _folder.key !== folder.key)
|
|
isFolderRemoved = true
|
|
return true
|
|
}
|
|
data.notes.forEach((note) => {
|
|
note.storage = storage.key
|
|
note.folder = folder.key
|
|
_notes.push(Note.forge(note))
|
|
})
|
|
})
|
|
|
|
return Promise.all(_notes)
|
|
.then((_notes) => {
|
|
notes = notes.concat(_notes)
|
|
let data = {
|
|
storage: storage,
|
|
notes: _notes
|
|
}
|
|
return isFolderRemoved
|
|
? storage.saveData().then(() => data)
|
|
: data
|
|
})
|
|
})
|
|
.then((data) => {
|
|
storages = storages.filter((storage) => storage.key !== data.storage.key)
|
|
storages.push(data.storage)
|
|
_saveCaches()
|
|
|
|
if (data.storage.data.folders.length < 1) {
|
|
return createFolder(data.storage.key, {
|
|
name: 'Default',
|
|
color: consts.FOLDER_COLORS[0]
|
|
}).then(() => data)
|
|
}
|
|
|
|
return data
|
|
})
|
|
.then((data) => {
|
|
return {
|
|
storage: data.storage.toJSON(),
|
|
notes: data.notes.map((note) => note.toJSON())
|
|
}
|
|
})
|
|
}
|
|
|
|
function removeStorage (key) {
|
|
storages = storages.filter((storage) => storage.key !== key)
|
|
_saveCaches()
|
|
notes = notes.filter((note) => note.storage !== key)
|
|
return Promise.resolve(true)
|
|
}
|
|
|
|
function renameStorage (key, name) {
|
|
let storage = _.find(storages, {key: key})
|
|
if (storage == null) throw new Error('Storage doesn\'t exist.')
|
|
storage.cache.name = name
|
|
storage.saveCache()
|
|
|
|
return Promise.resolve(storage.toJSON())
|
|
}
|
|
|
|
function migrateFromV5 (key, data) {
|
|
let oldFolders = data.folders
|
|
let oldArticles = data.articles
|
|
let storage = _.find(storages, {key: key})
|
|
if (storage == null) throw new Error('Storage doesn\'t exist.')
|
|
|
|
let migrateFolders = oldFolders.map((oldFolder) => {
|
|
let folderKey = keygen()
|
|
while (storage.data.folders.some((folder) => folder.key === folderKey)) {
|
|
folderKey = keygen()
|
|
}
|
|
let newFolder = {
|
|
key: folderKey,
|
|
name: oldFolder.name,
|
|
color: consts.FOLDER_COLORS[Math.floor(Math.random() * 7) % 7]
|
|
}
|
|
storage.data.folders.push(newFolder)
|
|
let articles = oldArticles.filter((article) => article.FolderKey === oldFolder.key)
|
|
let folderNotes = []
|
|
articles.forEach((article) => {
|
|
let noteKey = keygen()
|
|
while (notes.some((note) => note.storage === key && note.folder === folderKey && note.key === noteKey)) {
|
|
key = keygen()
|
|
}
|
|
if (article.mode === 'markdown') {
|
|
let newNote = new Note({
|
|
tags: article.tags,
|
|
createdAt: article.createdAt,
|
|
updatedAt: article.updatedAt,
|
|
folder: folderKey,
|
|
storage: key,
|
|
type: 'MARKDOWN_NOTE',
|
|
isStarred: false,
|
|
title: article.title,
|
|
content: '# ' + article.title + '\n\n' + article.content,
|
|
key: noteKey
|
|
})
|
|
notes.push(newNote)
|
|
folderNotes.push(newNote)
|
|
} else {
|
|
let newNote = new Note({
|
|
tags: article.tags,
|
|
createdAt: article.createdAt,
|
|
updatedAt: article.updatedAt,
|
|
folder: folderKey,
|
|
storage: key,
|
|
type: 'SNIPPET_NOTE',
|
|
isStarred: false,
|
|
title: article.title,
|
|
description: article.title,
|
|
key: noteKey,
|
|
snippets: [{
|
|
name: article.mode,
|
|
mode: article.mode,
|
|
content: article.content
|
|
}]
|
|
})
|
|
notes.push(newNote)
|
|
folderNotes.push(newNote)
|
|
}
|
|
})
|
|
|
|
return sander
|
|
.writeFile(path.join(storage.cache.path, folderKey, 'data.json'), JSON.stringify({
|
|
notes: folderNotes.map((note) => {
|
|
let json = note.toJSON()
|
|
delete json.storage
|
|
return json
|
|
})
|
|
}))
|
|
})
|
|
return Promise.all(migrateFolders)
|
|
.then(() => storage.saveData())
|
|
.then(() => {
|
|
return {
|
|
storage: storage.toJSON(),
|
|
notes: notes.filter((note) => note.storage === key)
|
|
.map((note) => note.toJSON())
|
|
}
|
|
})
|
|
}
|
|
|
|
function createFolder (key, input) {
|
|
let storage = _.find(storages, {key: key})
|
|
if (storage == null) throw new Error('Storage doesn\'t exist.')
|
|
|
|
let folderKey = keygen()
|
|
while (storage.data.folders.some((folder) => folder.key === folderKey)) {
|
|
folderKey = keygen()
|
|
}
|
|
|
|
let newFolder = {
|
|
key: folderKey,
|
|
name: input.name,
|
|
color: input.color
|
|
}
|
|
|
|
const defaultData = {notes: []}
|
|
// FS MUST BE MANIPULATED BY ASYNC METHOD
|
|
return sander
|
|
.writeFile(path.join(storage.cache.path, folderKey, 'data.json'), JSON.stringify(defaultData))
|
|
.then(() => {
|
|
storage.data.folders.push(newFolder)
|
|
return storage
|
|
.saveData()
|
|
.then((storage) => storage.toJSON())
|
|
})
|
|
}
|
|
|
|
function updateFolder (storageKey, folderKey, input) {
|
|
let storage = _.find(storages, {key: storageKey})
|
|
if (storage == null) throw new Error('Storage doesn\'t exist.')
|
|
let folder = _.find(storage.data.folders, {key: folderKey})
|
|
folder.color = input.color
|
|
folder.name = input.name
|
|
|
|
return storage
|
|
.saveData()
|
|
.then((storage) => storage.toJSON())
|
|
}
|
|
|
|
function removeFolder (storageKey, folderKey) {
|
|
let storage = _.find(storages, {key: storageKey})
|
|
if (storage == null) throw new Error('Storage doesn\'t exist.')
|
|
storage.data.folders = storage.data.folders.filter((folder) => folder.key !== folderKey)
|
|
notes = notes.filter((note) => note.storage !== storageKey || note.folder !== folderKey)
|
|
|
|
// FS MUST BE MANIPULATED BY ASYNC METHOD
|
|
return sander
|
|
.rimraf(path.join(storage.cache.path, folderKey))
|
|
.catch((err) => {
|
|
if (err.code === 'ENOENT') return true
|
|
else throw err
|
|
})
|
|
.then(() => storage.saveData())
|
|
.then((storage) => storage.toJSON())
|
|
}
|
|
|
|
function createMarkdownNote (storageKey, folderKey, input) {
|
|
let key = keygen()
|
|
while (notes.some((note) => note.storage === storageKey && note.folder === folderKey && note.key === key)) {
|
|
key = keygen()
|
|
}
|
|
|
|
let newNote = new Note(Object.assign({
|
|
tags: [],
|
|
title: '',
|
|
content: ''
|
|
}, input, {
|
|
type: 'MARKDOWN_NOTE',
|
|
storage: storageKey,
|
|
folder: folderKey,
|
|
key: key,
|
|
isStarred: false,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date()
|
|
}))
|
|
notes.push(newNote)
|
|
|
|
return newNote
|
|
.save()
|
|
.then(() => newNote.toJSON())
|
|
}
|
|
|
|
function createSnippetNote (storageKey, folderKey, input) {
|
|
let key = keygen()
|
|
while (notes.some((note) => note.storage === storageKey && note.folder === folderKey && note.key === key)) {
|
|
key = keygen()
|
|
}
|
|
|
|
let newNote = new Note(Object.assign({
|
|
tags: [],
|
|
title: '',
|
|
description: '',
|
|
snippets: [{
|
|
name: '',
|
|
mode: 'text',
|
|
content: ''
|
|
}]
|
|
}, input, {
|
|
type: 'SNIPPET_NOTE',
|
|
storage: storageKey,
|
|
folder: folderKey,
|
|
key: key,
|
|
isStarred: false,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date()
|
|
}))
|
|
notes.push(newNote)
|
|
|
|
return newNote
|
|
.save()
|
|
.then(() => newNote.toJSON())
|
|
}
|
|
|
|
function updateNote (storageKey, folderKey, noteKey, input) {
|
|
let note = _.find(notes, {
|
|
key: noteKey,
|
|
storage: storageKey,
|
|
folder: folderKey
|
|
})
|
|
|
|
switch (note.data.type) {
|
|
case 'MARKDOWN_NOTE':
|
|
note.data.title = input.title
|
|
note.data.tags = input.tags
|
|
note.data.content = input.content
|
|
note.data.updatedAt = input.updatedAt
|
|
break
|
|
case 'SNIPPET_NOTE':
|
|
note.data.title = input.title
|
|
note.data.tags = input.tags
|
|
note.data.description = input.description
|
|
note.data.snippets = input.snippets
|
|
note.data.updatedAt = input.updatedAt
|
|
}
|
|
|
|
return note.save()
|
|
.then(() => note.toJSON())
|
|
}
|
|
|
|
function removeNote (storageKey, folderKey, noteKey) {
|
|
notes = notes.filter((note) => note.storage !== storageKey || note.folder !== folderKey || note.key !== noteKey)
|
|
queueSaveFolder(storageKey, folderKey)
|
|
|
|
return Promise.resolve(null)
|
|
}
|
|
|
|
function moveNote (storageKey, folderKey, noteKey, newStorageKey, newFolderKey) {
|
|
let note = _.find(notes, {
|
|
key: noteKey,
|
|
storage: storageKey,
|
|
folder: folderKey
|
|
})
|
|
if (note == null) throw new Error('Note doesn\'t exist.')
|
|
|
|
let storage = _.find(storages, {key: newStorageKey})
|
|
if (storage == null) throw new Error('Storage doesn\'t exist.')
|
|
let folder = _.find(storage.data.folders, {key: newFolderKey})
|
|
if (folder == null) throw new Error('Folder doesn\'t exist.')
|
|
note.storage = storage.key
|
|
note.data.storage = storage.key
|
|
note.folder = folder.key
|
|
note.data.folder = folder.key
|
|
let key = note.key
|
|
while (notes.some((note) => note.storage === storage.key && note.folder === folder.key && note.key === key)) {
|
|
key = keygen()
|
|
}
|
|
note.key = key
|
|
note.data.key = key
|
|
note.uniqueKey = `${note.storage}-${note.folder}-${note.key}`
|
|
console.log(note.uniqueKey)
|
|
queueSaveFolder(storageKey, folderKey)
|
|
return note.save()
|
|
.then(() => note.toJSON())
|
|
}
|
|
|
|
export default {
|
|
init,
|
|
addStorage,
|
|
removeStorage,
|
|
renameStorage,
|
|
createFolder,
|
|
updateFolder,
|
|
removeFolder,
|
|
createMarkdownNote,
|
|
createSnippetNote,
|
|
updateNote,
|
|
removeNote,
|
|
moveNote,
|
|
migrateFromV5
|
|
}
|