Added custom LockChime support

Author: 3aa49ec6bfc910647fa1c5a013e48eef

src/website/package-lock.json

@@ -16,19 +16,26 @@
 		"@sveltejs/adapter-node": "^2.0.1",
 		"@sveltejs/kit": "^2.0.0",
 		"@sveltejs/vite-plugin-svelte": "^3.0.0",
+		"@types/cheerio": "^0.22.35",
 		"@types/node": "^20.10.5",
 		"@typescript-eslint/eslint-plugin": "^6.0.0",
 		"@typescript-eslint/parser": "^6.0.0",
+		"autoprefixer": "^10.4.16",
 		"eslint": "^8.28.0",
 		"eslint-config-prettier": "^9.1.0",
 		"eslint-plugin-svelte": "^2.30.0",
+		"postcss": "^8.4.32",
 		"prettier": "^3.1.1",
 		"prettier-plugin-svelte": "^3.1.2",
 		"svelte": "^4.2.7",
 		"svelte-check": "^3.6.0",
+		"tailwindcss": "^3.4.0",
 		"tslib": "^2.4.1",
 		"typescript": "^5.0.0",
 		"vite": "^5.0.3"
 	},
-	"type": "module"
+	"type": "module",
+	"dependencies": {
+		"cheerio": "^1.0.0-rc.12"
+	}
 }

src/website/package.json

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

src/website/postcss.config.js

@@ -0,0 +1,27 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+h1 {
+    @apply text-xl font-bold underline pb-2;
+}
+
+h2 {
+    @apply text-lg font-bold pb-1 pt-4;
+}
+
+ul {
+    @apply list-disc list-inside;
+}
+
+a {
+    @apply text-blue-500 underline;
+}
+
+select {
+    @apply border border-gray-300 py-1;
+}
+
+button {
+    @apply bg-blue-500 hover:bg-blue-700 text-white font-bold py-1 px-4 rounded;
+}

src/website/src/app.css

@@ -0,0 +1,5 @@
+<script>
+	import '../app.css';
+</script>
+
+<slot />

src/website/src/routes/+layout.svelte

@@ -6,6 +6,8 @@
 	let total = 0;
 	let logFiles: string[] = [];
 	let finishedApiCalls = false;
+	let lockChimes: any[] = [];
+	let selectedUrl = '';
 
 	async function add() {
 		const response = await fetch('/api/dashboard', {
@@ -33,21 +35,51 @@
 		return logFiles.logFiles;
 	}
 
+	async function getLockChimes() {
+		const response = await fetch('/api/lockChimes', {
+			method: 'GET',
+			headers: {
+				'content-type': 'application/json'
+			}
+		});
+
+		const lockChimes = await response.json();
+		console.log(lockChimes);
+
+		return lockChimes;
+	}
+
+	const installLockChime = async () => {
+		const response = await fetch('/api/lockChimes', {
+			method: 'POST',
+			body: JSON.stringify({ url: selectedUrl }),
+			headers: {
+				'content-type': 'application/json'
+			}
+		});
+
+		const installResponse = await response.json();
+		console.log(installResponse);
+	};
+
 	onMount(async () => {
 		logFiles = await listLogFiles();
+		lockChimes = await getLockChimes();
 		console.log(logFiles);
 		finishedApiCalls = true;
 	});
 </script>
 
+<div class="p-5">
+
 <h1>node-teslausb</h1>
 
 <h2>Log Files</h2>
 {#if finishedApiCalls == true}
 	{#if logFiles.length == 0}
 		<p>No log files found.</p>
 	{:else}
-		<ul>
+		<ul class="list-disc">
 			{#each logFiles as logFile}
 				<li><a href={`/viewLog/${logFile}`}>{logFile}</a></li>
 			{/each}
@@ -57,6 +89,27 @@
 	<p>Loading...</p>
 {/if}
 
+{#if finishedApiCalls}
+  <h2>Lock Chimes</h2>
+  {#if lockChimes.length == 0}
+    <p>No lock chimes found.</p>
+  {:else}
+    <select bind:value={selectedUrl}>
+      {#each lockChimes as lockChime}
+        <option value={lockChime.url}>{lockChime.title}</option>
+      {/each}
+    </select>
+    <button on:click={installLockChime}>Install</button>
+  {/if}
+  <div class="text-sm pt-1">
+	  Visit <a href="https://teslapro.hu/lockchimes/">https://teslapro.hu/lockchimes/</a> to listen to lock sounds before installing.
+	  <p class="pt-2">
+	<i>Note: currently, installation will happen within 2 minutes if no data is being synced.  Otherwise it will run once the sync finishes.</i>
+	</p>		
+  </div>
+{/if}
+
+</div>
 <!-- <p>Visit <a href="https://kit.svelte.dev">kit.svelte.dev</a> to read the documentation</p>
 
 <input type="number" bind:value={a}> +

src/website/src/routes/+page.svelte

@@ -0,0 +1,107 @@
+import { json } from '@sveltejs/kit';
+import cheerio from 'cheerio';
+import fs from 'fs/promises';
+import type { RequestEvent, RequestHandler } from '@sveltejs/kit';
+import { Readable } from 'stream';
+
+interface LockChime {
+    title: string;
+    url: string;
+}
+
+const getLockChimes = async (): Promise<LockChime[]> => {
+    try {
+        const url = 'https://teslapro.hu/lockchimes/';
+        const html = await fetchHTML(url);
+        return extractLockChimes(html);
+    } catch (error) {
+        console.error('Error fetching lock chimes:', error);
+        return [];
+    }
+};
+
+const fetchHTML = async (url: string): Promise<string> => {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Error fetching ${url}: ${response.statusText}`);
+    }
+    return await response.text();
+};
+
+const extractLockChimes = (html: string): LockChime[] => {
+    const $ = cheerio.load(html);
+    const lockChimes: LockChime[] = [];
+
+    $('.card').each((i, element) => {
+        const title = $(element).find('.card-title').text().trim();
+        let url = $(element).find('a').attr('href') ?? '';
+        if (url) {
+            url = `https://teslapro.hu/lockchimes/${url}`;
+        }
+
+        if (title && url) {
+            lockChimes.push({ title, url });
+        }
+    });
+
+    return lockChimes;
+};
+
+const downloadLockChime = async (url: string): Promise<string> => {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Error fetching ${url}: ${response.statusText}`);
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    const filename = 'LockChime.wav';
+    const tmpPath = `/tmp/${filename}`;
+
+    await fs.writeFile(tmpPath, buffer);
+
+    return tmpPath;
+};
+
+async function readableStreamToBuffer(readable: ReadableStream<Uint8Array>): Promise<Buffer> {
+    const reader = readable.getReader();
+    const chunks: Uint8Array[] = [];
+
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+    }
+
+    return Buffer.concat(chunks);
+}
+
+export async function GET({ request }) {
+    const lockChimes = await getLockChimes();
+    // const logNames = Object.keys(logNameToPathMapping);
+    return json(lockChimes);
+}
+
+export const POST: RequestHandler = async (event: RequestEvent) => {
+    // Convert ReadableStream to Buffer
+    const buffer = await readableStreamToBuffer(event.request.body!);
+
+    // Convert Buffer to string (assuming the content is text-based like JSON)
+    const rawBody = buffer.toString();
+
+    // Parse the string as JSON (if the content type is JSON)
+    const parsedBody = JSON.parse(rawBody);
+    console.log("lockChimeUrl:",parsedBody)
+
+    await downloadLockChime(parsedBody.url);
+
+    return new Response(JSON.stringify({ message: `OK` }), {
+        status: 200,
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    });
+}
+
+// Usage
+// console.log(lockChimes)

src/website/src/routes/api/lockChimes/+server.ts

@@ -0,0 +1,9 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: ['./src/**/*.{html,js,svelte,ts}'],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+

src/website/tailwind.config.js

@@ -4,6 +4,7 @@ import { getRcloneConfig, rcloneCopyWithProgress } from './modules/rclone.js';
 import { logWithTimestamp, errorWithTimestamp } from './modules/log.js';
 import { restartWifi, checkIfArchiveIsReachable } from './modules/network.js';
 import { mountTeslaCamAsReadOnly, unmountTeslaCam } from './modules/storage.js';
+import { checkLockChime } from './modules/lockChimes.js';
 
 const config = {
     archive: {
@@ -30,6 +31,8 @@ const processInterval = async () => {
 
     // TODO: add a health check that checks - if on wifi, but no wifi clients, and cannot connect to source, or copy job has been running for 2+ hrs (once refactored to run 1 rclone job per folder), then reboot
 
+    await checkLockChime();
+
     const archiveReachable = await checkIfArchiveIsReachable(config.archive.server);
     if (archiveReachable === false) {
         await restartWifi();

src/worker/index.js

@@ -0,0 +1,25 @@
+import { logWithTimestamp } from "./log";
+import { mountTeslaCamAsReadWrite, mountUsbDriveToHost, unmountTeslaCam, unmountUsbDriveFromHost } from "./storage";
+
+export const checkLockChime = async () => {
+    const configPath = '/tmp/LockChime.wav';
+    if (fs.existsSync(configPath) === false) return
+
+    logWithTimestamp(`LockChime.wav found, installing...`)
+    await installLockChime();
+
+    logWithTimestamp(`LockChime.wav installed, removing /tmp/LockChime.wav...`)
+    await executeBashCommand(`rm /tmp/LockChime.wav`)
+    
+    logWithTimestamp(`LockChime.wav removed.`)
+
+}
+
+const installLockChime = async () => {
+    unmountTeslaCam();
+    mountTeslaCamAsReadWrite();
+    unmountUsbDriveFromHost();
+    logWithTimestamp(`Copying LockChime.wav to USB drive`)
+    await executeBashCommand(`cp /tmp/LockChime.wav /mnt/usb/TeslaCam/SentryClips/`)
+    mountUsbDriveToHost();
+}

src/worker/modules/lockChimes.js

@@ -2,15 +2,30 @@ import { logWithTimestamp, errorWithTimestamp } from "./log.js"
 import { executeBashCommand } from "./bash.js"
 
 export const mountTeslaCamAsReadOnly = async () => {
-    logWithTimestamp("Mounting TeslaCam")
+    logWithTimestamp("Mounting TeslaCam as ro")
     await executeBashCommand("sudo mount -o ro /vusb/TeslaCam /mnt/TeslaCam && systemctl daemon-reload")
 }
 
+export const mountTeslaCamAsReadWrite = async () => {
+    logWithTimestamp("Mounting TeslaCam as rw - this can corrupt data if also being written to the by the host")
+    await executeBashCommand("sudo mount -o rw /vusb/TeslaCam /mnt/TeslaCam && systemctl daemon-reload")
+}
+
 export const unmountTeslaCam = async () => {
     logWithTimestamp("Unmounting TeslaCam")
     await executeBashCommand("sudo umount /mnt/TeslaCam && systemctl daemon-reload")
 }
 
+export const unmountUsbDriveFromHost = async () => {
+    logWithTimestamp("Unmounting USB drive from host")
+    await executeBashCommand("sudo rmmod g_mass_storage")
+}
+
+export const mountUsbDriveToHost = async () => {
+    logWithTimestamp("Mounting USB drive to host")
+    await executeBashCommand("sudo modprobe g_mass_storage file=/vusb/TeslaCam")
+}
+
 // Not in use - leaving for now as it may be useful later
 // async function listFolderContents(folderPath, recursive = false) {
 //     let entries = [];