From b1bff1f8e5af3cfd4243c2f42bfb7da415dec4b4 Mon Sep 17 00:00:00 2001
From: Christopher Bisset <chris@gurucomputing.com.au>
Date: Sun, 11 Sep 2022 16:13:22 +1000
Subject: [PATCH] extracted sort functions from get functions

---
 src/lib/common/apiFunctions.svelte | 66 +++-----------------------
 src/lib/common/sorting.svelte      | 75 ++++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+), 59 deletions(-)
 create mode 100644 src/lib/common/sorting.svelte

diff --git a/src/lib/common/apiFunctions.svelte b/src/lib/common/apiFunctions.svelte
index 371544c..aefe786 100644
--- a/src/lib/common/apiFunctions.svelte
+++ b/src/lib/common/apiFunctions.svelte
@@ -1,14 +1,13 @@
 <script context="module" lang="ts">
 	import { APIKey, Device, PreAuthKey, Route, User } from '$lib/common/classes';
 	import { deviceStore, userStore, apiTestStore } from '$lib/common/stores.js';
+	import { sortDevices, sortUsers } from '$lib/common/sorting.svelte';
 	import { filterDevices, filterUsers } from './searching.svelte';
 
-	export async function getUsers(): Promise<any> {
+	export async function getUsers() {
 		// variables in local storage
 		let headscaleURL = localStorage.getItem('headscaleURL') || '';
 		let headscaleAPIKey = localStorage.getItem('headscaleAPIKey') || '';
-		let sortKey = localStorage.getItem('headscaleUserSort') || '';
-		let sortDirection = localStorage.getItem('headscaleUserSortDirection') || '';
 
 		// endpoint url for getting users
 		let endpointURL = '/api/v1/namespace';
@@ -41,33 +40,9 @@
 			});
 
 		await headscaleUsersResponse.json().then((data) => {
-			let collator = new Intl.Collator([], { numeric: true });
-			if (sortDirection == 'ascending') {
-				switch (sortKey) {
-					case 'id':
-						headscaleUsers = data.namespaces.sort((a: User, b: User) => collator.compare(a.id, b.id));
-						break;
-					case 'createdAt':
-						headscaleUsers = data.namespaces.sort((a: User, b: User) => -collator.compare(a.createdAt, b.createdAt));
-						break;
-					case 'name':
-						headscaleUsers = data.namespaces.sort((a: User, b: User) => collator.compare(a.name, b.name));
-						break;
-				}
-			}
-			if (sortDirection == 'descending') {
-				switch (sortKey) {
-					case 'id':
-						headscaleUsers = data.namespaces.sort((a: User, b: User) => -collator.compare(a.id, b.id));
-						break;
-					case 'createdAt':
-						headscaleUsers = data.namespaces.sort((a: User, b: User) => collator.compare(a.createdAt, b.createdAt));
-						break;
-					case 'name':
-						headscaleUsers = data.namespaces.sort((a: User, b: User) => -collator.compare(a.name, b.name));
-						break;
-				}
-			}
+			headscaleUsers = data.namespaces
+			// sort the users
+			headscaleUsers = sortUsers(headscaleUsers);
 		});
 		// Set the store
 		apiTestStore.set('succeeded');
@@ -273,8 +248,6 @@
 		// variables in local storage
 		let headscaleURL = localStorage.getItem('headscaleURL') || '';
 		let headscaleAPIKey = localStorage.getItem('headscaleAPIKey') || '';
-		let sortKey = localStorage.getItem('headscaleDeviceSort') || '';
-		let sortDirection = localStorage.getItem('headscaleDeviceSortDirection') || '';
 
 		// endpoint url for getting users
 		let endpointURL = '/api/v1/machine';
@@ -308,33 +281,8 @@
 			});
 
 		await headscaleDeviceResponse.json().then((data) => {
-			let collator = new Intl.Collator([], { numeric: true });
-			if (sortDirection == 'ascending') {
-				switch (sortKey) {
-					case 'id':
-						headscaleDevices = data.machines.sort((a: Device, b: Device) => collator.compare(a.id, b.id));
-						break;
-					case 'lastSeen':
-						headscaleDevices = data.machines.sort((a: Device, b: Device) => -collator.compare(a.lastSeen, b.lastSeen));
-						break;
-					case 'givenName':
-						headscaleDevices = data.machines.sort((a: Device, b: Device) => collator.compare(a.givenName, b.givenName));
-						break;
-				}
-			}
-			if (sortDirection == 'descending') {
-				switch (sortKey) {
-					case 'id':
-						headscaleDevices = data.machines.sort((a: Device, b: Device) => -collator.compare(a.id, b.id));
-						break;
-					case 'lastSeen':
-						headscaleDevices = data.machines.sort((a: Device, b: Device) => collator.compare(a.lastSeen, b.lastSeen));
-						break;
-					case 'givenName':
-						headscaleDevices = data.machines.sort((a: Device, b: Device) => -collator.compare(a.givenName, b.givenName));
-						break;
-				}
-			}
+			headscaleDevices = data.machines
+			headscaleDevices = sortDevices(headscaleDevices)
 		});
 		// set the stores
 		apiTestStore.set('succeeded');
diff --git a/src/lib/common/sorting.svelte b/src/lib/common/sorting.svelte
new file mode 100644
index 0000000..e1f47c7
--- /dev/null
+++ b/src/lib/common/sorting.svelte
@@ -0,0 +1,75 @@
+<script context="module" lang="ts">
+	import type { Device, User } from './classes';
+
+	export function sortUsers(users: User[]): User[] {
+		let sortKey = localStorage.getItem('headscaleUserSort') || '';
+		let sortDirection = localStorage.getItem('headscaleUserSortDirection') || '';
+		let sortedUsers = users;
+
+		let collator = new Intl.Collator([], { numeric: true });
+		if (sortDirection == 'ascending') {
+			switch (sortKey) {
+				case 'id':
+					sortedUsers = users.sort((a: User, b: User) => collator.compare(a.id, b.id));
+					break;
+				case 'createdAt':
+					sortedUsers = users.sort((a: User, b: User) => -collator.compare(a.createdAt, b.createdAt));
+					break;
+				case 'name':
+					sortedUsers = users.sort((a: User, b: User) => collator.compare(a.name, b.name));
+					break;
+			}
+		}
+		if (sortDirection == 'descending') {
+			switch (sortKey) {
+				case 'id':
+					sortedUsers = users.sort((a: User, b: User) => -collator.compare(a.id, b.id));
+					break;
+				case 'createdAt':
+					sortedUsers = users.sort((a: User, b: User) => collator.compare(a.createdAt, b.createdAt));
+					break;
+				case 'name':
+					sortedUsers = users.sort((a: User, b: User) => -collator.compare(a.name, b.name));
+					break;
+			}
+		}
+
+		return sortedUsers;
+	}
+
+	export function sortDevices(devices: Device[]): Device[] {
+		let sortKey = localStorage.getItem('headscaleDeviceSort') || '';
+		let sortDirection = localStorage.getItem('headscaleDeviceSortDirection') || '';
+		let sortedDevices = devices;
+
+		let collator = new Intl.Collator([], { numeric: true });
+		if (sortDirection == 'ascending') {
+			switch (sortKey) {
+				case 'id':
+					sortedDevices = devices.sort((a: Device, b: Device) => collator.compare(a.id, b.id));
+					break;
+				case 'lastSeen':
+					sortedDevices = devices.sort((a: Device, b: Device) => -collator.compare(a.lastSeen, b.lastSeen));
+					break;
+				case 'givenName':
+					sortedDevices = devices.sort((a: Device, b: Device) => collator.compare(a.givenName, b.givenName));
+					break;
+			}
+		}
+		if (sortDirection == 'descending') {
+			switch (sortKey) {
+				case 'id':
+					sortedDevices = devices.sort((a: Device, b: Device) => -collator.compare(a.id, b.id));
+					break;
+				case 'lastSeen':
+					sortedDevices = devices.sort((a: Device, b: Device) => collator.compare(a.lastSeen, b.lastSeen));
+					break;
+				case 'givenName':
+					sortedDevices = devices.sort((a: Device, b: Device) => -collator.compare(a.givenName, b.givenName));
+					break;
+			}
+		}
+
+		return sortedDevices;
+	}
+</script>