Feature - Remote Notes!

src/fullcalendar_interop.ts

@@ -106,7 +106,7 @@ export function toEventInput(
 			daysOfWeek: frontmatter.daysOfWeek.map((c) => DAYS.indexOf(c)),
 			startRecur: frontmatter.startRecur,
 			endRecur: frontmatter.endRecur,
-			extendedProps: { isTask: false },
+			extendedProps: { isTask: false, remoteReplace: frontmatter.replaceRemote },
 		};
 		if (!frontmatter.allDay) {
 			event = {
@@ -146,6 +146,7 @@ export function toEventInput(
 						frontmatter.completed !== undefined &&
 						frontmatter.completed !== null,
 					taskCompleted: frontmatter.completed,
+					remoteReplace: frontmatter.replaceRemote
 				},
 			};
 		} else {
@@ -158,6 +159,7 @@ export function toEventInput(
 						frontmatter.completed !== undefined &&
 						frontmatter.completed !== null,
 					taskCompleted: frontmatter.completed,
+					remoteReplace: frontmatter.replaceRemote
 				},
 			};
 		}

src/main.ts

@@ -3,7 +3,6 @@ import { CalendarView, FULL_CALENDAR_VIEW_TYPE } from "./ui/view";
 import { renderCalendar } from "./ui/calendar";
 
 import { EventModal } from "./ui/modal";
-import { toEventInput } from "./fullcalendar_interop";
 import {
 	DEFAULT_SETTINGS,
 	FullCalendarSettings,
@@ -15,7 +14,6 @@ export default class FullCalendarPlugin extends Plugin {
 	settings: FullCalendarSettings = DEFAULT_SETTINGS;
 
 	renderCalendar = renderCalendar;
-	processFrontmatter = toEventInput;
 
 	async activateView() {
 		this.app.workspace.detachLeavesOfType(FULL_CALENDAR_VIEW_TYPE);

src/models/Event.ts

@@ -1,4 +1,9 @@
 import { Calendar, EventInput } from "@fullcalendar/core";
+import { MetadataCache, Vault, WorkspaceLeaf } from "obsidian";
+import { parseFrontmatter } from "src/frontmatter";
+import { CalendarSource, EventFrontmatter } from "src/types";
+import { getColors } from "./util";
+
 import { dir } from "console";
 import { MetadataCache, TFile, Vault, WorkspaceLeaf } from "obsidian";
 import { toEventInput } from "src/fullcalendar_interop";

src/models/IcsSource.ts

@@ -1,22 +1,29 @@
 import { EventSourceInput } from "@fullcalendar/core";
-import { request } from "obsidian";
+import { request, Vault } from "obsidian";
+import FullCalendarPlugin from "src/main";
 import { FCError, ICalSource } from "src/types";
 import { IcalExpander } from "vendor/fullcalendar-ical/ical-expander/IcalExpander";
 import {
 	expandICalEvents,
 	makeICalExpander,
 } from "vendor/fullcalendar-ical/icalendar";
 import { EventSource } from "./EventSource";
+import { RemoteReplaceEvent } from "./RemoteReplaceEvent";
 import { getColors } from "./util";
 
 export class IcsSource extends EventSource {
 	info: ICalSource;
-	constructor(info: ICalSource) {
+	plugin: FullCalendarPlugin;
+	vault: Vault;
+	constructor(info: ICalSource, plugin: FullCalendarPlugin, vault: Vault) {
 		super();
 		this.info = info;
+		this.plugin = plugin;
+		this.vault = vault;
 	}
 
 	async toApi(): Promise<EventSourceInput | FCError> {
+		let $ = this;
 		let url = this.info.url;
 		if (url.startsWith("webcal")) {
 			url = "https" + url.slice("webcal".length);
@@ -51,7 +58,9 @@ export class IcsSource extends EventSource {
 					start,
 					end,
 				});
-				return events;
+				return events.filter((ev)=> {
+					return !RemoteReplaceEvent.checkNoteCreateP(ev, $.plugin, $.vault);
+				});
 			},
 			editable: false,
 			...getColors(this.info.color),

src/models/NoteEvent.ts

@@ -1,8 +1,22 @@
 import { MetadataCache, TFile, Vault, WorkspaceLeaf } from "obsidian";
+import { modifyFrontmatter } from "src/frontmatter";
+import { EventFrontmatter, FCError, validateFrontmatter } from "src/types";
+import { LocalEvent } from "./Event";
 import { modifyFrontmatter } from "src/serialization/frontmatter";
 import { OFCEvent, FCError, validateEvent } from "src/types";
 import { basenameFromEvent, LocalEvent } from "./Event";
 
+function basenameFromEvent(event: EventFrontmatter): string {
+	switch (event.type) {
+		case "single":
+		case undefined:
+			return `${event.date} ${event.title}` + (event.startTime && event.endTime ? ` ${event.startTime}-${event.endTime}` : '');
+		case "recurring":
+			return `(Every ${event.daysOfWeek.join(",")}) ${event.title})`;
+	}
+}
+
+
 export class NoteEvent extends LocalEvent {
 	get path(): string {
 		return `${this.directory}/${this.filename}`;

src/models/NoteSource.ts

@@ -4,6 +4,7 @@ import { FCError, LocalCalendarSource } from "src/types";
 import { NoteEvent } from "./NoteEvent";
 import { EventSource } from "./EventSource";
 import { getColors } from "./util";
+import { RemoteReplaceEvent } from "./RemoteReplaceEvent";
 
 export class NoteSource extends EventSource {
 	info: LocalCalendarSource;
@@ -31,7 +32,10 @@ export class NoteSource extends EventSource {
 		let events: EventInput[] = [];
 		for (let file of eventFolder.children) {
 			if (file instanceof TFile) {
-				let event = NoteEvent.fromFile(this.cache, this.vault, file);
+				let event = RemoteReplaceEvent.fromFile(this.cache, this.vault, file);
+				if (!event){
+					event = NoteEvent.fromFile(this.cache, this.vault, file);
+				}
 				if (event) {
 					let calEvent = event.toCalendarEvent();
 					if (calEvent) {

src/models/RemoteReplaceEvent.ts

@@ -0,0 +1,143 @@
+import { EventInput } from "@fullcalendar/core";
+import { MetadataCache, TFile, Vault } from "obsidian";
+import { modifyFrontmatter } from "../serialization/frontmatter";
+import FullCalendarPlugin from "src/main";
+import { EventFrontmatter, FCError, LocalCalendarSource, OFCEvent, validateEvent } from "src/types";
+import { NoteEvent } from "./NoteEvent";
+
+function basenameFromEvent(event: EventFrontmatter): string {
+	switch (event.type) {
+		case "single":
+		case undefined:
+			return `${event.date} ${event.title}` + (event.startTime && event.endTime ? ` ${event.startTime}-${event.endTime}` : '');
+		case "recurring":
+			return `(Every ${event.daysOfWeek.join(",")}) ${event.title})`;
+	}
+}
+
+export class RemoteReplaceEvent extends NoteEvent {
+
+	constructor(
+		cache: MetadataCache,
+		vault: Vault,
+		data: OFCEvent,
+		{ directory, filename }: { directory: string; filename: string }
+	) {
+		super(cache, vault, data, {directory, filename});
+	}
+
+	static fromFile(
+		cache: MetadataCache,
+		vault: Vault,
+		file: TFile
+	): NoteEvent | null {
+		let data = validateEvent(cache.getFileCache(file)?.frontmatter);
+
+		if (!data) return null;
+		if (!data.replaceRemote) return null;
+		if (!data.title) {
+			data.title = file.basename;
+		}
+
+		return new NoteEvent(cache, vault, data, {
+			directory: file.parent.path,
+			filename: file.name,
+		});
+	}
+
+	static async create(
+		cache: MetadataCache,
+		vault: Vault,
+		directory: string,
+		data: EventFrontmatter
+	): Promise<NoteEvent> {
+		const filename = basenameFromEvent(data).replace(/\*|"|\\|\/|<|>|:|\||\?/g, '_');
+		const path = `${directory}/${filename}.md`;
+		if (vault.getAbstractFileByPath(path)) {
+			throw new FCError(`File with name '${filename}' already exists`);
+		}
+		const file = await vault.create(path, "");
+		await modifyFrontmatter(vault, file, data);
+
+		return new RemoteReplaceEvent(cache, vault, data, {
+			directory: file.parent.path,
+			filename: file.name,
+		});
+	}
+
+	static fromPath(
+		cache: MetadataCache,
+		vault: Vault,
+		path: string
+	): NoteEvent {
+		const file = vault.getAbstractFileByPath(path);
+		if (!(file instanceof TFile)) {
+			throw new FCError(`File not found at path: ${path}`);
+		}
+		const event = this.fromFile(cache, vault, file);
+		if (!event) {
+			throw new FCError(
+				`Could not construct event from file at path: ${path}`
+			);
+		}
+		return event;
+	}
+
+	async setData(data: EventFrontmatter): Promise<void> {
+		let file = this.file;
+		let filename = basenameFromEvent(data).replace(/\*|"|\\|\/|<|>|:|\||\?/g, '_');
+		let newFilename = `${filename}.md`;
+		if (
+			this.filename !== newFilename &&
+			this.vault.getAbstractFileByPath(
+				`${file.parent.path}/${newFilename}`
+			)
+		) {
+			throw new FCError(
+				"Multiple events with the same name on the same date are not yet supported. Please rename your event before moving it."
+			);
+		}
+
+		await modifyFrontmatter(this.vault, file, data);
+		if (this.filename !== newFilename) {
+			this.filename = newFilename;
+			await this.vault.rename(file, this.path);
+		}
+		this._data = data;
+	}
+
+	static noteCreatePath(ev: EventFrontmatter | EventInput, directory: string): string{
+		if (!ev.date || !ev.startTime || !ev.endTime){
+			let ds = new Date(Date.parse(ev.start));
+			let de = new Date(Date.parse(ev.end));
+			ev.date = `${ds.getFullYear()}-${("0" + (ds.getMonth() + 1)).slice(-2)}-${("0" + ds.getDate()).slice(-2)}`;
+			ev = {
+				...ev,
+				startTime: ("0" + ds.getHours()).slice(-2) + ":" + ("0" + ds.getMinutes()).slice(-2),
+				endTime:   ("0" + de.getHours()).slice(-2) + ":" + ("0" + de.getMinutes()).slice(-2),
+			};
+			if (ev.endTime == "00:00"){
+				ev.endTime = "23:59";
+			}
+		}
+		let filename = `${ev.date} ${ev.title}` + (ev.startTime && ev.endTime ? ` ${ev.startTime}-${ev.endTime}` : '');
+		filename = filename.replace(/\*|"|\\|\/|<|>|:|\||\?/g, '_');
+		return `${directory}/${filename}.md`;
+	}
+
+	static checkNoteCreateP(ev: EventFrontmatter | EventInput, plugin: FullCalendarPlugin, vault: Vault): string|null{
+		return RemoteReplaceEvent.checkNoteCreate(ev, plugin.settings.calendarSources.filter(
+			(s) => s.type === "local"
+		).map(s => (s as LocalCalendarSource).directory), vault);
+	}
+
+	static checkNoteCreate(ev: EventFrontmatter | EventInput, sources: string[], vault: Vault): string|null{
+		for (const dir of sources){
+			const path = RemoteReplaceEvent.noteCreatePath(ev, dir);
+			if(vault.getAbstractFileByPath(path)){
+				return path;
+			}
+		}
+		return null;
+	}
+}

src/types.ts

@@ -1,5 +1,3 @@
-import { MetadataCache, Vault } from "obsidian";
-
 export const PLUGIN_SLUG = "full-calendar-plugin";
 
 // Frontmatter
@@ -31,6 +29,14 @@ export type RecurringEventData = {
 	endRecur?: string;
 } & CommonEventData;
 
+export type ReplaceRemoteData = {
+	replaceRemote?: boolean;
+} & CommonEventData;
+
+export type EventFrontmatter =
+	| SingleEventData
+	| RecurringEventData
+	| ReplaceRemoteData;
 export type OFCEvent = SingleEventData | RecurringEventData;
 
 /*
@@ -41,11 +47,11 @@ export function validateEvent(obj?: Record<string, any>): OFCEvent | null {
 	if (obj === undefined) {
 		return null;
 	}
-
+	
 	if (!obj.title) {
 		return null;
 	}
-
+	
 	if (!obj.allDay && !obj.startTime) {
 		return null;
 	}
@@ -67,18 +73,21 @@ export function validateEvent(obj?: Record<string, any>): OFCEvent | null {
 			date: obj.date,
 			endDate: obj.endDate,
 			completed: obj.completed,
+			replaceRemote: obj.replaceRemote,
 			...timeInfo,
 		};
 	} else if (obj.type === "recurring") {
 		if (obj.daysOfWeek === undefined) {
 			return null;
 		}
 		return {
+			...obj,
 			title: obj.title,
 			type: "recurring",
 			daysOfWeek: obj.daysOfWeek,
 			startRecur: obj.startRecur,
 			endRecur: obj.endRecur,
+			replaceRemote: obj.replaceRemote,
 			...timeInfo,
 		};
 	}
@@ -90,6 +99,7 @@ export function validateEvent(obj?: Record<string, any>): OFCEvent | null {
 
 type CalendarSourceCommon = {
 	color: string;
+	name: string;
 };
 
 /**
@@ -139,7 +149,6 @@ type AuthType = BasicAuth;
  */
 export type CalDAVSource = {
 	type: "caldav";
-	name: string;
 	url: string;
 	homeUrl: string;
 } & CalendarSourceCommon &

src/ui/calendar.ts

@@ -188,6 +188,19 @@ export function renderCalendar(
 					container?.prepend(checkbox);
 				}
 			}
+			if (event.extendedProps.remoteReplace){
+				const strong = document.createElement("strong");
+				strong.type = "strong";
+				strong.innerText = "[N]";
+				strong.style = "margin-right: 2px;"
+
+				const container =
+					el.querySelector(".fc-event-time") ||
+					el.querySelector(".fc-event-title") ||
+					el.querySelector(".fc-list-event-title");
+
+				container?.prepend(strong);
+			}
 		},
 
 		longPressDelay: 250,

src/ui/components/CalendarSetting.tsx

@@ -135,14 +135,14 @@ export const CalendarSettingRow = ({
 			>
 				✕
 			</button>
+			{setting.type !== "local" && <NameSetting source={setting} />}
 			{setting.type === "local" ? (
 				<DirectorySetting source={setting} />
 			) : setting.type === "dailynote" ? (
 				<HeadingSetting source={setting} />
 			) : (
 				<UrlSetting source={setting} />
 			)}
-			{isCalDAV && <NameSetting source={setting} />}
 			{isCalDAV && <Username source={setting} />}
 			<input
 				style={{ maxWidth: "25%", minWidth: "3rem" }}