106 lines
3.8 KiB
TypeScript
106 lines
3.8 KiB
TypeScript
import { BadRequestException, Injectable } from "@nestjs/common";
|
|
import {
|
|
type BrandTemplateKey,
|
|
brandTemplateKeys,
|
|
getBrandTemplate,
|
|
getVisualTemplate,
|
|
getVisualTemplateManifest,
|
|
isVisualTemplateCompatible,
|
|
validateTemplatePackageManifest,
|
|
} from "@personal-brand/config";
|
|
import { PrismaService } from "../prisma.service.js";
|
|
import { compareTemplateVersions } from "../template-version-order.js";
|
|
import { record } from "./manifest-diff.helpers.js";
|
|
|
|
@Injectable()
|
|
export class PageSchemeService {
|
|
constructor(private readonly prisma: PrismaService) {}
|
|
|
|
async getPageSchemeCatalog() {
|
|
const versions = await this.prisma.templatePackageVersion.findMany({
|
|
where: { status: "published" },
|
|
orderBy: [{ importedAt: "desc" }, { createdAt: "desc" }],
|
|
});
|
|
const candidates = versions.flatMap((version) => {
|
|
const manifest = record(version.manifestSnapshot);
|
|
const visualTemplateKey = manifest.visualTemplateKey;
|
|
if (
|
|
manifest.packageKey !== version.packageKey ||
|
|
manifest.version !== version.version ||
|
|
typeof visualTemplateKey !== "string" ||
|
|
visualTemplateKey !== version.packageKey
|
|
)
|
|
return [];
|
|
const visualTemplate = getVisualTemplate(visualTemplateKey);
|
|
const visualManifest = getVisualTemplateManifest(visualTemplateKey);
|
|
if (!visualTemplate || !visualManifest) return [];
|
|
const supportedBusinessTypes = Array.isArray(manifest.supportedIndustryTemplates)
|
|
? manifest.supportedIndustryTemplates.filter(
|
|
(value): value is BrandTemplateKey =>
|
|
typeof value === "string" &&
|
|
brandTemplateKeys.includes(value) &&
|
|
Boolean(getBrandTemplate(value)),
|
|
)
|
|
: [];
|
|
if (
|
|
supportedBusinessTypes.length === 0 ||
|
|
supportedBusinessTypes.some(
|
|
(businessType) => !isVisualTemplateCompatible(visualTemplate, businessType),
|
|
) ||
|
|
validateTemplatePackageManifest(manifest).length > 0
|
|
)
|
|
return [];
|
|
return [
|
|
{
|
|
templatePackageVersionId: version.id,
|
|
packageKey: version.packageKey,
|
|
name: version.displayName,
|
|
description: visualManifest.description,
|
|
version: version.version,
|
|
supportedBusinessTypes,
|
|
},
|
|
];
|
|
});
|
|
const latestByPackage = new Map<string, string>();
|
|
for (const candidate of candidates) {
|
|
const latestVersion = latestByPackage.get(candidate.packageKey);
|
|
if (!latestVersion || compareTemplateVersions(candidate.version, latestVersion) > 0) {
|
|
latestByPackage.set(candidate.packageKey, candidate.version);
|
|
}
|
|
}
|
|
const pageSchemes = candidates.map(({ packageKey, ...candidate }) => ({
|
|
...candidate,
|
|
isLatestForPackage: latestByPackage.get(packageKey) === candidate.version,
|
|
}));
|
|
|
|
return {
|
|
businesses: brandTemplateKeys.map((key) => {
|
|
const template = getBrandTemplate(key);
|
|
if (!template) throw new BadRequestException("业务类型配置不完整");
|
|
return { key, name: template.name, description: template.description };
|
|
}),
|
|
pageSchemes,
|
|
};
|
|
}
|
|
|
|
async getPageSchemeOptions(brandId: string) {
|
|
const brand = await this.prisma.brandProfile.findUnique({
|
|
where: { id: brandId },
|
|
select: { templateKey: true },
|
|
});
|
|
const template = brand ? getBrandTemplate(brand.templateKey) : undefined;
|
|
if (!brand || !template) throw new BadRequestException("品牌业务类型无效");
|
|
const catalog = await this.getPageSchemeCatalog();
|
|
return {
|
|
business: {
|
|
key: template.key,
|
|
name: template.name,
|
|
description: template.description,
|
|
},
|
|
pageSchemes: catalog.pageSchemes.filter((scheme) =>
|
|
scheme.supportedBusinessTypes.includes(template.key),
|
|
),
|
|
};
|
|
}
|
|
}
|