feat: add tasks page (#692)

packages/cron-jobs/src/index.ts

@@ -0,0 +1,14 @@
+import { analyticsJob } from "./jobs/analytics";
+import { iconsUpdaterJob } from "./jobs/icons-updater";
+import { smartHomeEntityStateJob } from "./jobs/integrations/home-assistant";
+import { pingJob } from "./jobs/ping";
+import { createCronJobGroup } from "./lib";
+
+export const jobGroup = createCronJobGroup({
+  analytics: analyticsJob,
+  iconsUpdater: iconsUpdaterJob,
+  ping: pingJob,
+  smartHomeEntityState: smartHomeEntityStateJob,
+});
+
+export type JobGroupKeys = ReturnType<(typeof jobGroup)["getKeys"]>[number];

packages/cron-jobs/src/jobs/analytics.ts

@@ -0,0 +1,29 @@
+import SuperJSON from "superjson";
+
+import { sendServerAnalyticsAsync } from "@homarr/analytics";
+import { EVERY_WEEK } from "@homarr/cron-jobs-core/expressions";
+import { db, eq } from "@homarr/db";
+import { serverSettings } from "@homarr/db/schema/sqlite";
+import type { defaultServerSettings } from "@homarr/server-settings";
+
+import { createCronJob } from "../lib";
+
+export const analyticsJob = createCronJob("analytics", EVERY_WEEK, {
+  runOnStart: true,
+}).withCallback(async () => {
+  const analyticSetting = await db.query.serverSettings.findFirst({
+    where: eq(serverSettings.settingKey, "analytics"),
+  });
+
+  if (!analyticSetting) {
+    return;
+  }
+
+  const value = SuperJSON.parse<(typeof defaultServerSettings)["analytics"]>(analyticSetting.value);
+
+  if (!value.enableGeneral) {
+    return;
+  }
+
+  await sendServerAnalyticsAsync();
+});

packages/cron-jobs/src/jobs/icons-updater.ts

@@ -0,0 +1,97 @@
+import { Stopwatch } from "@homarr/common";
+import { EVERY_WEEK } from "@homarr/cron-jobs-core/expressions";
+import type { InferInsertModel } from "@homarr/db";
+import { db, inArray } from "@homarr/db";
+import { createId } from "@homarr/db/client";
+import { iconRepositories, icons } from "@homarr/db/schema/sqlite";
+import { fetchIconsAsync } from "@homarr/icons";
+import { logger } from "@homarr/log";
+
+import { createCronJob } from "../lib";
+
+export const iconsUpdaterJob = createCronJob("iconsUpdater", EVERY_WEEK, {
+  runOnStart: true,
+}).withCallback(async () => {
+  logger.info("Updating icon repository cache...");
+  const stopWatch = new Stopwatch();
+  const repositoryIconGroups = await fetchIconsAsync();
+  const countIcons = repositoryIconGroups
+    .map((group) => group.icons.length)
+    .reduce((partialSum, arrayLength) => partialSum + arrayLength, 0);
+  logger.info(
+    `Successfully fetched ${countIcons} icons from ${repositoryIconGroups.length} repositories within ${stopWatch.getElapsedInHumanWords()}`,
+  );
+
+  const databaseIconGroups = await db.query.iconRepositories.findMany({
+    with: {
+      icons: true,
+    },
+  });
+
+  const skippedChecksums: string[] = [];
+  let countDeleted = 0;
+  let countInserted = 0;
+
+  logger.info("Updating icons in database...");
+  stopWatch.reset();
+
+  const newIconRepositories: InferInsertModel<typeof iconRepositories>[] = [];
+  const newIcons: InferInsertModel<typeof icons>[] = [];
+
+  for (const repositoryIconGroup of repositoryIconGroups) {
+    if (!repositoryIconGroup.success) {
+      continue;
+    }
+
+    const repositoryInDb = databaseIconGroups.find((dbIconGroup) => dbIconGroup.slug === repositoryIconGroup.slug);
+    const repositoryIconGroupId: string = repositoryInDb?.id ?? createId();
+    if (!repositoryInDb?.id) {
+      newIconRepositories.push({
+        id: repositoryIconGroupId,
+        slug: repositoryIconGroup.slug,
+      });
+    }
+
+    for (const icon of repositoryIconGroup.icons) {
+      if (databaseIconGroups.flatMap((group) => group.icons).some((dbIcon) => dbIcon.checksum === icon.checksum)) {
+        skippedChecksums.push(icon.checksum);
+        continue;
+      }
+
+      newIcons.push({
+        id: createId(),
+        checksum: icon.checksum,
+        name: icon.fileNameWithExtension,
+        url: icon.imageUrl.href,
+        iconRepositoryId: repositoryIconGroupId,
+      });
+      countInserted++;
+    }
+  }
+
+  const deadIcons = databaseIconGroups
+    .flatMap((group) => group.icons)
+    .filter((icon) => !skippedChecksums.includes(icon.checksum));
+
+  await db.transaction(async (transaction) => {
+    if (newIconRepositories.length >= 1) {
+      await transaction.insert(iconRepositories).values(newIconRepositories);
+    }
+
+    if (newIcons.length >= 1) {
+      await transaction.insert(icons).values(newIcons);
+    }
+    if (deadIcons.length >= 1) {
+      await transaction.delete(icons).where(
+        inArray(
+          icons.checksum,
+          deadIcons.map((icon) => icon.checksum),
+        ),
+      );
+    }
+
+    countDeleted += deadIcons.length;
+  });
+
+  logger.info(`Updated database within ${stopWatch.getElapsedInHumanWords()} (-${countDeleted}, +${countInserted})`);
+});

packages/cron-jobs/src/jobs/integrations/home-assistant.ts

@@ -0,0 +1,65 @@
+import SuperJSON from "superjson";
+
+import { decryptSecret } from "@homarr/common";
+import { EVERY_MINUTE } from "@homarr/cron-jobs-core/expressions";
+import { db, eq } from "@homarr/db";
+import { items } from "@homarr/db/schema/sqlite";
+import { HomeAssistantIntegration } from "@homarr/integrations";
+import { logger } from "@homarr/log";
+import { homeAssistantEntityState } from "@homarr/redis";
+
+// This import is done that way to avoid circular dependencies.
+import type { WidgetComponentProps } from "../../../../widgets";
+import { createCronJob } from "../../lib";
+
+export const smartHomeEntityStateJob = createCronJob("smartHomeEntityState", EVERY_MINUTE).withCallback(async () => {
+  const itemsForIntegration = await db.query.items.findMany({
+    where: eq(items.kind, "smartHome-entityState"),
+    with: {
+      integrations: {
+        with: {
+          integration: {
+            with: {
+              secrets: {
+                columns: {
+                  kind: true,
+                  value: true,
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  });
+
+  for (const itemForIntegration of itemsForIntegration) {
+    const integration = itemForIntegration.integrations[0]?.integration;
+    if (!integration) {
+      continue;
+    }
+
+    const options = SuperJSON.parse<WidgetComponentProps<"smartHome-entityState">["options"]>(
+      itemForIntegration.options,
+    );
+
+    const homeAssistant = new HomeAssistantIntegration({
+      ...integration,
+      decryptedSecrets: integration.secrets.map((secret) => ({
+        ...secret,
+        value: decryptSecret(secret.value),
+      })),
+    });
+    const state = await homeAssistant.getEntityStateAsync(options.entityId);
+
+    if (!state.success) {
+      logger.error("Unable to fetch data from Home Assistant");
+      continue;
+    }
+
+    await homeAssistantEntityState.publishAsync({
+      entityId: options.entityId,
+      state: state.data.state,
+    });
+  }
+});

packages/cron-jobs/src/jobs/ping.ts

@@ -0,0 +1,25 @@
+import { EVERY_MINUTE } from "@homarr/cron-jobs-core/expressions";
+import { logger } from "@homarr/log";
+import { sendPingRequestAsync } from "@homarr/ping";
+import { pingChannel, pingUrlChannel } from "@homarr/redis";
+
+import { createCronJob } from "../lib";
+
+export const pingJob = createCronJob("ping", EVERY_MINUTE).withCallback(async () => {
+  const urls = await pingUrlChannel.getAllAsync();
+
+  for (const url of new Set(urls)) {
+    const pingResult = await sendPingRequestAsync(url);
+
+    if ("statusCode" in pingResult) {
+      logger.debug(`executed ping for url ${url} with status code ${pingResult.statusCode}`);
+    } else {
+      logger.error(`Executing ping for url ${url} failed with error: ${pingResult.error}`);
+    }
+
+    await pingChannel.publishAsync({
+      url,
+      ...pingResult,
+    });
+  }
+});

packages/cron-jobs/src/lib/index.ts

@@ -0,0 +1,28 @@
+import { beforeCallbackAsync, onCallbackErrorAsync, onCallbackSuccessAsync } from "@homarr/cron-job-status/publisher";
+import { createCronJobFunctions } from "@homarr/cron-jobs-core";
+import type { Logger } from "@homarr/cron-jobs-core/logger";
+import { logger } from "@homarr/log";
+import type { TranslationObject } from "@homarr/translation";
+
+class WinstonCronJobLogger implements Logger {
+  logDebug(message: string) {
+    logger.debug(message);
+  }
+
+  logInfo(message: string) {
+    logger.info(message);
+  }
+
+  logError(error: unknown) {
+    logger.error(error);
+  }
+}
+
+export const { createCronJob, createCronJobGroup } = createCronJobFunctions<
+  keyof TranslationObject["management"]["page"]["tool"]["tasks"]["job"]
+>({
+  logger: new WinstonCronJobLogger(),
+  beforeCallback: beforeCallbackAsync,
+  onCallbackSuccess: onCallbackSuccessAsync,
+  onCallbackError: onCallbackErrorAsync,
+});