170 lines
4.6 KiB
TypeScript
170 lines
4.6 KiB
TypeScript
|
|
import { localize } from '../services/localization';
|
|
import { arrayRemove } from '../utils/arrays';
|
|
import { useUiStore } from '../ui/store';
|
|
import { ZeroCompiledEditor } from './compile';
|
|
|
|
function unlocked(config, model, field)
|
|
{
|
|
if (!config || !model || !model.blueprint)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return canUnlock(config, model, field)
|
|
&& (model.blueprint.desync.indexOf(field.path) > -1
|
|
|| model.blueprint.desync.find(x => field.path.indexOf(x + '.') === 0) != null);
|
|
}
|
|
|
|
|
|
function canUnlock(config, model, field)
|
|
{
|
|
if (!config || !model || !model.blueprint)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return config.unlocked.indexOf(field.path) > -1
|
|
|| config.unlocked.find(x => field.path.indexOf(x + '.') === 0) != null;
|
|
}
|
|
|
|
|
|
function isBlueprintChild(config, route, model)
|
|
{
|
|
return model && route.query.scope != 'shared' && !!model.blueprint;
|
|
}
|
|
|
|
|
|
function isBlueprintParent(config, route, model)
|
|
{
|
|
return model && route.query.scope == 'shared' && !model.blueprint;
|
|
}
|
|
|
|
|
|
async function lock(config, model, field)
|
|
{
|
|
arrayRemove(model.blueprint.desync, field.path);
|
|
//let blueprint = await BlueprintApi.getById(model.blueprint.id);
|
|
//return blueprint[field.path];
|
|
}
|
|
|
|
|
|
function unlock(config, model, field)
|
|
{
|
|
model.blueprint.desync.push(field.path);
|
|
}
|
|
|
|
|
|
/**
|
|
* [TODO] description
|
|
* @typedef {object} EditorBlueprint
|
|
* @param {string} alias - Alias which is used to match an editor
|
|
* @param {function} unlocked - Whether a field is unlocked and can be changed
|
|
* @param {function} canUnlock - Whether a field can be unlocked
|
|
* @param {EditorBlueprintField[]} fields - Fields which can be altered in synchronization
|
|
*/
|
|
|
|
/**
|
|
* [TODO] description
|
|
* @typedef {object} EditorBlueprintField
|
|
* @param {string} path - Property path
|
|
* @param {string} label - Label which describes the property
|
|
* @param {string} description - Additional description for this property
|
|
* @param {function} synced - Whether this field is synchronized with the parent
|
|
*/
|
|
|
|
/**
|
|
* [TODO] description
|
|
* @param {string} alias - Alias for the tab
|
|
* @returns {EditorBlueprint}
|
|
*/
|
|
export function createBlueprintConfig(alias: string, editor: ZeroCompiledEditor)
|
|
{
|
|
const store = useUiStore();
|
|
let blueprintAlias = editor.alias;
|
|
let canBeBlueprinted = store.blueprints.indexOf(blueprintAlias) > -1;
|
|
|
|
if (!blueprintAlias || !canBeBlueprinted)
|
|
{
|
|
return {
|
|
alias: blueprintAlias,
|
|
isEnabled: false,
|
|
unlocked: () => true,
|
|
canUnlock: () => false,
|
|
isBlueprintParent: () => false,
|
|
isBlueprintChild: () => false,
|
|
lock: () => { },
|
|
unlock: () => { },
|
|
fields: []
|
|
};
|
|
}
|
|
|
|
let config = {
|
|
unlocked: []
|
|
}
|
|
|
|
// check for blueprint availability
|
|
//config.isParent = this.value && this.$route.query.scope === 'shared';
|
|
//config.isNewParent = config.isParent && !this.value.id;
|
|
//config.isChild = !config.isParent && this.value && !!this.value.blueprint;
|
|
|
|
// get all editor fields
|
|
let fields = [];
|
|
let processed = ['blueprint'];
|
|
let defaults = ['name', /*'alias',*/ 'isActive', 'sort', /*'key'*/];
|
|
|
|
// add blueprint setting for default fields
|
|
defaults.forEach(alias =>
|
|
{
|
|
processed.push(alias);
|
|
|
|
//if (config.unlocked.indexOf(alias) > -1)
|
|
//{
|
|
fields.push({
|
|
path: alias,
|
|
label: localize("@ui.entityfields." + alias),
|
|
description: localize("@ui.entityfields." + alias + "_text", { hideEmpty: true }),
|
|
synced: model => !model.blueprint || model.blueprint.desync.indexOf(alias) < 0
|
|
});
|
|
//}
|
|
});
|
|
|
|
// add blueprint setting for custom fields
|
|
editor.tabs.forEach(tab =>
|
|
{
|
|
tab.fieldsets.forEach(set =>
|
|
{
|
|
set.fields.forEach(field =>
|
|
{
|
|
let alias = field.path;
|
|
|
|
if (processed.indexOf(alias) < 0)
|
|
{
|
|
processed.push(alias);
|
|
|
|
if (config.unlocked.indexOf(alias) > -1 || config.unlocked.find(x => alias.indexOf(x + '.') === 0))
|
|
{
|
|
fields.push({
|
|
path: alias,
|
|
label: field.label,
|
|
description: field.description,
|
|
synced: model => !model.blueprint || model.blueprint.desync.indexOf(alias) < 0
|
|
});
|
|
}
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
return {
|
|
alias: blueprintAlias,
|
|
isEnabled: true,
|
|
unlocked: (model, field) => unlocked(config, model, field),
|
|
canUnlock: (model, field) => canUnlock(config, model, field),
|
|
unlock: async (model, field) => await unlock(config, model, field),
|
|
lock: async (model, field) => await lock(config, model, field),
|
|
isBlueprintParent: (route, model) => isBlueprintParent(config, route, model),
|
|
isBlueprintChild: (route, model) => isBlueprintChild(config, route, model),
|
|
fields: fields
|
|
};
|
|
}; |