mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
197 lines
7.7 KiB
TypeScript
197 lines
7.7 KiB
TypeScript
import { Badge, Button, List } from "@usememos/ui";
|
|
import { useEffect, useMemo, useState } from "react";
|
|
import InfoChip from "@/components/Settings/InfoChip";
|
|
import { getIdentityProviderTypeLabel, getSSOProviderUid } from "@/components/Settings/sso-display";
|
|
import { identityProviderServiceClient, userServiceClient } from "@/connect";
|
|
import { findManagedResource, useConfigurationStatus } from "@/hooks/useConfigurationQueries";
|
|
import useCurrentUser from "@/hooks/useCurrentUser";
|
|
import { absolutifyLink } from "@/lib/browser";
|
|
import { handleError } from "@/lib/error";
|
|
import { showErrorToast, toast } from "@/lib/toast";
|
|
import { IdentityProvider, IdentityProvider_Type } from "@/types/proto/api/idp_service_pb";
|
|
import { LinkedIdentity } from "@/types/proto/api/user_service_pb";
|
|
import { useTranslate } from "@/utils/i18n";
|
|
import { storeOAuthState } from "@/utils/oauth";
|
|
import ManagedByConfigurationChip from "./ManagedByConfigurationChip";
|
|
import SettingGroup from "./SettingGroup";
|
|
import { SettingList } from "./SettingList";
|
|
|
|
interface LinkedIdentityRow {
|
|
name: string;
|
|
providerUid: string;
|
|
title: string;
|
|
typeLabel: string;
|
|
externalUid: string;
|
|
isLinked: boolean;
|
|
linkedIdentity?: LinkedIdentity;
|
|
identityProvider: IdentityProvider;
|
|
}
|
|
|
|
const LinkedIdentitySection = () => {
|
|
const t = useTranslate();
|
|
const currentUser = useCurrentUser();
|
|
const configurationStatus = useConfigurationStatus();
|
|
const [identityProviderList, setIdentityProviderList] = useState<IdentityProvider[]>([]);
|
|
const [linkedIdentityList, setLinkedIdentityList] = useState<LinkedIdentity[]>([]);
|
|
|
|
const fetchData = async () => {
|
|
if (!currentUser?.name) {
|
|
return;
|
|
}
|
|
const [{ identityProviders }, { linkedIdentities }] = await Promise.all([
|
|
identityProviderServiceClient.listIdentityProviders({}),
|
|
userServiceClient.listLinkedIdentities({ parent: currentUser.name }),
|
|
]);
|
|
setIdentityProviderList(identityProviders);
|
|
setLinkedIdentityList(linkedIdentities);
|
|
};
|
|
|
|
useEffect(() => {
|
|
if (!currentUser?.name) {
|
|
return;
|
|
}
|
|
fetchData().catch((error: unknown) => {
|
|
handleError(error, showErrorToast, {
|
|
context: "Load linked identities",
|
|
});
|
|
});
|
|
}, [currentUser?.name]);
|
|
|
|
const oauthIdentityProviders = useMemo(
|
|
() => identityProviderList.filter((identityProvider) => identityProvider.type === IdentityProvider_Type.OAUTH2),
|
|
[identityProviderList],
|
|
);
|
|
|
|
const linkedIdentityByProviderName = useMemo(() => {
|
|
const mapping = new Map<string, LinkedIdentity>();
|
|
for (const linkedIdentity of linkedIdentityList) {
|
|
if (!mapping.has(linkedIdentity.identityProvider)) {
|
|
mapping.set(linkedIdentity.identityProvider, linkedIdentity);
|
|
}
|
|
}
|
|
return mapping;
|
|
}, [linkedIdentityList]);
|
|
|
|
const rows = useMemo<LinkedIdentityRow[]>(
|
|
() =>
|
|
oauthIdentityProviders.map((identityProvider) => {
|
|
const linkedIdentity = linkedIdentityByProviderName.get(identityProvider.name);
|
|
return {
|
|
name: identityProvider.name,
|
|
providerUid: getSSOProviderUid(identityProvider.name),
|
|
title: identityProvider.title,
|
|
typeLabel: getIdentityProviderTypeLabel(identityProvider.type),
|
|
externalUid: linkedIdentity?.externalUid ?? "",
|
|
isLinked: !!linkedIdentity,
|
|
linkedIdentity,
|
|
identityProvider,
|
|
};
|
|
}),
|
|
[linkedIdentityByProviderName, oauthIdentityProviders],
|
|
);
|
|
|
|
const handleLinkIdentityProvider = async (identityProvider: IdentityProvider) => {
|
|
if (!currentUser?.name) {
|
|
return;
|
|
}
|
|
const redirectUri = absolutifyLink("/auth/callback");
|
|
const oauth2Config = identityProvider.config?.config?.case === "oauth2Config" ? identityProvider.config.config.value : undefined;
|
|
if (!oauth2Config) {
|
|
showErrorToast(t("setting.sso.invalid-config"));
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const returnUrl = `${window.location.pathname}${window.location.search}${window.location.hash}`;
|
|
const { state, codeChallenge } = await storeOAuthState(identityProvider.name, "link", returnUrl, currentUser.name);
|
|
|
|
let authUrl = `${oauth2Config.authUrl}?client_id=${
|
|
oauth2Config.clientId
|
|
}&redirect_uri=${encodeURIComponent(redirectUri)}&state=${state}&response_type=code&scope=${encodeURIComponent(
|
|
oauth2Config.scopes.join(" "),
|
|
)}`;
|
|
|
|
if (codeChallenge) {
|
|
authUrl += `&code_challenge=${codeChallenge}&code_challenge_method=S256`;
|
|
}
|
|
|
|
window.location.href = authUrl;
|
|
} catch (error) {
|
|
handleError(error, showErrorToast, {
|
|
context: "Failed to initiate OAuth flow",
|
|
fallbackMessage: t("error.link-identity-failed"),
|
|
});
|
|
}
|
|
};
|
|
|
|
const handleUnlinkIdentityProvider = async (row: LinkedIdentityRow) => {
|
|
if (!row.linkedIdentity?.name) {
|
|
return;
|
|
}
|
|
try {
|
|
await userServiceClient.deleteLinkedIdentity({
|
|
name: row.linkedIdentity.name,
|
|
});
|
|
await fetchData();
|
|
toast.add({ title: t("setting.sso.unlink-success", { name: row.title }), type: "success" });
|
|
} catch (error) {
|
|
handleError(error, showErrorToast, {
|
|
context: "Delete linked identity",
|
|
fallbackMessage: t("error.unlink-identity-failed"),
|
|
});
|
|
}
|
|
};
|
|
|
|
return (
|
|
<SettingGroup showSeparator title={t("setting.sso.accounts-title")} description={t("setting.sso.accounts-description")}>
|
|
{rows.length === 0 ? (
|
|
<p className="py-6 text-center mu-body text-mu-text-secondary">{t("setting.sso.no-sso-found")}</p>
|
|
) : (
|
|
<SettingList>
|
|
{rows.map((row) => (
|
|
<List.Item key={row.name} className="flex items-start gap-3">
|
|
<div className="min-w-0 flex-1 space-y-2">
|
|
<div className="flex flex-wrap items-center gap-2">
|
|
<span className="min-w-0 mu-label break-words text-mu-text">{row.title}</span>
|
|
<Badge size="xs">{row.typeLabel}</Badge>
|
|
</div>
|
|
<div className="flex flex-wrap items-center gap-2">
|
|
<InfoChip label={t("setting.sso.provider-uid")} value={row.providerUid} />
|
|
</div>
|
|
<div className="flex flex-wrap items-center gap-2">
|
|
<Badge tone={row.isLinked ? "neutral" : "outline"}>
|
|
{row.isLinked ? t("setting.sso.linked") : t("setting.sso.not-linked")}
|
|
</Badge>
|
|
{row.isLinked && row.externalUid ? (
|
|
<InfoChip label={t("setting.sso.extern-uid")} value={row.externalUid} tooltip={row.externalUid} />
|
|
) : null}
|
|
<ManagedByConfigurationChip resource={findManagedResource(configurationStatus, row.linkedIdentity?.name ?? "")} />
|
|
</div>
|
|
<p className="mu-caption text-mu-text-secondary">
|
|
{row.isLinked ? t("setting.sso.extern-uid-description") : t("setting.sso.not-linked-description")}
|
|
</p>
|
|
</div>
|
|
<div className="shrink-0">
|
|
{row.linkedIdentity ? (
|
|
// A link the configuration declares is unlinked in its file, not here.
|
|
findManagedResource(configurationStatus, row.linkedIdentity.name) ? null : (
|
|
<Button variant="neutral" onClick={() => handleUnlinkIdentityProvider(row)}>
|
|
{t("common.unlink")}
|
|
</Button>
|
|
)
|
|
) : (
|
|
<Button variant="neutral" onClick={() => handleLinkIdentityProvider(row.identityProvider)}>
|
|
{t("common.link")}
|
|
</Button>
|
|
)}
|
|
</div>
|
|
</List.Item>
|
|
))}
|
|
</SettingList>
|
|
)}
|
|
</SettingGroup>
|
|
);
|
|
};
|
|
|
|
export default LinkedIdentitySection;
|