2020-11-05 18:58:23 +02:00
|
|
|
import Setting from '../../../models/Setting';
|
|
|
|
import shim from '../../../shim';
|
|
|
|
import uuid from '../../../uuid';
|
|
|
|
import readonlyProperties from '../utils/readonlyProperties';
|
|
|
|
import defaultSaveOptions from '../utils/defaultSaveOptions';
|
|
|
|
import defaultAction from '../utils/defaultAction';
|
2021-02-01 14:41:25 +02:00
|
|
|
import BaseModel, { ModelType } from '../../../BaseModel';
|
2020-11-05 18:58:23 +02:00
|
|
|
import defaultLoadOptions from '../utils/defaultLoadOptions';
|
|
|
|
import { RequestMethod, Request } from '../Api';
|
|
|
|
import markdownUtils from '../../../markdownUtils';
|
2020-11-11 13:52:47 +02:00
|
|
|
import collectionToPaginatedResults from '../utils/collectionToPaginatedResults';
|
2020-11-05 18:58:23 +02:00
|
|
|
|
2021-01-29 20:45:11 +02:00
|
|
|
import { reg } from '../../../registry';
|
|
|
|
import Database from '../../../database';
|
2021-01-22 19:41:11 +02:00
|
|
|
import Folder from '../../../models/Folder';
|
|
|
|
import Note from '../../../models/Note';
|
|
|
|
import Tag from '../../../models/Tag';
|
|
|
|
import Resource from '../../../models/Resource';
|
2021-01-30 13:08:11 +02:00
|
|
|
import htmlUtils from '../../../htmlUtils';
|
2021-01-22 19:41:11 +02:00
|
|
|
import markupLanguageUtils from '../../../markupLanguageUtils';
|
2020-11-05 18:58:23 +02:00
|
|
|
const mimeUtils = require('../../../mime-utils.js').mime;
|
|
|
|
const md5 = require('md5');
|
2021-04-11 19:01:06 +02:00
|
|
|
import HtmlToMd from '../../../HtmlToMd';
|
2020-11-05 18:58:23 +02:00
|
|
|
const urlUtils = require('../../../urlUtils.js');
|
|
|
|
const ArrayUtils = require('../../../ArrayUtils.js');
|
2021-11-19 13:26:01 +02:00
|
|
|
const { mimeTypeFromHeaders } = require('../../../net-utils');
|
2020-11-05 18:58:23 +02:00
|
|
|
const { fileExtension, safeFileExtension, safeFilename, filename } = require('../../../path-utils');
|
2021-11-22 19:17:28 +02:00
|
|
|
const { fileUriToPath } = require('../../../urlUtils');
|
2020-11-07 17:59:37 +02:00
|
|
|
const { MarkupToHtml } = require('@joplin/renderer');
|
2020-11-11 13:52:47 +02:00
|
|
|
const { ErrorNotFound } = require('../utils/errors');
|
2020-11-05 18:58:23 +02:00
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
let htmlToMdParser_: any = null;
|
2020-11-05 18:58:23 +02:00
|
|
|
|
|
|
|
function htmlToMdParser() {
|
|
|
|
if (htmlToMdParser_) return htmlToMdParser_;
|
|
|
|
htmlToMdParser_ = new HtmlToMd();
|
|
|
|
return htmlToMdParser_;
|
|
|
|
}
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
async function requestNoteToNote(requestNote: any) {
|
|
|
|
const output: any = {
|
2020-11-05 18:58:23 +02:00
|
|
|
title: requestNote.title ? requestNote.title : '',
|
|
|
|
body: requestNote.body ? requestNote.body : '',
|
|
|
|
};
|
|
|
|
|
|
|
|
if (requestNote.id) output.id = requestNote.id;
|
|
|
|
|
|
|
|
const baseUrl = requestNote.base_url ? requestNote.base_url : '';
|
|
|
|
|
|
|
|
if (requestNote.body_html) {
|
|
|
|
if (requestNote.convert_to === 'html') {
|
|
|
|
const style = await buildNoteStyleSheet(requestNote.stylesheets);
|
|
|
|
const minify = require('html-minifier').minify;
|
|
|
|
|
|
|
|
const minifyOptions = {
|
|
|
|
// Remove all spaces and, especially, newlines from tag attributes, as that would
|
|
|
|
// break the rendering.
|
|
|
|
customAttrCollapse: /.*/,
|
|
|
|
// Need to remove all whitespaces because whitespace at a beginning of a line
|
|
|
|
// means a code block in Markdown.
|
|
|
|
collapseWhitespace: true,
|
|
|
|
minifyCSS: true,
|
|
|
|
maxLineLength: 300,
|
|
|
|
};
|
|
|
|
|
|
|
|
const uglifycss = require('uglifycss');
|
|
|
|
const styleString = uglifycss.processString(style.join('\n'), {
|
|
|
|
// Need to set a max length because Ace Editor takes forever
|
|
|
|
// to display notes with long lines.
|
|
|
|
maxLineLen: 200,
|
|
|
|
});
|
|
|
|
|
|
|
|
const styleTag = style.length ? `<style>${styleString}</style>` + '\n' : '';
|
|
|
|
let minifiedHtml = '';
|
|
|
|
try {
|
|
|
|
minifiedHtml = minify(requestNote.body_html, minifyOptions);
|
|
|
|
} catch (error) {
|
|
|
|
console.warn('Could not minify HTML - using non-minified HTML instead', error);
|
|
|
|
minifiedHtml = requestNote.body_html;
|
|
|
|
}
|
|
|
|
output.body = styleTag + minifiedHtml;
|
|
|
|
output.body = htmlUtils.prependBaseUrl(output.body, baseUrl);
|
|
|
|
output.markup_language = MarkupToHtml.MARKUP_LANGUAGE_HTML;
|
|
|
|
} else {
|
|
|
|
// Convert to Markdown
|
|
|
|
// Parsing will not work if the HTML is not wrapped in a top level tag, which is not guaranteed
|
|
|
|
// when getting the content from elsewhere. So here wrap it - it won't change anything to the final
|
|
|
|
// rendering but it makes sure everything will be parsed.
|
|
|
|
output.body = await htmlToMdParser().parse(`<div>${requestNote.body_html}</div>`, {
|
|
|
|
baseUrl: baseUrl,
|
|
|
|
anchorNames: requestNote.anchor_names ? requestNote.anchor_names : [],
|
|
|
|
});
|
|
|
|
output.markup_language = MarkupToHtml.MARKUP_LANGUAGE_MARKDOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (requestNote.parent_id) {
|
|
|
|
output.parent_id = requestNote.parent_id;
|
|
|
|
} else {
|
|
|
|
const folder = await Folder.defaultFolder();
|
|
|
|
if (!folder) throw new Error('Cannot find folder for note');
|
|
|
|
output.parent_id = folder.id;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ('source_url' in requestNote) output.source_url = requestNote.source_url;
|
|
|
|
if ('author' in requestNote) output.author = requestNote.author;
|
|
|
|
if ('user_updated_time' in requestNote) output.user_updated_time = Database.formatValue(Database.TYPE_INT, requestNote.user_updated_time);
|
|
|
|
if ('user_created_time' in requestNote) output.user_created_time = Database.formatValue(Database.TYPE_INT, requestNote.user_created_time);
|
|
|
|
if ('is_todo' in requestNote) output.is_todo = Database.formatValue(Database.TYPE_INT, requestNote.is_todo);
|
|
|
|
if ('markup_language' in requestNote) output.markup_language = Database.formatValue(Database.TYPE_INT, requestNote.markup_language);
|
|
|
|
if ('longitude' in requestNote) output.longitude = requestNote.longitude;
|
|
|
|
if ('latitude' in requestNote) output.latitude = requestNote.latitude;
|
|
|
|
if ('altitude' in requestNote) output.altitude = requestNote.altitude;
|
|
|
|
|
|
|
|
if (!output.markup_language) output.markup_language = MarkupToHtml.MARKUP_LANGUAGE_MARKDOWN;
|
|
|
|
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
async function buildNoteStyleSheet(stylesheets: any[]) {
|
2020-11-05 18:58:23 +02:00
|
|
|
if (!stylesheets) return [];
|
|
|
|
|
|
|
|
const output = [];
|
|
|
|
|
|
|
|
for (const stylesheet of stylesheets) {
|
|
|
|
if (stylesheet.type === 'text') {
|
|
|
|
output.push(stylesheet.value);
|
|
|
|
} else if (stylesheet.type === 'url') {
|
|
|
|
try {
|
|
|
|
const tempPath = `${Setting.value('tempDir')}/${md5(`${Math.random()}_${Date.now()}`)}.css`;
|
|
|
|
await shim.fetchBlob(stylesheet.value, { path: tempPath, maxRetry: 1 });
|
|
|
|
const text = await shim.fsDriver().readFile(tempPath);
|
|
|
|
output.push(text);
|
|
|
|
await shim.fsDriver().remove(tempPath);
|
|
|
|
} catch (error) {
|
|
|
|
reg.logger().warn(`Cannot download stylesheet at ${stylesheet.value}`, error);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
throw new Error(`Invalid stylesheet type: ${stylesheet.type}`);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
async function tryToGuessImageExtFromMimeType(response: any, imagePath: string) {
|
2021-11-19 13:26:01 +02:00
|
|
|
const mimeType = mimeTypeFromHeaders(response.headers);
|
2020-11-05 18:58:23 +02:00
|
|
|
if (!mimeType) return imagePath;
|
|
|
|
|
|
|
|
const newExt = mimeUtils.toFileExtension(mimeType);
|
|
|
|
if (!newExt) return imagePath;
|
|
|
|
|
|
|
|
const newImagePath = `${imagePath}.${newExt}`;
|
|
|
|
await shim.fsDriver().move(imagePath, newImagePath);
|
|
|
|
return newImagePath;
|
|
|
|
}
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
async function downloadImage(url: string /* , allowFileProtocolImages */) {
|
2020-11-05 18:58:23 +02:00
|
|
|
const tempDir = Setting.value('tempDir');
|
|
|
|
|
|
|
|
// The URL we get to download have been extracted from the Markdown document
|
|
|
|
url = markdownUtils.unescapeLinkUrl(url);
|
|
|
|
|
|
|
|
const isDataUrl = url && url.toLowerCase().indexOf('data:') === 0;
|
|
|
|
|
|
|
|
const name = isDataUrl ? md5(`${Math.random()}_${Date.now()}`) : filename(url);
|
|
|
|
let fileExt = isDataUrl ? mimeUtils.toFileExtension(mimeUtils.fromDataUrl(url)) : safeFileExtension(fileExtension(url).toLowerCase());
|
|
|
|
if (!mimeUtils.fromFileExtension(fileExt)) fileExt = ''; // If the file extension is unknown - clear it.
|
|
|
|
if (fileExt) fileExt = `.${fileExt}`;
|
|
|
|
|
|
|
|
// Append a UUID because simply checking if the file exists is not enough since
|
|
|
|
// multiple resources can be downloaded at the same time (race condition).
|
|
|
|
let imagePath = `${tempDir}/${safeFilename(name)}_${uuid.create()}${fileExt}`;
|
|
|
|
|
|
|
|
try {
|
|
|
|
if (isDataUrl) {
|
|
|
|
await shim.imageFromDataUrl(url, imagePath);
|
|
|
|
} else if (urlUtils.urlProtocol(url).toLowerCase() === 'file:') {
|
|
|
|
// Can't think of any reason to disallow this at this point
|
|
|
|
// if (!allowFileProtocolImages) throw new Error('For security reasons, this URL with file:// protocol cannot be downloaded');
|
2021-11-22 19:17:28 +02:00
|
|
|
const localPath = fileUriToPath(url);
|
2020-11-05 18:58:23 +02:00
|
|
|
await shim.fsDriver().copy(localPath, imagePath);
|
|
|
|
} else {
|
|
|
|
const response = await shim.fetchBlob(url, { path: imagePath, maxRetry: 1 });
|
|
|
|
|
|
|
|
// If we could not find the file extension from the URL, try to get it
|
|
|
|
// now based on the Content-Type header.
|
|
|
|
if (!fileExt) imagePath = await tryToGuessImageExtFromMimeType(response, imagePath);
|
|
|
|
}
|
|
|
|
return imagePath;
|
|
|
|
} catch (error) {
|
|
|
|
reg.logger().warn(`Cannot download image at ${url}`, error);
|
|
|
|
return '';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
async function downloadImages(urls: string[] /* , allowFileProtocolImages:boolean */) {
|
2020-11-05 18:58:23 +02:00
|
|
|
const PromisePool = require('es6-promise-pool');
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
const output: any = {};
|
2020-11-05 18:58:23 +02:00
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
const downloadOne = async (url: string) => {
|
2020-11-05 18:58:23 +02:00
|
|
|
const imagePath = await downloadImage(url); // , allowFileProtocolImages);
|
|
|
|
if (imagePath) output[url] = { path: imagePath, originalUrl: url };
|
|
|
|
};
|
|
|
|
|
|
|
|
let urlIndex = 0;
|
|
|
|
const promiseProducer = () => {
|
|
|
|
if (urlIndex >= urls.length) return null;
|
|
|
|
|
|
|
|
const url = urls[urlIndex++];
|
|
|
|
return downloadOne(url);
|
|
|
|
};
|
|
|
|
|
|
|
|
const concurrency = 10;
|
|
|
|
const pool = new PromisePool(promiseProducer, concurrency);
|
|
|
|
await pool.start();
|
|
|
|
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
async function createResourcesFromPaths(urls: string[]) {
|
2020-11-05 18:58:23 +02:00
|
|
|
for (const url in urls) {
|
|
|
|
if (!urls.hasOwnProperty(url)) continue;
|
2020-11-12 21:13:28 +02:00
|
|
|
const urlInfo: any = urls[url];
|
2020-11-05 18:58:23 +02:00
|
|
|
try {
|
|
|
|
const resource = await shim.createResourceFromPath(urlInfo.path);
|
|
|
|
urlInfo.resource = resource;
|
|
|
|
} catch (error) {
|
|
|
|
reg.logger().warn(`Cannot create resource for ${url}`, error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return urls;
|
|
|
|
}
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
async function removeTempFiles(urls: string[]) {
|
2020-11-05 18:58:23 +02:00
|
|
|
for (const url in urls) {
|
|
|
|
if (!urls.hasOwnProperty(url)) continue;
|
2020-11-12 21:13:28 +02:00
|
|
|
const urlInfo: any = urls[url];
|
2020-11-05 18:58:23 +02:00
|
|
|
try {
|
|
|
|
await shim.fsDriver().remove(urlInfo.path);
|
|
|
|
} catch (error) {
|
|
|
|
reg.logger().warn(`Cannot remove ${urlInfo.path}`, error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
function replaceImageUrlsByResources(markupLanguage: number, md: string, urls: any, imageSizes: any) {
|
|
|
|
const imageSizesIndexes: any = {};
|
2020-11-05 18:58:23 +02:00
|
|
|
|
|
|
|
if (markupLanguage === MarkupToHtml.MARKUP_LANGUAGE_HTML) {
|
2020-11-12 21:13:28 +02:00
|
|
|
return htmlUtils.replaceImageUrls(md, (imageUrl: string) => {
|
|
|
|
const urlInfo: any = urls[imageUrl];
|
2020-11-05 18:58:23 +02:00
|
|
|
if (!urlInfo || !urlInfo.resource) return imageUrl;
|
|
|
|
return Resource.internalUrl(urlInfo.resource);
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
// eslint-disable-next-line no-useless-escape
|
2020-11-12 21:13:28 +02:00
|
|
|
return md.replace(/(!\[.*?\]\()([^\s\)]+)(.*?\))/g, (_match: any, before: string, imageUrl: string, after: string) => {
|
2020-11-05 18:58:23 +02:00
|
|
|
const urlInfo = urls[imageUrl];
|
|
|
|
if (!urlInfo || !urlInfo.resource) return before + imageUrl + after;
|
|
|
|
if (!(urlInfo.originalUrl in imageSizesIndexes)) imageSizesIndexes[urlInfo.originalUrl] = 0;
|
|
|
|
|
|
|
|
const resourceUrl = Resource.internalUrl(urlInfo.resource);
|
|
|
|
const imageSizesCollection = imageSizes[urlInfo.originalUrl];
|
|
|
|
|
|
|
|
if (!imageSizesCollection) {
|
|
|
|
// In some cases, we won't find the image size information for that particular URL. Normally
|
|
|
|
// it will only happen when using the "Clip simplified page" feature, which can modify the
|
|
|
|
// image URLs (for example it will select a smaller size resolution). In that case, it's
|
|
|
|
// fine to return the image as-is because it has already good dimensions.
|
|
|
|
return before + resourceUrl + after;
|
|
|
|
}
|
|
|
|
|
|
|
|
const imageSize = imageSizesCollection[imageSizesIndexes[urlInfo.originalUrl]];
|
|
|
|
imageSizesIndexes[urlInfo.originalUrl]++;
|
|
|
|
|
|
|
|
if (imageSize && (imageSize.naturalWidth !== imageSize.width || imageSize.naturalHeight !== imageSize.height)) {
|
|
|
|
return `<img width="${imageSize.width}" height="${imageSize.height}" src="${resourceUrl}"/>`;
|
|
|
|
} else {
|
|
|
|
return before + resourceUrl + after;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Note must have been saved first
|
2020-11-12 21:13:28 +02:00
|
|
|
async function attachImageFromDataUrl(note: any, imageDataUrl: string, cropRect: any) {
|
2020-11-05 18:58:23 +02:00
|
|
|
const tempDir = Setting.value('tempDir');
|
|
|
|
const mime = mimeUtils.fromDataUrl(imageDataUrl);
|
|
|
|
let ext = mimeUtils.toFileExtension(mime) || '';
|
|
|
|
if (ext) ext = `.${ext}`;
|
|
|
|
const tempFilePath = `${tempDir}/${md5(`${Math.random()}_${Date.now()}`)}${ext}`;
|
2020-11-12 21:13:28 +02:00
|
|
|
const imageConvOptions: any = {};
|
2020-11-05 18:58:23 +02:00
|
|
|
if (cropRect) imageConvOptions.cropRect = cropRect;
|
|
|
|
await shim.imageFromDataUrl(imageDataUrl, tempFilePath, imageConvOptions);
|
|
|
|
return await shim.attachFileToNote(note, tempFilePath);
|
|
|
|
}
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
export default async function(request: Request, id: string = null, link: string = null) {
|
2020-11-05 18:58:23 +02:00
|
|
|
if (request.method === 'GET') {
|
|
|
|
if (link && link === 'tags') {
|
2021-02-01 14:41:25 +02:00
|
|
|
return collectionToPaginatedResults(ModelType.Tag, await Tag.tagsByNoteId(id), request);
|
2020-11-05 18:58:23 +02:00
|
|
|
} else if (link && link === 'resources') {
|
|
|
|
const note = await Note.load(id);
|
|
|
|
if (!note) throw new ErrorNotFound();
|
|
|
|
const resourceIds = await Note.linkedResourceIds(note.body);
|
|
|
|
const output = [];
|
2020-11-13 23:45:25 +02:00
|
|
|
const loadOptions = defaultLoadOptions(request, BaseModel.TYPE_RESOURCE);
|
2020-11-05 18:58:23 +02:00
|
|
|
for (const resourceId of resourceIds) {
|
|
|
|
output.push(await Resource.load(resourceId, loadOptions));
|
|
|
|
}
|
2021-02-01 14:41:25 +02:00
|
|
|
return collectionToPaginatedResults(ModelType.Resource, output, request);
|
2020-11-05 18:58:23 +02:00
|
|
|
} else if (link) {
|
|
|
|
throw new ErrorNotFound();
|
|
|
|
}
|
|
|
|
|
|
|
|
return defaultAction(BaseModel.TYPE_NOTE, request, id, link);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (request.method === RequestMethod.POST) {
|
|
|
|
const requestId = Date.now();
|
|
|
|
const requestNote = JSON.parse(request.body);
|
|
|
|
|
|
|
|
// const allowFileProtocolImages = urlUtils.urlProtocol(requestNote.base_url).toLowerCase() === 'file:';
|
|
|
|
|
|
|
|
const imageSizes = requestNote.image_sizes ? requestNote.image_sizes : {};
|
|
|
|
|
2020-11-12 21:13:28 +02:00
|
|
|
let note: any = await requestNoteToNote(requestNote);
|
2020-11-05 18:58:23 +02:00
|
|
|
|
|
|
|
const imageUrls = ArrayUtils.unique(markupLanguageUtils.extractImageUrls(note.markup_language, note.body));
|
|
|
|
|
|
|
|
reg.logger().info(`Request (${requestId}): Downloading images: ${imageUrls.length}`);
|
|
|
|
|
|
|
|
let result = await downloadImages(imageUrls); // , allowFileProtocolImages);
|
|
|
|
|
|
|
|
reg.logger().info(`Request (${requestId}): Creating resources from paths: ${Object.getOwnPropertyNames(result).length}`);
|
|
|
|
|
|
|
|
result = await createResourcesFromPaths(result);
|
|
|
|
await removeTempFiles(result);
|
|
|
|
note.body = replaceImageUrlsByResources(note.markup_language, note.body, result, imageSizes);
|
|
|
|
|
|
|
|
reg.logger().info(`Request (${requestId}): Saving note...`);
|
|
|
|
|
|
|
|
const saveOptions = defaultSaveOptions('POST', note.id);
|
|
|
|
saveOptions.autoTimestamp = false; // No auto-timestamp because user may have provided them
|
|
|
|
const timestamp = Date.now();
|
|
|
|
note.updated_time = timestamp;
|
|
|
|
note.created_time = timestamp;
|
|
|
|
if (!('user_updated_time' in note)) note.user_updated_time = timestamp;
|
|
|
|
if (!('user_created_time' in note)) note.user_created_time = timestamp;
|
|
|
|
|
|
|
|
note = await Note.save(note, saveOptions);
|
|
|
|
|
|
|
|
if (requestNote.tags) {
|
|
|
|
const tagTitles = requestNote.tags.split(',');
|
|
|
|
await Tag.setNoteTagsByTitles(note.id, tagTitles);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (requestNote.image_data_url) {
|
|
|
|
note = await attachImageFromDataUrl(note, requestNote.image_data_url, requestNote.crop_rect);
|
|
|
|
}
|
|
|
|
|
|
|
|
reg.logger().info(`Request (${requestId}): Created note ${note.id}`);
|
|
|
|
|
|
|
|
return note;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (request.method === 'PUT') {
|
|
|
|
const note = await Note.load(id);
|
|
|
|
|
|
|
|
if (!note) throw new ErrorNotFound();
|
|
|
|
|
|
|
|
const saveOptions = {
|
|
|
|
...defaultSaveOptions('PUT', note.id),
|
|
|
|
autoTimestamp: false, // No auto-timestamp because user may have provided them
|
|
|
|
userSideValidation: true,
|
|
|
|
};
|
|
|
|
|
|
|
|
const timestamp = Date.now();
|
|
|
|
|
|
|
|
const newProps = request.bodyJson(readonlyProperties('PUT'));
|
|
|
|
if (!('user_updated_time' in newProps)) newProps.user_updated_time = timestamp;
|
|
|
|
|
|
|
|
let newNote = {
|
|
|
|
...note,
|
|
|
|
...newProps,
|
|
|
|
updated_time: timestamp,
|
|
|
|
};
|
|
|
|
|
|
|
|
newNote = await Note.save(newNote, saveOptions);
|
|
|
|
|
|
|
|
const requestNote = JSON.parse(request.body);
|
|
|
|
if (requestNote.tags || requestNote.tags === '') {
|
|
|
|
const tagTitles = requestNote.tags.split(',');
|
|
|
|
await Tag.setNoteTagsByTitles(id, tagTitles);
|
|
|
|
}
|
|
|
|
|
|
|
|
return newNote;
|
|
|
|
}
|
|
|
|
|
|
|
|
return defaultAction(BaseModel.TYPE_NOTE, request, id, link);
|
|
|
|
}
|