Track HiveGrid Cloud planning reference

This commit is contained in:
david committed 2026-06-26 20:48:01 +02:00
1 parent b3d5ea6764
commit e341c5938a
5784 files changed
+1104929 -3

No files matched your search

@@ -0,0 +1,147 @@
import { ActionFunctionArgs, LoaderFunctionArgs, MetaFunction, redirect, useActionData, useLoaderData } from "react-router";
import { t as i18nT } from "i18next";
import { Form, useNavigate, useOutlet, useParams } from "react-router";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import ButtonSecondary from "~/components/ui/buttons/ButtonSecondary";
import LoadingButton from "~/components/ui/buttons/LoadingButton";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import ActionResultModal from "~/components/ui/modals/ActionResultModal";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import { getTranslations } from "~/locale/i18next.server";
import KbArticleForm from "~/modules/knowledgeBase/components/bases/KbArticleForm";
import {
KnowledgeBaseArticleWithDetails,
getKbArticleByIdInKnowledgeBase,
updateKnowledgeBaseArticleInKnowledgeBase,
} from "~/modules/knowledgeBase/db/kbArticles.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import KnowledgeBaseService from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
export const meta: MetaFunction<typeof loader> = ({ data }) => data?.metatags || [];
type LoaderData = {
metatags: MetaTagsDto;
knowledgeBase: KnowledgeBaseDto;
item: KnowledgeBaseArticleWithDetails;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const { t } = await getTranslations(request);
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (!knowledgeBase) {
throw redirect(adminPath("knowledge-base/bases", { mode: "host-aware" }));
}
const item = await getKbArticleByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!item) {
throw redirect(adminPath(`knowledge-base/bases/${params.slug!}/articles`, { mode: "host-aware" }));
}
const data: LoaderData = {
metatags: [{ title: `${t("shared.edit")}: ${item.title} | ${knowledgeBase.title} | ${t("knowledgeBase.title")} | ${process.env.APP_NAME}` }],
knowledgeBase,
item,
};
return data;
};
type ActionData = {
error?: string;
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.update");
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
const item = await getKbArticleByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!item) {
return Response.json({ error: t("knowledgeBase.admin.errors.articleNotFound") }, { status: 400 });
}
if (action === "edit") {
const content = form.get("content")?.toString() ?? "";
const contentType = form.get("contentType")?.toString() ?? "";
const result = await updateKnowledgeBaseArticleInKnowledgeBase(
{ id: item.id, knowledgeBaseId: knowledgeBase.id, language: params.lang! },
{
contentDraft: content,
contentType,
}
);
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.admin.errors.articleNotFound") }, { status: 404 });
}
return redirect(adminPath(`knowledge-base/bases/${params.slug}/articles/${params.lang}/${params.id}`, { mode: "host-aware" }));
}
return Response.json({ error: t("knowledgeBase.admin.errors.invalidAction") }, { status: 400 });
};
export default function () {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const params = useParams();
const outlet = useOutlet();
const navigate = useNavigate();
return (
<Form method="post" className="space-y-6">
<input type="hidden" name="action" value="edit" hidden readOnly />
<EditPageLayout
title={`${data.item.title}`}
withHome={false}
menu={[
{ title: i18nT("knowledgeBase.authoring.breadcrumbs.knowledgeBases"), routePath: adminPath("knowledge-base/bases", { mode: "host-aware" }) },
{ title: data.knowledgeBase.title, routePath: adminPath(`knowledge-base/bases/${data.knowledgeBase.slug}`, { mode: "host-aware" }) },
{ title: i18nT("knowledgeBase.authoring.breadcrumbs.articles"), routePath: adminPath(`knowledge-base/bases/${params.slug}/articles`, { mode: "host-aware" }) },
{ title: params.lang!, routePath: adminPath(`knowledge-base/bases/${params.slug}/articles/${params.lang}`, { mode: "host-aware" }) },
{
title: data.item.title,
routePath: adminPath(`knowledge-base/bases/${params.slug}/articles/${params.lang}/${params.id}`, { mode: "host-aware" }),
},
]}
buttons={
<>
<ButtonSecondary to={adminPath(`knowledge-base/bases/${params.slug}/articles/${params.lang}/${params.id}`, { mode: "host-aware" })}>
<div>{i18nT("knowledgeBase.authoring.actions.cancel")}</div>
</ButtonSecondary>
<LoadingButton type="submit">
<div>{i18nT("knowledgeBase.authoring.actions.saveDraft")}</div>
</LoadingButton>
</>
}
>
<div className="space-y-2">
<KbArticleForm item={data.item} />
</div>
<ActionResultModal actionData={actionData} showSuccess={false} />
<SlideOverWideEmpty
title={i18nT("knowledgeBase.authoring.articleSettings.title")}
open={!!outlet}
onClose={() => {
navigate(".", { replace: true });
}}
className="sm:max-w-sm"
overflowYScroll={true}
>
<div className="-mx-1 -mt-3">
<div className="space-y-4">{outlet}</div>
</div>
</SlideOverWideEmpty>
</EditPageLayout>
</Form>
);
}
@@ -0,0 +1,180 @@
import { ActionFunctionArgs, LoaderFunctionArgs, MetaFunction, redirect, useActionData, useLoaderData } from "react-router";
import { Form, useNavigate, useOutlet, useParams } from "react-router";
import ButtonPrimary from "~/components/ui/buttons/ButtonPrimary";
import ButtonSecondary from "~/components/ui/buttons/ButtonSecondary";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import KbArticleContent from "~/modules/knowledgeBase/components/articles/KbArticleContent";
import { getKbArticleByIdInKnowledgeBase, updateKnowledgeBaseArticleInKnowledgeBase } from "~/modules/knowledgeBase/db/kbArticles.db.server";
import { KbArticleDto } from "~/modules/knowledgeBase/dtos/KbArticleDto";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import KnowledgeBaseService from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import KnowledgeBaseUtils from "~/modules/knowledgeBase/utils/KnowledgeBaseUtils";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import { getTranslations } from "~/locale/i18next.server";
import { useEffect } from "react";
import { useTranslation } from "react-i18next";
import { toast } from "sonner";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
export const meta: MetaFunction<typeof loader> = ({ data }) => data?.metatags || [];
type LoaderData = {
metatags: MetaTagsDto;
knowledgeBase: KnowledgeBaseDto;
item: KbArticleDto;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const { t } = await getTranslations(request);
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (!knowledgeBase) {
throw redirect(adminPath("knowledge-base/bases", { mode: "host-aware" }));
}
const item = await KnowledgeBaseService.getArticleById({
kb: knowledgeBase,
id: params.id!,
params: { lang: params.lang },
request,
});
if (!item) {
throw redirect(adminPath(`knowledge-base/bases/${params.slug!}/articles`, { mode: "host-aware" }));
}
const data: LoaderData = {
metatags: [{ title: `${item.title} | ${knowledgeBase.title} | ${t("knowledgeBase.title")} | ${process.env.APP_NAME}` }],
knowledgeBase,
item,
};
return data;
};
type ActionData = {
error?: string;
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.update");
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
const item = await getKbArticleByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!item) {
return Response.json({ error: t("knowledgeBase.admin.errors.articleNotFound") }, { status: 400 });
}
if (action === "togglePublish") {
if (!item.categoryId) {
return Response.json({ error: t("knowledgeBase.admin.errors.articleCategoryRequired") }, { status: 400 });
}
let publishedAt = item.publishedAt;
let contentPublished = item.contentPublished;
if (item.publishedAt) {
publishedAt = null;
} else {
publishedAt = new Date();
contentPublished = item.contentDraft;
}
var text = KnowledgeBaseService.contentAsText(contentPublished);
const result = await updateKnowledgeBaseArticleInKnowledgeBase(
{ id: item.id, knowledgeBaseId: knowledgeBase.id, language: params.lang! },
{
publishedAt,
contentPublished,
contentPublishedAsText: text,
}
);
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.admin.errors.articleNotFound") }, { status: 404 });
}
return Response.json({ success: true });
}
return Response.json({ error: t("knowledgeBase.admin.errors.invalidAction") }, { status: 400 });
};
export default function () {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const params = useParams();
const outlet = useOutlet();
const navigate = useNavigate();
const { t } = useTranslation();
useEffect(() => {
if (actionData?.error) {
toast.error(actionData.error);
}
}, [actionData]);
return (
<Form method="post" className="space-y-6">
<input type="hidden" name="action" value="togglePublish" hidden readOnly />
<EditPageLayout
title={`${data.item.title}`}
withHome={false}
menu={[
{ title: t("knowledgeBase.adminArticles.breadcrumbs.knowledgeBases"), routePath: adminPath("knowledge-base/bases", { mode: "host-aware" }) },
{ title: data.knowledgeBase.title, routePath: adminPath(`knowledge-base/bases/${data.knowledgeBase.slug}`, { mode: "host-aware" }) },
{ title: t("knowledgeBase.article.plural"), routePath: adminPath(`knowledge-base/bases/${params.slug}/articles`, { mode: "host-aware" }) },
{ title: params.lang!, routePath: adminPath(`knowledge-base/bases/${params.slug}/articles/${params.lang}`, { mode: "host-aware" }) },
{
title: data.item.title,
routePath: adminPath(`knowledge-base/bases/${params.slug}/articles/${params.lang}/${params.id}`, { mode: "host-aware" }),
},
]}
buttons={
<>
<ButtonSecondary to="settings">
<div>{t("knowledgeBase.adminArticles.actions.settings")}</div>
</ButtonSecondary>
<ButtonSecondary to="edit">
<div>{t("knowledgeBase.adminArticleDetail.actions.editLatest")}</div>
</ButtonSecondary>
{data.item.publishedAt && (
<ButtonSecondary to={KnowledgeBaseUtils.getArticleUrl({ kb: data.knowledgeBase, article: data.item, params: {} })} target="_blank">
<div>{t("knowledgeBase.adminArticleDetail.actions.preview")}</div>
</ButtonSecondary>
)}
<ButtonPrimary type="submit" destructive={!!data.item.publishedAt}>
{data.item.publishedAt ? (
<div>{t("knowledgeBase.adminArticleDetail.actions.unpublish")}</div>
) : (
<div>{t("knowledgeBase.adminArticleDetail.actions.publish")}</div>
)}
</ButtonPrimary>
</>
}
>
<div className="space-y-2">
<div className="mx-auto max-w-4xl space-y-3 py-12">
<KbArticleContent item={data.item} content={data.item.contentDraft} />
</div>
</div>
<SlideOverWideEmpty
title={t("knowledgeBase.adminArticles.settingsTitle")}
open={!!outlet}
onClose={() => {
navigate(".", { replace: true });
}}
className="sm:max-w-lg"
overflowYScroll={true}
>
<div className="-mx-1 -mt-3">
<div className="space-y-4">{outlet}</div>
</div>
</SlideOverWideEmpty>
</EditPageLayout>
</Form>
);
}
@@ -0,0 +1,224 @@
import { ActionFunctionArgs, LoaderFunctionArgs, MetaFunction, redirect, useLoaderData } from "react-router";
import { useSubmit } from "react-router";
import { useRef } from "react";
import { useTranslation } from "react-i18next";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import ConfirmModal, { RefConfirmModal } from "~/components/ui/modals/ConfirmModal";
import { getTranslations } from "~/locale/i18next.server";
import KbArticleSettingsForm from "~/modules/knowledgeBase/components/bases/KbArticleSettingsForm";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import {
KnowledgeBaseArticleSimple,
KnowledgeBaseArticleWithDetails,
deleteKnowledgeBaseArticleInKnowledgeBase,
getFeaturedKnowledgeBaseArticles,
getKbArticleByIdInKnowledgeBase,
getKbArticleBySlug,
getKnowledgeBaseArticlesSimple,
updateKnowledgeBaseArticleInKnowledgeBase,
} from "~/modules/knowledgeBase/db/kbArticles.db.server";
import { KnowledgeBaseCategorySimple, getAllKnowledgeBaseCategories } from "~/modules/knowledgeBase/db/kbCategories.db.server";
import { getAllKnowledgeBaseNames } from "~/modules/knowledgeBase/db/knowledgeBase.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import KnowledgeBaseService from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import KnowledgeBaseUtils from "~/modules/knowledgeBase/utils/KnowledgeBaseUtils";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { validateCSRFToken } from "~/utils/session.server";
import { appendCSRFToken } from "~/utils/csrf";
export const meta: MetaFunction<typeof loader> = ({ data }) => data?.metatags || [];
type LoaderData = {
metatags: MetaTagsDto;
knowledgeBase: KnowledgeBaseDto;
item: KnowledgeBaseArticleWithDetails;
allKnowledgeBases: { id: string; title: string }[];
allArticles: KnowledgeBaseArticleSimple[];
allCategories: KnowledgeBaseCategorySimple[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const { t } = await getTranslations(request);
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (!knowledgeBase) {
throw redirect(adminPath("knowledge-base/bases", { mode: "host-aware" }));
}
const item = await getKbArticleByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!item) {
throw redirect(adminPath(`knowledge-base/bases/${params.slug!}/articles`, { mode: "host-aware" }));
}
const allCategories = await getAllKnowledgeBaseCategories({ knowledgeBaseSlug: knowledgeBase.slug, language: params.lang! });
const allArticles = await getKnowledgeBaseArticlesSimple({ knowledgeBaseId: knowledgeBase.id, language: params.lang! });
const data: LoaderData = {
metatags: [{ title: `${t("shared.settings")}: ${item.title} | ${knowledgeBase.title} | ${t("knowledgeBase.title")} | ${process.env.APP_NAME}` }],
knowledgeBase,
item,
allKnowledgeBases: await getAllKnowledgeBaseNames(),
allArticles,
allCategories: allCategories.map((category) => ({
id: category.id,
knowledgeBaseId: category.knowledgeBaseId,
title: category.title,
language: category.language,
sections: category.sections.map((section) => ({ id: section.id, order: section.order, title: section.title })),
})),
};
return data;
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.update");
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const routeKnowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (!routeKnowledgeBase) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.knowledgeBaseNotFound") }, { status: 400 });
}
const item = await getKbArticleByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: routeKnowledgeBase.id, language: params.lang! });
if (!item) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.articleNotFound") }, { status: 400 });
}
if (action === "edit") {
const knowledgeBaseId = form.get("knowledgeBaseId")?.toString() ?? "";
const categoryId = form.get("categoryId")?.toString() ?? "";
const sectionId = form.get("sectionId")?.toString() ?? "";
const language = form.get("language")?.toString() ?? "";
const slug = form.get("slug")?.toString() ?? "";
const title = form.get("title")?.toString() ?? "";
const description = form.get("description")?.toString() ?? "";
const seoImage = form.get("seoImage")?.toString() ?? "";
const isFeatured = Boolean(form.get("isFeatured"));
const relatedArticles = form.getAll("relatedArticles[]").map((l) => l.toString());
const knowledgeBase = await KnowledgeBaseService.getById({ id: knowledgeBaseId, request });
if (!knowledgeBase) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.knowledgeBaseNotFound") }, { status: 400 });
}
if (knowledgeBase.id !== routeKnowledgeBase.id || language !== params.lang) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.articleScopeMismatch") }, { status: 400 });
}
const scopedCategories = await getAllKnowledgeBaseCategories({ knowledgeBaseSlug: routeKnowledgeBase.slug, language: params.lang! });
const category = categoryId.length ? scopedCategories.find((candidate) => candidate.id === categoryId) : null;
if (categoryId.length && !category) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.categoryNotFound") }, { status: 400 });
}
if (sectionId.length && !category?.sections.some((section) => section.id === sectionId)) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.sectionNotFound") }, { status: 400 });
}
const scopedArticleIds = new Set(
(await getKnowledgeBaseArticlesSimple({ knowledgeBaseId: routeKnowledgeBase.id, language: params.lang! })).map((article) => article.id)
);
if (relatedArticles.some((articleId) => !scopedArticleIds.has(articleId))) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.relatedArticleNotFound") }, { status: 400 });
}
const existingLanguage = KnowledgeBaseUtils.supportedLanguages.find((f) => f.value === language);
if (!existingLanguage) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.languageNotFound", { language }) }, { status: 400 });
}
const existing = await getKbArticleBySlug({
knowledgeBaseId,
slug,
language,
});
if (existing && existing.id !== item.id) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.slugAlreadyExists") }, { status: 400 });
}
let featuredOrder = item.featuredOrder;
if (isFeatured) {
if (!item.featuredOrder) {
const featuredArticles = await getFeaturedKnowledgeBaseArticles({
knowledgeBaseId,
language,
});
let maxOrder = 0;
if (featuredArticles.length > 0) {
maxOrder = Math.max(...featuredArticles.map((p) => p.featuredOrder ?? 0));
}
featuredOrder = maxOrder + 1;
}
} else {
featuredOrder = null;
}
const result = await updateKnowledgeBaseArticleInKnowledgeBase(
{ id: item.id, knowledgeBaseId: routeKnowledgeBase.id, language: params.lang! },
{
categoryId: categoryId?.length ? categoryId : null,
sectionId: sectionId?.length ? sectionId : null,
slug,
title,
description,
order: item.order,
language,
featuredOrder,
seoImage,
relatedArticles,
}
);
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.articleNotFound") }, { status: 404 });
}
return redirect(adminPath(`knowledge-base/bases/${knowledgeBase.slug}/articles/${language}/${item.id}`, { mode: "host-aware" }));
} else if (action === "delete") {
await verifyUserHasPermission(request, "admin.kb.delete");
const result = await deleteKnowledgeBaseArticleInKnowledgeBase({ id: item.id, knowledgeBaseId: routeKnowledgeBase.id, language: params.lang! });
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.articleSettings.errors.articleNotFound") }, { status: 404 });
}
return redirect(adminPath(`knowledge-base/bases/${routeKnowledgeBase.slug}/articles/${params.lang}`, { mode: "host-aware" }));
}
return Response.json({ error: t("knowledgeBase.articleSettings.errors.invalidAction") }, { status: 400 });
};
export default function () {
const data = useLoaderData<LoaderData>();
const submit = useSubmit();
const { t } = useTranslation();
const confirmDelete = useRef<RefConfirmModal>(null);
function onDelete() {
confirmDelete.current?.show(
t("knowledgeBase.adminCategories.confirmDelete.article.title"),
t("shared.delete"),
t("shared.cancel"),
t("knowledgeBase.adminCategories.confirmDelete.article.description", { title: data.item.title })
);
}
function onConfirmedDelete() {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "delete");
submit(form, {
method: "post",
});
}
return (
<div>
<KbArticleSettingsForm
allKnowledgeBases={data.allKnowledgeBases}
allArticles={data.allArticles}
allCategories={data.allCategories}
item={data.item}
onDelete={onDelete}
/>
<ConfirmModal ref={confirmDelete} onYes={onConfirmedDelete} destructive />
</div>
);
}
@@ -0,0 +1,403 @@
import { ActionFunctionArgs, LoaderFunctionArgs, redirect, useActionData, useLoaderData } from "react-router";
import { Link, useNavigate, useOutlet, useParams, useSubmit } from "react-router";
import { useTranslation } from "react-i18next";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import { PaginationDto } from "~/application/dtos/data/PaginationDto";
import { Colors } from "~/application/enums/shared/Colors";
import SimpleBadge from "~/components/ui/badges/SimpleBadge";
import ButtonPrimary from "~/components/ui/buttons/ButtonPrimary";
import DateCell from "~/components/ui/dates/DateCell";
import PlusIcon from "~/components/ui/icons/PlusIcon";
import InputCheckbox from "~/components/ui/input/InputCheckbox";
import InputFilters from "~/components/ui/input/InputFilters";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import ActionResultModal from "~/components/ui/modals/ActionResultModal";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import TableSimple from "~/components/ui/tables/TableSimple";
import { useLocaleFormatters } from "~/locale/format";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { getTranslations } from "~/locale/i18next.server";
import {
KnowledgeBaseArticleWithDetails,
getAllKnowledgeBaseArticlesWithPagination,
getKbArticleByIdInKnowledgeBase,
updateKnowledgeBaseArticleInKnowledgeBase,
} from "~/modules/knowledgeBase/db/kbArticles.db.server";
import { getAllKnowledgeBaseCategories, updateKnowledgeBaseCategoryOrderInKnowledgeBase } from "~/modules/knowledgeBase/db/kbCategories.db.server";
import { updateKnowledgeBaseCategorySectionOrderInKnowledgeBase } from "~/modules/knowledgeBase/db/kbCategorySections.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import KnowledgeBaseService, { getKnowledgeBaseActionErrorKey } from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import KnowledgeBaseUtils from "~/modules/knowledgeBase/utils/KnowledgeBaseUtils";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getFiltersFromCurrentUrl, getPaginationFromCurrentUrl } from "~/utils/helpers/RowPaginationHelper";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { appendCSRFToken } from "~/utils/csrf";
import type { TFunction } from "i18next";
type LoaderData = {
knowledgeBase: KnowledgeBaseDto;
items: KnowledgeBaseArticleWithDetails[];
pagination: PaginationDto;
filterableProperties: FilterablePropertyDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const { t } = await getTranslations(request);
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (!knowledgeBase) {
return redirect(adminPath("knowledge-base/bases", { mode: "host-aware" }));
}
const urlSearchParams = new URL(request.url).searchParams;
const currentPagination = getPaginationFromCurrentUrl(urlSearchParams);
const filterableProperties: FilterablePropertyDto[] = [
{
name: "title",
title: t("knowledgeBase.adminArticles.fields.title"),
},
{
name: "description",
title: t("knowledgeBase.adminArticles.fields.description"),
},
{
name: "categoryId",
title: t("knowledgeBase.adminArticles.fields.category"),
options: [
{ value: "null", name: t("knowledgeBase.adminArticles.filters.noCategoryValue") },
...(await getAllKnowledgeBaseCategories({ knowledgeBaseSlug: knowledgeBase.slug, language: params.lang! })).map((item) => {
return {
value: item.id,
name: item.title,
};
}),
],
},
{
name: "content",
title: t("knowledgeBase.adminArticles.fields.content"),
},
];
const filters = getFiltersFromCurrentUrl(request, filterableProperties);
const filtered = {
title: filters.properties.find((f) => f.name === "title")?.value ?? filters.query ?? undefined,
description: filters.properties.find((f) => f.name === "description")?.value ?? filters.query ?? undefined,
categoryId: filters.properties.find((f) => f.name === "categoryId")?.value ?? undefined,
content: filters.properties.find((f) => f.name === "content")?.value ?? filters.query ?? undefined,
};
const { items, pagination } = await getAllKnowledgeBaseArticlesWithPagination({
knowledgeBaseSlug: params.slug!,
language: params.lang!,
pagination: currentPagination,
filters: {
title: filtered.title,
description: filtered.description,
categoryId: filtered.categoryId === "null" ? null : filtered.categoryId,
content: filtered.content,
},
});
const data: LoaderData = {
knowledgeBase,
items,
pagination,
filterableProperties,
};
return data;
};
type ActionData = {
error?: string;
};
function formatLanguageName(language: string, locale: string, t: TFunction) {
try {
return (new Intl.DisplayNames([locale], { type: "language" }).of(language) ?? KnowledgeBaseUtils.getLanguageName(language, t)) || language;
} catch {
return KnowledgeBaseUtils.getLanguageName(language, t) || language;
}
}
export const action = async ({ request, params }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.update");
const userInfo = await getUserInfo(request);
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const kb = await KnowledgeBaseService.get({ slug: params.slug!, request });
if (action === "new") {
await verifyUserHasPermission(request, "admin.kb.create");
const created = await KnowledgeBaseService.newArticle({
kb,
params,
userId: userInfo.userId,
position: "last",
});
return redirect(adminPath(`knowledge-base/bases/${kb.slug}/articles/${params.lang}/${created.id}/edit`, { mode: "host-aware" }));
} else if (action === "set-orders") {
const items: { id: string; order: number }[] = form.getAll("orders[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
await Promise.all(
items.map(async ({ id, order }) => {
await updateKnowledgeBaseCategoryOrderInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang!, order: Number(order) });
})
);
return Response.json({ updated: true });
} else if (action === "set-section-orders") {
const items: { id: string; order: number }[] = form.getAll("orders[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
await Promise.all(
items.map(async ({ id, order }) => {
await updateKnowledgeBaseCategorySectionOrderInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang!, order: Number(order) });
})
);
return Response.json({ updated: true });
} else if (action === "duplicate") {
await verifyUserHasPermission(request, "admin.kb.create");
try {
const id = form.get("id")?.toString() ?? "";
const item = await KnowledgeBaseService.duplicateArticle({ kb, language: params.lang!, articleId: id });
return redirect(adminPath(`knowledge-base/bases/${kb.slug}/articles/${params.lang}/${item.id}`, { mode: "host-aware" }));
} catch (e: unknown) {
return Response.json({ error: t(getKnowledgeBaseActionErrorKey(e)) }, { status: 400 });
}
} else if (action === "toggle") {
const id = form.get("id")?.toString() ?? "";
const isFeatured = form.get("isFeatured")?.toString() === "true";
const item = await getKbArticleByIdInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang! });
if (!item) {
return Response.json({ error: t("knowledgeBase.admin.errors.notFound") }, { status: 404 });
}
let featuredOrder = item.featuredOrder;
if (isFeatured) {
if (!item.featuredOrder) {
const featuredArticles = await KnowledgeBaseService.getFeaturedArticles({
kb,
params: {},
request,
});
let maxOrder = 0;
if (featuredArticles.length > 0) {
maxOrder = Math.max(...featuredArticles.map((p) => p.featuredOrder ?? 0));
}
featuredOrder = maxOrder + 1;
}
} else {
featuredOrder = null;
}
const result = await updateKnowledgeBaseArticleInKnowledgeBase(
{ id: item.id, knowledgeBaseId: kb.id, language: params.lang! },
{
featuredOrder,
}
);
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.admin.errors.notFound") }, { status: 404 });
}
return Response.json({ success: t("knowledgeBase.admin.success.updated") });
}
return Response.json({ error: t("knowledgeBase.admin.errors.invalidAction") }, { status: 400 });
};
export default function () {
const { t } = useTranslation();
const formatters = useLocaleFormatters();
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const params = useParams();
const languageName = formatLanguageName(params.lang!, formatters.locale, t);
const outlet = useOutlet();
const navigate = useNavigate();
const submit = useSubmit();
function onDuplicate(item: KnowledgeBaseArticleWithDetails) {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "duplicate");
form.set("id", item.id);
submit(form, {
method: "post",
});
}
function onToggle(item: KnowledgeBaseArticleWithDetails, isFeatured: boolean) {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "toggle");
form.set("isFeatured", isFeatured ? "true" : "false");
form.set("id", item.id.toString());
submit(form, {
method: "post",
});
}
return (
<EditPageLayout
title={t("knowledgeBase.adminArticles.titleWithLanguage", { language: languageName })}
withHome={false}
menu={[
{ title: t("knowledgeBase.adminArticles.breadcrumbs.knowledgeBases"), routePath: adminPath("knowledge-base/bases", { mode: "host-aware" }) },
{ title: data.knowledgeBase.title, routePath: adminPath(`knowledge-base/bases/${data.knowledgeBase.slug}`, { mode: "host-aware" }) },
{ title: t("knowledgeBase.article.plural"), routePath: adminPath(`knowledge-base/bases/${params.slug}/articles`, { mode: "host-aware" }) },
{ title: languageName, routePath: adminPath(`knowledge-base/bases/${params.slug}/articles/${params.lang}`, { mode: "host-aware" }) },
]}
buttons={
<>
<InputFilters filters={data.filterableProperties} />
<ButtonPrimary
onClick={() => {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "new");
submit(form, {
method: "post",
});
}}
>
<div>{t("knowledgeBase.article.new")}</div>
<PlusIcon className="h-5 w-5" />
</ButtonPrimary>
</>
}
>
<div className="space-y-2">
<TableSimple
items={data.items}
pagination={data.pagination}
actions={[
{
title: t("knowledgeBase.adminArticles.actions.settings"),
onClickRoute: (_, item) => `${item.id}/settings`,
},
{
title: t("knowledgeBase.adminArticles.actions.duplicate"),
onClick: (_, item) => onDuplicate(item),
},
{
title: t("knowledgeBase.adminArticles.actions.edit"),
onClickRoute: (_, item) => `${item.id}`,
},
]}
headers={[
{
name: "status",
title: t("knowledgeBase.adminArticles.fields.status"),
value: (i) => (
<div>
{!i.publishedAt ? (
<SimpleBadge title={t("knowledgeBase.adminArticles.status.draft")} color={Colors.GRAY} />
) : (
<SimpleBadge title={t("knowledgeBase.adminArticles.status.published")} color={Colors.TEAL} />
)}
</div>
),
},
{
name: "title",
title: t("knowledgeBase.adminArticles.fields.title"),
className: "w-full",
value: (i) => (
<div className="space-y-1">
<Link to={i.id} className="font-medium hover:underline">
{i.title}
</Link>
{/* <div className="text-muted-foreground text-sm">{i.description}</div> */}
{/* <div className="text-sm text-muted-foreground">{i.slug}</div>
<div className="text-muted-foreground text-sm">{i.description}</div> */}
</div>
),
},
{
name: "category",
title: t("knowledgeBase.adminArticles.fields.category"),
value: (i) => (
<div>
{i.category ? (
<div className="flex flex-col">
<div>{i.category.title}</div>
{i.section && <div className="text-muted-foreground text-xs">{i.section.title}</div>}
</div>
) : (
<Link to={`${i.id}/settings`} className="text-muted-foreground text-xs italic hover:underline">
{t("knowledgeBase.adminArticles.empty.noCategory")}
</Link>
)}
</div>
),
},
{
name: "characters",
title: t("knowledgeBase.adminArticles.metrics.characters"),
value: (i) => formatters.number(i.contentPublishedAsText.length, { maximumFractionDigits: 0 }),
},
{
name: "views",
title: t("knowledgeBase.adminArticles.metrics.views"),
value: (i) => formatters.number(i._count.views, { maximumFractionDigits: 0 }),
},
{
name: "upvotes",
title: t("knowledgeBase.adminArticles.metrics.upvotes"),
value: (i) => formatters.number(i._count.upvotes, { maximumFractionDigits: 0 }),
},
{
name: "downvotes",
title: t("knowledgeBase.adminArticles.metrics.downvotes"),
value: (i) => formatters.number(i._count.downvotes, { maximumFractionDigits: 0 }),
},
{
name: "featured",
title: t("knowledgeBase.adminArticles.fields.featured"),
value: (i) => {
return <InputCheckbox asToggle value={i.featuredOrder ? true : false} setValue={(checked) => onToggle(i, Boolean(checked))} />;
},
},
{
name: "createdAt",
title: t("shared.createdAt"),
value: (i) => (
<div className="flex flex-col">
<DateCell date={i.createdAt} displays={["ymd"]} />
<div>
{i.createdByUser ? (
<div>
{i.createdByUser.firstName} {i.createdByUser.lastName}
</div>
) : (
<div className="text-muted-foreground text-xs italic hover:underline">{t("knowledgeBase.adminArticles.empty.noAuthor")}</div>
)}
</div>
</div>
),
},
]}
/>
</div>
<ActionResultModal actionData={actionData} showSuccess={false} />
<SlideOverWideEmpty
title={t("knowledgeBase.adminArticles.settingsTitle")}
open={!!outlet}
onClose={() => {
navigate(".", { replace: true });
}}
className="sm:max-w-sm"
overflowYScroll={true}
>
<div className="-mx-1 -mt-3">
<div className="space-y-4">{outlet}</div>
</div>
</SlideOverWideEmpty>
</EditPageLayout>
);
}
@@ -0,0 +1,68 @@
import { LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { Link, useParams } from "react-router";
import { useTranslation } from "react-i18next";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { KnowledgeBaseArticleWithDetails, getAllKnowledgeBaseArticles } from "~/modules/knowledgeBase/db/kbArticles.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import KnowledgeBaseService from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import KnowledgeBaseUtils from "~/modules/knowledgeBase/utils/KnowledgeBaseUtils";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
type LoaderData = {
knowledgeBase: KnowledgeBaseDto;
items: KnowledgeBaseArticleWithDetails[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (!knowledgeBase) {
return redirect(adminPath("knowledge-base/bases", { mode: "host-aware" }));
}
const items = await getAllKnowledgeBaseArticles({
knowledgeBaseSlug: params.slug!,
language: undefined,
});
const data: LoaderData = {
knowledgeBase,
items,
};
return data;
};
export default function () {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout
title={t("knowledgeBase.authoring.articles.title")}
withHome={false}
menu={[
{ title: t("knowledgeBase.authoring.breadcrumbs.knowledgeBases"), routePath: adminPath("knowledge-base/bases", { mode: "host-aware" }) },
{ title: data.knowledgeBase.title, routePath: adminPath(`knowledge-base/bases/${data.knowledgeBase.slug}`, { mode: "host-aware" }) },
{ title: t("knowledgeBase.authoring.breadcrumbs.articles"), routePath: adminPath(`knowledge-base/bases/${params.slug}/articles`, { mode: "host-aware" }) },
]}
>
<div className="space-y-2">
{data.knowledgeBase.languages.map((f) => {
return (
<div key={f} className="space-y-2">
<Link
to={f}
className="border-border hover:border-border relative block space-y-2 rounded-lg border-2 border-dashed px-12 py-6 text-center focus:border-solid focus:outline-hidden"
>
<div className="font-bold">{KnowledgeBaseUtils.getLanguageName(f, t)}</div>
<div className="text-sm">
{t("knowledgeBase.authoring.articles.count", { count: data.items.filter((x) => x.language === f).length })}
</div>
</Link>
</div>
);
})}
</div>
</EditPageLayout>
);
}
@@ -0,0 +1,879 @@
import { ActionFunctionArgs, LoaderFunctionArgs, redirect, useActionData, useLoaderData } from "react-router";
import { Link, useLocation, useNavigate, useOutlet, useParams, useSubmit } from "react-router";
import clsx from "clsx";
import { useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { Colors } from "~/application/enums/shared/Colors";
import ColorBadge from "~/components/ui/badges/ColorBadge";
import DocumentDuplicateIconFilled from "~/components/ui/icons/DocumentDuplicateIconFilled";
import PencilIcon from "~/components/ui/icons/PencilIcon";
import PlusIcon from "~/components/ui/icons/PlusIcon";
import TrashIcon from "~/components/ui/icons/TrashIcon";
import FolderIconFilled from "~/components/ui/icons/entities/FolderIconFilled";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import ActionResultModal from "~/components/ui/modals/ActionResultModal";
import ConfirmModal, { RefConfirmModal } from "~/components/ui/modals/ConfirmModal";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import DraggableList from "~/components/ui/sort/DraggableList";
import OrderListButtons from "~/components/ui/sort/OrderListButtons";
import { getTranslations } from "~/locale/i18next.server";
import {
deleteKnowledgeBaseArticleInKnowledgeBase,
getKbArticleByIdInKnowledgeBase,
getKbArticleBySlug,
updateKnowledgeBaseArticleInKnowledgeBase,
updateKnowledgeBaseArticleOrderInKnowledgeBase,
} from "~/modules/knowledgeBase/db/kbArticles.db.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import {
deleteKnowledgeBaseCategoryInKnowledgeBase,
getAllKnowledgeBaseCategories,
getKbCategoryByIdInKnowledgeBase,
updateKnowledgeBaseCategoryOrderInKnowledgeBase,
} from "~/modules/knowledgeBase/db/kbCategories.db.server";
import {
deleteKnowledgeBaseCategorySectionInCategory,
getKbCategorySectionByIdInCategory,
updateKnowledgeBaseCategorySectionOrderInKnowledgeBase,
} from "~/modules/knowledgeBase/db/kbCategorySections.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import { KnowledgeBaseCategoryWithDetails } from "~/modules/knowledgeBase/helpers/KbCategoryModelHelper";
import KnowledgeBaseService, { getKnowledgeBaseActionErrorKey } from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import KnowledgeBaseUtils from "~/modules/knowledgeBase/utils/KnowledgeBaseUtils";
import UrlUtils from "~/utils/app/UrlUtils";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { appendCSRFToken } from "~/utils/csrf";
import { useLocaleFormatters } from "~/locale/format";
type LoaderData = {
knowledgeBase: KnowledgeBaseDto;
items: KnowledgeBaseCategoryWithDetails[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (!knowledgeBase) {
return redirect(adminPath("knowledge-base/bases", { mode: "host-aware" }));
}
const items = await getAllKnowledgeBaseCategories({
knowledgeBaseSlug: params.slug!,
language: params.lang!,
});
const data: LoaderData = {
knowledgeBase,
items,
};
return data;
};
type ActionData = {
error?: string;
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.update");
const { t } = await getTranslations(request);
const userInfo = await getUserInfo(request);
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const kb = await KnowledgeBaseService.get({ slug: params.slug!, request });
if (action === "set-orders") {
const items: { id: string; order: number }[] = form.getAll("orders[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
await Promise.all(
items.map(async ({ id, order }) => {
await updateKnowledgeBaseCategoryOrderInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang!, order: Number(order) });
})
);
return Response.json({ updated: true });
} else if (action === "set-section-orders") {
const items: { id: string; order: number }[] = form.getAll("orders[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
await Promise.all(
items.map(async ({ id, order }) => {
await updateKnowledgeBaseCategorySectionOrderInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang!, order: Number(order) });
})
);
return Response.json({ updated: true });
} else if (action === "set-article-orders") {
const items: { id: string; order: number }[] = form.getAll("orders[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
await Promise.all(
items.map(async ({ id, order }) => {
await updateKnowledgeBaseArticleOrderInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang!, order: Number(order) });
})
);
return Response.json({ updated: true });
} else if (action === "delete-category") {
await verifyUserHasPermission(request, "admin.kb.delete");
const id = form.get("id")?.toString() ?? "";
const existing = await getKbCategoryByIdInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang! });
if (!existing) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.categoryNotFound") }, { status: 400 });
}
const result = await deleteKnowledgeBaseCategoryInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang! });
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.categoryNotFound") }, { status: 404 });
}
return Response.json({ deleted: true });
} else if (action === "delete-section") {
await verifyUserHasPermission(request, "admin.kb.delete");
const id = form.get("id")?.toString() ?? "";
const category = kb.id
? (await getAllKnowledgeBaseCategories({ knowledgeBaseSlug: kb.slug, language: params.lang! })).find((item) =>
item.sections.some((section) => section.id === id)
)
: null;
const existing = category ? await getKbCategorySectionByIdInCategory({ id, categoryId: category.id }) : null;
if (!existing) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.sectionNotFound") }, { status: 400 });
}
const result = await deleteKnowledgeBaseCategorySectionInCategory({ id, categoryId: category!.id });
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.sectionNotFound") }, { status: 404 });
}
return Response.json({ deleted: true });
} else if (action === "delete-article") {
await verifyUserHasPermission(request, "admin.kb.delete");
const id = form.get("id")?.toString() ?? "";
const existing = await getKbArticleByIdInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang! });
if (!existing) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.articleNotFound") }, { status: 400 });
}
const result = await deleteKnowledgeBaseArticleInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang! });
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.articleNotFound") }, { status: 404 });
}
return Response.json({ deleted: true });
} else if (action === "duplicate") {
await verifyUserHasPermission(request, "admin.kb.create");
try {
const categoryId = form.get("id")?.toString() ?? "";
await KnowledgeBaseService.duplicateCategory({ kb, language: params.lang!, categoryId });
return Response.json({ duplicated: true });
} catch (e: unknown) {
return Response.json({ error: t(getKnowledgeBaseActionErrorKey(e)) }, { status: 400 });
}
} else if (action === "new") {
await verifyUserHasPermission(request, "admin.kb.create");
try {
const categoryId = form.get("categoryId")?.toString() ?? "";
const sectionId = form.get("sectionId")?.toString() ?? "";
const position = form.get("position")?.toString() ?? "";
const title = form.get("title")?.toString() ?? "";
const slug = form.get("slug")?.toString() ?? "";
const scopedCategories = await getAllKnowledgeBaseCategories({ knowledgeBaseSlug: kb.slug, language: params.lang! });
const category = categoryId.length ? scopedCategories.find((candidate) => candidate.id === categoryId) : null;
if (categoryId.length && !category) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.categoryNotFound") }, { status: 400 });
}
if (sectionId.length && !category?.sections.some((section) => section.id === sectionId)) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.sectionNotFound") }, { status: 400 });
}
await KnowledgeBaseService.newArticle({
kb,
params,
categoryId: categoryId.length > 0 ? categoryId : undefined,
sectionId: sectionId.length > 0 ? sectionId : undefined,
userId: userInfo.userId,
title: title.length > 0 ? title : undefined,
initialSlug: slug.length > 0 ? slug : undefined,
position: position as any,
});
return Response.json({ created: true });
} catch (e: unknown) {
return Response.json({ error: t(getKnowledgeBaseActionErrorKey(e)) }, { status: 400 });
}
} else if (action === "update-article-title") {
try {
const id = form.get("id")?.toString() ?? "";
const title = form.get("title")?.toString() ?? "";
const slug = UrlUtils.slugify(title);
const existingArticle = await getKbArticleByIdInKnowledgeBase({ id, knowledgeBaseId: kb.id, language: params.lang! });
if (!existingArticle) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.articleNotFound") }, { status: 400 });
}
const existing = await getKbArticleBySlug({
knowledgeBaseId: kb.id,
slug,
language: params.lang!,
});
if (existing && existing.id !== id) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.slugAlreadyExists") }, { status: 400 });
}
const result = await updateKnowledgeBaseArticleInKnowledgeBase(
{ id, knowledgeBaseId: kb.id, language: params.lang! },
{
title,
slug,
}
);
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.adminCategories.errors.articleNotFound") }, { status: 404 });
}
return Response.json({ updated: true });
} catch (e: unknown) {
return Response.json({ error: t(getKnowledgeBaseActionErrorKey(e)) }, { status: 400 });
}
}
return Response.json({ error: t("knowledgeBase.adminCategories.errors.invalidAction") }, { status: 400 });
};
export default function () {
const { t } = useTranslation();
const formatters = useLocaleFormatters();
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const params = useParams();
const outlet = useOutlet();
const navigate = useNavigate();
const submit = useSubmit();
const location = useLocation();
const [toggledCategories, setToggledCategories] = useState<string[]>([]);
const confirmDeleteCategory = useRef<RefConfirmModal>(null);
const confirmDeleteSection = useRef<RefConfirmModal>(null);
const confirmDeleteArticle = useRef<RefConfirmModal>(null);
function onDelete(item: KnowledgeBaseCategoryWithDetails) {
confirmDeleteCategory.current?.setValue(item);
confirmDeleteCategory.current?.show(
t("knowledgeBase.adminCategories.confirmDelete.category.title"),
t("shared.delete"),
t("shared.cancel"),
t("knowledgeBase.adminCategories.confirmDelete.category.description", { title: item.title })
);
}
function onConfirmedDeleteCategory(item: KnowledgeBaseCategoryWithDetails) {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "delete-category");
form.set("id", item.id);
submit(form, {
method: "post",
});
}
function onDeleteSection(item: { id: string; title: string }) {
confirmDeleteSection.current?.setValue(item);
confirmDeleteSection.current?.show(
t("knowledgeBase.adminCategories.confirmDelete.section.title"),
t("shared.delete"),
t("shared.cancel"),
t("knowledgeBase.adminCategories.confirmDelete.section.description", { title: item.title })
);
}
function onConfirmedDeleteSection(item: KnowledgeBaseCategoryWithDetails) {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "delete-section");
form.set("id", item.id);
submit(form, {
method: "post",
});
}
function onDuplicate(item: KnowledgeBaseCategoryWithDetails) {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "duplicate");
form.set("id", item.id);
submit(form, {
method: "post",
});
}
function onNewArticle(categoryId: string, sectionId: string | undefined, position: "first" | "last") {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "new");
form.set("categoryId", categoryId);
form.set("sectionId", sectionId ?? "");
form.set("position", position);
submit(form, {
method: "post",
});
}
function onDeleteArticle(item: { id: string; title: string }) {
confirmDeleteArticle.current?.setValue(item);
confirmDeleteArticle.current?.show(
t("knowledgeBase.adminCategories.confirmDelete.article.title"),
t("shared.delete"),
t("shared.cancel"),
t("knowledgeBase.adminCategories.confirmDelete.article.description", { title: item.title })
);
}
function onConfirmedDeleteArticle(item: { id: string; title: string }) {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "delete-article");
form.set("id", item.id);
submit(form, {
method: "post",
});
}
function getOutletTitle() {
if (location.pathname.includes("/sections/")) {
if (params.section) {
return t("knowledgeBase.adminCategories.slideOver.editSection");
} else {
return t("knowledgeBase.adminCategories.slideOver.createSection");
}
} else {
if (params.id) {
return t("knowledgeBase.adminCategories.slideOver.editCategory");
} else {
return t("knowledgeBase.adminCategories.slideOver.createCategory");
}
}
}
function onUpdateArticleTitle(article: { id: string; title: string }) {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "update-article-title");
form.set("id", article.id);
form.set("title", article.title);
submit(form, {
method: "post",
});
}
return (
<EditPageLayout
title={t("knowledgeBase.adminCategories.titleWithLanguage", { language: KnowledgeBaseUtils.getLanguageName(params.lang!, t) })}
withHome={false}
menu={[
{ title: t("knowledgeBase.adminCategories.breadcrumbs.knowledgeBases"), routePath: adminPath("knowledge-base/bases", { mode: "host-aware" }) },
{ title: data.knowledgeBase.title, routePath: adminPath(`knowledge-base/bases/${data.knowledgeBase.slug}`, { mode: "host-aware" }) },
{
title: t("knowledgeBase.adminCategories.breadcrumbs.categories"),
routePath: adminPath(`knowledge-base/bases/${params.slug}/categories`, { mode: "host-aware" }),
},
{ title: params.lang!, routePath: adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }) },
]}
>
<div className="space-y-2">
{/* {JSON.stringify({
articles: data.items.map((f) => {
return {
title: f.title,
articles: f.articles.filter((a) => !a.sectionId).map((a) => a.title),
sections: f.sections.map((s) => {
return {
title: s.title,
articles: f.articles.filter((a) => a.sectionId === s.id).map((a) => a.title),
};
}),
};
}),
})} */}
{data.items.map((item, idx) => {
return (
<div key={idx} className="space-y-2">
<div className="border-border bg-background rounded-md border px-4 py-0.5 shadow-2xs">
<div className="space-y-2">
<div className="flex items-center justify-between space-x-2">
<div className="flex items-center space-x-2 truncate">
<div className="flex items-center space-x-3 truncate">
<div className="hidden shrink-0 sm:flex">
<OrderListButtons index={idx} items={data.items} editable={true} />
</div>
<div className="text-foreground flex items-center space-x-2 truncate text-sm">
<div className="flex items-baseline space-x-1 truncate">
<div className="flex flex-col">
<div className="flex items-baseline space-x-2">
<div>
{item.title}
{item.sections.length > 0 && (
<span className="ml-1 truncate text-xs">
({t("knowledgeBase.adminCategories.counts.sections", { count: item.sections.length, formattedCount: formatters.number(item.sections.length) })})
</span>
)}
</div>
<div>•</div>
{item.articles.filter((f) => f.publishedAt).length > 0 ? (
<div className="text-muted-foreground truncate text-xs">
{t("knowledgeBase.adminCategories.counts.articles", {
count: item.articles.filter((f) => f.publishedAt).length,
formattedCount: formatters.number(item.articles.filter((f) => f.publishedAt).length),
})}
</div>
) : (
<div className="text-muted-foreground truncate text-xs">{t("knowledgeBase.adminCategories.empty.noArticles")}</div>
)}
</div>
<div className="text-muted-foreground text-xs">{item.description}</div>
</div>
</div>
</div>
</div>
</div>
<div className="flex shrink-0 space-x-1">
<div className="flex items-center space-x-1 truncate p-1">
<DeleteButton
onDelete={() => onDelete(item)}
canDelete={item.articles.length === 0}
label={t("knowledgeBase.adminCategories.actions.deleteCategory")}
/>
<button
type="button"
aria-label={t("knowledgeBase.adminCategories.actions.toggleCategory", { title: item.title })}
title={t("knowledgeBase.adminCategories.actions.toggleCategory", { title: item.title })}
onClick={() => {
setToggledCategories((prev) => {
if (prev.includes(item.id)) {
return prev.filter((f) => f !== item.id);
}
return [...prev, item.id];
});
}}
className="hover:bg-secondary/90 focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden"
>
<FolderIconFilled className="hover:text-muted-foreground h-4 w-4 text-gray-300" />
</button>
<Link
to={item.id}
aria-label={t("knowledgeBase.adminCategories.actions.editCategory", { title: item.title })}
title={t("knowledgeBase.adminCategories.actions.editCategory", { title: item.title })}
className="hover:bg-secondary/90 focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden"
>
<PencilIcon className="group-hover:text-muted-foreground h-4 w-4 text-gray-300" />
</Link>
<button
type="button"
aria-label={t("knowledgeBase.adminCategories.actions.duplicateCategory", { title: item.title })}
title={t("knowledgeBase.adminCategories.actions.duplicateCategory", { title: item.title })}
onClick={() => onDuplicate(item)}
className="hover:bg-secondary/90 focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden"
>
<DocumentDuplicateIconFilled className="hover:text-muted-foreground h-4 w-4 text-gray-300" />
</button>
<button
type="button"
aria-label={t("knowledgeBase.adminCategories.actions.addArticleFirst", { title: item.title })}
title={t("knowledgeBase.adminCategories.actions.addArticleFirst", { title: item.title })}
onClick={() => onNewArticle(item.id, undefined, "first")}
className="hover:bg-secondary/90 focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden"
>
<PlusIcon className="hover:text-muted-foreground h-4 w-4 text-gray-300" />
</button>
</div>
</div>
</div>
</div>
{toggledCategories.includes(item.id) && (
<CategorySections
kb={data.knowledgeBase}
category={item}
onDeleteSection={onDeleteSection}
onNewArticle={onNewArticle}
onDeleteArticle={onDeleteArticle}
onUpdateArticleTitle={onUpdateArticleTitle}
/>
)}
</div>
</div>
);
})}
<Link
to={`new`}
className="focus:ring-ring border-border hover:border-border relative block w-full rounded-lg border-2 border-dashed px-12 py-6 text-center focus:ring-2 focus:ring-offset-2 focus:outline-hidden"
>
<PlusIcon className="text-foreground mx-auto h-5" />
<span className="text-foreground mt-2 block text-sm font-medium">{t("knowledgeBase.adminCategories.actions.addNewCategory")}</span>
</Link>
</div>
<ConfirmModal ref={confirmDeleteCategory} onYes={onConfirmedDeleteCategory} destructive />
<ConfirmModal ref={confirmDeleteSection} onYes={onConfirmedDeleteSection} destructive />
<ConfirmModal ref={confirmDeleteArticle} onYes={onConfirmedDeleteArticle} destructive />
<ActionResultModal actionData={actionData} showSuccess={false} />
<SlideOverWideEmpty
title={getOutletTitle()}
open={!!outlet}
onClose={() => {
navigate(".", { replace: true });
}}
className="sm:max-w-sm"
overflowYScroll={true}
>
<div className="-mx-1 -mt-3">
<div className="space-y-4">{outlet}</div>
</div>
</SlideOverWideEmpty>
</EditPageLayout>
);
}
function CategorySections({
kb,
category,
onDeleteSection,
onNewArticle,
onDeleteArticle,
onUpdateArticleTitle,
}: {
kb: KnowledgeBaseDto;
category: KnowledgeBaseCategoryWithDetails;
onDeleteSection: (section: { id: string; title: string }) => void;
onNewArticle: (categoryId: string, sectionId: string | undefined, position: "first" | "last") => void;
onDeleteArticle: (article: { id: string; title: string }) => void;
onUpdateArticleTitle: (article: { id: string; title: string }) => void;
}) {
const { t } = useTranslation();
const formatters = useLocaleFormatters();
const [toggledSections, setToggledSections] = useState<string[]>([]);
const articles = category.articles.filter((f) => !f.sectionId).sort((a, b) => a.order - b.order);
return (
<div className="space-y-2 pb-2">
<div className="border-border bg-secondary w-full space-y-2 rounded-md border px-2 py-2">
<div className="text-foreground/80 text-sm font-medium">{t("knowledgeBase.adminCategories.sections.articles")}</div>
<div className="space-y-2">
<ArticlesList kb={kb} articles={articles} onUpdateArticleTitle={onUpdateArticleTitle} onDeleteArticle={onDeleteArticle} />
<button
type="button"
onClick={() => onNewArticle(category.id, undefined, "last")}
className="focus:ring-ring border-border hover:border-border relative block w-full rounded-lg border-2 border-dashed px-12 py-4 text-center focus:ring-2 focus:ring-offset-2 focus:outline-hidden"
>
<span className="text-muted-foreground block text-xs font-medium">
{t("knowledgeBase.adminCategories.actions.addArticleTo", { title: category.title })}
</span>
</button>
</div>
<div className="text-foreground/80 text-sm font-medium">{t("knowledgeBase.adminCategories.sections.sections")}</div>
<div className="space-y-2">
{category.sections.map((item, idx) => {
return (
<div key={idx} className="border-border bg-background rounded-md border px-4 py-0.5 shadow-2xs">
<div className="space-y-2">
<div className="flex items-center justify-between space-x-2">
<div className="flex items-center space-x-2 truncate">
<div className="flex items-center space-x-3 truncate">
<div className="hidden shrink-0 sm:flex">
<OrderListButtons
formData={{
categoryId: item.id,
}}
actionName="set-section-orders"
index={idx}
items={category.sections}
editable={true}
/>
</div>
<div className="text-foreground flex items-center space-x-2 truncate text-sm">
<div className="flex items-baseline space-x-1 truncate">
<div className="flex flex-col">
<div className="flex items-baseline space-x-2">
<div>{item.title}</div>
<div>•</div>
<div className="text-muted-foreground truncate text-xs">
{t("knowledgeBase.adminCategories.counts.articles", {
count: category.articles.filter((f) => f.sectionId === item.id).length,
formattedCount: formatters.number(category.articles.filter((f) => f.sectionId === item.id).length),
})}
</div>
</div>
{/* <div className="text-xs text-muted-foreground">{item.description}</div> */}
</div>
</div>
</div>
</div>
</div>
<div className="flex shrink-0 space-x-1">
<div className="flex items-center space-x-1 truncate p-1">
<DeleteButton
onDelete={() => onDeleteSection(item)}
canDelete={category.articles.filter((f) => f.sectionId === item.id).length === 0}
label={t("knowledgeBase.adminCategories.actions.deleteSection")}
/>
<button
type="button"
aria-label={t("knowledgeBase.adminCategories.actions.toggleSection", { title: item.title })}
title={t("knowledgeBase.adminCategories.actions.toggleSection", { title: item.title })}
onClick={() => {
setToggledSections((prev) => {
if (prev.includes(item.id)) {
return prev.filter((f) => f !== item.id);
}
return [...prev, item.id];
});
}}
className="hover:bg-secondary/90 focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden"
>
<FolderIconFilled className="hover:text-muted-foreground h-4 w-4 text-gray-300" />
</button>
<Link
to={`${category.id}/sections/${item.id}`}
aria-label={t("knowledgeBase.adminCategories.actions.editSection", { title: item.title })}
title={t("knowledgeBase.adminCategories.actions.editSection", { title: item.title })}
className="hover:bg-secondary/90 focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden"
>
<PencilIcon className="group-hover:text-muted-foreground h-4 w-4 text-gray-300" />
</Link>
<button
type="button"
aria-label={t("knowledgeBase.adminCategories.actions.addArticleFirst", { title: item.title })}
title={t("knowledgeBase.adminCategories.actions.addArticleFirst", { title: item.title })}
onClick={() => onNewArticle(category.id, item.id, "first")}
className="hover:bg-secondary/90 focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden"
>
<PlusIcon className="hover:text-muted-foreground h-4 w-4 text-gray-300" />
</button>
</div>
</div>
</div>
</div>
{toggledSections.includes(item.id) && (
<SectionArticles
kb={kb}
category={category}
section={item}
onNewArticle={onNewArticle}
onUpdateArticleTitle={onUpdateArticleTitle}
onDeleteArticle={onDeleteArticle}
/>
)}
</div>
);
})}
<Link
to={`${category.id}/sections/new`}
className="focus:ring-ring border-border hover:border-border relative block w-full rounded-lg border-2 border-dashed px-12 py-4 text-center focus:ring-2 focus:ring-offset-2 focus:outline-hidden"
>
<span className="text-muted-foreground block text-xs font-medium">{t("knowledgeBase.adminCategories.actions.addSection")}</span>
</Link>
</div>
</div>
</div>
);
}
function SectionArticles({
kb,
category,
section,
onNewArticle,
onUpdateArticleTitle,
onDeleteArticle,
}: {
kb: KnowledgeBaseDto;
category: KnowledgeBaseCategoryWithDetails;
section: { id: string; order: number; title: string; description: string };
onNewArticle: (categoryId: string, sectionId: string, position: "first" | "last") => void;
onUpdateArticleTitle: (article: { id: string; title: string }) => void;
onDeleteArticle: (article: { id: string; title: string }) => void;
}) {
const { t } = useTranslation();
const articles = category.articles.filter((f) => f.sectionId === section.id).sort((a, b) => a.order - b.order);
return (
<div className="space-y-2 pb-2">
<div className="border-border bg-secondary w-full space-y-2 rounded-md border px-2 py-2">
<div className="space-y-2">
<ArticlesList kb={kb} articles={articles} onUpdateArticleTitle={onUpdateArticleTitle} onDeleteArticle={onDeleteArticle} />
{/* {articles.map((item, idx) => {
return (
<div key={idx} className="rounded-md border border-border bg-background px-4 py-0.5 shadow-2xs">
<div className="space-y-2">
<div className="flex items-center justify-between space-x-2">
<div className="flex items-center space-x-2 truncate">
<div className=" flex items-center space-x-3 truncate">
<div className="hidden shrink-0 sm:flex">
<OrderListButtons actionName="set-article-orders" index={idx} items={articles} editable={true} />
</div>
<div className="flex items-center space-x-2 truncate text-sm text-foreground">
<div className="flex items-baseline space-x-1 truncate">
<div className="flex flex-col">
<div className="flex items-center space-x-2">
<ColorBadge color={item.publishedAt ? Colors.GREEN : Colors.YELLOW} />
<div className="flex items-baseline space-x-1">{item.title}</div>
</div>
</div>
</div>
</div>
</div>
</div>
<div className="flex shrink-0 space-x-1">
<div className="flex items-center space-x-1 truncate p-1">
<Link
to={adminPath(`knowledge-base/bases/${kb.slug}/articles/${item.language}/${item.id}`, { mode: "host-aware" })}
className="group flex items-center rounded-md border border-transparent p-2 hover:bg-secondary/90 focus:bg-secondary/90 focus:outline-hidden focus:ring-2 focus:ring-gray-400 focus:ring-offset-1"
>
<PencilIcon className="h-4 w-4 text-gray-300 group-hover:text-muted-foreground" />
</Link>
<button
type="button"
className="group flex items-center rounded-md border border-transparent p-2 hover:bg-secondary/90 focus:bg-secondary/90 focus:outline-hidden focus:ring-2 focus:ring-gray-400 focus:ring-offset-1"
onClick={() => onDeleteArticle(item)}
>
<TrashIcon className="h-4 w-4 text-gray-300 group-hover:text-muted-foreground" />
</button>
</div>
</div>
</div>
</div>
</div>
);
})} */}
<button
type="button"
onClick={() => onNewArticle(category.id, section.id, "last")}
className="focus:ring-ring border-border hover:border-border relative block w-full rounded-lg border-2 border-dashed px-12 py-4 text-center focus:ring-2 focus:ring-offset-2 focus:outline-hidden"
>
<span className="text-muted-foreground block text-xs font-medium">
{t("knowledgeBase.adminCategories.actions.addArticleTo", { title: section.title })}
</span>
</button>
</div>
</div>
</div>
);
}
function ArticlesList({
kb,
articles,
onUpdateArticleTitle,
onDeleteArticle,
}: {
kb: KnowledgeBaseDto;
articles: {
id: string;
order: number;
title: string;
description: string;
slug: string;
language: string;
sectionId: string | null;
publishedAt: Date | null;
}[];
onUpdateArticleTitle: (article: { id: string; title: string }) => void;
onDeleteArticle: (article: { id: string; title: string }) => void;
}) {
const { t } = useTranslation();
const handleUpdateArticleTitle = (articleId: string, newTitle: string) => {
const article = articles.find((article) => article.id === articleId);
if (article) {
const updatedArticle = { ...article, title: newTitle };
onUpdateArticleTitle(updatedArticle);
}
};
return (
<DraggableList
className="space-y-1"
items={articles}
actionName="set-article-orders"
render={(item) => {
return (
<div className="border-border bg-background rounded-md border px-4 py-0.5 shadow-2xs">
<div className="space-y-2">
<div className="flex items-center justify-between space-x-2">
<div className="flex items-center space-x-2 truncate">
<div className="flex items-center space-x-3 truncate">
{/* <div className="hidden shrink-0 sm:flex">
<OrderListButtons actionName="set-article-orders" index={idx} items={articles} editable={true} />
</div> */}
<div className="text-foreground flex items-center space-x-2 truncate text-sm">
<div className="flex items-baseline space-x-1 truncate">
<div className="flex flex-col">
<div className="flex items-center space-x-2">
<ColorBadge color={item.publishedAt ? Colors.GREEN : Colors.YELLOW} />
<div className="flex flex-col">
<div
className="text-foreground flex cursor-text items-baseline space-x-1 text-sm focus:outline-hidden"
contentEditable
suppressContentEditableWarning
onBlur={(event) => handleUpdateArticleTitle(item.id, event.target.innerText)}
onPaste={(event) => {
event.preventDefault();
const plainText = event.clipboardData.getData("text/plain");
(event.target as HTMLElement).textContent = plainText;
}}
>
{item.title || t("knowledgeBase.adminCategories.untitledArticle")}
</div>
<div className="text-muted-foreground text-xs">
{KnowledgeBaseUtils.getArticleUrl({
kb,
article: item,
params: {},
})}
</div>
</div>
</div>
{/* <div className="text-xs text-muted-foreground">{item.description}</div> */}
</div>
</div>
</div>
</div>
</div>
<div className="flex shrink-0 space-x-1">
<div className="flex items-center space-x-1 truncate p-1">
<Link
to={adminPath(`knowledge-base/bases/${kb.slug}/articles/${item.language}/${item.id}`, { mode: "host-aware" })}
aria-label={t("knowledgeBase.adminCategories.actions.editArticle", { title: item.title })}
title={t("knowledgeBase.adminCategories.actions.editArticle", { title: item.title })}
className="hover:bg-secondary/90 focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden"
>
<PencilIcon className="group-hover:text-muted-foreground h-4 w-4 text-gray-300" />
</Link>
<button
type="button"
aria-label={t("knowledgeBase.adminCategories.actions.deleteArticle")}
title={t("knowledgeBase.adminCategories.actions.deleteArticle")}
className="hover:bg-secondary/90 focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden"
onClick={() => onDeleteArticle(item)}
>
<TrashIcon className="group-hover:text-muted-foreground h-4 w-4 text-gray-300" />
</button>
</div>
</div>
</div>
</div>
</div>
);
}}
/>
);
}
function DeleteButton({ onDelete, canDelete, label }: { onDelete: () => void; canDelete: boolean; label: string }) {
return (
<button
type="button"
aria-label={label}
title={label}
className={clsx(
"focus:bg-secondary/90 group flex items-center rounded-md border border-transparent p-2 focus:ring-2 focus:ring-gray-400 focus:ring-offset-1 focus:outline-hidden",
!canDelete ? "cursor-not-allowed opacity-50" : "hover:bg-secondary/90"
)}
disabled={!canDelete}
onClick={onDelete}
>
<TrashIcon className={clsx("h-4 w-4 text-gray-300", canDelete && "group-hover:text-muted-foreground")} />
</button>
);
}
@@ -0,0 +1,136 @@
import { ActionFunctionArgs, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useParams, useSubmit } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import KbCategorySectionForm from "~/modules/knowledgeBase/components/bases/KbCategorySectionForm";
import { updateKnowledgeBaseArticleOrderInSection } from "~/modules/knowledgeBase/db/kbArticles.db.server";
import { getKbCategoryByIdInKnowledgeBase } from "~/modules/knowledgeBase/db/kbCategories.db.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import {
KnowledgeBaseCategorySectionWithDetails,
deleteKnowledgeBaseCategorySectionInCategory,
getKbCategorySectionByIdInCategory,
updateKnowledgeBaseCategorySectionInCategory,
} from "~/modules/knowledgeBase/db/kbCategorySections.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import { KnowledgeBaseCategoryWithDetails } from "~/modules/knowledgeBase/helpers/KbCategoryModelHelper";
import KnowledgeBaseService, { getKnowledgeBaseActionErrorKey } from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { validateCSRFToken } from "~/utils/session.server";
import { appendCSRFToken } from "~/utils/csrf";
type LoaderData = {
knowledgeBase: KnowledgeBaseDto;
category: KnowledgeBaseCategoryWithDetails;
item: KnowledgeBaseCategorySectionWithDetails;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
const category = await getKbCategoryByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!category) {
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
}
const item = await getKbCategorySectionByIdInCategory({ id: params.section!, categoryId: category.id });
if (!item) {
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}/${params.id}`, { mode: "host-aware" }));
}
const data: LoaderData = {
knowledgeBase,
category,
item,
};
return data;
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.update");
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const form = await request.formData();
const action = form.get("action")?.toString();
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (!knowledgeBase) {
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
}
const category = await getKbCategoryByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!category) {
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
}
const item = await getKbCategorySectionByIdInCategory({ id: params.section!, categoryId: category.id });
if (!item) {
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}/${params.id}`, { mode: "host-aware" }));
}
if (action === "edit") {
await verifyUserHasPermission(request, "admin.kb.update");
const order = Number(form.get("order")?.toString() ?? "");
const title = form.get("title")?.toString() ?? "";
const description = form.get("description")?.toString() ?? "";
try {
const result = await updateKnowledgeBaseCategorySectionInCategory(
{ id: item.id, categoryId: category.id },
{
order,
title,
description,
}
);
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.admin.errors.sectionNotFound") }, { status: 404 });
}
} catch (e: unknown) {
return Response.json({ error: t(getKnowledgeBaseActionErrorKey(e)) }, { status: 400 });
}
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
} else if (action === "delete") {
await verifyUserHasPermission(request, "admin.kb.delete");
const result = await deleteKnowledgeBaseCategorySectionInCategory({ id: item.id, categoryId: category.id });
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.admin.errors.sectionNotFound") }, { status: 404 });
}
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
} else if (action === "set-orders") {
await verifyUserHasPermission(request, "admin.kb.update");
const items: { id: string; order: number }[] = form.getAll("orders[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
await Promise.all(
items.map(async ({ id, order }) => {
await updateKnowledgeBaseArticleOrderInSection({ id, sectionId: item.id, order: Number(order) });
})
);
return Response.json({ updated: true });
} else {
return Response.json({ error: t("knowledgeBase.admin.errors.invalidForm") }, { status: 400 });
}
};
export default function () {
const data = useLoaderData<LoaderData>();
const submit = useSubmit();
const params = useParams();
function onDelete() {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "delete");
submit(form, {
method: "post",
});
}
return (
<div>
<KbCategorySectionForm knowledgeBase={data.knowledgeBase} category={data.category} language={params.lang!} item={data.item} onDelete={onDelete} />
</div>
);
}
@@ -0,0 +1,87 @@
import { ActionFunctionArgs, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import KbCategorySectionForm from "~/modules/knowledgeBase/components/bases/KbCategorySectionForm";
import { getKbCategoryByIdInKnowledgeBase } from "~/modules/knowledgeBase/db/kbCategories.db.server";
import { createKnowledgeBaseCategorySection } from "~/modules/knowledgeBase/db/kbCategorySections.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import { KnowledgeBaseCategoryWithDetails } from "~/modules/knowledgeBase/helpers/KbCategoryModelHelper";
import KnowledgeBaseService, { getKnowledgeBaseActionErrorKey } from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
knowledgeBase: KnowledgeBaseDto;
category: KnowledgeBaseCategoryWithDetails;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
const category = await getKbCategoryByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!category) {
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
}
const data: LoaderData = {
knowledgeBase,
category,
};
return data;
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.update");
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const form = await request.formData();
const action = form.get("action")?.toString();
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
const category = await getKbCategoryByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!category) {
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
}
if (action === "new") {
await verifyUserHasPermission(request, "admin.kb.create");
const title = form.get("title")?.toString() ?? "";
const description = form.get("description")?.toString() ?? "";
let maxOrder = 0;
if (category.sections.length > 0) {
maxOrder = Math.max(...category.sections.map((i) => i.order));
}
try {
await createKnowledgeBaseCategorySection({
categoryId: category.id,
order: maxOrder + 1,
title,
description,
});
} catch (e: unknown) {
return Response.json({ error: t(getKnowledgeBaseActionErrorKey(e)) }, { status: 400 });
}
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
} else {
return Response.json({ error: t("knowledgeBase.admin.errors.invalidForm") }, { status: 400 });
}
};
export default function () {
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<div>
<KbCategorySectionForm knowledgeBase={data.knowledgeBase} category={data.category} language={params.lang!} />
</div>
);
}
@@ -0,0 +1,152 @@
import { ActionFunctionArgs, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useParams, useSubmit } from "react-router";
import { useRef } from "react";
import { useTranslation } from "react-i18next";
import ConfirmModal, { RefConfirmModal } from "~/components/ui/modals/ConfirmModal";
import { getTranslations } from "~/locale/i18next.server";
import KbCategoryForm from "~/modules/knowledgeBase/components/bases/KbCategoryForm";
import { updateKnowledgeBaseArticleOrderInCategory } from "~/modules/knowledgeBase/db/kbArticles.db.server";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import {
deleteKnowledgeBaseCategoryInKnowledgeBase,
getKbCategoryByIdInKnowledgeBase,
getKbCategoryBySlug,
updateKnowledgeBaseCategoryInKnowledgeBase,
} from "~/modules/knowledgeBase/db/kbCategories.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import { KnowledgeBaseCategoryWithDetails } from "~/modules/knowledgeBase/helpers/KbCategoryModelHelper";
import KnowledgeBaseService, { getKnowledgeBaseActionErrorKey } from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { validateCSRFToken } from "~/utils/session.server";
import { appendCSRFToken } from "~/utils/csrf";
type LoaderData = {
knowledgeBase: KnowledgeBaseDto;
item: KnowledgeBaseCategoryWithDetails;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
const item = await getKbCategoryByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!item) {
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
}
const data: LoaderData = {
knowledgeBase,
item,
};
return data;
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.update");
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const form = await request.formData();
const action = form.get("action")?.toString();
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
const item = await getKbCategoryByIdInKnowledgeBase({ id: params.id!, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (!item) {
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
}
if (action === "edit") {
const slug = form.get("slug")?.toString() ?? "";
const title = form.get("title")?.toString() ?? "";
const description = form.get("description")?.toString() ?? "";
const icon = form.get("icon")?.toString() ?? "";
const seoImage = form.get("seoImage")?.toString() ?? "";
const existing = await getKbCategoryBySlug({
knowledgeBaseId: knowledgeBase.id,
slug,
language: params.lang!,
});
if (existing && existing.id !== item.id) {
return Response.json({ error: t("knowledgeBase.admin.errors.slugAlreadyExists") }, { status: 400 });
}
try {
const result = await updateKnowledgeBaseCategoryInKnowledgeBase(
{ id: item.id, knowledgeBaseId: knowledgeBase.id, language: params.lang! },
{
slug,
title,
description,
icon,
language: params.lang!,
seoImage,
}
);
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.admin.errors.categoryNotFound") }, { status: 404 });
}
} catch (e: unknown) {
return Response.json({ error: t(getKnowledgeBaseActionErrorKey(e)) }, { status: 400 });
}
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
} else if (action === "delete") {
await verifyUserHasPermission(request, "admin.kb.delete");
const result = await deleteKnowledgeBaseCategoryInKnowledgeBase({ id: item.id, knowledgeBaseId: knowledgeBase.id, language: params.lang! });
if (result.count !== 1) {
return Response.json({ error: t("knowledgeBase.admin.errors.categoryNotFound") }, { status: 404 });
}
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
} else if (action === "set-orders") {
const items: { id: string; order: number }[] = form.getAll("orders[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
await Promise.all(
items.map(async ({ id, order }) => {
await updateKnowledgeBaseArticleOrderInCategory({ id, categoryId: item.id, order: Number(order) });
})
);
return Response.json({ updated: true });
} else {
return Response.json({ error: t("knowledgeBase.admin.errors.invalidForm") }, { status: 400 });
}
};
export default function () {
const data = useLoaderData<LoaderData>();
const submit = useSubmit();
const params = useParams();
const { t } = useTranslation();
const confirmDelete = useRef<RefConfirmModal>(null);
function onDelete() {
confirmDelete.current?.show(
t("knowledgeBase.adminCategories.confirmDelete.category.title"),
t("shared.delete"),
t("shared.cancel"),
t("knowledgeBase.adminCategories.confirmDelete.category.description", { title: data.item.title })
);
}
function onConfirmedDelete() {
const form = new FormData();
appendCSRFToken(form);
form.set("action", "delete");
submit(form, {
method: "post",
});
}
return (
<div>
<KbCategoryForm knowledgeBase={data.knowledgeBase} language={params.lang!} item={data.item} onDelete={onDelete} />
<ConfirmModal ref={confirmDelete} onYes={onConfirmedDelete} destructive />
</div>
);
}
@@ -0,0 +1,95 @@
import { ActionFunctionArgs, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import KbCategoryForm from "~/modules/knowledgeBase/components/bases/KbCategoryForm";
import { createKnowledgeBaseCategory, getAllKnowledgeBaseCategories, getKbCategoryBySlug } from "~/modules/knowledgeBase/db/kbCategories.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import KnowledgeBaseService, { getKnowledgeBaseActionErrorKey } from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
knowledgeBase: KnowledgeBaseDto;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
const data: LoaderData = {
knowledgeBase,
};
return data;
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.update");
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const form = await request.formData();
const action = form.get("action")?.toString();
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (action === "new") {
await verifyUserHasPermission(request, "admin.kb.create");
const slug = form.get("slug")?.toString() ?? "";
const title = form.get("title")?.toString() ?? "";
const description = form.get("description")?.toString() ?? "";
const icon = form.get("icon")?.toString() ?? "";
const seoImage = form.get("seoImage")?.toString() ?? "";
const allCategories = await getAllKnowledgeBaseCategories({
knowledgeBaseSlug: params.slug!,
language: params.lang!,
});
let maxOrder = 0;
if (allCategories.length > 0) {
maxOrder = Math.max(...allCategories.map((i) => i.order));
}
const existing = await getKbCategoryBySlug({
knowledgeBaseId: knowledgeBase.id,
slug,
language: params.lang!,
});
if (existing) {
return Response.json({ error: t("knowledgeBase.admin.errors.slugAlreadyExists") }, { status: 400 });
}
try {
await createKnowledgeBaseCategory({
knowledgeBaseId: knowledgeBase.id,
slug,
title,
description,
icon,
language: params.lang!,
seoImage,
order: maxOrder + 1,
});
} catch (e: unknown) {
return Response.json({ error: t(getKnowledgeBaseActionErrorKey(e)) }, { status: 400 });
}
return redirect(adminPath(`knowledge-base/bases/${params.slug}/categories/${params.lang}`, { mode: "host-aware" }));
} else {
return Response.json({ error: t("knowledgeBase.admin.errors.invalidForm") }, { status: 400 });
}
};
export default function () {
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<div>
<KbCategoryForm knowledgeBase={data.knowledgeBase} language={params.lang!} />
</div>
);
}
@@ -0,0 +1,72 @@
import { LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { Link, useParams } from "react-router";
import { useTranslation } from "react-i18next";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { getAllKnowledgeBaseCategories } from "~/modules/knowledgeBase/db/kbCategories.db.server";
import { KnowledgeBaseDto } from "~/modules/knowledgeBase/dtos/KnowledgeBaseDto";
import { KnowledgeBaseCategoryWithDetails } from "~/modules/knowledgeBase/helpers/KbCategoryModelHelper";
import KnowledgeBaseService from "~/modules/knowledgeBase/service/KnowledgeBaseService.server";
import KnowledgeBaseUtils from "~/modules/knowledgeBase/utils/KnowledgeBaseUtils";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { adminPath } from "~/utils/app/CanonicalUrlUtils";
type LoaderData = {
knowledgeBase: KnowledgeBaseDto;
items: KnowledgeBaseCategoryWithDetails[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await verifyUserHasPermission(request, "admin.kb.view");
const knowledgeBase = await KnowledgeBaseService.get({
slug: params.slug!,
request,
});
if (!knowledgeBase) {
return redirect(adminPath("knowledge-base/bases", { mode: "host-aware" }));
}
const items = await getAllKnowledgeBaseCategories({
knowledgeBaseSlug: params.slug!,
language: undefined,
});
const data: LoaderData = {
knowledgeBase,
items,
};
return data;
};
export default function () {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout
title={t("knowledgeBase.authoring.categories.title")}
withHome={false}
menu={[
{ title: t("knowledgeBase.authoring.breadcrumbs.knowledgeBases"), routePath: adminPath("knowledge-base/bases", { mode: "host-aware" }) },
{ title: data.knowledgeBase.title, routePath: adminPath(`knowledge-base/bases/${data.knowledgeBase.slug}`, { mode: "host-aware" }) },
{
title: t("knowledgeBase.authoring.breadcrumbs.categories"),
routePath: adminPath(`knowledge-base/bases/${params.slug}/categories`, { mode: "host-aware" }),
},
]}
>
<div className="space-y-2">
{data.knowledgeBase.languages.map((f) => {
return (
<div key={f} className="space-y-2">
<Link
to={f}
className="border-border hover:border-border relative block space-y-2 rounded-lg border-2 border-dashed px-12 py-6 text-center focus:border-solid focus:outline-hidden"
>
<div className="font-bold">{KnowledgeBaseUtils.getLanguageName(f, t)}</div>
<div className="text-sm">
{t("knowledgeBase.authoring.categories.count", { count: data.items.filter((x) => x.language === f).length })}
</div>
</Link>
</div>
);
})}
</div>
</EditPageLayout>
);
}