1
0
mirror of https://github.com/laurent22/joplin.git synced 2024-12-12 08:54:00 +02:00
joplin/ReactNativeClient/lib/services/InteropService.js

289 lines
8.7 KiB
JavaScript
Raw Normal View History

const BaseItem = require('lib/models/BaseItem.js');
const BaseModel = require('lib/BaseModel.js');
const Resource = require('lib/models/Resource.js');
const Folder = require('lib/models/Folder.js');
const NoteTag = require('lib/models/NoteTag.js');
const Note = require('lib/models/Note.js');
const Tag = require('lib/models/Tag.js');
const { basename, filename } = require('lib/path-utils.js');
const fs = require('fs-extra');
const ArrayUtils = require('lib/ArrayUtils');
const { sprintf } = require('sprintf-js');
const { shim } = require('lib/shim');
const { _ } = require('lib/locale');
const { fileExtension } = require('lib/path-utils');
const { uuid } = require('lib/uuid.js');
const { toTitleCase } = require('lib/string-utils');
2018-02-25 19:01:16 +02:00
class InteropService {
2018-02-27 22:04:38 +02:00
constructor() {
this.modules_ = null;
}
modules() {
if (this.modules_) return this.modules_;
let importModules = [
{
format: 'jex',
fileExtensions: ['jex'],
sources: ['file'],
description: _('Joplin Export File'),
}, {
format: 'md',
fileExtensions: ['md', 'markdown'],
sources: ['file', 'directory'],
2018-02-27 22:04:38 +02:00
isNoteArchive: false, // Tells whether the file can contain multiple notes (eg. Enex or Jex format)
description: _('Markdown'),
}, {
format: 'raw',
sources: ['directory'],
description: _('Joplin Export Directory'),
}, {
format: 'enex',
fileExtensions: ['enex'],
sources: ['file'],
description: _('Evernote Export File'),
2018-02-27 22:04:38 +02:00
},
];
let exportModules = [
{
format: 'jex',
fileExtensions: ['jex'],
target: 'file',
description: _('Joplin Export File'),
}, {
format: 'raw',
target: 'directory',
description: _('Joplin Export Directory'),
}, {
format: 'json',
target: 'directory',
description: _('Json Export Directory'),
}, {
format: 'md',
target: 'directory',
description: _('Markdown'),
2018-02-27 22:04:38 +02:00
},
];
importModules = importModules.map((a) => {
const className = 'InteropService_Importer_' + toTitleCase(a.format);
const output = Object.assign({}, {
type: 'importer',
path: 'lib/services/' + className,
}, a);
if (!('isNoteArchive' in output)) output.isNoteArchive = true;
2018-02-27 22:04:38 +02:00
return output;
});
exportModules = exportModules.map((a) => {
const className = 'InteropService_Exporter_' + toTitleCase(a.format);
return Object.assign({}, {
type: 'exporter',
path: 'lib/services/' + className,
}, a);
2018-02-27 22:04:38 +02:00
});
this.modules_ = importModules.concat(exportModules);
this.modules_ = this.modules_.map((a) => {
a.fullLabel = function(moduleSource = null) {
const label = [this.format.toUpperCase() + ' - ' + this.description];
if (moduleSource && this.sources.length > 1) {
label.push('(' + (moduleSource === 'file' ? _('File') : _('Directory')) + ')');
}
return label.join(' ');
};
return a;
});
2018-02-27 22:04:38 +02:00
return this.modules_;
}
moduleByFormat_(type, format) {
const modules = this.modules();
for (let i = 0; i < modules.length; i++) {
const m = modules[i];
if (m.format === format && m.type === type) return modules[i];
2018-02-26 21:16:01 +02:00
}
2018-02-27 22:04:38 +02:00
return null;
2018-02-25 19:01:16 +02:00
}
2018-02-27 22:04:38 +02:00
newModule_(type, format) {
const module = this.moduleByFormat_(type, format);
if (!module) throw new Error(_('Cannot load "%s" module for format "%s"', type, format));
const ModuleClass = require(module.path);
const output = new ModuleClass();
output.setMetadata(module);
return output;
2018-02-26 20:43:50 +02:00
}
2018-02-27 22:04:38 +02:00
moduleByFileExtension_(type, ext) {
ext = ext.toLowerCase();
const modules = this.modules();
for (let i = 0; i < modules.length; i++) {
const m = modules[i];
if (type !== m.type) continue;
if (m.fileExtensions && m.fileExtensions.indexOf(ext) >= 0) return m;
2018-02-27 22:04:38 +02:00
}
return null;
2018-02-26 21:16:01 +02:00
}
async import(options) {
2018-02-26 21:16:01 +02:00
if (!await shim.fsDriver().exists(options.path)) throw new Error(_('Cannot find "%s".', options.path));
options = Object.assign({}, {
format: 'auto',
destinationFolderId: null,
destinationFolder: null,
}, options);
2018-02-25 19:01:16 +02:00
if (options.format === 'auto') {
const module = this.moduleByFileExtension_('importer', fileExtension(options.path));
if (!module) throw new Error(_('Please specify import format for %s', options.path));
2018-02-27 22:04:38 +02:00
options.format = module.format;
2018-02-25 19:01:16 +02:00
}
if (options.destinationFolderId) {
const folder = await Folder.load(options.destinationFolderId);
2018-02-27 22:04:38 +02:00
if (!folder) throw new Error(_('Cannot find "%s".', options.destinationFolderId));
2018-02-26 20:43:50 +02:00
options.destinationFolder = folder;
2018-02-25 19:01:16 +02:00
}
let result = { warnings: [] }
2018-02-25 19:01:16 +02:00
const importer = this.newModule_('importer', options.format);
2018-02-26 20:43:50 +02:00
await importer.init(options.path, options);
result = await importer.exec(result);
2018-02-25 19:01:16 +02:00
return result;
}
async export(options) {
const exportPath = options.path ? options.path : null;
let sourceFolderIds = options.sourceFolderIds ? options.sourceFolderIds : [];
const sourceNoteIds = options.sourceNoteIds ? options.sourceNoteIds : [];
const exportFormat = options.format ? options.format : 'jex';
const result = { warnings: [] }
const itemsToExport = [];
const queueExportItem = (itemType, itemOrId) => {
itemsToExport.push({
type: itemType,
itemOrId: itemOrId
});
}
let exportedNoteIds = [];
let resourceIds = [];
const folderIds = await Folder.allIds();
let fullSourceFolderIds = sourceFolderIds.slice();
for (let i = 0; i < sourceFolderIds.length; i++) {
const id = sourceFolderIds[i];
const childrenIds = await Folder.childrenIds(id);
fullSourceFolderIds = fullSourceFolderIds.concat(childrenIds);
}
sourceFolderIds = fullSourceFolderIds;
for (let folderIndex = 0; folderIndex < folderIds.length; folderIndex++) {
const folderId = folderIds[folderIndex];
if (sourceFolderIds.length && sourceFolderIds.indexOf(folderId) < 0) continue;
if (!sourceNoteIds.length) await queueExportItem(BaseModel.TYPE_FOLDER, folderId);
const noteIds = await Folder.noteIds(folderId);
for (let noteIndex = 0; noteIndex < noteIds.length; noteIndex++) {
const noteId = noteIds[noteIndex];
if (sourceNoteIds.length && sourceNoteIds.indexOf(noteId) < 0) continue;
const note = await Note.load(noteId);
await queueExportItem(BaseModel.TYPE_NOTE, note);
exportedNoteIds.push(noteId);
2018-05-03 14:11:45 +02:00
const rids = await Note.linkedResourceIds(note.body);
resourceIds = resourceIds.concat(rids);
}
}
resourceIds = ArrayUtils.unique(resourceIds);
for (let i = 0; i < resourceIds.length; i++) {
await queueExportItem(BaseModel.TYPE_RESOURCE, resourceIds[i]);
}
const noteTags = await NoteTag.all();
let exportedTagIds = [];
for (let i = 0; i < noteTags.length; i++) {
const noteTag = noteTags[i];
if (exportedNoteIds.indexOf(noteTag.note_id) < 0) continue;
await queueExportItem(BaseModel.TYPE_NOTE_TAG, noteTag.id);
exportedTagIds.push(noteTag.tag_id);
}
for (let i = 0; i < exportedTagIds.length; i++) {
await queueExportItem(BaseModel.TYPE_TAG, exportedTagIds[i]);
}
const exporter = this.newModule_('exporter', exportFormat);
await exporter.init(exportPath);
const typeOrder = [BaseModel.TYPE_FOLDER, BaseModel.TYPE_RESOURCE, BaseModel.TYPE_NOTE, BaseModel.TYPE_TAG, BaseModel.TYPE_NOTE_TAG];
const context = {
resourcePaths: {},
};
for (let typeOrderIndex = 0; typeOrderIndex < typeOrder.length; typeOrderIndex++) {
const type = typeOrder[typeOrderIndex];
for (let i = 0; i < itemsToExport.length; i++) {
const itemType = itemsToExport[i].type;
if (itemType !== type) continue;
const ItemClass = BaseItem.getClassByItemType(itemType);
const itemOrId = itemsToExport[i].itemOrId;
const item = typeof itemOrId === 'object' ? itemOrId : await ItemClass.load(itemOrId);
if (!item) {
if (itemType === BaseModel.TYPE_RESOURCE) {
result.warnings.push(sprintf('A resource that does not exist is referenced in a note. The resource was skipped. Resource ID: %s', itemOrId));
} else {
result.warnings.push(sprintf('Cannot find item with type "%s" and ID %s. Item was skipped.', ItemClass.tableName(), JSON.stringify(itemOrId)));
}
continue;
}
if (item.encryption_applied || item.encryption_blob_encrypted) throw new Error(_('This item is currently encrypted: %s "%s". Please wait for all items to be decrypted and try again.', BaseModel.modelTypeToName(itemType), item.title ? item.title : item.id));
2018-02-27 22:51:07 +02:00
try {
if (itemType == BaseModel.TYPE_RESOURCE) {
const resourcePath = Resource.fullPath(item);
context.resourcePaths[item.id] = resourcePath;
exporter.updateContext(context);
await exporter.processResource(item, resourcePath);
}
await exporter.processItem(ItemClass, item);
} catch (error) {
result.warnings.push(error.message);
}
}
}
await exporter.close();
return result;
}
}
module.exports = InteropService;