cabloy 5.1.94 → 5.1.96

package/zova/src/suite/cabloy-basic/modules/basic-details/src/service/detail.tsx

@@ -1,7 +1,7 @@
 import { celEnvBase } from '@cabloy/utils';
 import { classes } from 'typestyle';
 import { VNode } from 'vue';
-import { BeanBase, UseScope } from 'zova';
+import { BeanBase, deepExtend, UseScope } from 'zova';
 import { ZovaJsx } from 'zova-jsx';
 import { Service } from 'zova-module-a-bean';
 import {
@@ -123,10 +123,62 @@ export class ServiceDetail<TData extends {} = {}> extends BeanBase {
     }
   }
 
+  public buildSubmittedDetailItem(data: TypeFormOnSubmitData<TData>, dataOld?: TData) {
+    const detailItem = deepExtend({}, dataOld ?? {}, data.value) as Record<string, any>;
+    const properties = this.$sdk.loadSchemaProperties(this.formSchema, this.schemaScene);
+    if (!properties || properties.length === 0 || !this.formRef) return detailItem as TData;
+    for (const property of properties) {
+      this._hydrateDetailItemRelation(detailItem, property, data);
+    }
+    return detailItem as TData;
+  }
+
   public submitData(data: TypeFormOnSubmitData<TData>) {
     this.options.onSubmitData?.(data, this.dialogInstance!);
   }
 
+  private _hydrateDetailItemRelation(
+    detailItem: Record<string, any>,
+    property: ISchemaObjectExtensionField,
+    data: TypeFormOnSubmitData<TData>,
+  ) {
+    const renderProvider = property.rest?.render;
+    if (renderProvider !== 'basic-image:formFieldImage') return;
+    const relationName = this._getRelationNameOfField(property, property.rest);
+    if (!relationName) return;
+    const relationValue = data.formApi.getFieldValue(relationName as never);
+    detailItem[relationName] = this._cloneRelationValue(relationValue);
+  }
+
+  private _getRelationNameOfField(
+    property: ISchemaObjectExtensionField,
+    options?: Record<string, any>,
+  ) {
+    return this._inferRelationName(property.key, options?.relationName as string | undefined);
+  }
+
+  private _inferRelationName(fieldName?: string, relationName?: string) {
+    if (relationName) return relationName;
+    if (!fieldName) return undefined;
+    if (fieldName.endsWith('Ids')) {
+      return `${fieldName.slice(0, -3)}s`;
+    }
+    if (fieldName.endsWith('Id')) {
+      return fieldName.slice(0, -2);
+    }
+    return undefined;
+  }
+
+  private _cloneRelationValue(relationValue: unknown) {
+    if (Array.isArray(relationValue)) {
+      return deepExtend([], relationValue);
+    }
+    if (relationValue && typeof relationValue === 'object') {
+      return deepExtend({}, relationValue as Record<string, any>);
+    }
+    return relationValue;
+  }
+
   openDialogForm() {
     const options = this.options;
     this.dialogInstance = this.$appModal.dialog(

package/zova/src/suite/cabloy-basic/modules/basic-image/cli/openapi.config.ts

@@ -0,0 +1,9 @@
+import type { ZovaOpenapiConfigModule } from 'zova-openapi';
+
+export default function (): ZovaOpenapiConfigModule {
+  return {
+    operations: {
+      match: [/^Image_*/],
+    },
+  };
+}

package/zova/src/suite/cabloy-basic/modules/basic-image/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "zova-module-basic-image",
+  "version": "5.0.0",
+  "description": "",
+  "keywords": [
+    "Zova Module"
+  ],
+  "author": "",
+  "files": [
+    "mock",
+    "dist",
+    "src",
+    "icons",
+    "assets",
+    "cli"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/zova.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "dependencies": {
+    "vue-advanced-cropper": "^2.8.9"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "replace": {
+      "exports.\\..types": "./dist/index.d.ts"
+    },
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "basic-image",
+  "zovaModule": {
+    "dependencies": {
+      "basic-app": "5.0.0"
+    }
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-image/src/.metadata/component/formFieldImage.ts

@@ -0,0 +1,31 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerFormFieldImageProps } from '../../component/formFieldImage/controller.jsx';
+
+import { ControllerFormFieldImage } from '../../component/formFieldImage/controller.jsx';
+export type ZFormFieldImageProps = {
+  controllerRef?: (ref: ControllerFormFieldImage) => void;
+} & ControllerFormFieldImageProps;
+
+type ControllerInnerProps = TypeControllerInnerProps<
+  ControllerFormFieldImageProps,
+  keyof typeof ControllerFormFieldImage.$propsDefault
+>;
+declare module 'zova-module-basic-image' {
+  export interface ControllerFormFieldImage {
+    $props: ControllerInnerProps;
+  }
+}
+
+export const ZFormFieldImage = defineComponent((_props: ZFormFieldImageProps) => {
+  useController(ControllerFormFieldImage, undefined, undefined);
+  return () => {};
+}, prepareComponentOptions(ControllerFormFieldImage.$componentOptions));
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'basic-image:formFieldImage': ControllerFormFieldImageProps;
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-image/src/.metadata/index.ts

@@ -0,0 +1,191 @@
+// eslint-disable
+/** api: begin */
+export * from '../api/image.js';
+
+import 'zova';
+declare module 'zova' {
+  
+  
+}
+declare module 'zova-module-basic-image' {
+  
+        export interface ApiImage {
+          /** @internal */
+          get scope(): ScopeModuleBasicImage;
+        }
+
+        export interface ApiImage {
+          get $beanFullName(): 'basic-image.api.image';
+          get $onionName(): 'basic-image:image';
+          
+        } 
+}
+/** api: end */
+/** api: begin */
+import { ApiImage } from '../api/image.js';
+export interface IModuleApi {
+  'image': ApiImage;
+}
+/** api: end */
+/** api: begin */
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'basic-image.api.image': ApiImage;
+  }
+}
+/** api: end */
+/** openapi: begin */
+export * from '../api/openapi/index.js';
+/** openapi: end */
+/** apiSchema: begin */
+export * from '../apiSchema/image.js';
+
+import 'zova';
+declare module 'zova' {
+  
+  
+}
+declare module 'zova-module-basic-image' {
+  
+        export interface ApiSchemaImage {
+          /** @internal */
+          get scope(): ScopeModuleBasicImage;
+        }
+
+        export interface ApiSchemaImage {
+          get $beanFullName(): 'basic-image.apiSchema.image';
+          get $onionName(): 'basic-image:image';
+          
+        } 
+}
+/** apiSchema: end */
+/** apiSchema: begin */
+import { ApiSchemaImage } from '../apiSchema/image.js';
+export interface IModuleApiSchema {
+  'image': ApiSchemaImage;
+}
+/** apiSchema: end */
+/** apiSchema: begin */
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'basic-image.apiSchema.image': ApiSchemaImage;
+  }
+}
+/** apiSchema: end */
+/** controller: begin */
+export * from '../component/formFieldImage/controller.jsx';
+
+import 'zova';
+declare module 'zova' {
+  
+  
+}
+declare module 'zova-module-basic-image' {
+  
+        export interface ControllerFormFieldImage {
+          /** @internal */
+          get scope(): ScopeModuleBasicImage;
+        } 
+}
+/** controller: end */
+/** controller: begin */
+import { ControllerFormFieldImage } from '../component/formFieldImage/controller.jsx';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordLocal {
+    'basic-image.controller.formFieldImage': ControllerFormFieldImage;
+  }
+}
+/** controller: end */
+
+/** components: begin */
+export * from './component/formFieldImage.js';
+import { ZFormFieldImage } from './component/formFieldImage.js';
+export const components = {
+  'formFieldImage': ZFormFieldImage,
+};
+import 'zova';
+declare module 'zova' {
+export interface IComponentRecord {
+  'basic-image:formFieldImage': ControllerFormFieldImage;
+}
+export interface IZovaComponentRecord {
+  'basic-image:formFieldImage': typeof ZFormFieldImage;
+}
+}
+/** components: end */
+/** tableCell: begin */
+export * from '../bean/tableCell.image.jsx';
+import { ITableCellOptionsImage } from '../bean/tableCell.image.jsx';
+import 'zova-module-a-table';
+declare module 'zova-module-a-table' {
+  
+    export interface ITableCellRecord {
+      'basic-image:image': ITableCellOptionsImage;
+    }
+
+  
+}
+declare module 'zova-module-basic-image' {
+  
+        export interface TableCellImage {
+          /** @internal */
+          get scope(): ScopeModuleBasicImage;
+        }
+
+        export interface TableCellImage {
+          get $beanFullName(): 'basic-image.tableCell.image';
+          get $onionName(): 'basic-image:image';
+          get $onionOptions(): ITableCellOptionsImage;
+        } 
+}
+/** tableCell: end */
+/** tableCell: begin */
+import { TableCellImage } from '../bean/tableCell.image.jsx';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'basic-image.tableCell.image': TableCellImage;
+  }
+}
+/** tableCell: end */
+/** locale: begin */
+import { locales } from './locales.js';
+/** locale: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, TypeModuleLocales, TypeLocaleBase } from 'zova';
+import { Scope } from 'zova-module-a-bean';
+
+@Scope()
+export class ScopeModuleBasicImage extends BeanScopeBase {}
+
+export interface ScopeModuleBasicImage {
+  util: BeanScopeUtil;
+locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+api: IModuleApi;
+apiSchema: IModuleApiSchema;
+}
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanScopeRecord {
+    'basic-image': ScopeModuleBasicImage;
+  }
+  
+  
+
+  export interface IBeanScopeLocale {
+    'basic-image': (typeof locales)[TypeLocaleBase];
+  }
+
+  
+}
+
+export function locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `basic-image::${K}` {
+  return `basic-image::${key}`;
+}  
+/** scope: end */

package/zova/src/suite/cabloy-basic/modules/basic-image/src/.metadata/locales.ts

@@ -0,0 +1,7 @@
+import locale_en_us from '../config/locale/en-us.js';
+import locale_zh_cn from '../config/locale/zh-cn.js';
+
+export const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn,
+};

package/zova/src/suite/cabloy-basic/modules/basic-image/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'basic-image';
+export { ScopeModuleBasicImage as ScopeModule } from './index.js';

package/zova/src/suite/cabloy-basic/modules/basic-image/src/api/image.ts

@@ -0,0 +1,104 @@
+import type { IApiActionOptions } from 'zova-module-a-api';
+
+import { Api, BeanApiBase } from 'zova-module-a-api';
+
+import type { components, paths } from './openapi/index.js';
+
+import { OpenApiBaseURL } from './openapi/index.js';
+
+/** Image_createUploadToken */
+export const ApiApiImagecreateUploadTokenPath = '/api/image/upload-token';
+export type ApiApiImagecreateUploadTokenPath = '/api/image/upload-token';
+export type ApiApiImagecreateUploadTokenMethod = 'post';
+export type ApiApiImagecreateUploadTokenRequestBody =
+  components['schemas']['a-image.dto.imageUploadTokenRequest'];
+export type ApiApiImagecreateUploadTokenResponseBody =
+  paths[ApiApiImagecreateUploadTokenPath][ApiApiImagecreateUploadTokenMethod]['responses']['200']['content']['application/json']['data'];
+
+/** Image_upload */
+export const ApiApiImageuploadPath = '/api/image/upload';
+export type ApiApiImageuploadPath = '/api/image/upload';
+export type ApiApiImageuploadMethod = 'post';
+export type ApiApiImageuploadRequestBody = {
+  token: string;
+  /** Format: binary */
+  image: Blob;
+};
+export type ApiApiImageuploadResponseBody =
+  paths[ApiApiImageuploadPath][ApiApiImageuploadMethod]['responses']['200']['content']['application/json']['data'];
+
+/** Image_createDirectUpload */
+export const ApiApiImagecreateDirectUploadPath = '/api/image/direct-upload';
+export type ApiApiImagecreateDirectUploadPath = '/api/image/direct-upload';
+export type ApiApiImagecreateDirectUploadMethod = 'post';
+export type ApiApiImagecreateDirectUploadRequestBody =
+  components['schemas']['a-image.dto.imageDirectUploadRequest'];
+export type ApiApiImagecreateDirectUploadResponseBody =
+  paths[ApiApiImagecreateDirectUploadPath][ApiApiImagecreateDirectUploadMethod]['responses']['200']['content']['application/json']['data'];
+
+/** Image_uploadUrl */
+export const ApiApiImageuploadUrlPath = '/api/image/upload-url';
+export type ApiApiImageuploadUrlPath = '/api/image/upload-url';
+export type ApiApiImageuploadUrlMethod = 'post';
+export type ApiApiImageuploadUrlRequestBody =
+  components['schemas']['a-image.dto.imageUploadUrlRequest'];
+export type ApiApiImageuploadUrlResponseBody =
+  paths[ApiApiImageuploadUrlPath][ApiApiImageuploadUrlMethod]['responses']['200']['content']['application/json']['data'];
+
+/** Image_delivery */
+export const ApiApiImagedeliveryPath = '/api/image/delivery/{imageId}';
+export type ApiApiImagedeliveryPath = '/api/image/delivery/{imageId}';
+export type ApiApiImagedeliveryMethod = 'get';
+export type ApiApiImagedeliveryRequestParams =
+  paths[ApiApiImagedeliveryPath][ApiApiImagedeliveryMethod]['parameters']['path'];
+export type ApiApiImagedeliveryRequestQuery =
+  paths[ApiApiImagedeliveryPath][ApiApiImagedeliveryMethod]['parameters']['query'];
+export type ApiApiImagedeliveryResponseBody =
+  paths[ApiApiImagedeliveryPath][ApiApiImagedeliveryMethod]['responses']['200']['content']['application/json']['data'];
+
+@Api()
+export class ApiImage extends BeanApiBase {
+  createUploadToken(body: ApiApiImagecreateUploadTokenRequestBody, options?: IApiActionOptions) {
+    return this.$fetch.post<any, ApiApiImagecreateUploadTokenResponseBody>(
+      ApiApiImagecreateUploadTokenPath,
+      body,
+      this.$configPrepare(OpenApiBaseURL(this.sys), options, true),
+    );
+  }
+
+  upload(body: ApiApiImageuploadRequestBody, options?: IApiActionOptions) {
+    return this.$fetch.post<any, ApiApiImageuploadResponseBody>(
+      ApiApiImageuploadPath,
+      this.$formData(body),
+      this.$configPrepare(OpenApiBaseURL(this.sys), options, true),
+    );
+  }
+
+  createDirectUpload(body: ApiApiImagecreateDirectUploadRequestBody, options?: IApiActionOptions) {
+    return this.$fetch.post<any, ApiApiImagecreateDirectUploadResponseBody>(
+      ApiApiImagecreateDirectUploadPath,
+      body,
+      this.$configPrepare(OpenApiBaseURL(this.sys), options, true),
+    );
+  }
+
+  uploadUrl(body: ApiApiImageuploadUrlRequestBody, options?: IApiActionOptions) {
+    return this.$fetch.post<any, ApiApiImageuploadUrlResponseBody>(
+      ApiApiImageuploadUrlPath,
+      body,
+      this.$configPrepare(OpenApiBaseURL(this.sys), options, true),
+    );
+  }
+
+  delivery(
+    options: {
+      params: ApiApiImagedeliveryRequestParams;
+      query?: ApiApiImagedeliveryRequestQuery;
+    } & IApiActionOptions,
+  ) {
+    return this.$fetch.get<any, ApiApiImagedeliveryResponseBody>(
+      this.$pathTranslate(ApiApiImagedeliveryPath, options.params),
+      this.$configPrepare(OpenApiBaseURL(this.sys), options, true),
+    );
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-image/src/api/openapi/baseURL.ts

@@ -0,0 +1,5 @@
+import type { ZovaSys } from 'zova';
+
+export const OpenApiBaseURL = (sys: ZovaSys) => {
+  return sys.util.getOpenApiBaseURL('OPENAPI_BASE_URL_BASIC_IMAGE');
+};

package/zova/src/suite/cabloy-basic/modules/basic-image/src/api/openapi/index.ts

@@ -0,0 +1,3 @@
+export * from './baseURL.js';
+export * from './schemas.js';
+export * from './types.js';