1175 lines
34 KiB
JavaScript
1175 lines
34 KiB
JavaScript
let db = require('@config/database')
|
|
|
|
let Note = module.exports = {}
|
|
|
|
let Tags = require('@models/Tag')
|
|
let Attachment = require('@models/Attachment')
|
|
let ShareNote = require('@models/ShareNote')
|
|
|
|
let ProcessText = require('@helpers/ProcessText')
|
|
|
|
const DiffMatchPatch = require('@helpers/DiffMatchPatch')
|
|
|
|
const crypto = require('crypto')
|
|
const cs = require('@helpers/CryptoString')
|
|
const rp = require('request-promise');
|
|
const fs = require('fs')
|
|
const gm = require('gm')
|
|
|
|
Note.test = (userId, masterKey, printResults) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
|
|
let testNoteId = 0
|
|
let testNoteId2 = 0
|
|
let sharedNoteId = 0 //ID of note shared with user
|
|
const shareUserId = 61
|
|
|
|
Note.create(userId, 'Random Note','With Random Text dogs', masterKey)
|
|
.then( newNoteId => {
|
|
if(printResults) console.log('Test: Created Note -> ', newNoteId)
|
|
return Note.create(userId, 'Yo, note','a second test note cheese mate', masterKey)
|
|
})
|
|
.then( newNoteId => {
|
|
if(printResults) console.log('Test: Created Note -> ', newNoteId)
|
|
testNoteId2 = newNoteId
|
|
//Create a blank note to test updating note and reindexing it
|
|
return Note.create(userId, '','', masterKey)
|
|
})
|
|
.then(newNoteId => {
|
|
|
|
if(printResults) console.log('Test: Created Note -> ', newNoteId)
|
|
testNoteId = newNoteId
|
|
|
|
return Note.update
|
|
(userId, testNoteId, 'Note text', 'Test Note beans barns Title', 0, 0, 0, 'hash', masterKey)
|
|
|
|
})
|
|
.then(() => {
|
|
|
|
if(printResults) console.log('Test: Update Note '+testNoteId+' - Pass')
|
|
|
|
return Note.get(userId, testNoteId, masterKey)
|
|
|
|
})
|
|
.then(() => {
|
|
|
|
if(printResults) console.log('Test: Open Updated Note - Pass')
|
|
|
|
return Note.reindex(userId, masterKey)
|
|
|
|
})
|
|
.then(() => {
|
|
|
|
if(printResults) console.log('Test: Reindex normal note - Pass')
|
|
|
|
return Note.encryptedIndexSearch(userId, 'beans barns', null, masterKey)
|
|
|
|
})
|
|
.then(textSearchResults => {
|
|
|
|
if(textSearchResults['ids'] && textSearchResults['ids'].length >= 1){
|
|
if(printResults) console.log('Test: Normal Note Search Index - Pass')
|
|
} else { console.log('Test: Search Index - Fail-------------> 🥱') }
|
|
|
|
return ShareNote.addUserToSharedNote(userId, testNoteId, shareUserId, masterKey)
|
|
})
|
|
.then(({success, shareUserId, sharedUserNoteId}) => {
|
|
|
|
if(printResults) console.log('Test: Set Note To Shared - Pass')
|
|
|
|
sharedNoteId = sharedUserNoteId
|
|
|
|
return Note.get(userId, testNoteId, masterKey)
|
|
|
|
})
|
|
.then(() => {
|
|
|
|
if(printResults) console.log('Test: Open Shared Note - Pass')
|
|
|
|
return Note.update
|
|
(userId, testNoteId, 'Shared Update', 'Test Note yarnsmarf Title', 0, 0, 0, 'hash', masterKey)
|
|
})
|
|
.then(() => {
|
|
|
|
if(printResults) console.log('Test: Update Shared Note - Pass')
|
|
|
|
return Note.reindex(userId, masterKey)
|
|
})
|
|
.then( reindexResults => {
|
|
|
|
if(printResults) console.log(`Test: Reindex Notes - ${reindexResults?'Pass':'Fail'}`)
|
|
|
|
return Note.encryptedIndexSearch(userId, 'yarnsmarf', null, masterKey)
|
|
|
|
})
|
|
.then(textSearchResults => {
|
|
|
|
if(textSearchResults['ids'] && textSearchResults['ids'].length >= 1){
|
|
|
|
if(printResults) console.log('Test: Search Index - Pass')
|
|
|
|
} else { console.log('Test: Search Index - Fail') }
|
|
|
|
return Note.delete(userId, testNoteId, masterKey)
|
|
|
|
})
|
|
.then(results => {
|
|
|
|
if(printResults) console.log('Test: Delete Note - Pass')
|
|
|
|
return Note.encryptedIndexSearch(userId, 'yarnsmarf', null, masterKey)
|
|
|
|
})
|
|
.then(textSearchResults => {
|
|
|
|
if(textSearchResults['ids'] && textSearchResults['ids'].length == 0){
|
|
if(printResults) console.log('Test: Search Deleted Note Text - Pass')
|
|
} else { console.log('Test: Search Deleted Note Text - Fail') }
|
|
|
|
return Note.delete(shareUserId, sharedNoteId)
|
|
|
|
})
|
|
.then(() => {
|
|
|
|
if(printResults) console.log('Test: Delete Shared Note - Pass')
|
|
|
|
return ShareNote.addUserToSharedNote(userId, testNoteId2, shareUserId, masterKey)
|
|
})
|
|
.then(({success, shareUserId, sharedUserNoteId}) => {
|
|
|
|
if(printResults) console.log('Test: Created Another New Shared Note - pass')
|
|
|
|
return ShareNote.removeUserFromSharedNote(userId, testNoteId2, sharedUserNoteId, masterKey)
|
|
})
|
|
.then(() => {
|
|
|
|
if(printResults) console.log('Test: Unshared New Shared Note -> convert back to normal note - pass')
|
|
|
|
return Note.get(userId, testNoteId2, masterKey)
|
|
})
|
|
.then(() => {
|
|
|
|
if(printResults) console.log('Test: Decrypt unshared note - pass')
|
|
|
|
let User = require('@models/User')
|
|
return User.deleteUser(userId, '1')
|
|
})
|
|
.then(results => {
|
|
|
|
if(printResults) console.log('Test: Delete User Account - Pass')
|
|
|
|
return resolve('Test: Complete ---')
|
|
|
|
})
|
|
})
|
|
}
|
|
|
|
//Returns insertedId of new note
|
|
Note.create = (userId, noteTitle = '', noteText = '', masterKey) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
if(userId == null || userId < 10){ reject('User Id required to create note') }
|
|
|
|
const created = Math.round((+new Date)/1000)
|
|
const salt = cs.createSmallSalt()
|
|
const snippetSalt = cs.createSmallSalt()
|
|
|
|
const snippetObj = JSON.stringify([noteTitle, noteText.substring(0, 500)])
|
|
const snippet = cs.encrypt(masterKey, snippetSalt, snippetObj)
|
|
|
|
const textObject = JSON.stringify([noteTitle, noteText])
|
|
const encryptedText = cs.encrypt(masterKey, salt, textObject)
|
|
|
|
db.promise()
|
|
.query(`INSERT INTO note_raw_text (text, salt, updated) VALUE (?, ?, ?)`, [encryptedText, salt, (+new Date)])
|
|
.then( (rows, fields) => {
|
|
|
|
const rawTextId = rows[0].insertId
|
|
|
|
return db.promise()
|
|
.query('INSERT INTO note (user_id, note_raw_text_id, created, quick_note, snippet, snippet_salt, indexed) VALUES (?,?,?,?,?,?,0)',
|
|
[userId, rawTextId, created, 0, snippet, snippetSalt])
|
|
})
|
|
.then((rows, fields) => {
|
|
|
|
if(SocketIo){
|
|
SocketIo.to(userId).emit('new_note_created', rows[0].insertId)
|
|
}
|
|
|
|
// Indexing is done on save
|
|
resolve(rows[0].insertId) //Only return the new note ID when creating a new note
|
|
})
|
|
.catch(console.log)
|
|
})
|
|
}
|
|
|
|
// Called when a note is close
|
|
// Will attempt to reindex all notes that are flagged in database as not indexed
|
|
// Limit to 100 notes per batch
|
|
// removeId = array of Ids to remove, [122,223]
|
|
Note.reindex = (userId, masterKey, removeId = null) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
if(!masterKey || masterKey.length == 0){
|
|
return reject('Master key needed for reindex')
|
|
}
|
|
|
|
let notIndexedNoteIds = []
|
|
let searchIndex = null
|
|
let searchIndexSalt = null
|
|
let foundNotes = null
|
|
let userPrivateKey = null
|
|
|
|
let User = require('@models/User')
|
|
User.generateKeypair(userId, masterKey)
|
|
.then(({publicKey, privateKey}) => {
|
|
|
|
userPrivateKey = privateKey
|
|
//First check if we have any notes to index
|
|
return db.promise().query(`
|
|
SELECT note.id, text, salt, encrypted_share_password_key FROM note
|
|
JOIN note_raw_text ON note.note_raw_text_id = note_raw_text.id
|
|
WHERE indexed = 0 AND salt IS NOT NULL AND trashed = 0
|
|
AND user_id = ? LIMIT 100`, [userId])
|
|
|
|
})
|
|
.then((rows, fields) => {
|
|
|
|
//Halt execution if there are no new notes
|
|
foundNotes = rows[0]
|
|
|
|
//Remove ID from index but don't reindex text
|
|
if(removeId != null){
|
|
removeId.forEach(removeId => {
|
|
foundNotes.push({
|
|
id:removeId,
|
|
text:'',
|
|
salt: null,
|
|
})
|
|
})
|
|
}
|
|
|
|
if(foundNotes.length == 0){
|
|
throw new Error('No new notes to index')
|
|
}
|
|
|
|
//Select search index, if it doesn't exist, create it
|
|
return db.promise().query(`SELECT * FROM user_encrypted_search_index WHERE user_id = ? LIMIT 1`, [userId])
|
|
|
|
})
|
|
.then((rows, fields) => {
|
|
|
|
if(rows[0].length == 0){
|
|
|
|
//Create search index entry, return an object
|
|
searchIndexSalt = cs.createSmallSalt()
|
|
|
|
//Select all user notes to recreate index
|
|
return db.promise().query(`
|
|
SELECT note.id, text, salt, encrypted_share_password_key FROM note
|
|
JOIN note_raw_text ON note.note_raw_text_id = note_raw_text.id
|
|
WHERE user_id = ?`, [userId])
|
|
.then((rows, fields) => {
|
|
|
|
foundNotes = rows[0]
|
|
return db.promise().query("INSERT INTO user_encrypted_search_index (`user_id`, `salt`) VALUES (?,?)", [userId, searchIndexSalt])
|
|
})
|
|
.then((rows, fields) => {
|
|
//return a fresh search index
|
|
return new Promise((resolve, reject) => { resolve('{}') })
|
|
})
|
|
|
|
|
|
} else {
|
|
|
|
const row = rows[0][0]
|
|
searchIndexSalt = row.salt
|
|
|
|
//Decrypt search index and continue.
|
|
let decipheredSearchIndex = '{}'
|
|
if(row.index && row.index.length > 0){
|
|
//Decrypt json, do not parse json yet, we want raw text
|
|
decipheredSearchIndex = cs.decrypt(masterKey, searchIndexSalt, row.index)
|
|
}
|
|
|
|
return new Promise((resolve, reject) => { resolve( decipheredSearchIndex ) })
|
|
}
|
|
|
|
})
|
|
.then(rawSearchIndex => {
|
|
|
|
if(rawSearchIndex == null){
|
|
throw new Error('Search Index Not Found/Decrypted')
|
|
}
|
|
|
|
searchIndex = rawSearchIndex
|
|
|
|
//Remove all instances of IDs from text
|
|
foundNotes.forEach(note => {
|
|
|
|
notIndexedNoteIds.push(note.id)
|
|
|
|
//Remove every instance of note id
|
|
const removeId = new RegExp(note.id,"gm")
|
|
const removeDoubles = new RegExp(',,',"g")
|
|
// const removeTrail = new RegExp(',]',"g")
|
|
|
|
searchIndex = searchIndex
|
|
.replace(removeId, '')
|
|
.replace(removeDoubles, ',')
|
|
.replace(/,]/g, ']')
|
|
.replace(/\[\,/g, '[') //search [,
|
|
})
|
|
|
|
searchIndex = JSON.parse(searchIndex)
|
|
|
|
//Remove unused words, this may not be needed and it increases overhead
|
|
Object.keys(searchIndex).forEach(word => {
|
|
if(searchIndex[word].length == 0){
|
|
delete searchIndex[word]
|
|
}
|
|
})
|
|
|
|
//Process text of each note and add it to the index
|
|
let reindexQueue = []
|
|
let reindexTimer = 0
|
|
foundNotes.forEach(note => {
|
|
|
|
reindexTimer += 50
|
|
let reindexPromise = new Promise((resolve, reject) => {
|
|
setTimeout(() => {
|
|
|
|
if(masterKey == null || note.salt == null){
|
|
console.log('Error indexing note', note.id)
|
|
return resolve(true)
|
|
}
|
|
|
|
let currentNoteKey = masterKey
|
|
|
|
//Decrypt shared key if it exists
|
|
const encryptedShareKey = note.encrypted_share_password_key
|
|
if(encryptedShareKey != null){
|
|
currentNoteKey = crypto.privateDecrypt(userPrivateKey,
|
|
Buffer.from(encryptedShareKey, 'base64') )
|
|
}
|
|
|
|
//Decrypt text with proper key
|
|
const noteHtml = cs.decrypt(currentNoteKey, note.salt, note.text)
|
|
|
|
const rawText =
|
|
ProcessText.removeHtml(noteHtml) //Remove HTML
|
|
.toLowerCase()
|
|
.replace(/style=".*?"/g,'') //Remove inline styles
|
|
.replace (/&#{0,1}[a-z0-9]+;/ig, '') //remove HTML entities
|
|
.replace(/[^A-Za-z0-9]/g, ' ') //Convert all to a-z only
|
|
.replace(/ +(?= )/g,'') //Remove double spaces
|
|
|
|
rawText.split(' ').forEach(word => {
|
|
|
|
//Skip small words
|
|
if(word.length <= 2){ return }
|
|
|
|
if(Array.isArray( searchIndex[word] )){
|
|
if(searchIndex[word].indexOf( note.id ) == -1){
|
|
searchIndex[word].push( note.id )
|
|
}
|
|
} else {
|
|
searchIndex[word] = [ note.id ]
|
|
}
|
|
})
|
|
|
|
return resolve(true)
|
|
|
|
}, reindexTimer)
|
|
})
|
|
|
|
reindexQueue.push(reindexPromise)
|
|
|
|
})
|
|
|
|
return Promise.all(reindexQueue)
|
|
})
|
|
.then(rawSearchIndex => {
|
|
|
|
const created = Math.round((+new Date)/1000)
|
|
const jsonSearchIndex = JSON.stringify(searchIndex)
|
|
const encryptedJsonIndex = cs.encrypt(masterKey, searchIndexSalt, jsonSearchIndex)
|
|
|
|
return db.promise().query("UPDATE user_encrypted_search_index SET `index` = ?, `last_update` = ? WHERE (`user_id` = ?) LIMIT 1",
|
|
[encryptedJsonIndex, created, userId])
|
|
.then((rows, fields) => {
|
|
|
|
return db.promise().query('UPDATE note SET `indexed` = 1 WHERE (`id` IN (?))', [notIndexedNoteIds])
|
|
|
|
})
|
|
.then((rows, fields) => {
|
|
|
|
// console.log('Indexd Note Count: ' + rows[0]['affectedRows'])
|
|
resolve(true)
|
|
|
|
})
|
|
|
|
}).catch(error => {
|
|
console.log('Reindex Error:')
|
|
console.log(error)
|
|
})
|
|
})
|
|
}
|
|
|
|
// Returns updated note text
|
|
Note.update = (userId, noteId, noteText, noteTitle, color, pinned, archived, hash, masterKey) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
// const now = Math.round((+new Date)/1000)
|
|
const now = +new Date
|
|
|
|
let noteSnippet = ''
|
|
|
|
let User = require('@models/User')
|
|
let userPrivateKey = null
|
|
User.getPrivateKey(userId, masterKey)
|
|
.then(privateKey => {
|
|
|
|
userPrivateKey = privateKey
|
|
|
|
return db.promise()
|
|
.query(`
|
|
SELECT note_raw_text_id, salt, snippet_salt, encrypted_share_password_key FROM note
|
|
JOIN note_raw_text ON note_raw_text_id = note_raw_text.id
|
|
WHERE note.id = ? AND user_id = ?`, [noteId, userId])
|
|
|
|
})
|
|
.then((rows, fields) => {
|
|
|
|
const textId = rows[0][0]['note_raw_text_id']
|
|
let salt = rows[0][0]['salt']
|
|
let snippetSalt = rows[0][0]['snippet_salt']
|
|
|
|
//Shared notes use encrypted key - decrypt key then decrypt note
|
|
const encryptedShareKey = rows[0][0].encrypted_share_password_key
|
|
if(encryptedShareKey != null){
|
|
masterKey = crypto.privateDecrypt(userPrivateKey, Buffer.from(encryptedShareKey, 'base64') )
|
|
}
|
|
|
|
let encryptedNoteText = ''
|
|
//Create encrypted snippet if its a long note
|
|
let snippet = ''
|
|
if(noteText.length > 500){
|
|
snippet = JSON.stringify([noteTitle, noteText.substring(0, 500)])
|
|
noteSnippet = cs.encrypt(masterKey, snippetSalt, snippet)
|
|
}
|
|
|
|
//Encrypt note text
|
|
const textObject = JSON.stringify([noteTitle, noteText])
|
|
encryptedNoteText = cs.encrypt(masterKey, salt, textObject)
|
|
|
|
//
|
|
// @TODO - this needs some kind of rate limiting
|
|
// A note shared with a lot of users could do a ton of updates every save
|
|
//
|
|
//Update text snippet for all other shared users
|
|
db.promise().query('SELECT * FROM note WHERE note_raw_text_id = ? AND id != ?', [textId, noteId])
|
|
.then((rows, fields) => {
|
|
for (var i = 0; i < rows[0].length; i++) {
|
|
const otherNote = rows[0][i]
|
|
//Re-encrypt for other user
|
|
let updatedSnippet = '' //Default to no snippet
|
|
if(noteText.length > 500){
|
|
updatedSnippet = cs.encrypt(masterKey, otherNote.snippet_salt, snippet)
|
|
}
|
|
db.promise().query('UPDATE note SET snippet = ? WHERE id = ?', [updatedSnippet, otherNote.id])
|
|
.then((rows, fields) => {
|
|
SocketIo.to(otherNote['user_id']).emit('new_note_text_saved', {'noteId':otherNote.id, hash})
|
|
})
|
|
}
|
|
})
|
|
|
|
|
|
//Update Note text
|
|
return db.promise()
|
|
.query('UPDATE note_raw_text SET text = ?, updated = ? WHERE id = ?', [encryptedNoteText, now, textId])
|
|
})
|
|
.then( (rows, fields) => {
|
|
|
|
//Set openend time to a minute ago
|
|
const theFuture = Math.round((+new Date)/1000) + 10
|
|
|
|
//Update other note attributes
|
|
return db.promise()
|
|
.query('UPDATE note SET pinned = ?, archived = ?, color = ?, snippet = ?, indexed = 0, opened = ? WHERE id = ? AND user_id = ? LIMIT 1',
|
|
[pinned, archived, color, noteSnippet, theFuture, noteId, userId])
|
|
|
|
})
|
|
.then((rows, fields) => {
|
|
|
|
if(SocketIo){
|
|
SocketIo.to(userId).emit('new_note_text_saved', {noteId, hash})
|
|
}
|
|
|
|
//Async attachment reindex
|
|
Attachment.scanTextForWebsites(SocketIo, userId, noteId, noteText)
|
|
|
|
//Send back updated response
|
|
resolve(rows[0])
|
|
})
|
|
.catch(console.log)
|
|
})
|
|
}
|
|
|
|
Note.setPinned = (userId, noteId, pinnedBoolean) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
const pinned = pinnedBoolean ? 1:0
|
|
const now = (+new Date)
|
|
|
|
//Update other note attributes
|
|
return db.promise()
|
|
.query('UPDATE note JOIN note_raw_text ON note_raw_text_id = note_raw_text.id SET pinned = ?, updated = ? WHERE note.id = ? AND user_id = ?',
|
|
[pinned, now, noteId, userId])
|
|
.then((rows, fields) => {
|
|
SocketIo.to(userId).emit('note_attribute_modified', noteId)
|
|
resolve(true)
|
|
})
|
|
})
|
|
}
|
|
|
|
Note.setArchived = (userId, noteId, archivedBoolead) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
const archived = archivedBoolead ? 1:0
|
|
const now = (+new Date)
|
|
|
|
//Update other note attributes
|
|
return db.promise()
|
|
.query('UPDATE note JOIN note_raw_text ON note_raw_text_id = note_raw_text.id SET archived = ?, updated = ? WHERE note.id = ? AND user_id = ?',
|
|
[archived, now, noteId, userId])
|
|
.then((rows, fields) => {
|
|
SocketIo.to(userId).emit('note_attribute_modified', noteId)
|
|
resolve(true)
|
|
})
|
|
})
|
|
}
|
|
|
|
Note.setTrashed = (userId, noteId, trashedBoolean, masterKey) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
const trashed = trashedBoolean ? 1:0
|
|
const now = (+new Date)
|
|
|
|
//Update other note attributes
|
|
return db.promise()
|
|
.query('UPDATE note JOIN note_raw_text ON note_raw_text_id = note_raw_text.id SET trashed = ?, updated = ?, indexed = 0 WHERE note.id = ? AND user_id = ?',
|
|
[trashed, now, noteId, userId])
|
|
.then((rows, fields) => {
|
|
|
|
const removeFromIndex = []
|
|
if(trashed){
|
|
//Remove note from index
|
|
removeFromIndex.push(noteId)
|
|
}
|
|
Note.reindex(userId, masterKey, removeFromIndex)
|
|
|
|
|
|
SocketIo.to(userId).emit('note_attribute_modified', noteId)
|
|
resolve(true)
|
|
})
|
|
})
|
|
}
|
|
|
|
//
|
|
// Delete a note and all its remaining parts
|
|
//
|
|
Note.delete = (userId, noteId, masterKey = null) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
//
|
|
// Delete, note, text, search index and associated tags
|
|
// Leave the attachments, they can be deleted on their own
|
|
// Leave Tags, their text is shared
|
|
|
|
let rawTextId = null
|
|
let noteTextCount = 0
|
|
|
|
// Lookup the note text ID, we need this to count usages
|
|
db.promise()
|
|
.query('SELECT note_raw_text_id FROM note WHERE id = ? AND user_id = ?', [noteId, userId])
|
|
.then((rows, fields) => {
|
|
|
|
//Save the raw text ID
|
|
rawTextId = rows[0][0]['note_raw_text_id']
|
|
|
|
return db.promise()
|
|
.query('SELECT count(id) as count FROM note WHERE note_raw_text_id = ?', [rawTextId])
|
|
})
|
|
.then((rows, fields) => {
|
|
|
|
//Save the number of times the note is used
|
|
noteTextCount = rows[0][0]['count']
|
|
|
|
//Don't delete text if its shared
|
|
if(noteTextCount == 1){
|
|
//If text is only used on one note, delete it (its not shared)
|
|
return db.promise()
|
|
.query('SELECT count(id) as count FROM note WHERE note_raw_text_id = ?', [rawTextId])
|
|
} else {
|
|
return new Promise((resolve, reject) => {
|
|
resolve(true)
|
|
})
|
|
}
|
|
})
|
|
.then( results => {
|
|
// Delete Note entry for this user.
|
|
return db.promise()
|
|
.query('DELETE FROM note WHERE note.id = ? AND note.user_id = ?', [noteId, userId])
|
|
})
|
|
.then( results => {
|
|
// Delete hidden attachments for this note (files for attachment are already gone)
|
|
return db.promise()
|
|
.query('DELETE FROM attachment WHERE visible = 0 AND note_id = ? AND user_id = ?', [noteId, userId])
|
|
})
|
|
.then((rows, fields) => {
|
|
// delete tags
|
|
return db.promise()
|
|
.query('DELETE FROM note_tag WHERE note_tag.note_id = ? AND note_tag.user_id = ?', [noteId,userId])
|
|
})
|
|
.then((rows, fields) => {
|
|
|
|
//IF there are notes with a matching raw text id, we want to update their share status
|
|
db.promise().query('SELECT id FROM note WHERE note_raw_text_id = ?',[rawTextId])
|
|
.then((rows, fields) => {
|
|
if(rows[0].length == 1){
|
|
db.promise().query('UPDATE note SET shared = 0 WHERE id = ?', [rows[0][0]['id']])
|
|
}
|
|
})
|
|
|
|
SocketIo.to(userId).emit('update_counts')
|
|
|
|
if(masterKey){
|
|
//Remove note ID from index
|
|
Note.reindex(userId, masterKey, [noteId])
|
|
.then(results => {
|
|
return resolve(true)
|
|
})
|
|
} else {
|
|
return resolve(true)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
Note.get = (userId, noteId, masterKey) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
let User = require('@models/User')
|
|
|
|
if(!masterKey || masterKey.length == 0){
|
|
return reject('Get note called without master key')
|
|
}
|
|
|
|
let userPrivateKey = null;
|
|
|
|
User.getPrivateKey(userId, masterKey)
|
|
.then(privateKey => {
|
|
|
|
//Grab users private key
|
|
userPrivateKey = privateKey
|
|
|
|
return db.promise()
|
|
.query(`
|
|
SELECT
|
|
note_raw_text.text,
|
|
note_raw_text.salt,
|
|
note_raw_text.updated as updated,
|
|
note.id,
|
|
note.user_id,
|
|
note.created,
|
|
note.pinned,
|
|
note.archived,
|
|
note.trashed,
|
|
note.color,
|
|
note.shared,
|
|
note.encrypted_share_password_key,
|
|
count(distinct attachment.id) as attachment_count,
|
|
note.note_raw_text_id as rawTextId,
|
|
shareUser.username as shareUsername
|
|
FROM note
|
|
JOIN note_raw_text ON (note_raw_text.id = note.note_raw_text_id)
|
|
LEFT JOIN attachment ON (note.id = attachment.note_id)
|
|
LEFT JOIN user as shareUser ON (note.share_user_id = shareUser.id)
|
|
WHERE note.user_id = ? AND note.id = ? LIMIT 1`, [userId, noteId])
|
|
|
|
})
|
|
.then((rows, fields) => {
|
|
|
|
let noteLockedOut = false
|
|
let noteData = rows[0][0]
|
|
// const rawTextId = noteData['rawTextId']
|
|
|
|
//Block access to notes if invalid or user doesn't have access
|
|
if(!noteData || !noteData['user_id'] || noteData['user_id'] != userId || noteData['id'] != noteId){
|
|
return resolve(false)
|
|
}
|
|
|
|
//Shared notes use encrypted key - decrypt key then decrypt note
|
|
if(noteData.encrypted_share_password_key != null){
|
|
masterKey = crypto.privateDecrypt(userPrivateKey,
|
|
Buffer.from(noteData.encrypted_share_password_key, 'base64') )
|
|
}
|
|
|
|
//Normal Encrypted note
|
|
const decipheredText = cs.decrypt(masterKey, noteData.salt, noteData.text)
|
|
if(decipheredText == null){
|
|
throw new Error('Unable to decropt note text')
|
|
}
|
|
//Parse title and text from encrypted data and update object
|
|
const textObject = JSON.parse(decipheredText)
|
|
noteData.title = textObject[0]
|
|
noteData.text = textObject[1]
|
|
|
|
const nowTime = Math.round((+new Date)/1000)
|
|
db.promise().query(`UPDATE note SET opened = ? WHERE (id = ?)`, [nowTime, noteId])
|
|
|
|
//Return note data
|
|
// delete noteData.salt //remove salt from return data
|
|
// delete noteData.encrypted_share_password_key
|
|
noteData.lockedOut = noteLockedOut
|
|
resolve(noteData)
|
|
|
|
})
|
|
.catch(error => {
|
|
console.log(error)
|
|
resolve(false)
|
|
})
|
|
})
|
|
}
|
|
|
|
//Public note share action -> may not be used
|
|
Note.getShared = (noteId, sharedKey) => {
|
|
return new Promise((resolve, reject) => {
|
|
db.promise()
|
|
.query(`
|
|
SELECT
|
|
note_raw_text.text,
|
|
note_raw_text.salt,
|
|
note_raw_text.updated as updated,
|
|
note.id,
|
|
note.user_id,
|
|
note.created,
|
|
note.pinned,
|
|
note.archived,
|
|
note.trashed,
|
|
note.color,
|
|
note.shared,
|
|
note.encrypted_share_password_key,
|
|
note.note_raw_text_id as rawTextId
|
|
FROM note
|
|
JOIN note_raw_text ON (note_raw_text.id = note.note_raw_text_id)
|
|
WHERE note.id = ? LIMIT 1`, [noteId])
|
|
.then((rows, fields) => {
|
|
|
|
let noteData = rows[0][0]
|
|
|
|
const decipheredText = cs.decrypt(sharedKey, noteData.salt, noteData.text)
|
|
if(decipheredText == null){
|
|
throw new Error('Unable to decropt note text')
|
|
}
|
|
|
|
const success = true
|
|
const noteObject = JSON.parse(decipheredText)
|
|
const title = noteObject[0]
|
|
const text = noteObject[1]
|
|
const styleObject = JSON.parse(noteData.color)
|
|
|
|
return resolve({success, title, text, styleObject})
|
|
|
|
})
|
|
.catch(error => {
|
|
resolve({'success':false})
|
|
})
|
|
})
|
|
}
|
|
|
|
// Searches text index, returns nothing if there is no search query
|
|
Note.encryptedIndexSearch = (userId, searchQuery, searchTags, masterKey) => {
|
|
return new Promise((resolve, reject) => {
|
|
|
|
if(searchQuery.length == 0){
|
|
resolve(null)
|
|
} else {
|
|
|
|
if(!masterKey || masterKey == null){
|
|
console.log('Attempting to search wiouth key')
|
|
return resolve(null)
|
|
}
|
|
|
|
//Search the search index
|
|
db.promise().query(`SELECT * FROM user_encrypted_search_index WHERE user_id = ? LIMIT 1`, [userId])
|
|
.then((rows, fields) => {
|
|
|
|
if(rows[0].length == 1){
|
|
|
|
//Lookup, decrypt and parse search index
|
|
const row = rows[0][0]
|
|
const decipheredSearchIndex = cs.decrypt(masterKey, row.salt, row.index)
|
|
const searchIndex = JSON.parse(decipheredSearchIndex)
|
|
|
|
//Clean up search word, leave in spaces, split to array
|
|
const words = searchQuery.toLowerCase().replace(/[^a-z0-9 ]/g, '').split(' ')
|
|
|
|
let wordSearchCount = 0;
|
|
|
|
|
|
let partialWords = [] //For debugging
|
|
let exactWords = [] //For debugging
|
|
|
|
|
|
let exactWordIdSets = []
|
|
let partialMatchNoteIds = []
|
|
|
|
words.forEach(word => {
|
|
|
|
//Skip short words
|
|
if(word.length <= 2){
|
|
return
|
|
}
|
|
|
|
//count all words being searched
|
|
wordSearchCount++
|
|
|
|
//Save all exact match sets if found
|
|
if(searchIndex[word]){
|
|
// exactWords.push(word) //Words for debugging
|
|
exactWordIdSets.push(...searchIndex[word])
|
|
}
|
|
|
|
//Find all partial word matches in index
|
|
Object.keys(searchIndex).forEach(wordIndex => {
|
|
if( wordIndex.indexOf(word) != -1 && wordIndex != word){
|
|
// partialWords.push(wordIndex) //partialWords for debugging
|
|
partialMatchNoteIds.push(...searchIndex[wordIndex])
|
|
}
|
|
})
|
|
|
|
})
|
|
|
|
//If more than one work was searched, remove notes that don't contain both
|
|
if(words.length > 1 && exactWordIdSets.length > 0){
|
|
|
|
//Find ids that appear more than once, this means there was an exact match in more than one note
|
|
let overlappingIds = exactWordIdSets.filter((e, i, a) => a.indexOf(e) !== i)
|
|
overlappingIds = [...new Set(overlappingIds)]
|
|
|
|
//If there are notes that appear
|
|
if(overlappingIds.length > 0){
|
|
exactWordIdSets = overlappingIds
|
|
}
|
|
|
|
//If note appears in partial and exact, show only that set
|
|
const partialIntersect = exactWordIdSets.filter(x => partialMatchNoteIds.includes(x))
|
|
if(partialIntersect.length > 0){
|
|
exactWordIdSets = partialIntersect
|
|
partialMatchNoteIds = []
|
|
}
|
|
}
|
|
|
|
//Remove duplicates from final id sets
|
|
let finalExact = [ ...new Set(exactWordIdSets) ]
|
|
let finalPartial = [ ...new Set(partialMatchNoteIds) ]
|
|
|
|
//Remove exact matches from partials set if there is overlap
|
|
if(finalExact.length > 0 && finalPartial.length > 0){
|
|
finalPartial = finalPartial
|
|
.filter( ( el ) => !finalExact.includes( el ) )
|
|
}
|
|
|
|
//Combine the two filtered sets
|
|
let finalIdSearchSet = finalExact.concat(finalPartial)
|
|
|
|
// let searchData = {
|
|
// 'query':searchQuery,
|
|
// 'words_count': words.length,
|
|
// 'exact_matches': exactWordIdSets.length,
|
|
// 'word_search_count': wordSearchCount,
|
|
// 'exactWords': exactWords,
|
|
// 'exact': finalExact,
|
|
// 'partialWords': partialWords,
|
|
// 'partial': finalPartial,
|
|
// }
|
|
|
|
// //Lump all found note ids into one array
|
|
// searchData['ids'] = finalIdSearchSet
|
|
// searchData['total'] = searchData['ids'].length
|
|
|
|
// console.log('-----------------')
|
|
// console.log(searchData)
|
|
// console.log('-----------------')
|
|
|
|
return resolve({ 'ids':finalIdSearchSet })
|
|
|
|
|
|
} else {
|
|
return resolve(null)
|
|
}
|
|
|
|
})
|
|
}
|
|
|
|
})
|
|
}
|
|
|
|
Note.search = (userId, searchQuery, searchTags, fastFilters, masterKey) => {
|
|
return new Promise((resolve, reject) => {
|
|
//Define return data objects
|
|
let returnData = {
|
|
'notes':[],
|
|
'total':0,
|
|
}
|
|
|
|
let userPrivateKey = null
|
|
|
|
let User = require('@models/User')
|
|
User.generateKeypair(userId, masterKey)
|
|
.then(({publicKey, privateKey}) => {
|
|
|
|
userPrivateKey = privateKey
|
|
return Note.encryptedIndexSearch(userId, searchQuery, searchTags, masterKey)
|
|
})
|
|
.then( (textSearchResults) => {
|
|
|
|
//Pull out search results from previous query
|
|
let textSearchIds = []
|
|
let returnTagResults = false
|
|
let searchAllNotes = false
|
|
|
|
if(textSearchResults != null){
|
|
textSearchIds = textSearchResults['ids']
|
|
returnData['total'] = textSearchIds.length
|
|
// highlights = textSearchResults['snippets']
|
|
}
|
|
|
|
//No results, return empty data
|
|
if(textSearchIds.length == 0 && searchQuery.length > 0){
|
|
return resolve(returnData)
|
|
}
|
|
|
|
// Base of the query, modified with fastFilters
|
|
// Add to query for character counts -> CHAR_LENGTH(note.text) as chars
|
|
|
|
//SUBSTRING(note_raw_text.text, 1, 500) as text,
|
|
let searchParams = [userId]
|
|
let noteSearchQuery = `
|
|
SELECT note.id,
|
|
note.snippet as snippetText,
|
|
note.snippet_salt as snippetSalt,
|
|
note_raw_text.text as noteText,
|
|
note_raw_text.salt as noteSalt,
|
|
note_raw_text.updated as updated,
|
|
opened,
|
|
color,
|
|
count(distinct note_tag.id) as tag_count,
|
|
count(distinct attachment.id) as attachment_count,
|
|
note.pinned,
|
|
note.archived,
|
|
note.trashed,
|
|
GROUP_CONCAT(DISTINCT tag.text,":",tag.id) as tags,
|
|
GROUP_CONCAT(DISTINCT attachment.file_location) as thumbs,
|
|
shareUser.username as shareUsername,
|
|
note.shared,
|
|
note.encrypted_share_password_key,
|
|
note.indexed
|
|
FROM note
|
|
JOIN note_raw_text ON (note_raw_text.id = note.note_raw_text_id)
|
|
LEFT JOIN note_tag ON (note.id = note_tag.note_id)
|
|
LEFT JOIN tag ON (tag.id = note_tag.tag_id)
|
|
LEFT JOIN attachment ON (note.id = attachment.note_id AND attachment.visible = 1)
|
|
LEFT JOIN user as shareUser ON (note.share_user_id = shareUser.id)
|
|
WHERE note.user_id = ?
|
|
`
|
|
|
|
//If text search returned results, limit search to those ids
|
|
if(textSearchIds.length > 0){
|
|
searchParams.push(textSearchIds)
|
|
noteSearchQuery += ' AND note.id IN (?)'
|
|
searchAllNotes = true
|
|
}
|
|
|
|
//If Specific ID's are being searched, search ALL notes
|
|
if(fastFilters.noteIdSet && fastFilters.noteIdSet.length > 0){
|
|
searchParams.push(fastFilters.noteIdSet)
|
|
noteSearchQuery += ' AND note.id IN (?)'
|
|
searchAllNotes = true
|
|
}
|
|
|
|
//If tags are passed, use those tags in search
|
|
if(searchTags.length > 0){
|
|
searchParams.push(searchTags)
|
|
noteSearchQuery += ' AND note_tag.tag_id IN (?) AND note.trashed = 0'
|
|
searchAllNotes = true
|
|
}
|
|
|
|
|
|
|
|
//Show archived notes, only if fast filter is set, default to not archived
|
|
if(searchAllNotes == false){
|
|
|
|
//Default set of filters for all notes
|
|
if(fastFilters.notesHome == 1){
|
|
noteSearchQuery += ' AND note.archived = 0 AND note.trashed = 0 AND note.share_user_id IS NULL'
|
|
}
|
|
|
|
if(fastFilters.onlyShowSharedNotes == 1){
|
|
//share_user_id means your shared them, a note with a shared user id filled in means it was shared
|
|
noteSearchQuery += ` AND share_user_id IS NOT NULL OR (note.shared = 2 AND note.user_id = ?) AND note.trashed = 0`
|
|
searchParams.push(userId)
|
|
//Show notes shared with you
|
|
}
|
|
if(fastFilters.onlyArchived == 1){
|
|
noteSearchQuery += ' AND note.archived = 1 AND note.trashed = 0' //Show Archived
|
|
}
|
|
|
|
if(fastFilters.onlyShowTrashed == 1){
|
|
noteSearchQuery += ' AND note.trashed = 1' //Show Exclude
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Finish up note query
|
|
noteSearchQuery += ' GROUP BY note.id'
|
|
|
|
//Only show notes with Tags
|
|
if(fastFilters.withTags == 1){
|
|
noteSearchQuery += ' HAVING tag_count > 0'
|
|
}
|
|
//Only show notes with links
|
|
if(fastFilters.withLinks == 1){
|
|
noteSearchQuery += ' HAVING attachment_count > 0'
|
|
}
|
|
//Only show archived notes
|
|
// if(fastFilters.onlyArchived == 1){
|
|
// noteSearchQuery += ' HAVING note.archived = 1'
|
|
// }
|
|
// //Only show trashed notes
|
|
// if(fastFilters.onlyShowTrashed == 1){
|
|
// noteSearchQuery += ' HAVING note.trashed = 1'
|
|
// }
|
|
|
|
//
|
|
// Always prioritize pinned notes in searches.
|
|
|
|
//Default Sort, order by last updated
|
|
let defaultOrderBy = ' ORDER BY note.pinned DESC, updated DESC, note.created DESC, note.opened DESC'
|
|
|
|
//Order by Last Created Date
|
|
if(fastFilters.lastCreated == 1){
|
|
defaultOrderBy = ' ORDER BY note.pinned DESC, note.created DESC, updated DESC, note.opened DESC, id DESC'
|
|
}
|
|
//Order by last Opened Date
|
|
if(fastFilters.lastOpened == 1){
|
|
defaultOrderBy = ' ORDER BY note.pinned DESC, opened DESC, updated DESC, note.created DESC, id DESC'
|
|
}
|
|
|
|
//Append Order by to query
|
|
noteSearchQuery += defaultOrderBy
|
|
|
|
|
|
//Manage limit params if set
|
|
if(fastFilters.limitSize > 0 || fastFilters.limitOffset > 0){
|
|
|
|
const limitSize = parseInt(fastFilters.limitSize, 10) || 10 //Use int or default to 10
|
|
const limitOffset = parseInt(fastFilters.limitOffset, 10) || 0 //Either parse int, or use zero
|
|
|
|
noteSearchQuery += ` LIMIT ${limitOffset}, ${limitSize}`
|
|
}
|
|
|
|
// console.log('------------- Final Query --------------')
|
|
// console.log(noteSearchQuery)
|
|
// console.log('------------- ----------- --------------')
|
|
|
|
db.promise()
|
|
.query(noteSearchQuery, searchParams)
|
|
.then((noteRows, noteFields) => {
|
|
|
|
//Push all notes
|
|
returnData['notes'] = noteRows[0]
|
|
|
|
//pull out all note ids so we can fetch all tags for those notes
|
|
returnData['notes'].forEach(note => {
|
|
|
|
//Current note key may change, default to master key
|
|
let currentNoteKey = masterKey
|
|
|
|
//Shared notes use encrypted key - decrypt key then decrypt note
|
|
const encryptedShareKey = note.encrypted_share_password_key
|
|
if(encryptedShareKey != null){
|
|
currentNoteKey = crypto.privateDecrypt(userPrivateKey,
|
|
Buffer.from(encryptedShareKey, 'base64') )
|
|
}
|
|
|
|
|
|
//Only long notes have snippets, decipher it if present
|
|
let displayTitle = ''
|
|
let displayText = ''
|
|
|
|
let encryptedText = note.noteText
|
|
let relatedSalt = note.noteSalt
|
|
|
|
//Default to note text, use snippet if set
|
|
if(note.snippetSalt && note.snippetText && note.snippetSalt.length > 0 && note.snippetText.length > 0){
|
|
encryptedText = note.snippetText
|
|
relatedSalt = note.snippetSalt
|
|
}
|
|
|
|
try {
|
|
const decipheredText = cs.decrypt(currentNoteKey, relatedSalt, encryptedText)
|
|
const textObject = JSON.parse(decipheredText)
|
|
if(textObject != null && textObject.length == 2){
|
|
if(textObject[0] && textObject[0] != null && textObject[0].length > 0){
|
|
displayTitle = textObject[0]
|
|
}
|
|
if(textObject[1] && textObject[1] != null && textObject[1].length > 0){
|
|
displayText = textObject[1]
|
|
}
|
|
}
|
|
} catch(err) {
|
|
console.log('Error opening note id -> '+note.id+' for userId -> '+userId)
|
|
console.log(err)
|
|
}
|
|
|
|
|
|
|
|
note.title = displayTitle
|
|
note.subtext = ProcessText.stripDoubleBlankLines(displayText)
|
|
|
|
//Limit number of attachment thumbs to 4
|
|
if(note.thumbs){
|
|
//Convert comma delimited string to array
|
|
let thumbArray = note.thumbs.split(',').reverse()
|
|
//Limit array to 4 or size of array
|
|
thumbArray.length = Math.min(thumbArray.length, 4)
|
|
note.thumbs = thumbArray
|
|
}
|
|
|
|
//Clear out note.text before sending it to front end, its being used in title and subtext
|
|
delete note.snippetText
|
|
delete note.snippetSalt
|
|
delete note.noteText
|
|
delete note.noteSalt
|
|
delete note.encrypted_share_password_key
|
|
delete note.text //Passed back as title and subtext
|
|
})
|
|
|
|
|
|
return resolve(returnData)
|
|
|
|
|
|
})
|
|
.catch(console.log)
|
|
|
|
})
|
|
.catch(console.log)
|
|
|
|
})
|
|
} |