Bulk import #26

Author: mProjectsCode

src/main.ts

@@ -1,8 +1,8 @@
-import {FrontMatterCache, Notice, Plugin, TFile} from 'obsidian';
+import {Notice, Plugin, TFile, TFolder} from 'obsidian';
 import {DEFAULT_SETTINGS, MediaDbPluginSettings, MediaDbSettingTab} from './settings/Settings';
 import {APIManager} from './api/APIManager';
 import {MediaTypeModel} from './models/MediaTypeModel';
-import {replaceIllegalFileNameCharactersInString} from './utils/Utils';
+import {dateTimeToString, markdownTable, replaceIllegalFileNameCharactersInString} from './utils/Utils';
 import {OMDbAPI} from './api/apis/OMDbAPI';
 import {MediaDbAdvancedSearchModal} from './modals/MediaDbAdvancedSearchModal';
 import {MediaDbSearchResultModal} from './modals/MediaDbSearchResultModal';
@@ -14,6 +14,7 @@ import {MediaTypeManager} from './utils/MediaTypeManager';
 import {SteamAPI} from './api/apis/SteamAPI';
 import {ModelPropertyMapper} from './settings/ModelPropertyMapper';
 import {YAMLConverter} from './utils/YAMLConverter';
+import {MediaDbFolderImportModal} from './modals/MediaDbFolderImportModal';
 
 export default class MediaDbPlugin extends Plugin {
 	settings: MediaDbPluginSettings;
@@ -30,6 +31,16 @@ export default class MediaDbPlugin extends Plugin {
 		);
 		ribbonIconEl.addClass('obsidian-media-db-plugin-ribbon-class');
 
+		this.registerEvent(this.app.workspace.on('file-menu', (menu, file) => {
+			if (file instanceof TFolder) {
+				menu.addItem(item => {
+					item.setTitle('Create Media DB entries from folder')
+						.setIcon('database')
+						.onClick(() => this.createEntriesFromFolder(file as TFolder));
+				});
+			}
+		}));
+
 		// register command to open search modal
 		this.addCommand({
 			id: 'open-media-db-search-modal',
@@ -74,16 +85,23 @@ export default class MediaDbPlugin extends Plugin {
 		this.modelPropertyMapper = new ModelPropertyMapper(this.settings);
 	}
 
-	async createMediaDbNote(modal: () => Promise<MediaTypeModel>): Promise<void> {
+	async createMediaDbNote(modal: () => Promise<MediaTypeModel[]>): Promise<void> {
+		let models: MediaTypeModel[] = [];
 		try {
-			let data: MediaTypeModel = await modal();
-			data = await this.apiManager.queryDetailedInfo(data);
-
-			await this.createMediaDbNoteFromModel(data);
+			models = await modal();
 		} catch (e) {
 			console.warn(e);
 			new Notice(e.toString());
 		}
+
+		for (const model of models) {
+			try {
+				await this.createMediaDbNoteFromModel(await this.apiManager.queryDetailedInfo(model));
+			} catch (e) {
+				console.warn(e);
+				new Notice(e.toString());
+			}
+		}
 	}
 
 	async createMediaDbNoteFromModel(mediaTypeModel: MediaTypeModel): Promise<void> {
@@ -126,44 +144,23 @@ export default class MediaDbPlugin extends Plugin {
 		}
 	}
 
-	async openMediaDbAdvancedSearchModal(): Promise<MediaTypeModel> {
-		return new Promise(((resolve, reject) => {
-			new MediaDbAdvancedSearchModal(this.app, this, (err, results) => {
-				if (err) return reject(err);
-				new MediaDbSearchResultModal(this.app, this, results, (err2, res) => {
-					if (err2) return reject(err2);
-					resolve(res);
-				}).open();
-			}).open();
-		}));
-	}
-
-	async openMediaDbIdSearchModal(): Promise<MediaTypeModel> {
-		return new Promise(((resolve, reject) => {
-			new MediaDbIdSearchModal(this.app, this, (err, res) => {
-				if (err) return reject(err);
-				resolve(res);
-			}).open();
-		}));
-	}
-
 	async updateActiveNote() {
 		const activeFile: TFile = this.app.workspace.getActiveFile();
 		if (!activeFile) {
 			throw new Error('MDB | there is no active note');
 		}
 
 		let metadata: any = this.app.metadataCache.getFileCache(activeFile).frontmatter;
+		metadata = JSON.parse(JSON.stringify(metadata)); // deep copy
 		delete metadata.position; // remove unnecessary data from the FrontMatterCache
 		metadata = this.modelPropertyMapper.convertObjectBack(metadata);
 
-		console.log(metadata)
+		console.log(metadata);
 
 		if (!metadata?.type || !metadata?.dataSource || !metadata?.id) {
 			throw new Error('MDB | active note is not a Media DB entry or is missing metadata');
 		}
 
-
 		let oldMediaTypeModel = this.mediaTypeManager.createMediaTypeModelFromMediaType(metadata, metadata.type);
 
 		let newMediaTypeModel = await this.apiManager.queryDetailedInfoById(metadata.id, metadata.dataSource);
@@ -178,6 +175,94 @@ export default class MediaDbPlugin extends Plugin {
 		await this.createMediaDbNoteFromModel(newMediaTypeModel);
 	}
 
+	async createEntriesFromFolder(folder: TFolder) {
+		const erroredFiles: { filePath: string, error: string }[] = [];
+
+		const {selectedAPI, titleFieldName} = await new Promise((resolve, reject) => {
+			new MediaDbFolderImportModal(this.app, this, ((selectedAPI, titleFieldName) => {
+				resolve({selectedAPI, titleFieldName});
+			})).open();
+		});
+
+		const selectedAPIs = {};
+		for (const api of this.apiManager.apis) {
+			// @ts-ignore
+			selectedAPIs[api.apiName] = api.apiName === selectedAPI;
+		}
+
+		for (const child of folder.children) {
+			if (child instanceof TFile) {
+				const file = child as TFile;
+				let metadata: any = this.app.metadataCache.getFileCache(file).frontmatter;
+
+				let title = metadata[titleFieldName];
+				if (!title) {
+					erroredFiles.push({filePath: file.path, error: `metadata field \'${titleFieldName}\' not found or empty`});
+					continue;
+				}
+
+				let results: MediaTypeModel[] = [];
+				try {
+					results = await this.apiManager.query(title, selectedAPIs);
+				} catch (e) {
+					erroredFiles.push({filePath: file.path, error: e.toString()});
+					continue;
+				}
+				if (!results || results.length === 0) {
+					erroredFiles.push({filePath: file.path, error: `no search results`});
+					continue;
+				}
+
+				let selectedResults: MediaTypeModel[] = await new Promise((resolve, reject) => {
+					const searchResultModal = new MediaDbSearchResultModal(this.app, this, results, (err, res) => {
+						if (err) return reject(err);
+						resolve(res);
+					});
+					searchResultModal.title = `Results for \'${title}\'`;
+					searchResultModal.open();
+				});
+
+				await this.createMediaDbNote(async () => selectedResults);
+			}
+		}
+
+		if (erroredFiles.length > 0) {
+			const title = `bulk import error report ${dateTimeToString(new Date())}`;
+			const filePath = `${this.settings.folder.replace(/\/$/, '')}/${title}.md`;
+
+			const table = [['file', 'error']].concat(erroredFiles.map(x => [x.filePath, x.error]));
+			// console.log(table)
+			let fileContent = `# ${title}\n\n${markdownTable(table)}`;
+
+			const targetFile = await this.app.vault.create(filePath, fileContent);
+		}
+	}
+
+	async openMediaDbAdvancedSearchModal(): Promise<MediaTypeModel[]> {
+		return new Promise(((resolve, reject) => {
+			new MediaDbAdvancedSearchModal(this.app, this, (err, results) => {
+				if (err) {
+					return reject(err);
+				}
+				new MediaDbSearchResultModal(this.app, this, results, (err2, res) => {
+					if (err2) {
+						return reject(err2);
+					}
+					resolve(res);
+				}).open();
+			}).open();
+		}));
+	}
+
+	async openMediaDbIdSearchModal(): Promise<MediaTypeModel> {
+		return new Promise(((resolve, reject) => {
+			new MediaDbIdSearchModal(this.app, this, (err, res) => {
+				if (err) return reject(err);
+				resolve(res);
+			}).open();
+		}));
+	}
+
 	async loadSettings() {
 		this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
 	}

src/modals/MediaDbFolderImportModal.ts

@@ -0,0 +1,59 @@
+import {App, ButtonComponent, DropdownComponent, Modal, Setting, TextComponent} from 'obsidian';
+import MediaDbPlugin from '../main';
+
+export class MediaDbFolderImportModal extends Modal {
+	plugin: MediaDbPlugin;
+	onSubmit: (selectedAPI: string, titleFieldName: string) => void;
+	selectedApi: string;
+	searchBtn: ButtonComponent;
+	titleFieldName: string;
+
+	constructor(app: App, plugin: MediaDbPlugin, onSubmit: (selectedAPI: string, titleFieldName: string) => void) {
+		super(app);
+		this.plugin = plugin;
+		this.onSubmit = onSubmit;
+		this.selectedApi = plugin.apiManager.apis[0].apiName;
+	}
+
+	submit() {
+		this.onSubmit(this.selectedApi, this.titleFieldName);
+		this.close();
+	}
+
+	onOpen() {
+		const {contentEl} = this;
+
+		contentEl.createEl('h2', {text: 'Create Media DB entries from folder'});
+
+		const apiSelectorWrapper = contentEl.createEl('div', {cls: 'media-db-plugin-list-wrapper'});
+		const apiSelectorTextWrapper = apiSelectorWrapper.createEl('div', {cls: 'media-db-plugin-list-text-wrapper'});
+		apiSelectorTextWrapper.createEl('span', {text: 'API to search', cls: 'media-db-plugin-list-text'});
+
+		const apiSelectorComponent = new DropdownComponent(apiSelectorWrapper);
+		apiSelectorComponent.onChange((value: string) => {
+			this.selectedApi = value;
+		});
+		for (const api of this.plugin.apiManager.apis) {
+			apiSelectorComponent.addOption(api.apiName, api.apiName);
+		}
+		apiSelectorWrapper.appendChild(apiSelectorComponent.selectEl);
+
+
+		const placeholder = 'Title metadata field name';
+		const titleFieldNameComponent = new TextComponent(contentEl);
+		titleFieldNameComponent.inputEl.style.width = '100%';
+		titleFieldNameComponent.setPlaceholder(placeholder);
+		titleFieldNameComponent.onChange(value => this.titleFieldName = value);
+
+		contentEl.appendChild(titleFieldNameComponent.inputEl);
+
+		new Setting(contentEl)
+			.addButton(btn => btn.setButtonText('Cancel').onClick(() => this.close()))
+			.addButton(btn => btn.setButtonText('Ok').setCta().onClick(() => this.submit()));
+	}
+
+	onClose() {
+		const {contentEl} = this;
+		contentEl.empty();
+	}
+}

src/modals/MediaDbSearchResultModal.ts

@@ -1,35 +1,32 @@
-import {App, SuggestModal} from 'obsidian';
+import {App} from 'obsidian';
 import {MediaTypeModel} from '../models/MediaTypeModel';
 import MediaDbPlugin from '../main';
+import {SelectModal} from './SelectModal';
 
-export class MediaDbSearchResultModal extends SuggestModal<MediaTypeModel> {
-	suggestion: MediaTypeModel[];
+export class MediaDbSearchResultModal extends SelectModal<MediaTypeModel> {
 	plugin: MediaDbPlugin;
-	onChoose: (error: Error, result?: MediaTypeModel) => void;
+	heading: string;
+	onChoose: (error: Error, result: MediaTypeModel[]) => void;
 
-	constructor(app: App, plugin: MediaDbPlugin, suggestion: MediaTypeModel[], onChoose: (error: Error, result?: MediaTypeModel) => void) {
-		super(app);
+	constructor(app: App, plugin: MediaDbPlugin, elements: MediaTypeModel[], onChoose: (error: Error, result: MediaTypeModel[]) => void) {
+		super(app, elements);
 		this.plugin = plugin;
-		this.suggestion = suggestion;
 		this.onChoose = onChoose;
-	}
 
-	getSuggestions(query: string): MediaTypeModel[] {
-		return this.suggestion.filter(item => {
-			const searchQuery = query.toLowerCase();
-			return item.title.toLowerCase().includes(searchQuery);
-		});
+		this.title = 'Search Results';
+		this.description = 'Select one or multiple search results.';
 	}
 
 	// Renders each suggestion item.
-	renderSuggestion(item: MediaTypeModel, el: HTMLElement) {
+	renderElement(item: MediaTypeModel, el: HTMLElement) {
 		el.createEl('div', {text: this.plugin.mediaTypeManager.getFileName(item)});
 		el.createEl('small', {text: `${item.englishTitle}\n`});
 		el.createEl('small', {text: `${item.type.toUpperCase() + (item.subType ? ` (${item.subType})` : '')} from ${item.dataSource}`});
 	}
 
 	// Perform action on the selected suggestion.
-	onChooseSuggestion(item: MediaTypeModel, evt: MouseEvent | KeyboardEvent) {
-		this.onChoose(null, item);
+	submit() {
+		this.onChoose(null, this.selectModalElements.filter(x => x.isActive()).map(x => x.value));
+		this.close();
 	}
 }

src/modals/SelectModal.ts

@@ -0,0 +1,72 @@
+import {App, Modal, Setting} from 'obsidian';
+import {SelectModalElement} from './SelectModalElement';
+
+export abstract class SelectModal<T> extends Modal {
+	multiSelect: boolean;
+	allowMultiSelect: boolean;
+
+	title: string;
+	description: string;
+
+	elements: T[];
+	selectModalElements: SelectModalElement<T>[];
+
+
+	constructor(app: App, elements: T[]) {
+		super(app);
+		this.elements = elements;
+		this.allowMultiSelect = true;
+
+		this.selectModalElements = [];
+	}
+
+	abstract renderElement(value: T, el: HTMLElement): any;
+
+	abstract submit(): void;
+
+	disableAllOtherElements(elementId: number) {
+		for (const selectModalElement of this.selectModalElements) {
+			if (selectModalElement.id !== elementId) {
+				selectModalElement.setActive(false);
+			}
+		}
+	}
+
+	async onOpen() {
+		const {contentEl} = this;
+
+		contentEl.createEl('h2', {text: this.title});
+		contentEl.createEl('p', {text: this.description});
+
+		if (this.allowMultiSelect) {
+			new Setting(contentEl)
+				.setName('Select Multiple')
+				.addToggle(cb => {
+					cb.setValue(this.multiSelect);
+					cb.onChange(value => {
+						this.multiSelect = value;
+						for (const selectModalElement of this.selectModalElements) {
+							selectModalElement.setActive(false);
+						}
+					});
+				});
+		}
+
+		const elementWrapper = contentEl.createDiv({cls: 'media-db-plugin-select-wrapper'});
+
+		let i = 0;
+		for (const element of this.elements) {
+			const selectModalElement = new SelectModalElement(element, contentEl, i, this, false);
+
+			this.selectModalElements.push(selectModalElement);
+
+			this.renderElement(element, selectModalElement.element);
+
+			i += 1;
+		}
+
+		new Setting(contentEl)
+			.addButton(btn => btn.setButtonText('Cancel').onClick(() => this.close()))
+			.addButton(btn => btn.setButtonText('Ok').setCta().onClick(() => this.submit()));
+	}
+}