✨ Add ad guard home

src/components/Dashboard/Modals/EditAppModal/Tabs/IntegrationTab/Components/InputElements/IntegrationSelector.tsx

@@ -1,5 +1,5 @@
 /* eslint-disable @next/next/no-img-element */
-import { Group, Select, SelectItem, Text } from '@mantine/core';
+import { Group, Image, Select, SelectItem, Text } from '@mantine/core';
 import { UseFormReturnType } from '@mantine/form';
 import { useTranslation } from 'next-i18next';
 import { forwardRef } from 'react';
@@ -87,9 +87,14 @@ export const IntegrationSelector = ({ form }: IntegrationSelectorProps) => {
     },
     {
       value: 'pihole',
-      image: 'https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons@master/png/pihole.png',
+      image: 'https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons@master/png/pi-hole.png',
       label: 'PiHole',
     },
+    {
+      value: 'adGuardHome',
+      image: 'https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons/png/adguard-home.png',
+      label: 'AdGuard Home',
+    },
   ].filter((x) => Object.keys(integrationFieldProperties).includes(x.value));
 
   const getNewProperties = (value: string | null): AppIntegrationPropertyType[] => {
@@ -133,11 +138,12 @@ export const IntegrationSelector = ({ form }: IntegrationSelectorProps) => {
       }
       icon={
         form.values.integration?.type && (
-          <img
+          <Image
             src={data.find((x) => x.value === form.values.integration?.type)?.image}
             alt="integration"
             width={20}
             height={20}
+            fit="contain"
           />
         )
       }
@@ -160,7 +166,7 @@ const SelectItemComponent = forwardRef<HTMLDivElement, ItemProps>(
   ({ image, label, description, ...others }: ItemProps, ref) => (
     <div ref={ref} {...others}>
       <Group noWrap>
-        <img src={image} alt="integration icon" width={20} height={20} />
+        <Image src={image} alt="integration icon" width={20} height={20} fit="contain" />
 
         <div>
           <Text size="sm">{label}</Text>

src/pages/api/modules/dns-hole/control.ts

@@ -5,6 +5,8 @@ import { NextApiRequest, NextApiResponse } from 'next';
 import { getConfig } from '../../../../tools/config/getConfig';
 import { findAppProperty } from '../../../../tools/client/app-properties';
 import { PiHoleClient } from '../../../../tools/server/sdk/pihole/piHole';
+import { ConfigAppType } from '../../../../types/app';
+import { AdGuard } from '../../../../tools/server/sdk/adGuard/adGuard';
 
 const getQuerySchema = z.object({
   status: z.enum(['enabled', 'disabled']),
@@ -21,29 +23,50 @@ export const Post = async (request: NextApiRequest, response: NextApiResponse) =
     return;
   }
 
-  const applicableApps = config.apps.filter((x) => x.integration?.type === 'pihole');
+  const applicableApps = config.apps.filter(
+    (x) => x.integration?.type && ['pihole', 'adGuardHome'].includes(x.integration?.type)
+  );
 
   for (let i = 0; i < applicableApps.length; i += 1) {
     const app = applicableApps[i];
 
-    const pihole = new PiHoleClient(
-      app.url,
-      findAppProperty(app, 'password')
-    );
-
-    switch (parseResult.data.status) {
-      case 'enabled':
-        await pihole.enable();
-        break;
-      case 'disabled':
-        await pihole.disable();
-        break;
+    if (app.integration?.type === 'pihole') {
+      await processPiHole(app, parseResult.data.status === 'disabled');
+      return;
     }
+
+    await processAdGuard(app, parseResult.data.status === 'disabled');
   }
 
   response.status(200).json({});
 };
 
+const processAdGuard = async (app: ConfigAppType, enable: boolean) => {
+  const adGuard = new AdGuard(
+    app.url,
+    findAppProperty(app, 'username'),
+    findAppProperty(app, 'password')
+  );
+
+  if (enable) {
+    await adGuard.disable();
+    return;
+  }
+
+  await adGuard.enable();
+};
+
+const processPiHole = async (app: ConfigAppType, enable: boolean) => {
+  const pihole = new PiHoleClient(app.url, findAppProperty(app, 'password'));
+
+  if (enable) {
+    await pihole.enable();
+    return;
+  }
+
+  await pihole.disable();
+};
+
 export default async (request: NextApiRequest, response: NextApiResponse) => {
   if (request.method === 'POST') {
     return Post(request, response);

src/pages/api/modules/dns-hole/summary.ts

@@ -1,16 +1,20 @@
+/* eslint-disable no-await-in-loop */
 import Consola from 'consola';
 import { getCookie } from 'cookies-next';
 import { NextApiRequest, NextApiResponse } from 'next';
 import { findAppProperty } from '../../../../tools/client/app-properties';
 import { getConfig } from '../../../../tools/config/getConfig';
 import { PiHoleClient } from '../../../../tools/server/sdk/pihole/piHole';
 import { AdStatistics } from '../../../../widgets/dnshole/type';
+import { AdGuard } from '../../../../tools/server/sdk/adGuard/adGuard';
 
 export const Get = async (request: NextApiRequest, response: NextApiResponse) => {
   const configName = getCookie('config-name', { req: request });
   const config = getConfig(configName?.toString() ?? 'default');
 
-  const applicableApps = config.apps.filter((x) => x.integration?.type === 'pihole');
+  const applicableApps = config.apps.filter(
+    (x) => x.integration?.type && ['pihole', 'adGuardHome'].includes(x.integration?.type)
+  );
 
   const data: AdStatistics = {
     domainsBeingBlocked: 0,
@@ -26,21 +30,46 @@ export const Get = async (request: NextApiRequest, response: NextApiResponse) =>
     const app = applicableApps[i];
 
     try {
-      const piHole = new PiHoleClient(app.url, findAppProperty(app, 'password'));
-
-      // eslint-disable-next-line no-await-in-loop
-      const summary = await piHole.getSummary();
-
-      data.domainsBeingBlocked += summary.domains_being_blocked;
-      data.adsBlockedToday += summary.ads_blocked_today;
-      data.dnsQueriesToday += summary.dns_queries_today;
-      data.status.push({
-        status: summary.status,
-        appId: app.id,
-      });
-      adsBlockedTodayPercentageArr.push(summary.ads_percentage_today);
+      switch (app.integration?.type) {
+        case 'pihole': {
+          const piHole = new PiHoleClient(app.url, findAppProperty(app, 'password'));
+          const summary = await piHole.getSummary();
+
+          data.domainsBeingBlocked += summary.domains_being_blocked;
+          data.adsBlockedToday += summary.ads_blocked_today;
+          data.dnsQueriesToday += summary.dns_queries_today;
+          data.status.push({
+            status: summary.status,
+            appId: app.id,
+          });
+          adsBlockedTodayPercentageArr.push(summary.ads_percentage_today);
+          break;
+        }
+        case 'adGuardHome': {
+          const adGuard = new AdGuard(
+            app.url,
+            findAppProperty(app, 'username'),
+            findAppProperty(app, 'password')
+          );
+
+          const stats = await adGuard.getStats();
+          const status = await adGuard.getStatus();
+          const countFilteredDomains = await adGuard.getCountFilteringDomains();
+
+          const blockedQueriesToday = stats.blocked_filtering.reduce((prev, sum) => prev + sum, 0);
+          const queriesToday = stats.dns_queries.reduce((prev, sum) => prev + sum, 0);
+          data.adsBlockedToday = blockedQueriesToday;
+          data.domainsBeingBlocked += countFilteredDomains;
+          data.dnsQueriesToday += queriesToday;
+          data.status.push({
+            status: status.protection_enabled ? 'enabled' : 'disabled',
+            appId: app.id,
+          });
+          adsBlockedTodayPercentageArr.push((queriesToday / blockedQueriesToday) * 100);
+        }
+      }
     } catch (err) {
-      Consola.error(`Failed to communicate with PiHole at ${app.url}: ${err}`);
+      Consola.error(`Failed to communicate with DNS hole at ${app.url}: ${err}`);
     }
   }
 

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,79 @@
+import { trimStringEnding } from '../../../shared/strings';
+import {
+  adGuardApiFilteringStatusSchema,
+  adGuardApiStatsResponseSchema,
+  adGuardApiStatusResponseSchema,
+} from './adGuard.schema';
+import { AdGuardStatsType } from './adGuard.type';
+
+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');
+  }
+}

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

@@ -0,0 +1,16 @@
+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;
+};

src/types/app.ts

@@ -45,7 +45,8 @@ export type IntegrationType =
   | 'plex'
   | 'jellyfin'
   | 'nzbGet'
-  | 'pihole';
+  | 'pihole'
+  | 'adGuardHome';
 
 export type AppIntegrationType = {
   type: IntegrationType | null;
@@ -86,6 +87,7 @@ export const integrationFieldProperties: {
   jellyfin: ['username', 'password'],
   plex: ['apiKey'],
   pihole: ['password'],
+  adGuardHome: ['username', 'password'],
 };
 
 export type IntegrationFieldDefinitionType = {