2021-01-22 19:41:11 +02:00
|
|
|
import { FolderEntity } from '../services/database/types';
|
|
|
|
import BaseModel from '../BaseModel';
|
|
|
|
import time from '../time';
|
|
|
|
import { _ } from '../locale';
|
|
|
|
|
2021-01-23 17:51:19 +02:00
|
|
|
import Note from './Note';
|
2021-01-29 20:45:11 +02:00
|
|
|
import Database from '../database';
|
2021-01-23 17:51:19 +02:00
|
|
|
import BaseItem from './BaseItem';
|
2020-11-05 18:58:23 +02:00
|
|
|
const { substrWithEllipsis } = require('../string-utils.js');
|
2017-05-15 21:10:00 +02:00
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
interface FolderEntityWithChildren extends FolderEntity {
|
|
|
|
children?: FolderEntity[];
|
|
|
|
}
|
|
|
|
|
|
|
|
export default class Folder extends BaseItem {
|
2017-05-15 21:10:00 +02:00
|
|
|
static tableName() {
|
2018-03-09 22:59:12 +02:00
|
|
|
return 'folders';
|
2017-05-15 21:10:00 +02:00
|
|
|
}
|
|
|
|
|
2017-07-03 21:50:45 +02:00
|
|
|
static modelType() {
|
|
|
|
return BaseModel.TYPE_FOLDER;
|
2017-05-18 21:58:01 +02:00
|
|
|
}
|
2019-07-29 15:43:53 +02:00
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static newFolder(): FolderEntity {
|
2017-05-15 21:10:00 +02:00
|
|
|
return {
|
|
|
|
id: null,
|
2018-03-09 22:59:12 +02:00
|
|
|
title: '',
|
2019-07-29 15:43:53 +02:00
|
|
|
};
|
2017-05-15 21:10:00 +02:00
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static fieldToLabel(field: string) {
|
|
|
|
const fieldsToLabels: any = {
|
2019-03-02 19:35:57 +02:00
|
|
|
title: _('title'),
|
|
|
|
last_note_user_updated_time: _('updated date'),
|
|
|
|
};
|
|
|
|
|
|
|
|
return field in fieldsToLabels ? fieldsToLabels[field] : field;
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static noteIds(parentId: string, options: any = null) {
|
2020-11-17 13:50:46 +02:00
|
|
|
options = Object.assign({}, {
|
|
|
|
includeConflicts: false,
|
|
|
|
}, options);
|
|
|
|
|
|
|
|
const where = ['parent_id = ?'];
|
|
|
|
if (!options.includeConflicts) {
|
|
|
|
where.push('is_conflict = 0');
|
|
|
|
}
|
|
|
|
|
2019-07-29 15:43:53 +02:00
|
|
|
return this.db()
|
2020-11-17 13:50:46 +02:00
|
|
|
.selectAll(`SELECT id FROM notes WHERE ${where.join(' AND ')}`, [parentId])
|
2021-01-22 19:41:11 +02:00
|
|
|
.then((rows: any[]) => {
|
2020-03-14 01:46:14 +02:00
|
|
|
const output = [];
|
2019-07-29 15:43:53 +02:00
|
|
|
for (let i = 0; i < rows.length; i++) {
|
2020-03-14 01:46:14 +02:00
|
|
|
const row = rows[i];
|
2019-07-29 15:43:53 +02:00
|
|
|
output.push(row.id);
|
|
|
|
}
|
|
|
|
return output;
|
|
|
|
});
|
2017-05-18 22:31:40 +02:00
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async subFolderIds(parentId: string) {
|
2018-05-09 10:53:47 +02:00
|
|
|
const rows = await this.db().selectAll('SELECT id FROM folders WHERE parent_id = ?', [parentId]);
|
2021-01-22 19:41:11 +02:00
|
|
|
return rows.map((r: FolderEntity) => r.id);
|
2018-05-09 10:53:47 +02:00
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async noteCount(parentId: string) {
|
2020-03-14 01:46:14 +02:00
|
|
|
const r = await this.db().selectOne('SELECT count(*) as total FROM notes WHERE is_conflict = 0 AND parent_id = ?', [parentId]);
|
2017-07-12 22:39:47 +02:00
|
|
|
return r ? r.total : 0;
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static markNotesAsConflict(parentId: string) {
|
2020-03-14 01:46:14 +02:00
|
|
|
const query = Database.updateQuery('notes', { is_conflict: 1 }, { parent_id: parentId });
|
2017-07-13 20:47:31 +02:00
|
|
|
return this.db().exec(query);
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async delete(folderId: string, options: any = null) {
|
2017-07-13 20:47:31 +02:00
|
|
|
if (!options) options = {};
|
2018-03-09 22:59:12 +02:00
|
|
|
if (!('deleteChildren' in options)) options.deleteChildren = true;
|
2017-07-13 20:47:31 +02:00
|
|
|
|
2020-03-14 01:46:14 +02:00
|
|
|
const folder = await Folder.load(folderId);
|
2017-07-13 20:47:31 +02:00
|
|
|
if (!folder) return; // noop
|
|
|
|
|
2019-07-29 15:43:53 +02:00
|
|
|
if (options.deleteChildren) {
|
2020-03-14 01:46:14 +02:00
|
|
|
const noteIds = await Folder.noteIds(folderId);
|
2020-03-14 12:01:45 +02:00
|
|
|
await Note.batchDelete(noteIds);
|
2018-05-09 10:53:47 +02:00
|
|
|
|
2020-03-14 01:46:14 +02:00
|
|
|
const subFolderIds = await Folder.subFolderIds(folderId);
|
2018-05-09 10:53:47 +02:00
|
|
|
for (let i = 0; i < subFolderIds.length; i++) {
|
|
|
|
await Folder.delete(subFolderIds[i]);
|
|
|
|
}
|
2017-06-25 09:52:25 +02:00
|
|
|
}
|
|
|
|
|
2017-06-25 17:17:40 +02:00
|
|
|
await super.delete(folderId, options);
|
2017-06-25 09:52:25 +02:00
|
|
|
|
|
|
|
this.dispatch({
|
2018-03-09 22:59:12 +02:00
|
|
|
type: 'FOLDER_DELETE',
|
2017-11-08 23:39:07 +02:00
|
|
|
id: folderId,
|
2017-05-16 22:42:23 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-07-15 17:35:40 +02:00
|
|
|
static conflictFolderTitle() {
|
2018-03-09 22:59:12 +02:00
|
|
|
return _('Conflicts');
|
2017-07-15 17:35:40 +02:00
|
|
|
}
|
2017-06-18 01:49:52 +02:00
|
|
|
|
2017-07-15 17:35:40 +02:00
|
|
|
static conflictFolderId() {
|
2018-03-09 22:59:12 +02:00
|
|
|
return 'c04f1c7c04f1c7c04f1c7c04f1c7c04f';
|
2017-07-15 17:35:40 +02:00
|
|
|
}
|
|
|
|
|
2021-01-29 20:45:11 +02:00
|
|
|
static conflictFolder(): FolderEntity {
|
2017-07-15 17:35:40 +02:00
|
|
|
return {
|
|
|
|
type_: this.TYPE_FOLDER,
|
|
|
|
id: this.conflictFolderId(),
|
2018-05-09 10:53:47 +02:00
|
|
|
parent_id: '',
|
2017-07-15 17:35:40 +02:00
|
|
|
title: this.conflictFolderTitle(),
|
|
|
|
updated_time: time.unixMs(),
|
2017-08-20 22:11:32 +02:00
|
|
|
user_updated_time: time.unixMs(),
|
2017-07-15 17:35:40 +02:00
|
|
|
};
|
|
|
|
}
|
2017-06-25 11:00:54 +02:00
|
|
|
|
2019-11-11 08:14:56 +02:00
|
|
|
// Calculates note counts for all folders and adds the note_count attribute to each folder
|
|
|
|
// Note: this only calculates the overall number of nodes for this folder and all its descendants
|
2021-01-22 19:41:11 +02:00
|
|
|
static async addNoteCounts(folders: any[], includeCompletedTodos = true) {
|
|
|
|
const foldersById: any = {};
|
2020-11-14 14:37:18 +02:00
|
|
|
for (const f of folders) {
|
2019-11-11 08:14:56 +02:00
|
|
|
foldersById[f.id] = f;
|
|
|
|
|
2020-11-14 14:37:18 +02:00
|
|
|
if (this.conflictFolderId() === f.id) {
|
|
|
|
f.note_count = await Note.conflictedCount();
|
|
|
|
} else {
|
|
|
|
f.note_count = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const where = ['is_conflict = 0'];
|
|
|
|
if (!includeCompletedTodos) where.push('(notes.is_todo = 0 OR notes.todo_completed = 0)');
|
2020-01-18 15:46:04 +02:00
|
|
|
|
2020-11-14 14:37:18 +02:00
|
|
|
const sql = `
|
|
|
|
SELECT folders.id as folder_id, count(notes.parent_id) as note_count
|
2020-01-18 15:46:04 +02:00
|
|
|
FROM folders LEFT JOIN notes ON notes.parent_id = folders.id
|
2020-11-14 14:37:18 +02:00
|
|
|
WHERE ${where.join(' AND ')}
|
|
|
|
GROUP BY folders.id
|
|
|
|
`;
|
2020-01-18 15:46:04 +02:00
|
|
|
|
2019-11-11 08:14:56 +02:00
|
|
|
const noteCounts = await this.db().selectAll(sql);
|
2021-01-22 19:41:11 +02:00
|
|
|
noteCounts.forEach((noteCount: any) => {
|
2019-11-11 08:14:56 +02:00
|
|
|
let parentId = noteCount.folder_id;
|
|
|
|
do {
|
2020-03-14 01:46:14 +02:00
|
|
|
const folder = foldersById[parentId];
|
2019-11-12 19:50:48 +02:00
|
|
|
if (!folder) break; // https://github.com/laurent22/joplin/issues/2079
|
2019-11-11 08:14:56 +02:00
|
|
|
folder.note_count = (folder.note_count || 0) + noteCount.note_count;
|
2020-06-07 13:47:43 +02:00
|
|
|
|
|
|
|
// Should not happen anymore but just to be safe, add the check below
|
|
|
|
// https://github.com/laurent22/joplin/issues/3334
|
|
|
|
if (folder.id === folder.parent_id) break;
|
|
|
|
|
2019-11-11 08:14:56 +02:00
|
|
|
parentId = folder.parent_id;
|
|
|
|
} while (parentId);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-03-02 19:35:57 +02:00
|
|
|
// Folders that contain notes that have been modified recently go on top.
|
|
|
|
// The remaining folders, that don't contain any notes are sorted by their own user_updated_time
|
2021-01-22 19:41:11 +02:00
|
|
|
static async orderByLastModified(folders: FolderEntity[], dir = 'DESC') {
|
2019-03-02 19:35:57 +02:00
|
|
|
dir = dir.toUpperCase();
|
|
|
|
const sql = 'select parent_id, max(user_updated_time) content_updated_time from notes where parent_id != "" group by parent_id';
|
|
|
|
const rows = await this.db().selectAll(sql);
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
const folderIdToTime: Record<string, number> = {};
|
2019-03-02 19:35:57 +02:00
|
|
|
for (let i = 0; i < rows.length; i++) {
|
|
|
|
const row = rows[i];
|
|
|
|
folderIdToTime[row.parent_id] = row.content_updated_time;
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
const findFolderParent = (folderId: string) => {
|
2019-03-02 19:35:57 +02:00
|
|
|
const folder = BaseModel.byId(folders, folderId);
|
|
|
|
if (!folder) return null; // For the rare case of notes that are associated with a no longer existing folder
|
|
|
|
if (!folder.parent_id) return null;
|
|
|
|
for (let i = 0; i < folders.length; i++) {
|
|
|
|
if (folders[i].id === folder.parent_id) return folders[i];
|
|
|
|
}
|
2019-11-20 20:14:11 +02:00
|
|
|
|
|
|
|
// In some rare cases, some folders may not have a parent, for example
|
|
|
|
// if it has not been downloaded via sync yet.
|
|
|
|
// https://github.com/laurent22/joplin/issues/2088
|
|
|
|
return null;
|
2019-07-29 15:43:53 +02:00
|
|
|
};
|
2019-03-02 19:35:57 +02:00
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
const applyChildTimeToParent = (folderId: string) => {
|
2019-03-02 19:35:57 +02:00
|
|
|
const parent = findFolderParent(folderId);
|
|
|
|
if (!parent) return;
|
|
|
|
|
2019-03-10 23:16:05 +02:00
|
|
|
if (folderIdToTime[parent.id] && folderIdToTime[parent.id] >= folderIdToTime[folderId]) {
|
|
|
|
// Don't change so that parent has the same time as the last updated child
|
|
|
|
} else {
|
|
|
|
folderIdToTime[parent.id] = folderIdToTime[folderId];
|
|
|
|
}
|
2019-07-29 15:43:53 +02:00
|
|
|
|
2019-03-02 19:35:57 +02:00
|
|
|
applyChildTimeToParent(parent.id);
|
2019-07-29 15:43:53 +02:00
|
|
|
};
|
2019-03-02 19:35:57 +02:00
|
|
|
|
2020-03-14 01:46:14 +02:00
|
|
|
for (const folderId in folderIdToTime) {
|
2019-03-02 19:35:57 +02:00
|
|
|
if (!folderIdToTime.hasOwnProperty(folderId)) continue;
|
|
|
|
applyChildTimeToParent(folderId);
|
|
|
|
}
|
|
|
|
|
|
|
|
const mod = dir === 'DESC' ? +1 : -1;
|
|
|
|
const output = folders.slice();
|
|
|
|
output.sort((a, b) => {
|
|
|
|
const aTime = folderIdToTime[a.id] ? folderIdToTime[a.id] : a.user_updated_time;
|
|
|
|
const bTime = folderIdToTime[b.id] ? folderIdToTime[b.id] : b.user_updated_time;
|
|
|
|
|
|
|
|
if (aTime < bTime) return +1 * mod;
|
|
|
|
if (aTime > bTime) return -1 * mod;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
});
|
|
|
|
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async all(options: any = null) {
|
2020-03-14 01:46:14 +02:00
|
|
|
const output = await super.all(options);
|
2017-07-15 17:35:40 +02:00
|
|
|
if (options && options.includeConflictFolder) {
|
2020-03-14 01:46:14 +02:00
|
|
|
const conflictCount = await Note.conflictedCount();
|
2017-07-15 17:35:40 +02:00
|
|
|
if (conflictCount) output.push(this.conflictFolder());
|
|
|
|
}
|
|
|
|
return output;
|
|
|
|
}
|
2017-06-25 11:00:54 +02:00
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async childrenIds(folderId: string) {
|
2018-06-10 20:15:40 +02:00
|
|
|
const folders = await this.db().selectAll('SELECT id FROM folders WHERE parent_id = ?', [folderId]);
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
let output: string[] = [];
|
2018-06-10 20:15:40 +02:00
|
|
|
|
|
|
|
for (let i = 0; i < folders.length; i++) {
|
|
|
|
const f = folders[i];
|
|
|
|
output.push(f.id);
|
2021-01-22 19:41:11 +02:00
|
|
|
const subChildrenIds = await this.childrenIds(f.id);
|
2018-06-10 20:15:40 +02:00
|
|
|
output = output.concat(subChildrenIds);
|
|
|
|
}
|
|
|
|
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async expandTree(folders: FolderEntity[], parentId: string) {
|
2020-03-11 16:20:25 +02:00
|
|
|
const folderPath = await this.folderPath(folders, parentId);
|
2020-06-16 00:59:42 +02:00
|
|
|
folderPath.pop(); // We don't expand the leaft notebook
|
|
|
|
|
2020-03-11 16:20:25 +02:00
|
|
|
for (const folder of folderPath) {
|
|
|
|
this.dispatch({
|
|
|
|
type: 'FOLDER_SET_COLLAPSED',
|
|
|
|
id: folder.id,
|
|
|
|
collapsed: false,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async allAsTree(folders: FolderEntity[] = null, options: any = null) {
|
2019-04-20 20:29:23 +02:00
|
|
|
const all = folders ? folders : await this.all(options);
|
2018-05-26 16:46:57 +02:00
|
|
|
|
|
|
|
// https://stackoverflow.com/a/49387427/561309
|
2021-01-22 19:41:11 +02:00
|
|
|
function getNestedChildren(models: FolderEntityWithChildren[], parentId: string) {
|
2019-07-29 15:43:53 +02:00
|
|
|
const nestedTreeStructure = [];
|
|
|
|
const length = models.length;
|
2018-05-26 16:46:57 +02:00
|
|
|
|
2019-07-29 15:43:53 +02:00
|
|
|
for (let i = 0; i < length; i++) {
|
|
|
|
const model = models[i];
|
2018-05-26 16:46:57 +02:00
|
|
|
|
2019-07-29 15:43:53 +02:00
|
|
|
if (model.parent_id == parentId) {
|
|
|
|
const children = getNestedChildren(models, model.id);
|
2018-05-26 16:46:57 +02:00
|
|
|
|
2019-07-29 15:43:53 +02:00
|
|
|
if (children.length > 0) {
|
|
|
|
model.children = children;
|
|
|
|
}
|
2018-05-26 16:46:57 +02:00
|
|
|
|
2019-07-29 15:43:53 +02:00
|
|
|
nestedTreeStructure.push(model);
|
|
|
|
}
|
|
|
|
}
|
2018-05-26 16:46:57 +02:00
|
|
|
|
2019-07-29 15:43:53 +02:00
|
|
|
return nestedTreeStructure;
|
2018-05-26 16:46:57 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return getNestedChildren(all, '');
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static folderPath(folders: FolderEntity[], folderId: string) {
|
|
|
|
const idToFolders: Record<string, FolderEntity> = {};
|
2020-07-28 19:50:34 +02:00
|
|
|
for (let i = 0; i < folders.length; i++) {
|
|
|
|
idToFolders[folders[i].id] = folders[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
const path = [];
|
|
|
|
while (folderId) {
|
|
|
|
const folder = idToFolders[folderId];
|
|
|
|
if (!folder) break; // Shouldn't happen
|
|
|
|
path.push(folder);
|
|
|
|
folderId = folder.parent_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
path.reverse();
|
|
|
|
|
|
|
|
return path;
|
2019-04-01 21:43:13 +02:00
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static folderPathString(folders: FolderEntity[], folderId: string, maxTotalLength = 80) {
|
2019-04-01 21:43:13 +02:00
|
|
|
const path = this.folderPath(folders, folderId);
|
2019-04-04 09:01:16 +02:00
|
|
|
|
|
|
|
let currentTotalLength = 0;
|
|
|
|
for (let i = 0; i < path.length; i++) {
|
|
|
|
currentTotalLength += path[i].title.length;
|
|
|
|
}
|
|
|
|
|
|
|
|
let pieceLength = maxTotalLength;
|
|
|
|
if (currentTotalLength > maxTotalLength) {
|
|
|
|
pieceLength = maxTotalLength / path.length;
|
|
|
|
}
|
|
|
|
|
2019-04-01 21:43:13 +02:00
|
|
|
const output = [];
|
|
|
|
for (let i = 0; i < path.length; i++) {
|
2019-04-04 09:01:16 +02:00
|
|
|
output.push(substrWithEllipsis(path[i].title, 0, pieceLength));
|
2019-04-01 21:43:13 +02:00
|
|
|
}
|
2019-04-04 09:01:16 +02:00
|
|
|
|
2019-04-01 21:43:13 +02:00
|
|
|
return output.join(' / ');
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static buildTree(folders: FolderEntity[]) {
|
|
|
|
const idToFolders: Record<string, any> = {};
|
2018-12-16 18:18:24 +02:00
|
|
|
for (let i = 0; i < folders.length; i++) {
|
2020-10-09 19:35:46 +02:00
|
|
|
idToFolders[folders[i].id] = Object.assign({}, folders[i]);
|
2018-12-16 18:18:24 +02:00
|
|
|
idToFolders[folders[i].id].children = [];
|
|
|
|
}
|
|
|
|
|
|
|
|
const rootFolders = [];
|
2020-03-14 01:46:14 +02:00
|
|
|
for (const folderId in idToFolders) {
|
2018-12-16 18:18:24 +02:00
|
|
|
if (!idToFolders.hasOwnProperty(folderId)) continue;
|
|
|
|
|
|
|
|
const folder = idToFolders[folderId];
|
|
|
|
if (!folder.parent_id) {
|
|
|
|
rootFolders.push(folder);
|
|
|
|
} else {
|
2018-12-31 18:33:20 +02:00
|
|
|
if (!idToFolders[folder.parent_id]) {
|
|
|
|
// It means the notebook is refering a folder that doesn't exist. In theory it shouldn't happen
|
|
|
|
// but sometimes does - https://github.com/laurent22/joplin/issues/1068#issuecomment-450594708
|
|
|
|
rootFolders.push(folder);
|
|
|
|
} else {
|
|
|
|
idToFolders[folder.parent_id].children.push(folder);
|
|
|
|
}
|
2018-12-16 18:18:24 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rootFolders;
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async sortFolderTree(folders: FolderEntityWithChildren[] = null) {
|
2020-05-09 17:19:30 +02:00
|
|
|
const output = folders ? folders : await this.allAsTree();
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
const sortFoldersAlphabetically = (folders: FolderEntityWithChildren[]) => {
|
|
|
|
folders.sort((a: FolderEntityWithChildren, b: FolderEntityWithChildren) => {
|
|
|
|
if (a.parent_id === b.parent_id) {
|
2020-05-09 17:19:30 +02:00
|
|
|
return a.title.localeCompare(b.title, undefined, { sensitivity: 'accent' });
|
|
|
|
}
|
2021-01-22 19:41:11 +02:00
|
|
|
return 0;
|
2020-05-09 17:19:30 +02:00
|
|
|
});
|
|
|
|
return folders;
|
|
|
|
};
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
const sortFolders = (folders: FolderEntityWithChildren[]) => {
|
2020-05-09 17:19:30 +02:00
|
|
|
for (let i = 0; i < folders.length; i++) {
|
|
|
|
const folder = folders[i];
|
|
|
|
if (folder.children) {
|
|
|
|
folder.children = sortFoldersAlphabetically(folder.children);
|
|
|
|
sortFolders(folder.children);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return folders;
|
|
|
|
};
|
|
|
|
|
|
|
|
sortFolders(sortFoldersAlphabetically(output));
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
2021-01-29 20:45:11 +02:00
|
|
|
static load(id: string, _options: any = null): Promise<FolderEntity> {
|
|
|
|
if (id == this.conflictFolderId()) return Promise.resolve(this.conflictFolder());
|
2017-07-15 17:35:40 +02:00
|
|
|
return super.load(id);
|
2017-06-19 20:58:49 +02:00
|
|
|
}
|
|
|
|
|
2017-06-27 22:16:03 +02:00
|
|
|
static defaultFolder() {
|
2018-03-09 22:59:12 +02:00
|
|
|
return this.modelSelectOne('SELECT * FROM folders ORDER BY created_time DESC LIMIT 1');
|
2017-06-25 01:19:11 +02:00
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async canNestUnder(folderId: string, targetFolderId: string) {
|
2018-05-09 10:53:47 +02:00
|
|
|
if (folderId === targetFolderId) return false;
|
|
|
|
|
|
|
|
const conflictFolderId = Folder.conflictFolderId();
|
|
|
|
if (folderId == conflictFolderId || targetFolderId == conflictFolderId) return false;
|
|
|
|
|
|
|
|
if (!targetFolderId) return true;
|
|
|
|
|
|
|
|
while (true) {
|
2020-03-14 01:46:14 +02:00
|
|
|
const folder = await Folder.load(targetFolderId);
|
2018-05-09 10:53:47 +02:00
|
|
|
if (!folder.parent_id) break;
|
|
|
|
if (folder.parent_id === folderId) return false;
|
|
|
|
targetFolderId = folder.parent_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
static async moveToFolder(folderId: string, targetFolderId: string) {
|
2018-05-09 10:53:47 +02:00
|
|
|
if (!(await this.canNestUnder(folderId, targetFolderId))) throw new Error(_('Cannot move notebook to this location'));
|
|
|
|
|
|
|
|
// When moving a note to a different folder, the user timestamp is not updated.
|
|
|
|
// However updated_time is updated so that the note can be synced later on.
|
|
|
|
|
|
|
|
const modifiedFolder = {
|
|
|
|
id: folderId,
|
|
|
|
parent_id: targetFolderId,
|
|
|
|
updated_time: time.unixMs(),
|
|
|
|
};
|
|
|
|
|
|
|
|
return Folder.save(modifiedFolder, { autoTimestamp: false });
|
|
|
|
}
|
|
|
|
|
2017-07-15 17:35:40 +02:00
|
|
|
// These "duplicateCheck" and "reservedTitleCheck" should only be done when a user is
|
|
|
|
// manually creating a folder. They shouldn't be done for example when the folders
|
2019-07-29 15:43:53 +02:00
|
|
|
// are being synced to avoid any strange side-effects. Technically it's possible to
|
2017-07-17 21:19:01 +02:00
|
|
|
// have folders and notes with duplicate titles (or no title), or with reserved words.
|
2021-01-22 19:41:11 +02:00
|
|
|
static async save(o: FolderEntity, options: any = null) {
|
2017-07-17 21:19:01 +02:00
|
|
|
if (!options) options = {};
|
|
|
|
|
|
|
|
if (options.userSideValidation === true) {
|
2018-03-09 22:59:12 +02:00
|
|
|
if (!('duplicateCheck' in options)) options.duplicateCheck = true;
|
|
|
|
if (!('reservedTitleCheck' in options)) options.reservedTitleCheck = true;
|
2019-07-29 15:43:53 +02:00
|
|
|
if (!('stripLeftSlashes' in options)) options.stripLeftSlashes = true;
|
2020-06-07 13:47:43 +02:00
|
|
|
|
|
|
|
if (o.id && o.parent_id && o.id === o.parent_id) {
|
|
|
|
throw new Error('Parent ID cannot be the same as ID');
|
|
|
|
}
|
2017-07-17 21:19:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (options.stripLeftSlashes === true && o.title) {
|
2019-07-29 15:43:53 +02:00
|
|
|
while (o.title.length && (o.title[0] == '/' || o.title[0] == '\\')) {
|
2017-07-17 21:19:01 +02:00
|
|
|
o.title = o.title.substr(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-13 21:53:31 +02:00
|
|
|
// We allow folders with duplicate titles so that folders with the same title can exist under different parent folder. For example:
|
|
|
|
//
|
|
|
|
// PHP
|
|
|
|
// Code samples
|
|
|
|
// Doc
|
|
|
|
// Java
|
|
|
|
// My project
|
|
|
|
// Doc
|
|
|
|
|
|
|
|
// if (options.duplicateCheck === true && o.title) {
|
|
|
|
// let existingFolder = await Folder.loadByTitle(o.title);
|
|
|
|
// if (existingFolder && existingFolder.id != o.id) throw new Error(_('A notebook with this title already exists: "%s"', o.title));
|
|
|
|
// }
|
2017-07-03 20:58:01 +02:00
|
|
|
|
2017-07-17 21:19:01 +02:00
|
|
|
if (options.reservedTitleCheck === true && o.title) {
|
2017-07-15 17:35:40 +02:00
|
|
|
if (o.title == Folder.conflictFolderTitle()) throw new Error(_('Notebooks cannot be named "%s", which is a reserved title.', o.title));
|
|
|
|
}
|
|
|
|
|
2021-01-22 19:41:11 +02:00
|
|
|
return super.save(o, options).then((folder: FolderEntity) => {
|
2017-07-03 20:03:14 +02:00
|
|
|
this.dispatch({
|
2018-03-09 22:59:12 +02:00
|
|
|
type: 'FOLDER_UPDATE_ONE',
|
2017-12-14 19:58:10 +02:00
|
|
|
item: folder,
|
2017-05-18 22:31:40 +02:00
|
|
|
});
|
2017-07-03 20:03:14 +02:00
|
|
|
return folder;
|
2017-05-18 22:31:40 +02:00
|
|
|
});
|
|
|
|
}
|
2017-05-15 21:10:00 +02:00
|
|
|
}
|