some more reminders work

src/components/PopupPicker.vue

@@ -0,0 +1,60 @@
+<script setup lang="ts">
+	import { IonModal, IonPicker, IonPickerColumn, IonPickerColumnOption } from '@ionic/vue';
+	import { onMounted, ref } from 'vue';
+
+	const self = ref();
+
+	type ColumnContent = {
+		name: string,
+		values: PickerValue[],
+		prefix?: string,
+		suffix?: string
+	}
+
+	type PickerValue = {
+		name: string,
+		value: string|number|undefined,
+		default?: boolean,
+		disabled?: boolean,
+		color?: string
+	}
+
+	const props = defineProps<{
+		content: ColumnContent[]
+	}>();
+
+	const values = defineModel<Map<string, string|number|undefined>>();
+
+	onMounted(() => {
+		for(const column of props.content)
+			values.value?.set(column.name, column.values.find(x => x.default)?.value || undefined);
+	});
+
+</script>
+
+<template>
+	<IonModal class="popup-picker" ref="self">
+		<IonPicker>
+			<IonPickerColumn
+				v-for="column in props.content"
+				@ionChange="(e) => { values?.set(column.name, e.detail.value) }"
+				:value="values?.get(column.name) || column.values.find(x => x.default)?.value || undefined"
+			>
+				<div slot="prefix" v-if="column.prefix">{{ column.prefix }}</div>
+				<IonPickerColumnOption v-for="option in column.values" :value="option.value" :color="option.color" :disabled="option.disabled">
+					{{ option.name }}
+				</IonPickerColumnOption>
+				<div slot="suffix" v-if="column.suffix">{{ column.suffix }}</div>
+			</IonPickerColumn>
+		</IonPicker>
+	</IonModal>
+</template>
+
+<style scoped>
+	ion-modal.popup-picker {
+		--backdrop-opacity: var(--ion-backdrop-opacity, 0.32) !important;
+		--border-radius: 16px;
+		--width: unset;
+		--height: unset;
+	}
+</style>

src/lib/db/entities.d.ts

@@ -1,41 +1,45 @@
-export type UUIDable = {
+export interface UUIDable {
 	uuid: UUID
 };
 
 export type UUID = string;
 
-export type BoardMessage = UUIDable & {
+export interface BoardMessage extends UUIDable {
 	member: UUID,
 	title: string,
 	body: string,
 	date: Date
 }
 
-export type BoardMessageComplete = Omit<BoardMessage, "member"> & { member: Member }
+export interface BoardMessageComplete extends BoardMessage {
+	member: Member
+}
 
-export type ChatMessage = UUIDable & {
+export interface ChatMessage extends UUIDable {
 	chat: UUID,
 	member: UUID,
 	date: Date,
 	message: string,
 }
 
-export type Chat = UUIDable & {
+export interface Chat extends UUIDable {
 	name: string,
 	image?: File
 }
 
-export type FrontingEntry = UUIDable & {
+export interface FrontingEntry extends UUIDable {
 	member: UUID,
 	startTime: Date,
 	endTime?: Date,
 	isMainFronter: boolean,
 	customStatus?: string
 }
 
-export type FrontingEntryComplete = Omit<FrontingEntry, "member"> & { member: Member }
+export interface FrontingEntryComplete extends FrontingEntry {
+	member: Member
+}
 
-export type JournalPost = UUIDable & {
+export interface JournalPost extends UUIDable {
 	member: UUID,
 	date: Date,
 	title: string,
@@ -45,12 +49,12 @@ export type JournalPost = UUIDable & {
 	tags: UUID[] // array of UUIDs
 }
 
-export type Attachment = UUIDable & {
+export interface Attachment extends UUIDable {
 	name: string,
 	file: File
 }
 
-export type Member = UUIDable & {
+export interface Member extends UUIDable {
 	name: string,
 	pronouns?: string,
 	description?: string,
@@ -62,32 +66,47 @@ export type Member = UUIDable & {
 	tags: UUID[] // array of UUIDs
 }
 
-type ReminderBase = UUIDable & {
+interface ReminderBase extends UUIDable {
 	name: string,
 	title: string,
 	message: string,
-	nativeId?: number
+	nativeId?: number // if nativeId is present then the reminder is active
 }
 
-export type EventReminder = ReminderBase & {
+interface EventReminder extends ReminderBase {
 	type: "event",
 	triggeringEvent: {
 		type: "memberAdded" | "memberRemoved",
 		filterQuery?: string
 	},
-	delay: number // seconds
+	delay: {
+		hours: number,
+		minutes: number
+	},
 
 	// make it either-or in regards to PeriodicReminder
-	scheduleOn?: never
+	scheduleEveryInterval?: never,
+	scheduleEveryWeekday?: never,
+	scheduleTimeAt?: never
 }
 
-export type PeriodicReminder = ReminderBase & {
+interface PeriodicReminder extends ReminderBase {
 	type: "periodic",
-	scheduleOn: {
+	scheduleEveryInterval?: {
 		year?: number,
 		month?: number,
 		day?: number,
-		weekday?: 1 | 2 | 3 | 4 | 5 | 6 | 7,
+	},
+	scheduleEveryWeekday?: {
+		monday?: boolean,
+		tuesday?: boolean,
+		wednesday?: boolean,
+		thursday?: boolean,
+		friday?: boolean,
+		saturday?: boolean,
+		sunday?: boolean
+	},
+	scheduleTimeAt?: {
 		hour?: number,
 		minute?: number,
 		second?: number
@@ -100,13 +119,13 @@ export type PeriodicReminder = ReminderBase & {
 
 export type Reminder = EventReminder | PeriodicReminder;
 
-export type System = UUIDable & {
+export interface System extends UUIDable {
 	name: string,
 	description?: string,
 	image?: File
 }
 
-export type Tag = UUIDable & {
+export interface Tag extends UUIDable {
 	name: string,
 	description?: string,
 	type: "member" | "journal",

src/lib/db/impl/dexie/reminders.ts

@@ -1,20 +1,24 @@
 import { db } from ".";
 import { DatabaseEvents, DatabaseEvent } from "../../events";
 import { makeUUIDv5 } from "../../../util/uuid";
-import { UUIDable, Reminder } from "../../entities";
+import { UUIDable, Reminder, UUID } from "../../entities";
 import { getSystemUUID } from "./system";
 
 async function genid(name: string) {
 	return makeUUIDv5((await getSystemUUID())!, `reminders\0${name}\0${Date.now()}`);
 }
 
+export function getReminders(){
+	return db.reminders.toArray();
+}
+
 export async function newReminder(reminder: Omit<Reminder, keyof UUIDable>) {
 	try{
 		const uuid = await genid(reminder.name);
 		await db.reminders.add({
 			...reminder,
 			uuid
-		});
+		} as Reminder);
 		DatabaseEvents.dispatchEvent(new DatabaseEvent("updated", {
 			table: "reminders",
 			event: "new",
@@ -25,3 +29,34 @@ export async function newReminder(reminder: Omit<Reminder, keyof UUIDable>) {
 		return false;
 	}
 }
+
+export async function removeReminder(uuid: UUID) {
+	try {
+		await db.reminders.delete(uuid);
+		DatabaseEvents.dispatchEvent(new DatabaseEvent("updated", {
+			table: "reminders",
+			event: "deleted",
+			data: uuid
+		}));
+		return true;
+	} catch (error) {
+		return false;
+	}
+}
+
+export async function updateReminder(uuid: UUID, newContent: Partial<Reminder>) {
+	try{
+		const updated = await db.reminders.update(uuid, newContent);
+		if(updated) {
+			DatabaseEvents.dispatchEvent(new DatabaseEvent("updated", {
+				table: "reminders",
+				event: "modified",
+				data: uuid
+			}));
+			return true;
+		}
+		return false;
+	}catch(error){
+		return false;
+	}
+}

src/lib/db/impl/dexie/types.d.ts

@@ -1,4 +1,5 @@
 import Dexie, { Table } from "dexie";
+import { BoardMessage, Chat, ChatMessage, FrontingEntry, JournalPost, Member, Reminder, System, Tag } from "../../entities";
 export type AmpersandDexieDatabase = Dexie & {
 	boardMessages: Table<BoardMessage>
 	chats: Table<Chat>

src/lib/db/impl/tauri/reminders.ts

@@ -1,13 +1,17 @@
 import { db } from ".";
 import { DatabaseEvents, DatabaseEvent } from "../../events";
 import { makeUUIDv5 } from "../../../util/uuid";
-import { UUIDable, Reminder } from "../../entities";
+import { UUIDable, Reminder, UUID } from "../../entities";
 import { getSystemUUID } from "./system";
 
 async function genid(name: string) {
 	return makeUUIDv5((await getSystemUUID())!, `reminders\0${name}\0${Date.now()}`);
 }
 
+export function getReminders(){
+	return db.reminders.toArray();
+}
+
 export async function newReminder(reminder: Omit<Reminder, keyof UUIDable>) {
 	try{
 		const uuid = await genid(reminder.name);
@@ -25,3 +29,34 @@ export async function newReminder(reminder: Omit<Reminder, keyof UUIDable>) {
 		return false;
 	}
 }
+
+export async function removeReminder(uuid: UUID) {
+	try {
+		await db.reminders.delete(uuid);
+		DatabaseEvents.dispatchEvent(new DatabaseEvent("updated", {
+			table: "reminders",
+			event: "deleted",
+			data: uuid
+		}));
+		return true;
+	} catch (error) {
+		return false;
+	}
+}
+
+export async function updateReminder(uuid: UUID, newContent: Partial<Reminder>) {
+	try{
+		const updated = await db.reminders.update(uuid, newContent);
+		if(updated) {
+			DatabaseEvents.dispatchEvent(new DatabaseEvent("updated", {
+				table: "reminders",
+				event: "modified",
+				data: uuid
+			}));
+			return true;
+		}
+		return false;
+	}catch(error){
+		return false;
+	}
+}

src/lib/db/tables/reminders.ts

@@ -1,7 +1,19 @@
-import { Reminder, UUIDable } from '../entities';
+import { Reminder, UUID, UUIDable } from '../entities';
 
 const impl = await ("isTauri" in window ? import('../impl/tauri/reminders') : import('../impl/dexie/reminders'));
 
+export function getReminders(){
+	return impl.getReminders();
+}
+
 export function newReminder(reminder: Omit<Reminder, keyof UUIDable>) {
 	return impl.newReminder(reminder);
 }
+
+export function removeReminder(uuid: UUID){
+	return impl.removeReminder(uuid);
+}
+
+export function updateReminder(uuid: UUID, newContent: Partial<Reminder>) {
+	return impl.updateReminder(uuid, newContent);
+}