import { defHttp } from '#/api/request';
|
|
export type FormulaEnabled = 'disabled' | 'enabled';
|
export type FormulaStatus = 'CANCELLED' | 'DRAFT' | 'PRE_RELEASE' | 'PUBLISHED';
|
export type FormulaType = 'BOOLEAN' | 'DECIMAL' | 'DECIMAL_LIST' | 'TEXT';
|
export type RoundMode = 'DOWN' | 'HALF_EVEN' | 'HALF_UP' | 'UP';
|
export type PreviewStatus = 'ERROR' | 'MISSING_INPUT' | 'SUCCESS';
|
export type DiagnosticSeverity = 'ERROR' | 'WARNING';
|
export type FormulaFunctionReturnType = 'BOOLEAN' | 'DECIMAL' | 'DYNAMIC';
|
|
export interface ParameterSlot {
|
canshuBianma: string;
|
canshuMingcheng: string;
|
danwei?: string;
|
id?: string;
|
paixu: number;
|
shifouBitian: 0 | 1;
|
shujuLeixing: FormulaType;
|
}
|
|
export interface Diagnostic {
|
code?: string;
|
end: number;
|
message?: string;
|
severity: DiagnosticSeverity;
|
start: number;
|
}
|
|
export interface FormulaRule {
|
biaodashi: string;
|
jieguoLeixing: FormulaType;
|
parameters: ParameterSlot[];
|
xiuyueMoshi?: RoundMode;
|
xiuyueXiaoshuWei?: number;
|
}
|
|
export interface FormulaValidation {
|
diagnostics: Diagnostic[];
|
inferredType?: FormulaType;
|
latex?: null | string;
|
}
|
|
export interface FormulaPreview {
|
diagnostics: Diagnostic[];
|
latex?: null | string;
|
rawResult?: unknown;
|
roundedResult?: unknown;
|
status: PreviewStatus;
|
}
|
|
export interface FormulaFunction {
|
category: string;
|
chineseName: string;
|
code: string;
|
description: string;
|
example: string;
|
returnType: FormulaFunctionReturnType;
|
signature: string;
|
}
|
|
export interface FormulaPageQuery {
|
bizEnabled?: FormulaEnabled;
|
currentPage: number;
|
keyword?: string;
|
pageSize: number;
|
}
|
|
export interface TemplateReferencePageQuery {
|
currentPage: number;
|
keyword?: string;
|
pageSize: number;
|
}
|
|
export interface FormulaListItem {
|
bizEnabled: FormulaEnabled;
|
dangqianBanbenHao?: number;
|
dangqianGongshiBanbenId?: string;
|
gengxinShijian?: string;
|
gongshiBianma: string;
|
gongshiMingcheng: string;
|
id: string;
|
mubanYinyongShu?: number;
|
yewuYongtu?: string;
|
zuixinFabuBanbenHao?: number;
|
}
|
|
export interface FormulaVersion extends FormulaRule {
|
banbenHao: number;
|
bizStatus: FormulaStatus;
|
chuangjianShijian?: string;
|
gengxinShijian?: string;
|
gongshiDingyiId: string;
|
id: string;
|
zuofeiYuanyin?: string;
|
}
|
|
export interface TemplateReferenceSummary {
|
bindingId: string;
|
bindingStatus?: string;
|
formulaVersionId: string;
|
templateId: string;
|
templateName?: string;
|
templateStatus?: string;
|
}
|
|
export interface FormulaDetail {
|
beizhu?: string;
|
bizEnabled: FormulaEnabled;
|
dangqianGongshiBanbenId?: string;
|
gongshiBianma: string;
|
gongshiMingcheng: string;
|
id: string;
|
mubanYinyongShu?: number;
|
templateReferences?: TemplateReferenceSummary[];
|
versions: FormulaVersion[];
|
yewuYongtu?: string;
|
}
|
|
export interface FormulaPage {
|
list: FormulaListItem[];
|
pagination: { currentPage: number; pageSize: number; total: number };
|
}
|
|
export interface TemplateReferencePage {
|
list: TemplateReferenceSummary[];
|
pagination: { currentPage: number; pageSize: number; total: number };
|
}
|
|
export interface CreateFormulaParams extends FormulaRule {
|
beizhu?: string;
|
gongshiMingcheng: string;
|
yewuYongtu?: string;
|
}
|
|
export interface CreateFormulaDraftParams {
|
beizhu?: string;
|
gongshiMingcheng: string;
|
parameters: ParameterSlot[];
|
yewuYongtu?: string;
|
}
|
|
export interface UpdateFormulaDefinitionParams {
|
beizhu?: string;
|
gongshiMingcheng: string;
|
yewuYongtu?: string;
|
}
|
|
export interface CreateFormulaVersionParams {
|
sourceVersionId: string;
|
}
|
|
export interface PreviewFormulaParams extends FormulaRule {
|
inputs: Record<string, Array<null | number | string> | boolean | null | number | string>;
|
}
|
|
export interface SwitchCurrentFormulaVersionParams {
|
reason: string;
|
versionId: string;
|
}
|
|
interface ApiResult<T> {
|
code: number;
|
data: T;
|
msg?: string;
|
}
|
|
const FORMULA_CATALOG_PREFIX = '/api/eln/formulaCatalog';
|
const formulaFunctionByCode = new Map<string, FormulaFunction>();
|
let formulaFunctionsLoaded = false;
|
let formulaFunctionsRequest: Promise<FormulaFunction[]> | undefined;
|
|
export function getFormulaPage(data: FormulaPageQuery) {
|
return defHttp.get<ApiResult<FormulaPage>>({ data, url: FORMULA_CATALOG_PREFIX });
|
}
|
|
export function createFormula(data: CreateFormulaParams) {
|
return defHttp.post<ApiResult<FormulaDetail>>({ data, url: FORMULA_CATALOG_PREFIX });
|
}
|
|
export function createFormulaDraft(data: CreateFormulaDraftParams) {
|
return defHttp.post<ApiResult<FormulaDetail>>({ data, url: `${FORMULA_CATALOG_PREFIX}/drafts` });
|
}
|
|
export function getFormulaDetail(id: string) {
|
return defHttp.get<ApiResult<FormulaDetail>>({ url: `${FORMULA_CATALOG_PREFIX}/${id}` });
|
}
|
|
export function getFormulaTemplateReferences(id: string, data: TemplateReferencePageQuery) {
|
return defHttp.get<ApiResult<TemplateReferencePage>>({ data, url: `${FORMULA_CATALOG_PREFIX}/${id}/templateReferences` });
|
}
|
|
export function updateFormulaDefinition(id: string, data: UpdateFormulaDefinitionParams) {
|
return defHttp.put<ApiResult<FormulaDetail>>({ data, url: `${FORMULA_CATALOG_PREFIX}/${id}` });
|
}
|
|
export function getFormulaFunctions(): Promise<FormulaFunction[]> {
|
if (formulaFunctionsLoaded) return Promise.resolve([...formulaFunctionByCode.values()]);
|
if (formulaFunctionsRequest) return formulaFunctionsRequest;
|
|
formulaFunctionsRequest = defHttp
|
.get<ApiResult<FormulaFunction[]>>({ url: `${FORMULA_CATALOG_PREFIX}/functions` })
|
.then((response) => {
|
for (const formula of response.data) formulaFunctionByCode.set(formula.code, formula);
|
formulaFunctionsLoaded = true;
|
return [...formulaFunctionByCode.values()];
|
})
|
.finally(() => {
|
formulaFunctionsRequest = undefined;
|
});
|
return formulaFunctionsRequest;
|
}
|
|
export function validateFormula(data: FormulaRule, signal?: AbortSignal) {
|
return defHttp.post<ApiResult<FormulaValidation>>({ data, signal, url: `${FORMULA_CATALOG_PREFIX}/validate` });
|
}
|
|
export function previewFormula(data: PreviewFormulaParams, signal?: AbortSignal) {
|
return defHttp.post<ApiResult<FormulaPreview>>({ data, signal, url: `${FORMULA_CATALOG_PREFIX}/preview` });
|
}
|
|
export function createFormulaVersion(formulaId: string, data: CreateFormulaVersionParams) {
|
return defHttp.post<ApiResult<FormulaVersion>>({ data, url: `${FORMULA_CATALOG_PREFIX}/${formulaId}/versions` });
|
}
|
|
export function updateFormulaVersion(versionId: string, data: FormulaRule) {
|
return defHttp.put<ApiResult<FormulaVersion>>({ data, url: `${FORMULA_CATALOG_PREFIX}/versions/${versionId}` });
|
}
|
|
export function preReleaseFormulaVersion(versionId: string) {
|
return defHttp.post<ApiResult<void>>({ url: `${FORMULA_CATALOG_PREFIX}/versions/${versionId}/preRelease` });
|
}
|
|
export function publishFormulaVersion(versionId: string) {
|
return defHttp.post<ApiResult<void>>({ url: `${FORMULA_CATALOG_PREFIX}/versions/${versionId}/publish` });
|
}
|
|
export function cancelFormulaVersion(versionId: string, reason: string) {
|
return defHttp.post<ApiResult<void>>({ data: { reason }, url: `${FORMULA_CATALOG_PREFIX}/versions/${versionId}/cancel` });
|
}
|
|
export function switchCurrentFormulaVersion(formulaId: string, data: SwitchCurrentFormulaVersionParams) {
|
return defHttp.post<ApiResult<void>>({ data, url: `${FORMULA_CATALOG_PREFIX}/${formulaId}/currentVersion` });
|
}
|
|
export function enableFormula(formulaId: string, reason: string) {
|
return defHttp.post<ApiResult<void>>({ data: { reason }, url: `${FORMULA_CATALOG_PREFIX}/${formulaId}/enable` });
|
}
|
|
export function disableFormula(formulaId: string, reason: string) {
|
return defHttp.post<ApiResult<void>>({ data: { reason }, url: `${FORMULA_CATALOG_PREFIX}/${formulaId}/disable` });
|
}
|
