Track HiveGrid Cloud planning reference

hivegrid-cloud/apps/web/app/modules/knowledgeBase/utils/KnowledgeBaseUtils.ts

@@ -0,0 +1,162 @@
+import type { TFunction } from "i18next";
+import UrlUtils from "~/utils/app/UrlUtils";
+import { KnowledgeBaseArticleWithDetails } from "../db/kbArticles.db.server";
+import { KbCategorySectionDto } from "../dtos/KbCategorySectionDto";
+import { KnowledgeBaseDto } from "../dtos/KnowledgeBaseDto";
+import { KbCategoryDto } from "../dtos/KbCategoryDto";
+import { KbArticleDto } from "../dtos/KbArticleDto";
+
+const defaultLanguage = "de";
+const supportedLanguages: { name: string; value: string; labelKey: string }[] = [
+  { name: "Deutsch", value: "de", labelKey: "shared.locales.de" },
+  { name: "English", value: "en", labelKey: "shared.locales.en" },
+];
+
+function getLanguageName(language: string, t?: TFunction) {
+  const supportedLanguage = supportedLanguages.find((l) => l.value === language);
+  if (!supportedLanguage) {
+    return "";
+  }
+  return t ? String(t(supportedLanguage.labelKey, { defaultValue: supportedLanguage.name })) : supportedLanguage.name;
+}
+
+function getSupportedLanguageOptions(t: TFunction): { name: string; value: string }[] {
+  return supportedLanguages.map((language) => ({
+    name: getLanguageName(language.value, t),
+    value: language.value,
+  }));
+}
+
+function getAvailableArticleSlug({ allArticles, initialSlug }: { allArticles: KnowledgeBaseArticleWithDetails[]; initialSlug: string }) {
+  let number = 1;
+  let slug = "";
+
+  const findExistingSlug = (slug: string) => {
+    return allArticles.find((p) => p.slug === slug);
+  };
+
+  do {
+    slug = `${initialSlug}-${number}`;
+    const existingWithSlug = findExistingSlug(slug);
+    if (!existingWithSlug) {
+      break;
+    }
+    // if (number > 10) {
+    //   throw Error("Too many duplicates");
+    // }
+    number++;
+  } while (true);
+
+  let maxOrder = 0;
+  let firstOrder = 0;
+  if (allArticles.length > 0) {
+    maxOrder = Math.max(...allArticles.map((p) => p.order));
+    firstOrder = Math.min(...allArticles.map((p) => p.order));
+  }
+  return {
+    slug,
+    maxOrder,
+    firstOrder,
+    number,
+  };
+}
+
+function getKbUrl({ kb, params }: { kb: { basePath: string; slug: string }; params: { lang?: string } }) {
+  let url = UrlUtils.join(kb.basePath, kb.slug);
+  const foundLang = supportedLanguages.find((l) => l.value === params.lang);
+  if (params.lang && foundLang) {
+    return `${url}/${params.lang}`;
+  }
+  return `${url}`;
+}
+
+function getArticleUrl({ kb, article, params }: { kb: { slug: string; basePath: string }; article: { slug: string }; params: { lang?: string } }) {
+  let kbUrl = getKbUrl({ kb, params });
+  return `${kbUrl}/articles/${article.slug}`;
+}
+
+function getCategoryUrl({ kb, category, params }: { kb: { slug: string; basePath: string }; category: { slug: string }; params: { lang?: string } }) {
+  let kbUrl = getKbUrl({ kb, params });
+  return `${kbUrl}/categories/${category.slug}`;
+}
+
+function getCategoryArticlesBySections({ kb, category }: { kb: KnowledgeBaseDto; category: KbCategoryDto }) {
+  let sections: {
+    section: KbCategorySectionDto | null;
+    articles: {
+      order: number;
+      title: string;
+      description: string;
+      href: string;
+      section: string | null;
+      sectionId: string | null;
+    }[];
+  }[] = [];
+  category.articles.forEach((article) => {
+    const section = category.sections.find((item) => item.id === article.sectionId) ?? null;
+    const sectionIndex = sections.findIndex((item) => item.section?.id === section?.id);
+    if (sectionIndex === -1) {
+      sections.push({
+        section,
+        articles: [
+          {
+            ...article,
+            section: section?.title ?? null,
+          },
+        ],
+      });
+    } else {
+      sections[sectionIndex].articles.push({
+        ...article,
+        section: section?.title ?? null,
+      });
+    }
+  });
+  sections.forEach((item) => {
+    item.articles = item.articles.sort((a, b) => {
+      if (a.order && b.order) {
+        return a.order - b.order;
+      }
+      return 0;
+    });
+  });
+  sections = sections.sort((a, b) => {
+    if (a.section?.order && b.section?.order) {
+      return a.section.order - b.section.order;
+    }
+    return -1;
+  });
+  return sections;
+}
+
+function fixDarkMode({ article }: { article: KbArticleDto }) {
+  const replaces = {
+    "rounded-sm bg-stone-100 p-5 font-mono font-medium text-stone-800": "rounded-sm bg-secondary text-secondary-foreground p-5 font-mono font-medium",
+    "rounded-sm bg-secondary p-5 font-mono font-medium": "rounded-sm bg-secondary text-secondary-foreground p-5 font-mono font-medium",
+    "rounded-md bg-secondary px-1.5 py-1 font-mono font-medium": "rounded-md bg-secondary text-secondary-foreground px-1.5 py-1 font-mono font-medium",
+    "rounded-md bg-stone-200 px-1.5 py-1 font-mono font-medium text-black":
+      "rounded-md bg-secondary px-1.5 py-1 font-mono font-medium text-secondary-foreground",
+    "text-stone-600 underline underline-offset-[3px] hover:text-stone-700 transition-colors cursor-pointer text-stone-600 underline underline-offset-[3px] hover:text-stone-700 transition-colors cursor-pointer":
+      "text-muted-foreground underline underline-offset-[3px] hover:text-foreground transition-colors cursor-pointer",
+    "underline underline-offset-[3px] hover:text-foreground transition-colors cursor-pointer":
+      "text-muted-foreground underline underline-offset-[3px] hover:text-foreground transition-colors cursor-pointer",
+  };
+  if (article.contentPublished) {
+    for (const [key, value] of Object.entries(replaces)) {
+      article.contentPublished = article.contentPublished.replaceAll(key, value);
+    }
+  }
+}
+
+export default {
+  defaultLanguage,
+  supportedLanguages,
+  getSupportedLanguageOptions,
+  getLanguageName,
+  getAvailableArticleSlug,
+  getKbUrl,
+  getArticleUrl,
+  getCategoryUrl,
+  getCategoryArticlesBySections,
+  fixDarkMode,
+};