refactor(client): use resource maps for enterprise templates

This commit is contained in:
WuYongJie 2026-11-12 17:26:23 +08:00
parent 748e7f0a9d
commit b21f34ad98
8 changed files with 70 additions and 258 deletions

View File

@ -1,105 +0,0 @@
import fs from 'node:fs/promises';
import path from 'node:path';
import {atomic,digest} from './store.mjs';
const key = file => JSON.stringify([file.fileId,file.revision||null]);
const snapshotFile = (root,version) => {
if (!/^files-[a-f0-9]{64}$/.test(version)) throw Error('知识库模板快照版本无效');
return path.join(root,'file-templates',version+'.json');
};
export const fileTemplateReady = entry => entry.status==='ready' && typeof entry.asset_manifest_path==='string' && !!entry.asset_manifest_path
&& typeof entry.mapping_asset_path==='string' && !!entry.mapping_asset_path;
/** Interpret the selected business files in the consumer; the library stores ordinary files. */
export async function buildFileTemplate(service,{entry,provenance},binding,task,buildPack) {
const base=path.posix.dirname(path.posix.dirname(provenance.path));
const pins=new Map(),assets=new Map();
const select=async relative=>{
const reference={fileId:path.posix.normalize(base+'/'+relative)};
await service.resolve([reference],task);
const meta=task.metadata.get(key(reference));
const fileId=meta.fileId||meta.id;
if (!fileId) throw Error('知识库模板文件缺少稳定身份');
const pin={...meta,fileId};
pins.set(fileId,pin);
task.metadata.set(key({fileId,revision:meta.revision}),pin);
return pin;
};
const read=async relative=>{
const meta=await select(relative);
const {value}=await service.json(meta.fileId,meta.revision,task);
return {meta,value};
};
const addAsset=(meta,role)=>{
let asset=assets.get(meta.fileId);
if(!asset){asset={assetId:meta.fileId,fileId:meta.fileId,path:meta.path,revision:meta.revision,sha256:meta.sha256,size:meta.size,roles:[]};assets.set(meta.fileId,asset);}
if(!asset.roles.includes(role))asset.roles.push(role);
return asset;
};
const checkBytes=(meta,sha256,size)=>{
if(meta.sha256!==sha256||meta.size!==size)throw Error('模板清单或字段映射与当前原稿版本不一致,请更新源资料');
};
const {meta:manifestMeta,value:sourceManifest}=await read(entry.asset_manifest_path);
if(sourceManifest.template_id!==entry.template_id||!Array.isArray(sourceManifest.documents))throw Error('模板资产清单与选择的模板不一致');
const parts=[['detail',entry],...['main_images','sku_images'].filter(kind=>entry[kind]?.status==='ready').map(kind=>[kind,entry[kind]])];
const components=[],mappings={};
for(const [kind,part] of parts){
const {meta:mappingMeta,value:raw}=await read(part.mapping_asset_path);
if(raw.template_id!==entry.template_id||raw.component!==kind||raw.mapping_version!==part.mapping_version)throw Error('模板字段映射与登记版本不一致');
const documents=sourceManifest.documents.filter(document=>document.component===kind);
if(!documents.length||kind==='detail'&&documents.length!==1)throw Error('模板组件原稿清单无效');
const sourceAssets=raw.source?.assets||documents.map(document=>({asset_id:document.asset_id,ps_asset_path:document.asset_path,
ps_sha256:raw.source?.sha256,ps_size_bytes:document.size_bytes,canvas_px:raw.canvas}));
const originals=[];
for(const document of documents){
const source=sourceAssets.find(source=>source.asset_id===document.asset_id);
if(!source||source.ps_asset_path!==document.asset_path||source.ps_sha256!==document.sha256
||JSON.stringify(source.canvas_px)!==JSON.stringify(document.canvas_px))throw Error('模板组件映射不属于清单原稿');
const meta=await select(document.asset_path);
checkBytes(meta,document.sha256,document.size_bytes);
originals.push(addAsset(meta,'original:'+kind).assetId);
}
const inventory=await select(part.inventory_asset_path);
addAsset(mappingMeta,'mapping:'+kind);addAsset(inventory,'inventory:'+kind);
components.push({component:kind,mappingVersion:raw.mapping_version,mappingAssetId:mappingMeta.fileId,sourceInventoryAssetId:inventory.fileId,originalAssetIds:originals});
mappings[kind]={...raw,source:{...raw.source,assets:sourceAssets,...(kind==='detail'?{sha256:documents[0].sha256}:{})},
...(kind==='detail'?{canvas:documents[0].canvas_px}:{}),fields:raw.fields.map(field=>({...field,asset_id:field.asset_id||field.ps_location?.asset_id,
ps_style:{...field.ps_style,coverage_rect:field.type==='图片'?field.ps_style.coverage_rect:field.ps_style.bounds}}))};
const {value:fonts}=await read(part.font_manifest_path);
const usedFonts=new Set(raw.fields.flatMap(field=>field.ps_style?.style_runs||[]).map(run=>run.font_name||run.font));
components.at(-1).unavailableFonts=(fonts.unavailable_postscript_names||[]).filter(name=>usedFonts.has(name));
for(const font of fonts.fonts){
const meta=await select(font.asset_path);
checkBytes(meta,font.sha256,font.size_bytes);
addAsset(meta,'font:'+kind);
}
}
const identity={id:entry.template_id,name:entry.template_name,brand:entry.brand,category:entry.category,
files:[...pins.values()].map(({fileId,revision})=>({fileId,revision})).sort((a,b)=>a.fileId.localeCompare(b.fileId))};
const version='files-'+digest(identity);
const manifest={sourceKind:'files',releaseId:version,template:{templateId:entry.template_id,name:entry.template_name,brand:entry.brand,category:entry.category,components,assets:[...assets.values()]}};
const pack=buildPack(manifest,manifestMeta.sha256,mappings,binding);
for(const component of components)if(component.unavailableFonts.length)pack.enterprise.components[component.component].unavailableFonts=component.unavailableFonts;
delete pack.enterprise.releaseId;
Object.assign(pack.enterprise,{adapterVersion:3,sourceKind:'files',snapshotVersion:version,
fileManifest:{fileId:manifestMeta.fileId,revision:manifestMeta.revision}});
const snapshot={version,pack,manifest,files:[...pins.values()]};
await atomic(snapshotFile(service.root,version),snapshot);
return snapshot;
}
/** Recheck current authority while keeping the project's original file revisions. */
export async function loadFileTemplate(service,version,task) {
let snapshot;
try{snapshot=JSON.parse(await fs.readFile(snapshotFile(service.root,version),'utf8'));}
catch(error){if(error.code==='ENOENT')throw Error('本机模板快照不存在,请重新选择知识库模板');throw error;}
if(snapshot.version!==version||snapshot.pack.version!==version)throw Error('知识库模板快照版本不一致');
await service.resolve(snapshot.files.map(file=>({fileId:file.fileId})),task);
for(const file of snapshot.files){
const current=task.metadata.get(key({fileId:file.fileId}));
task.metadata.set(key(file),{...current,revision:file.revision,sha256:file.sha256,size:file.size,downloadHeaders:file.downloadHeaders});
}
return snapshot;
}
export const templateAssetReference = (manifest,asset) => ['files','resource-map'].includes(manifest.sourceKind)?asset.fileId:`ekb:release/${manifest.releaseId}/${asset.assetId}`;

View File

@ -78,7 +78,7 @@ async function snapshot(service, set, part, binding, assets, version, mapping, b
const inventoryId=assets.find(a=>a.role==='layer_inventory')?.file.fileId;
const component={component:kind,mappingVersion:mapping.mapping_version,mappingAssetId:mappingId,sourceInventoryAssetId:inventoryId,originalAssetIds:originalIds};
const {key:templateId,name,brand,category,resourceSetId}=set.resourceSet;
const manifest={sourceKind:'resource-map',releaseId:version,template:{templateId,name,brand,category,
const manifest={sourceKind:'resource-map',version,template:{templateId,name,brand,category,
components:[component],assets:assets.map(({id,role,file})=>({...file,sha256:file.sha256.toLowerCase(),declaredId:id,assetId:file.fileId,roles:[role+':'+kind]}))}};
const pack=buildPack(manifest,version.slice(4),{[kind]:mapping},binding);
const originals=pack.enterprise.components[kind].originals;
@ -86,7 +86,6 @@ async function snapshot(service, set, part, binding, assets, version, mapping, b
const original=originals[0];
Object.assign(pack.enterprise,{sourceKind:'resource-map',adapterVersion:4,snapshotVersion:version,resourceSetId,
componentId:part.id,component:kind,originalAssetId:original.assetId,originalSha256:original.sha256,canvas:original.canvas});
delete pack.enterprise.releaseId;
pack.resourceFiles=assets.map(({file,role})=>({...ref(file),role}));
await atomic(snapshotPath(service,version),{pack,manifest});
return pack;

View File

@ -3,12 +3,8 @@ import path from 'node:path';
import {setTimeout as delay} from 'node:timers/promises';
import { EnterpriseKnowledge } from './enterprise-knowledge.mjs';
import { EnterpriseContext, imageKnowledge } from './enterprise-context.mjs';
import {loadFileTemplate,templateAssetReference} from './enterprise-file-templates.mjs';
import {resourceRequest,resourceSnapshot} from './enterprise-resource-map.mjs';
const reference = (release, asset) => `ekb:release/${release}${asset ? '/' + asset : ''}`;
async function waitForQuota(read, task) {
for (;;) {
task.signal?.throwIfAborted();
@ -37,61 +33,30 @@ export function brandProfiles(text) {
const asset = (manifest, id) => {
const item = manifest.template.assets.find(item => item.assetId === id);
if (!item) throw Error('发布清单缺少模板附件');
if (!item) throw Error('资源地图缺少模板附件');
return item;
};
// The adapter describes fields; the original Photoshop document remains the canvas.
export function detailPack(manifest, revision, mapping, binding) {
const template = manifest.template;
const component = template.components.find(item => item.component === 'detail');
if (!component || component.originalAssetIds.length !== 1 || mapping.template_id !== template.templateId || mapping.mapping_version !== component.mappingVersion) throw Error('详情模板原稿或映射版本不一致');
const original = asset(manifest, component.originalAssetIds[0]);
if (original.sha256 !== mapping.source.sha256) throw Error('模板字段映射不属于发布原稿');
const outputs = mapping.screens.map(screen => {
const [left, top, right, bottom] = screen.bounds;
const slots = mapping.fields.filter(field => field.screen_id === screen.screen_id).map(field => {
const [l, t, r, b] = field.ps_style.coverage_rect;
const x = Math.max(left, l), y = Math.max(top, t), x2 = Math.min(right, r), y2 = Math.min(bottom, b);
if (x2 <= x || y2 <= y) throw Error(`字段 ${field.field_id} 不在所属页面`);
const kind = field.type === '图片' ? 'image' : ['文案','参数'].includes(field.type) ? 'text' : null;
if (!kind) throw Error('未知模板字段类型');
const run = field.ps_style.style_runs?.[0];
return {fieldId:field.field_id, name:field.name, role:field.role, kind,
frame:{x:x-left, y:y-top, width:x2-x, height:y2-y}, nativeFrame:[l,t,r,b],
psLayer:field.ps_location, crop:'cover',
requirements:[field.purpose,field.fill_requirements,field.adaptation_requirements,field.output_spec,field.rules].filter(Boolean).join('\n'),
relatedFields:field.related_fields, example:field.reference,
...(kind === 'text' ? {font:{family:run?.font_name || '',size:run?.font_size || 24,weight:400,color:'#000000'},
maxChars:Math.max(1,Array.from(field.raw_text || field.reference || '').length),maxLines:Math.max(1,(field.raw_text || field.reference || '').split(/\r\n|\r|\n/).length)} : {})};
});
return {id:screen.screen_id,name:screen.title,component:'detail',width:right-left,height:bottom-top,top,slots};
});
return {schemaVersion:1,id:template.templateId,name:template.name,version:manifest.releaseId,
brandId:binding.brandId,categoryId:binding.categoryId,brandName:template.brand,categoryName:template.category,
enterprise:{releaseId:manifest.releaseId,manifestRevision:revision,adapterVersion:1,
mappingAssetId:component.mappingAssetId,inventoryAssetId:component.sourceInventoryAssetId,
originalAssetId:original.assetId,originalRevision:original.revision,originalSha256:original.sha256,canvas:mapping.canvas},outputs};
}
export function componentPack(manifest, revision, mappings, binding) {
function componentPack(manifest, revision, mappings, binding) {
const template=manifest.template;
const pack = mappings.detail ? detailPack(manifest, revision, mappings.detail, binding) : {
schemaVersion:1,id:template.templateId,name:template.name,version:manifest.releaseId,
const pack={schemaVersion:1,id:template.templateId,name:template.name,version:manifest.version,
brandId:binding.brandId,categoryId:binding.categoryId,brandName:template.brand,categoryName:template.category,
enterprise:{manifestRevision:revision},outputs:[]
};
pack.enterprise.adapterVersion = 2;
enterprise:{manifestRevision:revision},outputs:[]};
pack.enterprise.components = {};
for (const component of manifest.template.components) {
if (!['detail', 'main_images', 'sku_images'].includes(component.component)) continue;
const mapping = mappings[component.component];
if (!mapping || mapping.template_id !== manifest.template.templateId || mapping.mapping_version !== component.mappingVersion) throw Error('模板组件或映射版本不一致');
if(component.component==='detail'){
const original=asset(manifest,component.originalAssetIds[0]);
Object.assign(pack.enterprise,{mappingAssetId:component.mappingAssetId,inventoryAssetId:component.sourceInventoryAssetId,
originalAssetId:original.assetId,originalRevision:original.revision,originalSha256:original.sha256,canvas:mapping.canvas});
}
const sources = component.component === 'detail'
? [{assetId:component.originalAssetIds[0],canvas:mapping.canvas,sha256:mapping.source.sha256}]
: mapping.source.assets.map(source => {
const original = component.originalAssetIds.map(id=>asset(manifest,id)).find(item=>manifest.sourceKind==='resource-map' ? item.declaredId===source.asset_id : item.path.endsWith('/'+source.ps_asset_path));
if (!original || original.sha256.toLowerCase() !== source.ps_sha256?.toLowerCase()) throw Error('组件字段映射不属于发布原稿');
const original = component.originalAssetIds.map(id=>asset(manifest,id)).find(item=>item.declaredId===source.asset_id);
if (!original || original.sha256.toLowerCase() !== source.ps_sha256?.toLowerCase()) throw Error('组件字段映射不属于所选原稿');
return {assetId:original.assetId,sourceId:source.asset_id,canvas:source.canvas_px,sha256:source.ps_sha256};
});
if (sources.length !== component.originalAssetIds.length) throw Error('模板组件原稿清单不完整');
@ -206,23 +171,6 @@ export class EnterpriseTemplates {
}
return sources;
}
async pack(releaseId, revision, binding, task=operation({})) {
const {value:manifest,revision:actual} = await this.json(reference(releaseId),revision,task);
const component = manifest.template.components.find(item=>item.component==='detail');
if (!component) throw Error('该发布没有详情页模板');
const parts=manifest.template.components.filter(item=>item.component==='detail'||binding.adapterVersion!==1&&['main_images','sku_images'].includes(item.component));
await this.resolve(parts.map(part=>{const file=asset(manifest,part.mappingAssetId);return {fileId:reference(releaseId,file.assetId),revision:file.revision};}),task);
const mapping = asset(manifest,component.mappingAssetId);
const {value} = await this.json(reference(releaseId,mapping.assetId),mapping.revision,task);
// Existing projects keep their exact detail-only snapshot and field identities.
if(binding.adapterVersion===1)return {pack:detailPack(manifest,actual,value,binding),manifest};
const mappings={detail:value};
for(const part of manifest.template.components.filter(item=>['main_images','sku_images'].includes(item.component))) {
const file=asset(manifest,part.mappingAssetId);
mappings[part.component]=(await this.json(reference(releaseId,file.assetId),file.revision,task)).value;
}
return {pack:componentPack(manifest,actual,mappings,binding),manifest};
}
async request(input, options={}) {
const task=operation(options);
if (input.action === 'context') {
@ -235,8 +183,8 @@ export class EnterpriseTemplates {
return {context:{task:value.task,brandName:value.brandName,categoryName:value.categoryName,templateId:value.templateId,releaseId:value.releaseId,
skills:value.skills.map(({fileId,revision,path})=>({fileId,revision,path})),rules:value.rules,execution:value.execution}};
}
const library=(await waitForQuota(()=>this.client.call('list_libraries',{}, {signal:task.signal}),task)).result;
if (['choices','brand','catalog','resource-set','resource-component'].includes(input.action)) {
const library=(await waitForQuota(()=>this.client.call('list_libraries',{}, {signal:task.signal}),task)).result;
const result=await resourceRequest(this,input,library,task,waitForQuota,componentPack);
if(input.action==='brand'&&result.brand){
const sources=await this.brandSources(task);
@ -248,44 +196,36 @@ export class EnterpriseTemplates {
return result;
}
if (!['pack','prepare'].includes(input.action)) throw Error('模板操作无效');
if(input.sourceKind==='resource-map') {
try {return await this.prepare(input,task,await resourceSnapshot(this,input,task));}
catch(error) {
if(![409,412].includes(error.status))throw error;
const {result}=await waitForQuota(()=>this.client.call('get_resource_set',{resourceSetId:input.resourceSetId},{signal:task.signal}),task);
const component=result.components.find(part=>part.id===input.componentId);
const mismatched=component?.assets.filter(a=>a.status==='needs_review').map(a=>a.role==='mapping'?'字段映射':a.file.name)??[];
if(mismatched.length)throw Error(`模板资料版本不符:${mismatched.join('、')},请重新选择可用组件`);
const live=component?.assets??[];
const changed=(input.pinnedPack?.resourceFiles??[]).filter(pin=>
!live.some(asset=>asset.file.fileId===pin.fileId&&asset.file.revision===pin.revision));
const roles=[...new Set(changed.map(pin=>({original:'原稿',mapping:'字段映射',font:'字体',layer_inventory:'图层清单',font_manifest:'字体清单'})[pin.role]??'附件'))];
throw Error(`${roles.length?roles.join('、'):'所选组件资料'}已变化或不可读取,请重新确认资源组;原项目固定版本保留`);
}
if (input.sourceKind!=='resource-map') throw Error('请从企业知识库资源地图重新选择模板');
await waitForQuota(()=>this.client.call('list_libraries',{}, {signal:task.signal}),task);
try {return await this.prepare(input,task,await resourceSnapshot(this,input,task));}
catch(error) {
if(![409,412].includes(error.status))throw error;
const {result}=await waitForQuota(()=>this.client.call('get_resource_set',{resourceSetId:input.resourceSetId},{signal:task.signal}),task);
const component=result.components.find(part=>part.id===input.componentId);
const mismatched=component?.assets.filter(a=>a.status==='needs_review').map(a=>a.role==='mapping'?'字段映射':a.file.name)??[];
if(mismatched.length)throw Error(`模板资料版本不符:${mismatched.join('、')},请重新选择可用组件`);
const live=component?.assets??[];
const changed=(input.pinnedPack?.resourceFiles??[]).filter(pin=>
!live.some(asset=>asset.file.fileId===pin.fileId&&asset.file.revision===pin.revision));
const roles=[...new Set(changed.map(pin=>({original:'原稿',mapping:'字段映射',font:'字体',layer_inventory:'图层清单',font_manifest:'字体清单'})[pin.role]??'附件'))];
throw Error(`${roles.length?roles.join('、'):'所选组件资料'}已变化或不可读取,请从资源地图重新选择模板`);
}
if(input.action==='prepare'&&input.pinnedPack&&input.sourceKind!=='files') {
const {value:manifest}=await this.json(reference(input.releaseId),input.manifestRevision,task);
if(manifest.releaseId!==input.pinnedPack.version)throw Error('发布原稿不属于项目固定版本');
return this.prepare(input,task,{pack:input.pinnedPack,manifest});
}
const snapshot=input.sourceKind==='files'?await loadFileTemplate(this,input.snapshotVersion,task):await this.pack(input.releaseId,input.manifestRevision,input,task);
return this.prepare(input,task,input.pinnedPack?{...snapshot,pack:input.pinnedPack}:snapshot);
}
async prepare(input,task,{pack,manifest}) {
if (input.action === 'pack') return {pack};
const component=input.component||'detail';
if(pack.enterprise.components?.[component]?.unavailableFonts?.length)throw Error('当前模板组件所需字体尚未齐备,请补齐知识库字体资料');
const outputs=pack.outputs.filter(output=>output.component===component&&(!input.documentId||output.id===input.documentId));
if(!outputs.length)throw Error('当前固定模板没有所选组件,请检查模板更新');
const ids=[...new Set(outputs.map(output=>output.originalAssetId||pack.enterprise.originalAssetId))];
const fontAssets=manifest.template.assets.filter(item=>item.roles.includes('font:'+component)&&/\.(ttf|otf)$/i.test(item.path));
const attachments=manifest.template.assets.filter(item=>item.roles.includes('attachment:'+component));
const needed=[...ids.map(id=>asset(manifest,id)),...fontAssets,...attachments];
await this.resolve(needed.map(item=>({fileId:templateAssetReference(manifest,item),revision:item.revision})),task);
await this.resolve(needed.map(item=>({fileId:item.fileId,revision:item.revision})),task);
task.progress={phase:'download',completed:0,fileCount:new Set(needed.map(item=>item.assetId)).size};
const download=async item=>{
task.signal?.throwIfAborted();
const ref={fileId:templateAssetReference(manifest,item),revision:item.revision},key=fileKey(ref);
const ref={fileId:item.fileId,revision:item.revision},key=fileKey(ref);
if(!task.downloads.has(key))task.downloads.set(key,(async()=>{
const result=await waitForQuota(()=>this.client.download(ref,{metadata:task.metadata.get(key),signal:task.signal,
onProgress:value=>task.onProgress?.({...task.progress,...value})}),task);

View File

@ -171,20 +171,12 @@ test('re-reads the selected resource group after a version conflict and allows c
}}),{name:'AbortError'});
});
test('legacy releases use the saved project pack while fetching its fixed original',async t=>{
const {service,calls,request}=await fixture(t);
const releaseId='e'.repeat(32),assetId='a-'+'f'.repeat(32);
const pinnedPack={version:releaseId,enterprise:{components:{sku_images:{originals:[{assetId,canvas:[800,800]}]}}},
outputs:[{id:'K01',component:'sku_images',originalAssetId:assetId,slots:[{limitsSource:{maxChars:'example'}}]}]};
service.json=async (file,revision)=>{
assert.equal(file,'ekb:release/'+releaseId);
assert.equal(revision,version);
return {value:{releaseId,template:{assets:[{assetId,revision:version,path:'original.psd',roles:['original:sku_images']}]}}};
};
const prepared=await request({action:'prepare',component:'sku_images',releaseId,manifestRevision:version,pinnedPack});
assert.deepEqual(prepared.pack,pinnedPack);
assert.equal(calls.find(([name])=>name==='download')[1].args.fileId,`ekb:release/${releaseId}/${assetId}`);
assert.equal(calls.some(([name])=>name==='read_text'),false);
test('template preparation requires the resource map contract',async t=>{
const {calls,request}=await fixture(t);
for(const sourceKind of [undefined,'files']){
await assert.rejects(request({action:'prepare',sourceKind}),/从企业知识库资源地图重新选择/);
}
assert.deepEqual(calls,[]);
});
test('SKU smart-object mappings preserve the declared layer paths and use native text bounds',async t=>{

View File

@ -478,28 +478,23 @@ mod tests {
value
}
#[test]
fn enterprise_component_selection_survives_product_brief_roundtrip() {
fn resource_map_component_selection_survives_product_brief_roundtrip() {
let mut value = canvas_brief();
let release = value["templateSelection"]["version"].clone();
for version in [1,2] {
value["templateSelection"]["enterprise"] = json!({"adapterVersion":version,"releaseId":release,"components":{"main_images":{"originals":[{"assetId":"main"}]},"sku_images":{"originals":[{"assetId":"sku"}]}}});
let clean = brief(&value).unwrap();
assert_eq!(clean["templateSelection"],value["templateSelection"]);
assert_eq!(brief(&clean).unwrap(),clean);
}
value["templateSelection"]["enterprise"]["releaseId"] = json!("other-release");
assert!(brief(&value).unwrap_err().contains("版本身份"));
}
#[test]
fn file_template_selection_preserves_its_current_file_snapshot() {
let mut value = canvas_brief();
value["templateSelection"]["version"] = json!(format!("files-{}", "a".repeat(64)));
value["templateSelection"]["enterprise"] = json!({"adapterVersion":3,"sourceKind":"files",
"snapshotVersion":value["templateSelection"]["version"],"fileManifest":{"fileId":"manifest-file","revision":"manifest-r1"}});
value["templateSelection"]["version"] = json!(format!("map-{}", "a".repeat(64)));
value["templateSelection"]["enterprise"] = json!({"adapterVersion":4,"sourceKind":"resource-map",
"snapshotVersion":value["templateSelection"]["version"],"resourceSetId":"b".repeat(32),"componentId":"sku_images",
"components":{"sku_images":{"originals":[{"assetId":"sku"}]}}});
let clean = brief(&value).unwrap();
assert_eq!(clean["templateSelection"], value["templateSelection"]);
value["templateSelection"]["enterprise"]["snapshotVersion"] = json!("files-wrong");
assert!(brief(&value).unwrap_err().contains("版本身份"));
assert_eq!(brief(&clean).unwrap(), clean);
}
#[test]
fn legacy_enterprise_template_selections_are_rejected() {
let mut value = canvas_brief();
for adapter_version in [1, 2, 3] {
value["templateSelection"]["enterprise"] = json!({"adapterVersion":adapter_version});
assert!(brief(&value).unwrap_err().contains("版本身份"));
}
}
#[test]
fn canvas_brief_roundtrip_preserves_selected_template_multi_colour_and_explicit_clears() {

View File

@ -114,11 +114,7 @@ fn knowledge_catalog(pack:&Value, creation:&Value) -> R<Value> {
let brand=&creation["brief"]["brandId"];
let category=&creation["brief"]["categoryId"];
let brand_key=format!("enterprise:{}",brand.as_str().ok_or("项目品牌缺失")?);
let source=if pack["enterprise"]["sourceKind"]=="files" {
pack["enterprise"]["fileManifest"]["fileId"].as_str().ok_or("模板文件来源缺失")?.to_owned()
} else if pack["enterprise"]["sourceKind"] == "resource-map" {
pack["enterprise"]["resourceSetId"].as_str().ok_or("模板资源组缺失")?.to_owned()
} else { format!("ekb:release/{}",pack["version"].as_str().ok_or("模板版本缺失")?) };
let source=pack["enterprise"]["resourceSetId"].as_str().ok_or("模板资源组缺失")?;
let revision=&pack["contentHash"];
let screens=pack["outputs"].as_array().ok_or("模板页面缺失")?.iter()
.map(|output|json!({"id":output["id"],"title":output["name"],"role":"content"})).collect::<Vec<_>>();
@ -573,10 +569,11 @@ fn run_inner(b: &mut Backend, input: &Value, method: &str, events: &mpsc::Sender
mod tests {
use super::*;
#[test]
fn knowledge_selection_uses_the_published_template_without_a_platform_rule_binding() {
fn knowledge_selection_uses_the_resource_set_without_a_platform_rule_binding() {
let creation=json!({"brief":{"brandId":"ekb:brand:顾家","brandName":"顾家","categoryId":"ekb:category:电脑桌","categoryName":"电脑桌"},
"designSnapshot":{"brand":{"profile":{"tone":"","visualRules":{}}}}});
let pack=json!({"id":"GJ-DESK-DNZ0385","version":"published-release","contentHash":"a".repeat(64),"enterprise":{"canvas":[1440,46930]},
let pack=json!({"id":"GJ-DESK-DNZ0385","version":format!("map-{}", "a".repeat(64)),"contentHash":"a".repeat(64),
"enterprise":{"resourceSetId":"b".repeat(32),"canvas":[1440,46930]},
"outputs":(0..22).map(|index|json!({"id":format!("S{index:02}"),"name":"原稿模块"})).collect::<Vec<_>>()});
let catalog=knowledge_catalog(&pack,&creation).unwrap();
let saved=rule_cache::package("GJ-DESK-DNZ0385",&json!({"catalog":catalog,"revision":"a".repeat(64)}),None).unwrap();
@ -584,6 +581,7 @@ mod tests {
assert_eq!(saved["catalog"]["bindings"][0]["template"]["screens"].as_array().unwrap().len(),22);
assert_eq!(saved["catalog"]["bindings"][0]["template"]["sourceCanvas"],json!([1440,46930]));
assert_eq!(saved["catalog"]["source"],"enterprise-knowledge");
assert_eq!(saved["catalog"]["bindings"][0]["source"], "b".repeat(32));
}
use super::super::{Client, HashMap};
#[test]

View File

@ -556,10 +556,8 @@ fn enterprise_source(pack: &Value, source: &Value, outputs: &[&Value], variant:
return Err(format!("字段 {} 的图层名称或层级与发布映射不一致", field["fieldId"]));
}
*id
} else if pack["enterprise"]["adapterVersion"] == 4 {
layers.resolve(&field["psLayer"])?
} else {
return Err("字段原稿图层编号缺失".into());
layers.resolve(&field["psLayer"])?
};
let original_layer = doc.layer(id).ok_or("原稿图层不存在")?;
let original_psd_id = original_layer.psd_id;
@ -795,8 +793,10 @@ mod tests {
"slots":[{"fieldId":format!("{name}-I01"),"name":name,"kind":"image","crop":"cover","frame":{"x":0,"y":0,"width":8,"height":4},"nativeFrame":[0,0,8,4],"psLayer":{"layer_id":18,"name":format!("{name}-I01"),"path":format!("{name}-I01")}}]}));
originals.push(json!({"assetId":name,"originalPath":path,"canvas":[750,16]}));
}
let mut pack = json!({"schemaVersion":1,"id":"test","version":"release","name":"主图原稿","brandId":"brand","categoryId":"category",
"enterprise":{"adapterVersion":2,"releaseId":"release","manifestRevision":"a".repeat(64),"originalSha256":"b".repeat(64)},"outputs":outputs});
let version = format!("map-{}", "a".repeat(64));
let mut pack = json!({"schemaVersion":1,"id":"test","version":version,"name":"主图原稿","brandId":"brand","categoryId":"category",
"enterprise":{"adapterVersion":4,"sourceKind":"resource-map","snapshotVersion":version,"resourceSetId":"b".repeat(32),
"componentId":"main_images","manifestRevision":"c".repeat(64),"originalSha256":"d".repeat(64)},"outputs":outputs});
pack["contentHash"] = json!(super::super::template_slots::pack_hash(&pack).unwrap());
let variant = uuid::Uuid::new_v4().to_string();
let prepared = json!({"fonts":[],"originals":originals});

View File

@ -22,18 +22,12 @@ fn hex(value: &Value) -> bool {
}
pub(super) fn enterprise_version(enterprise: &Value, version: &Value) -> bool {
match enterprise["adapterVersion"].as_u64() {
Some(1 | 2) => enterprise["releaseId"] == *version,
Some(3) => enterprise["sourceKind"] == "files" && enterprise["snapshotVersion"] == *version
&& version.as_str().is_some_and(|s| s.len() == 70 && s.starts_with("files-") && s.bytes().skip(6).all(|b| b.is_ascii_hexdigit()))
&& enterprise["fileManifest"]["fileId"].as_str().is_some_and(|s| !s.is_empty())
&& enterprise["fileManifest"]["revision"].as_str().is_some_and(|s| !s.is_empty()),
Some(4) => enterprise["sourceKind"] == "resource-map" && enterprise["snapshotVersion"] == *version
&& version.as_str().is_some_and(|s| s.len() == 68 && s.starts_with("map-") && s.bytes().skip(4).all(|b| b.is_ascii_hexdigit()))
&& enterprise["resourceSetId"].as_str().is_some_and(|s| s.len() == 32 && s.bytes().all(|b| b.is_ascii_hexdigit()))
&& enterprise["componentId"].as_str().is_some_and(|s| !s.is_empty()),
_ => false,
}
enterprise["adapterVersion"] == 4
&& enterprise["sourceKind"] == "resource-map"
&& enterprise["snapshotVersion"] == *version
&& version.as_str().is_some_and(|s| s.len() == 68 && s.starts_with("map-") && s.bytes().skip(4).all(|b| b.is_ascii_hexdigit()))
&& enterprise["resourceSetId"].as_str().is_some_and(|s| s.len() == 32 && s.bytes().all(|b| b.is_ascii_hexdigit()))
&& enterprise["componentId"].as_str().is_some_and(|s| !s.is_empty())
}
/// The hash covers layout, fonts and all extra business metadata. Updating any
@ -624,15 +618,14 @@ mod tests {
assert_ne!(slot_id(&p, "S01-I01"), slot_id(&next, "S01-I01"));
}
#[test]
fn current_file_template_uses_fixed_snapshot_identity() {
fn enterprise_templates_require_a_resource_map_snapshot() {
let mut p = pack();
p["version"] = json!(format!("files-{}", "a".repeat(64)));
p["enterprise"] = json!({"adapterVersion":3,"sourceKind":"files","snapshotVersion":p["version"],
"fileManifest":{"fileId":"manifest-file","revision":"manifest-r1"},
"manifestRevision":"b".repeat(64),"originalSha256":"c".repeat(64)});
p["version"] = json!(format!("map-{}", "a".repeat(64)));
p["enterprise"] = json!({"adapterVersion":4,"sourceKind":"resource-map","snapshotVersion":p["version"],
"resourceSetId":"b".repeat(32),"componentId":"detail","manifestRevision":"c".repeat(64),"originalSha256":"d".repeat(64)});
p["contentHash"] = json!(pack_hash(&p).unwrap());
validate_pack(&p).unwrap();
p["enterprise"]["snapshotVersion"] = json!(format!("files-{}", "d".repeat(64)));
p["enterprise"]["snapshotVersion"] = json!(format!("map-{}", "e".repeat(64)));
p["contentHash"] = json!(pack_hash(&p).unwrap());
assert!(validate_pack(&p).unwrap_err().contains("版本身份"));
}