41 | 48 |

51 | 52 |

53 |

54 |

Create command

55 |

56 | Make the query into an executable command. 57 |

58 |

59 |

60 |

{ 64 | query.createCommand = !query.createCommand; 65 | emitHandleChange(); 66 | }} 67 | > 68 | 73 |

74 |

75 |

76 | 77 | 78 |

79 |

80 |

Use disabled folders

81 |

82 | Use disabled folders from settings. 83 |

84 |

85 |

86 |

{ 90 | query.useDisabledFolders = !query.useDisabledFolders; 91 | emitHandleChange(); 92 | }} 93 | > 94 | 99 |

100 |

101 |

102 | 103 | 104 |

105 |

106 |

Open in

107 |

Where to open the file.

108 |

109 |

110 | 119 |

120 |

121 | 122 | 123 |

124 |

125 |

Query type

126 |

127 | Use Regex, Dataview, or the default. 128 |

129 |

130 |

131 | 140 |

141 |

142 | 143 |

144 |

145 |

Query

146 |

147 | {queryDescription} 148 |

149 |

150 |

156 | 	</div>
157 | </div>
158 | 
159 | <style>
160 | 	.title {
161 | 		text-align: center;
162 | 	}
163 | 
164 | 	.title__input {
165 | 		text-align: center;
166 | 		background: transparent;
167 | 		padding: 0;
168 | 		border: none;
169 | 		font-size: var(--h2-size);
170 | 		width: 100%;
171 | 	}
172 | 
173 | 	.content {
174 | 		display: flex;
175 | 		flex-direction: column;
176 | 		gap: 1em;
177 | 	}
178 | </style>
179 |

--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
  1 | import { Plugin, TFile, TFolder } from "obsidian";
  2 | import { RandomNoteModal } from "src/gui/modals/OpenRandomNoteModal/openRandomNoteModal";
  3 | import { Search } from "./search";
  4 | import { DEFAULT_SETTINGS, SettingTab, Settings } from "./settings";
  5 | import type { Query, QueryOpenType } from "./types";
  6 | import {
  7 | 	deleteObsidianCommand,
  8 | 	flattenFile,
  9 | 	getPluginCommandId,
 10 | 	getRandomElement,
 11 | } from "./utilities";
 12 | 
 13 | export default class AdvancedRandomNote extends Plugin {
 14 | 	settings!: Settings;
 15 | 
 16 | 	async onload() {
 17 | 		// Load plugin settings
 18 | 		await this.loadSettings();
 19 | 
 20 | 		// Add random note modal command
 21 | 		this.addCommand({
 22 | 			id: "open-query-modal",
 23 | 			name: "Open query modal",
 24 | 			callback: () => this.handleOpenRandomFileModal(),
 25 | 		});
 26 | 
 27 | 		// Open generic random note
 28 | 		this.addCommand({
 29 | 			id: "open-random-note",
 30 | 			name: "Open random note",
 31 | 			callback: () => {
 32 | 				this.openRandomMarkdownFile();
 33 | 			},
 34 | 		});
 35 | 
 36 | 		// Open generic random note
 37 | 		this.addCommand({
 38 | 			id: "open-random-file",
 39 | 			name: "Open random file",
 40 | 			callback: () => {
 41 | 				this.openRandomVaultFile();
 42 | 			},
 43 | 		});
 44 | 
 45 | 		this.addRibbonIcon("dice", "Open random note modal", () => {
 46 | 			this.handleOpenRandomFileModal();
 47 | 		});
 48 | 
 49 | 		// File menu
 50 | 		this.registerEvent(
 51 | 			this.app.workspace.on("file-menu", (menu, file) => {
 52 | 				if (!(file instanceof TFolder) || file.isRoot()) return;
 53 | 
 54 | 				menu.addItem((item) => {
 55 | 					item.setTitle("Open random note")
 56 | 						.setIcon("dice")
 57 | 						.onClick(async () => {
 58 | 							const files = flattenFile(file);
 59 | 							const foundFiles = await new Search(
 60 | 								this
 61 | 							).searchFiles(files, file.path + "/");
 62 | 							this.openRandomFile(foundFiles);
 63 | 						});
 64 | 				});
 65 | 			})
 66 | 		);
 67 | 
 68 | 		// Setup saved queries
 69 | 		this.addQueryCommands();
 70 | 
 71 | 		// Add settings tab
 72 | 		this.addSettingTab(new SettingTab(this.app, this));
 73 | 
 74 | 		if (this.settings.debug) {
 75 | 			console.log("Loaded " + this.manifest.name);
 76 | 		}
 77 | 	}
 78 | 
 79 | 	async loadSettings() {
 80 | 		this.settings = Object.assign(
 81 | 			{},
 82 | 			DEFAULT_SETTINGS,
 83 | 			await this.loadData()
 84 | 		);
 85 | 	}
 86 | 
 87 | 	async saveSettings() {
 88 | 		await this.saveData(this.settings);
 89 | 	}
 90 | 
 91 | 	async openFile(file: TFile, openType: QueryOpenType = "Default") {
 92 | 		if (openType === "Default") openType = this.settings.openType;
 93 | 		switch (openType) {
 94 | 			case "New Window":
 95 | 				await this.app.workspace
 96 | 					.getLeaf("window")
 97 | 					.openFile(file, { active: this.settings.setActive });
 98 | 				return;
 99 | 			case "New Leaf":
100 | 				await this.app.workspace
101 | 					.getLeaf("tab")
102 | 					.openFile(file, { active: this.settings.setActive });
103 | 				return;
104 | 			default:
105 | 				await this.app.workspace.openLinkText(file.path, "", false, {
106 | 					active: this.settings.setActive,
107 | 				});
108 | 				break;
109 | 		}
110 | 	}
111 | 
112 | 	async openRandomFile(files: TFile[], openType: QueryOpenType = "Default") {
113 | 		// Get random note from files`
114 | 		const file = getRandomElement(files);
115 | 
116 | 		if (!file) return;
117 | 
118 | 		if (this.settings.debug) {
119 | 			console.log("Found and opened file:");
120 | 			console.log(file);
121 | 		}
122 | 
123 | 		// Open file
124 | 		await this.openFile(file, openType);
125 | 	}
126 | 
127 | 	async openRandomMarkdownFile() {
128 | 		const foundFiles = await new Search(this).searchFiles(
129 | 			this.app.vault.getMarkdownFiles()
130 | 		);
131 | 		await this.openRandomFile(foundFiles);
132 | 	}
133 | 
134 | 	async openRandomVaultFile() {
135 | 		const foundFiles = await new Search(this).searchFiles(
136 | 			this.app.vault.getFiles()
137 | 		);
138 | 		await this.openRandomFile(foundFiles);
139 | 	}
140 | 
141 | 	handleOpenRandomFileModal() {
142 | 		const modal = new RandomNoteModal(
143 | 			this.app,
144 | 			this.settings.queries,
145 | 			async (query: Query) => this.executeQuery(query)
146 | 		);
147 | 		modal.open();
148 | 	}
149 | 
150 | 	async executeQuery(query: Query) {
151 | 		const files = await new Search(this).search(query);
152 | 
153 | 		if (files.length <= 0) {
154 | 			return;
155 | 		}
156 | 
157 | 		await this.openRandomFile(files, query.openType);
158 | 	}
159 | 
160 | 	addQueryCommands() {
161 | 		this.settings.queries.forEach(
162 | 			(query) => query.createCommand && this.addQueryCommand(query)
163 | 		);
164 | 	}
165 | 
166 | 	addQueryCommand(query: Query) {
167 | 		this.addCommand({
168 | 			id: query.id,
169 | 			name: query.name,
170 | 			callback: async () => this.executeQuery(query),
171 | 		});
172 | 	}
173 | 
174 | 	removeQueryCommand(query: Query) {
175 | 		deleteObsidianCommand(
176 | 			this.app,
177 | 			getPluginCommandId(query.id, this.manifest)
178 | 		);
179 | 	}
180 | }
181 |

--------------------------------------------------------------------------------
/src/search.ts:
--------------------------------------------------------------------------------
  1 | import { Notice, TAbstractFile, TFile } from "obsidian";
  2 | import { getAPI } from "obsidian-dataview";
  3 | import AdvancedRandomNote from "./main";
  4 | import type {
  5 | 	ProcessedDefaultQuery,
  6 | 	Query,
  7 | 	RandomNoteResult,
  8 | 	SearchTag,
  9 | } from "./types";
 10 | import { getTagString, getTagStrings } from "./utilities";
 11 | 
 12 | export class Search {
 13 | 	plugin: AdvancedRandomNote;
 14 | 
 15 | 	constructor(plugin: AdvancedRandomNote) {
 16 | 		this.plugin = plugin;
 17 | 	}
 18 | 
 19 | 	async search(query: Query): Promise<RandomNoteResult> {
 20 | 		// Find files that match query
 21 | 		let result: TFile[] = [];
 22 | 		if (query.type === "Dataview") {
 23 | 			const api = getAPI();
 24 | 			if (!api) {
 25 | 				new Notice(
 26 | 					"Advanced Random Note: Dataview API could not be found, is Dataview installed?"
 27 | 				);
 28 | 				return [];
 29 | 			}
 30 | 
 31 | 			const dataviewResult = await api?.query(query.query);
 32 | 
 33 | 			if (!dataviewResult || !dataviewResult?.successful) {
 34 | 				new Notice(
 35 | 					"Advanced Random Note: Error running dataview query"
 36 | 				);
 37 | 				return [];
 38 | 			}
 39 | 
 40 | 			if (dataviewResult.value.type !== "list") {
 41 | 				new Notice(
 42 | 					"Advanced Random Note: Dataview query is not a list"
 43 | 				);
 44 | 				return [];
 45 | 			}
 46 | 
 47 | 			result = dataviewResult.value.values
 48 | 				.map((value) =>
 49 | 					this.plugin.app.vault.getAbstractFileByPath(value.path)
 50 | 				)
 51 | 				.filter((file) => file !== null && file instanceof TFile)
 52 | 				.map((file) => file as TFile);
 53 | 		} else {
 54 | 			const files = this.plugin.app.vault.getFiles();
 55 | 
 56 | 			if (query.type === "Regex") {
 57 | 				const regex = new RegExp(query.query);
 58 | 				result = files.filter((file) => regex.test(file.path));
 59 | 			} else {
 60 | 				result = files.filter((file) =>
 61 | 					this.checkFileToMatchQuery(file, query)
 62 | 				);
 63 | 			}
 64 | 		}
 65 | 
 66 | 		// Filter disabled folder
 67 | 		if (query.useDisabledFolders) {
 68 | 			result = result.filter((file) => !this.isInDisabledFolder(file));
 69 | 
 70 | 			if (result.length <= 0) {
 71 | 				new Notice(
 72 | 					"Advanced Random Note: Found zero files matching your query."
 73 | 				);
 74 | 			}
 75 | 		}
 76 | 
 77 | 		return result;
 78 | 	}
 79 | 
 80 | 	searchFiles = async (files: TFile[], disabledDisabledPaths?: string): Promise<RandomNoteResult> => {
 81 | 		const result = files.filter((file) => !this.isInDisabledFolder(file, disabledDisabledPaths));
 82 | 
 83 | 		if (result.length <= 0) {
 84 | 			new Notice(
 85 | 				"Advanced Random Note: Found zero files."
 86 | 			);
 87 | 		}
 88 | 
 89 | 		return result;
 90 | 	};
 91 | 
 92 | 	processQuery(query: Query): ProcessedDefaultQuery {
 93 | 		const regexResult = {
 94 | 			path: /path:(.*?)(tag:|file:|$)/.exec(query.query),
 95 | 			file: /file:(.*?)(tag:|path:|$)/.exec(query.query),
 96 | 			tags: /tag:(.*?)(file:|path:|$)/.exec(query.query),
 97 | 		};
 98 | 
 99 | 		const path = regexResult.path ? regexResult.path[1].trim() : "";
100 | 		const file = regexResult.file ? regexResult.file[1].trim() : "";
101 | 		const tags: SearchTag[] = (
102 | 			regexResult.tags ? regexResult.tags[1].trim().split(" ") : []
103 | 		).map((tag) => {
104 | 			const trimmedTag = tag.trim();
105 | 
106 | 			return {
107 | 				included: !trimmedTag.startsWith("!"),
108 | 				tag: getTagString(trimmedTag),
109 | 			};
110 | 		});
111 | 
112 | 		const processedQuery: ProcessedDefaultQuery = {
113 | 			path,
114 | 			file,
115 | 			tags,
116 | 		};
117 | 
118 | 		return processedQuery;
119 | 	}
120 | 
121 | 	checkFileToMatchQuery(file: TFile, query: Query) {
122 | 		// Process query
123 | 		const processedQuery = this.processQuery(query);
124 | 		return (
125 | 			this.checkTagsWithFile(processedQuery.tags, file) &&
126 | 			this.checkFilenameWithFile(processedQuery.file, file) &&
127 | 			this.checkPathWithFile(processedQuery.path, file)
128 | 		);
129 | 	}
130 | 
131 | 	checkTagsWithFile(tags: SearchTag[], file: TFile): boolean {
132 | 		if (tags.length <= 0) {
133 | 			return true;
134 | 		} else if (file.extension !== "md") {
135 | 			return false;
136 | 		}
137 | 
138 | 		const fileCache = this.plugin.app.metadataCache.getFileCache(file);
139 | 
140 | 		// Get file tags
141 | 		const fileCacheTags = fileCache?.tags ?? [];
142 | 		let frontmatterTags = fileCache?.frontmatter?.tags ?? [];
143 | 		const frontmatterTag = fileCache?.frontmatter?.tag;
144 | 
145 | 		if (frontmatterTags[0] === null) frontmatterTags = [];
146 | 
147 | 		// Combine tags
148 | 		let fileTags = fileCacheTags.map((tagCache) => tagCache.tag);
149 | 		fileTags = fileTags.concat(getTagStrings(frontmatterTags));
150 | 		if (frontmatterTag) {
151 | 			fileTags.push(getTagString(frontmatterTag));
152 | 		}
153 | 
154 | 		if (fileTags.length <= 0 && tags.length > 0) return false;
155 | 
156 | 		// Get excluded and included tags
157 | 		const includedTags = tags.filter((tag) => tag.included);
158 | 		const excludedTags = tags.filter((tag) => !tag.included);
159 | 		let includesTags = false;
160 | 		let excludesTags = false;
161 | 
162 | 		// Check included tags
163 | 		includesTags =
164 | 			(includedTags &&
165 | 				fileTags &&
166 | 				includedTags.every((searchTag) => {
167 | 					return fileTags.some((fileTag) =>
168 | 						fileTag.includes(searchTag.tag)
169 | 					);
170 | 				})) ||
171 | 			!includedTags;
172 | 
173 | 		// Check excluded tasks
174 | 		excludesTags =
175 | 			(excludedTags &&
176 | 				fileTags &&
177 | 				excludedTags.every((searchTag) => {
178 | 					return fileTags.every(
179 | 						(fileTag) => !fileTag.includes(searchTag.tag)
180 | 					);
181 | 				})) ||
182 | 			(excludedTags && !fileTags) ||
183 | 			!excludedTags;
184 | 
185 | 		return includesTags && excludesTags;
186 | 	}
187 | 
188 | 	checkFilenameWithFile(filename: string, file: TFile): boolean {
189 | 		return file.name.includes(filename);
190 | 	}
191 | 
192 | 	checkPathWithFile(path: string, file: TFile): boolean {
193 | 		return (
194 | 			(path !== "/" && file.path.includes(path)) ||
195 | 			(path === "/" && !file.path.includes(path))
196 | 		);
197 | 	}
198 | 
199 | 	isInDisabledFolder(file: TAbstractFile, disabledDisabledPaths?: string): boolean {
200 | 		if (this.plugin.settings.disabledFolders === "") return false;
201 | 
202 | 		return this.plugin.settings.disabledFolders
203 | 			.split(/\r?\n/)
204 | 			.some((disabledFolder) => {
205 | 				const trimmedFolder = disabledFolder.trim();
206 | 				if (disabledDisabledPaths && trimmedFolder === disabledDisabledPaths) return false;
207 | 				return trimmedFolder && file.path.startsWith(trimmedFolder);
208 | 			});
209 | 	}
210 | }
211 |

--------------------------------------------------------------------------------

Select Random Note Query

41 | 48 |