✨ Add ad guard home (#937)

* ✨ Add add guard home

* ✨ Add request for blocked domains and fix request for blocked queries

* ♻️ PR feedback

* ✅ Fix tests

src/tools/server/sdk/adGuard/adGuard.schema.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+
+export const adGuardApiStatsResponseSchema = z.object({
+  time_units: z.enum(['hours']),
+  top_queried_domains: z.array(z.record(z.string(), z.number())),
+  top_clients: z.array(z.record(z.string(), z.number())),
+  top_blocked_domains: z.array(z.record(z.string(), z.number())),
+  dns_queries: z.array(z.number()),
+  blocked_filtering: z.array(z.number()),
+  replaced_safebrowsing: z.array(z.number()),
+  replaced_parental: z.array(z.number()),
+  num_dns_queries: z.number().min(0),
+  num_blocked_filtering: z.number().min(0),
+  num_replaced_safebrowsing: z.number().min(0),
+  num_replaced_safesearch: z.number().min(0),
+  num_replaced_parental: z.number().min(0),
+  avg_processing_time: z.number().min(0).max(1),
+});
+
+export const adGuardApiStatusResponseSchema = z.object({
+  version: z.string(),
+  language: z.string(),
+  dns_addresses: z.array(z.string()),
+  dns_port: z.number().positive(),
+  http_port: z.number().positive(),
+  protection_disabled_duration: z.number(),
+  protection_enabled: z.boolean(),
+  dhcp_available: z.boolean(),
+  running: z.boolean(),
+});
+
+export const adGuardApiFilteringStatusSchema = z.object({
+  filters: z.array(z.object({
+    url: z.string().url(),
+    name: z.string(),
+    last_updated: z.string().optional(),
+    id: z.number().nonnegative(),
+    rules_count: z.number().nonnegative(),
+    enabled: z.boolean(),
+  })),
+});

src/tools/server/sdk/adGuard/adGuard.ts

@@ -0,0 +1,95 @@
+import { trimStringEnding } from '../../../shared/strings';
+import {
+  adGuardApiFilteringStatusSchema,
+  adGuardApiStatsResponseSchema,
+  adGuardApiStatusResponseSchema,
+} from './adGuard.schema';
+
+export class AdGuard {
+  private readonly baseHostName: string;
+
+  constructor(
+    hostname: string,
+    private readonly username: string,
+    private readonly password: string
+  ) {
+    this.baseHostName = trimStringEnding(hostname, ['/#', '/']);
+  }
+
+  async getStats(): Promise<AdGuardStatsType> {
+    const response = await fetch(`${this.baseHostName}/control/stats`, {
+      headers: {
+        Authorization: `Basic ${this.getAuthorizationHeaderValue()}`,
+      },
+    });
+
+    const data = await response.json();
+
+    return adGuardApiStatsResponseSchema.parseAsync(data);
+  }
+
+  async getStatus() {
+    const response = await fetch(`${this.baseHostName}/control/status`, {
+      headers: {
+        Authorization: `Basic ${this.getAuthorizationHeaderValue()}`,
+      },
+    });
+
+    const data = await response.json();
+
+    return adGuardApiStatusResponseSchema.parseAsync(data);
+  }
+
+  async getCountFilteringDomains() {
+    const response = await fetch(`${this.baseHostName}/control/filtering/status`, {
+      headers: {
+        Authorization: `Basic ${this.getAuthorizationHeaderValue()}`,
+      },
+    });
+
+    const data = await response.json();
+    const schemaData = await adGuardApiFilteringStatusSchema.parseAsync(data);
+
+    return schemaData.filters
+      .filter((filter) => filter.enabled)
+      .reduce((sum, filter) => filter.rules_count + sum, 0);
+  }
+
+  async disable() {
+    await this.changeProtectionStatus(false);
+  }
+  async enable() {
+    await this.changeProtectionStatus(false);
+  }
+
+  private async changeProtectionStatus(newStatus: boolean, duration = 0) {
+    await fetch(`${this.baseHostName}/control/protection`, {
+      method: 'POST',
+      body: JSON.stringify({
+        enabled: newStatus,
+        duration,
+      }),
+    });
+  }
+
+  private getAuthorizationHeaderValue() {
+    return Buffer.from(`${this.username}:${this.password}`).toString('base64');
+  }
+}
+
+export type AdGuardStatsType = {
+  time_units: string;
+  top_queried_domains: { [key: string]: number }[];
+  top_clients: { [key: string]: number }[];
+  top_blocked_domains: { [key: string]: number }[];
+  dns_queries: number[];
+  blocked_filtering: number[];
+  replaced_safebrowsing: number[];
+  replaced_parental: number[];
+  num_dns_queries: number;
+  num_blocked_filtering: number;
+  num_replaced_safebrowsing: number;
+  num_replaced_safesearch: number;
+  num_replaced_parental: number;
+  avg_processing_time: number;
+};

src/tools/server/sdk/pihole/piHole.ts

@@ -1,10 +1,11 @@
+import { trimStringEnding } from '../../../shared/strings';
 import { PiHoleApiStatusChangeResponse, PiHoleApiSummaryResponse } from './piHole.type';
 
 export class PiHoleClient {
   private readonly baseHostName: string;
 
   constructor(hostname: string, private readonly apiToken: string) {
-    this.baseHostName = this.trimStringEnding(hostname, ['/admin/index.php', '/admin', '/']);
+    this.baseHostName = trimStringEnding(hostname, ['/admin/index.php', '/admin', '/']);
   }
 
   async getSummary() {
@@ -60,15 +61,4 @@ export class PiHoleClient {
 
     return json as PiHoleApiStatusChangeResponse;
   }
-
-  private trimStringEnding(original: string, toTrimIfExists: string[]) {
-    for (let i = 0; i < toTrimIfExists.length; i += 1) {
-      if (!original.endsWith(toTrimIfExists[i])) {
-        continue;
-      }
-      return original.substring(0, original.indexOf(toTrimIfExists[i]));
-    }
-
-    return original;
-  }
 }

src/tools/shared/strings.ts

@@ -0,0 +1,10 @@
+export const trimStringEnding = (original: string, toTrimIfExists: string[]) => {
+  for (let i = 0; i < toTrimIfExists.length; i += 1) {
+    if (!original.endsWith(toTrimIfExists[i])) {
+      continue;
+    }
+    return original.substring(0, original.indexOf(toTrimIfExists[i]));
+  }
+
+  return original;
+};