cabloy 5.1.113 → 5.1.115

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/bean/meta.version.ts

@@ -0,0 +1,137 @@
+import type { IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+
+@Meta()
+export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
+  async update(options: IMetaVersionUpdateOptions) {
+    if (options.version !== 1) return;
+
+    const entityCouponTemplate = this.scope.entity.couponTemplate;
+    await this.bean.model.createTable(entityCouponTemplate.$table, table => {
+      table.comment(entityCouponTemplate.$comment.$table);
+      table.basicFields();
+      table.string(entityCouponTemplate.name, 100).comment(entityCouponTemplate.$comment.name);
+      table.string(entityCouponTemplate.state, 20).comment(entityCouponTemplate.$comment.state);
+      table
+        .string(entityCouponTemplate.currency, 3)
+        .comment(entityCouponTemplate.$comment.currency);
+      table
+        .integer(entityCouponTemplate.discountCents)
+        .comment(entityCouponTemplate.$comment.discountCents);
+      table
+        .integer(entityCouponTemplate.minSpendCents)
+        .comment(entityCouponTemplate.$comment.minSpendCents);
+      table
+        .dateTime(entityCouponTemplate.validFrom)
+        .comment(entityCouponTemplate.$comment.validFrom);
+      table
+        .dateTime(entityCouponTemplate.validUntil)
+        .comment(entityCouponTemplate.$comment.validUntil);
+      table
+        .integer(entityCouponTemplate.totalIssueLimit)
+        .nullable()
+        .comment(entityCouponTemplate.$comment.totalIssueLimit);
+      table
+        .integer(entityCouponTemplate.totalUsageLimit)
+        .nullable()
+        .comment(entityCouponTemplate.$comment.totalUsageLimit);
+      table
+        .integer(entityCouponTemplate.perCustomerIssueLimit)
+        .nullable()
+        .comment(entityCouponTemplate.$comment.perCustomerIssueLimit);
+      table
+        .int0(entityCouponTemplate.issuedCount)
+        .comment(entityCouponTemplate.$comment.issuedCount);
+      table
+        .int0(entityCouponTemplate.redeemedCount)
+        .comment(entityCouponTemplate.$comment.redeemedCount);
+      table
+        .string(entityCouponTemplate.description, 255)
+        .nullable()
+        .comment(entityCouponTemplate.$comment.description);
+    });
+
+    const entityCouponGrant = this.scope.entity.couponGrant;
+    await this.bean.model.createTable(entityCouponGrant.$table, table => {
+      table.comment(entityCouponGrant.$comment.$table);
+      table.basicFields();
+      table
+        .tableIdentity(entityCouponGrant.templateId)
+        .comment(entityCouponGrant.$comment.templateId);
+      table.userId(entityCouponGrant.userId).comment(entityCouponGrant.$comment.userId);
+      table.string(entityCouponGrant.couponCode, 80).comment(entityCouponGrant.$comment.couponCode);
+      table.string(entityCouponGrant.state, 20).comment(entityCouponGrant.$comment.state);
+      table
+        .string(entityCouponGrant.templateNameSnapshot, 100)
+        .comment(entityCouponGrant.$comment.templateNameSnapshot);
+      table
+        .string(entityCouponGrant.currencySnapshot, 3)
+        .comment(entityCouponGrant.$comment.currencySnapshot);
+      table
+        .integer(entityCouponGrant.discountCentsSnapshot)
+        .comment(entityCouponGrant.$comment.discountCentsSnapshot);
+      table
+        .integer(entityCouponGrant.minSpendCentsSnapshot)
+        .comment(entityCouponGrant.$comment.minSpendCentsSnapshot);
+      table
+        .dateTime(entityCouponGrant.validFromSnapshot)
+        .comment(entityCouponGrant.$comment.validFromSnapshot);
+      table
+        .dateTime(entityCouponGrant.validUntilSnapshot)
+        .comment(entityCouponGrant.$comment.validUntilSnapshot);
+      table
+        .tableIdentity(entityCouponGrant.reservationOrderId)
+        .nullable()
+        .comment(entityCouponGrant.$comment.reservationOrderId);
+      table
+        .string(entityCouponGrant.reservationCorrelationId, 100)
+        .nullable()
+        .comment(entityCouponGrant.$comment.reservationCorrelationId);
+      table
+        .dateTime(entityCouponGrant.reservedAt)
+        .nullable()
+        .comment(entityCouponGrant.$comment.reservedAt);
+      table
+        .tableIdentity(entityCouponGrant.redeemedOrderId)
+        .nullable()
+        .comment(entityCouponGrant.$comment.redeemedOrderId);
+      table
+        .dateTime(entityCouponGrant.redeemedAt)
+        .nullable()
+        .comment(entityCouponGrant.$comment.redeemedAt);
+    });
+
+    const entityCouponAudit = this.scope.entity.couponAudit;
+    await this.bean.model.createTable(entityCouponAudit.$table, table => {
+      table.comment(entityCouponAudit.$comment.$table);
+      table.basicFields();
+      table
+        .tableIdentity(entityCouponAudit.couponGrantId)
+        .comment(entityCouponAudit.$comment.couponGrantId);
+      table
+        .tableIdentity(entityCouponAudit.templateId)
+        .comment(entityCouponAudit.$comment.templateId);
+      table.userId(entityCouponAudit.userId).comment(entityCouponAudit.$comment.userId);
+      table
+        .userId(entityCouponAudit.actorId)
+        .nullable()
+        .comment(entityCouponAudit.$comment.actorId);
+      table
+        .tableIdentity(entityCouponAudit.orderId)
+        .nullable()
+        .comment(entityCouponAudit.$comment.orderId);
+      table.string(entityCouponAudit.operation, 20).comment(entityCouponAudit.$comment.operation);
+      table
+        .string(entityCouponAudit.fromState, 20)
+        .nullable()
+        .comment(entityCouponAudit.$comment.fromState);
+      table.string(entityCouponAudit.toState, 20).comment(entityCouponAudit.$comment.toState);
+      table.string(entityCouponAudit.reason, 255).comment(entityCouponAudit.$comment.reason);
+      table
+        .string(entityCouponAudit.correlationId, 100)
+        .comment(entityCouponAudit.$comment.correlationId);
+    });
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/bean/ssrMenu.couponTemplate.ts

@@ -0,0 +1,30 @@
+import type { IDecoratorSsrMenuOptions } from 'vona-module-a-ssr';
+import type { ISsrSiteOptionsCommerceAdmin } from 'vona-module-commerce-siteadmin';
+
+import { BeanBase } from 'vona';
+import { $order } from 'vona-module-a-openapiutils';
+import { SsrMenu } from 'vona-module-a-ssr';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface ISsrMenuOptionsCouponTemplate extends IDecoratorSsrMenuOptions<ISsrSiteOptionsCommerceAdmin> {}
+
+@SsrMenu<ISsrMenuOptionsCouponTemplate>({
+  items: {
+    couponTemplate: {
+      title: $locale('CouponTemplate'),
+      order: $order(1),
+      icon: undefined,
+      link: 'presetResource',
+      meta: {
+        params: {
+          resource: 'commerce-promotion:couponTemplate',
+        },
+      },
+      group: 'commerce-siteadmin:catalog',
+      roles: ['systemAdmin'],
+    },
+  },
+  site: ['commerce-siteadmin:commerceAdmin'],
+})
+export class SsrMenuCouponTemplate extends BeanBase {}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/config/locale/en-us.ts

@@ -0,0 +1,37 @@
+export default {
+  ActorId: 'Actor ID',
+  CouponAudit: 'Coupon Audit',
+  CouponCode: 'Coupon Code',
+  CouponGrant: 'Coupon Grant',
+  CouponGrantId: 'Coupon Grant ID',
+  CouponGrantState: 'Coupon State',
+  CouponOperation: 'Coupon Operation',
+  CouponTemplate: 'Coupon Template',
+  CouponTemplateId: 'Coupon Template ID',
+  CouponTemplateState: 'Template State',
+  CorrelationId: 'Correlation ID',
+  Currency: 'Currency',
+  Description: 'Description',
+  DiscountCents: 'Fixed Discount (Cents)',
+  FromState: 'Previous State',
+  IssuedCount: 'Issued Count',
+  MinSpendCents: 'Minimum Spend (Cents)',
+  Name: 'Name',
+  Operations: 'Operations',
+  OrderId: 'Order ID',
+  PerCustomerIssueLimit: 'Per-customer Issue Limit',
+  Reason: 'Reason',
+  RedeemedAt: 'Redeemed At',
+  RedeemedCount: 'Redeemed Count',
+  RedeemedOrderId: 'Redeemed Order ID',
+  ReservationCorrelationId: 'Reservation Correlation ID',
+  ReservationOrderId: 'Reservation Order ID',
+  ReservedAt: 'Reserved At',
+  TemplateNameSnapshot: 'Template Name Snapshot',
+  ToState: 'New State',
+  TotalIssueLimit: 'Total Issue Limit',
+  TotalUsageLimit: 'Total Usage Limit',
+  UserId: 'User ID',
+  ValidFrom: 'Valid From',
+  ValidUntil: 'Valid Until',
+};

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/config/locale/zh-cn.ts

@@ -0,0 +1,37 @@
+export default {
+  ActorId: '操作人 ID',
+  CouponAudit: '优惠券审计',
+  CouponCode: '优惠券代码',
+  CouponGrant: '优惠券发放',
+  CouponGrantId: '优惠券发放 ID',
+  CouponGrantState: '优惠券状态',
+  CouponOperation: '优惠券操作',
+  CouponTemplate: '优惠券模板',
+  CouponTemplateId: '优惠券模板 ID',
+  CouponTemplateState: '模板状态',
+  CorrelationId: '关联 ID',
+  Currency: '币种',
+  Description: '描述',
+  DiscountCents: '固定优惠（分）',
+  FromState: '原状态',
+  IssuedCount: '已发放数',
+  MinSpendCents: '最低消费（分）',
+  Name: '名称',
+  Operations: '操作',
+  OrderId: '订单 ID',
+  PerCustomerIssueLimit: '每客户发放上限',
+  Reason: '原因',
+  RedeemedAt: '核销时间',
+  RedeemedCount: '已核销数',
+  RedeemedOrderId: '核销订单 ID',
+  ReservationCorrelationId: '保留关联 ID',
+  ReservationOrderId: '保留订单 ID',
+  ReservedAt: '保留时间',
+  TemplateNameSnapshot: '模板名称快照',
+  ToState: '新状态',
+  TotalIssueLimit: '总发放上限',
+  TotalUsageLimit: '总使用上限',
+  UserId: '用户 ID',
+  ValidFrom: '开始时间',
+  ValidUntil: '结束时间',
+};

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/controller/coupon.ts

@@ -0,0 +1,37 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Passport } from 'vona-module-a-user';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+
+import { DtoCouponIssue } from '../dto/couponIssue.tsx';
+import { DtoCouponMineItem } from '../dto/couponMineItem.tsx';
+
+export interface IControllerOptionsCoupon extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsCoupon>('coupon')
+export class ControllerCoupon extends BeanBase {
+  @Web.get('mine')
+  @Api.body(v.array(DtoCouponMineItem))
+  async mine(): Promise<DtoCouponMineItem[]> {
+    const grants = await this.scope.service.coupon.mine();
+    return grants.map(grant => ({
+      id: grant.id,
+      couponCode: grant.couponCode,
+      templateName: grant.templateNameSnapshot,
+      currency: grant.currencySnapshot,
+      discountCents: grant.discountCentsSnapshot,
+      minSpendCents: grant.minSpendCentsSnapshot,
+      validUntil: grant.validUntilSnapshot,
+    }));
+  }
+
+  @Web.post('issue')
+  @Api.body(v.tableIdentity())
+  @Passport.systemAdmin()
+  async issue(@Arg.body() command: DtoCouponIssue): Promise<TableIdentity> {
+    return (await this.scope.service.coupon.issue(command)).id;
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/controller/couponTemplate.ts

@@ -0,0 +1,65 @@
+import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { Api, Resource, v } from 'vona-module-a-openapiutils';
+import { Passport } from 'vona-module-a-user';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+import { z } from 'zod';
+
+import type { ModelCouponTemplate } from '../model/couponTemplate.ts';
+
+import { DtoCouponTemplateCreate } from '../dto/couponTemplateCreate.tsx';
+import { DtoCouponTemplateSelectReq } from '../dto/couponTemplateSelectReq.tsx';
+import { DtoCouponTemplateSelectRes } from '../dto/couponTemplateSelectRes.tsx';
+import { DtoCouponTemplateUpdate } from '../dto/couponTemplateUpdate.tsx';
+import { DtoCouponTemplateView } from '../dto/couponTemplateView.tsx';
+
+export interface IControllerOptionsCouponTemplate extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsCouponTemplate>('couponTemplate')
+@Resource()
+export class ControllerCouponTemplate extends BeanBase {
+  @Web.post()
+  @Api.body(v.tableIdentity())
+  @Passport.systemAdmin()
+  async create(@Arg.body() couponTemplate: DtoCouponTemplateCreate): Promise<TableIdentity> {
+    return (await this.scope.service.couponTemplate.create(couponTemplate)).id;
+  }
+
+  @Web.get()
+  @Api.body(DtoCouponTemplateSelectRes)
+  @Passport.systemAdmin()
+  async select(
+    @Arg.filter(DtoCouponTemplateSelectReq) params: IQueryParams<ModelCouponTemplate>,
+  ): Promise<DtoCouponTemplateSelectRes> {
+    return await this.scope.service.couponTemplate.select(params);
+  }
+
+  @Web.get(':id')
+  @Api.body(v.optional(), v.object(DtoCouponTemplateView))
+  @Passport.systemAdmin()
+  async view(
+    @Arg.param('id', v.tableIdentity()) id: TableIdentity,
+  ): Promise<DtoCouponTemplateView | undefined> {
+    return await this.scope.service.couponTemplate.view(id);
+  }
+
+  @Web.patch(':id')
+  @Api.body(z.null())
+  @Passport.systemAdmin()
+  async update(
+    @Arg.param('id', v.tableIdentity()) id: TableIdentity,
+    @Arg.body() couponTemplate: DtoCouponTemplateUpdate,
+  ): Promise<void> {
+    await this.scope.service.couponTemplate.update(id, couponTemplate);
+  }
+
+  @Web.delete(':id')
+  @Api.body(z.null())
+  @Passport.systemAdmin()
+  async delete(@Arg.param('id', v.tableIdentity()) id: TableIdentity): Promise<void> {
+    await this.scope.service.couponTemplate.delete(id);
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/dto/couponIssue.tsx

@@ -0,0 +1,22 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsCouponIssue extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCouponIssue>()
+export class DtoCouponIssue {
+  @Api.field(v.required(), v.tableIdentity())
+  templateId: TableIdentity;
+
+  @Api.field(v.required(), v.tableIdentity())
+  userId: TableIdentity;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  correlationId: string;
+
+  @Api.field(v.required(), v.min(1), v.max(255))
+  reason: string;
+}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/dto/couponMineItem.tsx

@@ -0,0 +1,32 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { z } from 'zod';
+
+export interface IDtoOptionsCouponMineItem extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCouponMineItem>()
+export class DtoCouponMineItem {
+  @Api.field(v.required(), v.tableIdentity())
+  id: TableIdentity;
+
+  @Api.field(v.required(), v.min(1), v.max(80))
+  couponCode: string;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  templateName: string;
+
+  @Api.field(v.required(), z.literal('USD'))
+  currency: 'USD';
+
+  @Api.field(v.required(), z.number().int().positive())
+  discountCents: number;
+
+  @Api.field(v.required(), z.number().int().nonnegative())
+  minSpendCents: number;
+
+  @Api.field(v.required())
+  validUntil: Date;
+}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/dto/couponTemplateCreate.tsx

@@ -0,0 +1,43 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { z } from 'zod';
+
+export interface IDtoOptionsCouponTemplateCreate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCouponTemplateCreate>()
+export class DtoCouponTemplateCreate {
+  @Api.field(v.required(), v.min(2), v.max(100))
+  name: string;
+
+  @Api.field(v.required(), z.enum(['draft', 'active']))
+  state: 'draft' | 'active';
+
+  @Api.field(v.required(), z.literal('USD'))
+  currency: 'USD';
+
+  @Api.field(v.required(), z.number().int().positive())
+  discountCents: number;
+
+  @Api.field(v.required(), z.number().int().nonnegative())
+  minSpendCents: number;
+
+  @Api.field(v.required())
+  validFrom: Date;
+
+  @Api.field(v.required())
+  validUntil: Date;
+
+  @Api.field(v.optional(), z.number().int().positive())
+  totalIssueLimit?: number;
+
+  @Api.field(v.optional(), z.number().int().positive())
+  totalUsageLimit?: number;
+
+  @Api.field(v.optional(), z.number().int().positive())
+  perCustomerIssueLimit?: number;
+
+  @Api.field(v.optional(), v.max(255))
+  description?: string;
+}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/dto/couponTemplateSelectReq.tsx

@@ -0,0 +1,28 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $makeSchema, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { EntityCouponTemplate } from '../entity/couponTemplate.tsx';
+
+export interface IDtoOptionsCouponTemplateSelectReq extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCouponTemplateSelectReq>({
+  openapi: { filter: { table: 'commercePromotionCouponTemplate' } },
+  fields: {
+    name: $makeSchema(v.optional(), z.string()),
+    createdAt: $makeSchema(
+      ZovaRender.field('basic-date:formFieldDateRange'),
+      v.filterTransform('a-web:dateRange'),
+      v.optional(),
+      z.string(),
+    ),
+  },
+})
+export class DtoCouponTemplateSelectReq extends $Dto.queryPage(EntityCouponTemplate, [
+  'name',
+  'createdAt',
+]) {}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/dto/couponTemplateSelectRes.tsx

@@ -0,0 +1,11 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+
+import { DtoCouponTemplateSelectResItem } from './couponTemplateSelectResItem.tsx';
+
+export interface IDtoOptionsCouponTemplateSelectRes extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCouponTemplateSelectRes>()
+export class DtoCouponTemplateSelectRes extends $Dto.listAndCount(DtoCouponTemplateSelectResItem) {}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/dto/couponTemplateSelectResItem.tsx

@@ -0,0 +1,39 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+import { ModelCouponTemplate } from '../model/couponTemplate.ts';
+
+export interface IDtoOptionsCouponTemplateSelectResItem extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCouponTemplateSelectResItem>({
+  blocks: [
+    ZovaRender.block('basic-page:blockPage', {
+      blocks: [
+        ZovaRender.block('basic-page:blockFilter'),
+        ZovaRender.block('basic-page:blockToolbarBulk', {
+          actions: [ZovaRender.tableActionBulk('basic-table:actionCreate')],
+        }),
+        ZovaRender.block('basic-page:blockTable'),
+        ZovaRender.block('basic-page:blockPager'),
+      ],
+    }),
+  ],
+})
+export class DtoCouponTemplateSelectResItem extends $Dto.get(() => ModelCouponTemplate) {
+  @Api.field(
+    v.title($locale('Operations')),
+    ZovaRender.order(1, 'max'),
+    ZovaRender.cell('basic-table:actionOperationsRow', {
+      actions: [
+        ZovaRender.tableActionRow('basic-table:actionUpdate'),
+        ZovaRender.tableActionRow('basic-table:actionDelete'),
+      ],
+    }),
+  )
+  _operationsRow?: unknown;
+}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/dto/couponTemplateUpdate.tsx

@@ -0,0 +1,19 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { z } from 'zod';
+
+export interface IDtoOptionsCouponTemplateUpdate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCouponTemplateUpdate>()
+export class DtoCouponTemplateUpdate {
+  @Api.field(v.optional(), v.min(2), v.max(100))
+  name?: string;
+
+  @Api.field(v.optional(), z.enum(['draft', 'active', 'disabled']))
+  state?: 'draft' | 'active' | 'disabled';
+
+  @Api.field(v.optional(), v.max(255))
+  description?: string;
+}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/dto/couponTemplateView.tsx

@@ -0,0 +1,25 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { ModelCouponTemplate } from '../model/couponTemplate.ts';
+
+export interface IDtoOptionsCouponTemplateView extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCouponTemplateView>({
+  blocks: [
+    ZovaRender.block('basic-pageentry:blockPageEntry', {
+      blocks: [
+        ZovaRender.block('basic-pageentry:blockForm'),
+        ZovaRender.block('basic-pageentry:blockToolbarRow', {
+          actions: [
+            ZovaRender.formActionRow('basic-form:actionBack', { permission: { public: true } }),
+          ],
+        }),
+      ],
+    }),
+  ],
+})
+export class DtoCouponTemplateView extends $Dto.get(() => ModelCouponTemplate) {}

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/entity/couponAudit.tsx

@@ -0,0 +1,73 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { z } from 'zod';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import type { TypeCouponGrantState } from './couponGrant.tsx';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export type TypeCouponAuditOperation = 'issue' | 'reserve' | 'release' | 'redeem' | 'expire';
+
+export interface IEntityOptionsCouponAudit extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsCouponAudit>('commercePromotionCouponAudit', {
+  openapi: { title: $locale('CouponAudit') },
+  fields: {
+    id: $makeMetadata(ZovaRender.order(1, 'core')),
+    iid: $makeMetadata(ZovaRender.visible(false)),
+    deleted: $makeMetadata(ZovaRender.visible(false)),
+    createdAt: $makeMetadata(
+      ZovaRender.order(-2, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+    updatedAt: $makeMetadata(ZovaRender.visible(false)),
+  },
+})
+export class EntityCouponAudit extends EntityBase {
+  @Api.field(v.title($locale('CouponGrantId')), v.required(), v.tableIdentity())
+  couponGrantId: TableIdentity;
+
+  @Api.field(v.title($locale('CouponTemplateId')), v.required(), v.tableIdentity())
+  templateId: TableIdentity;
+
+  @Api.field(v.title($locale('UserId')), v.required(), v.tableIdentity())
+  userId: TableIdentity;
+
+  @Api.field(v.title($locale('OrderId')), v.optional(), v.tableIdentity())
+  orderId?: TableIdentity;
+
+  @Api.field(v.title($locale('ActorId')), v.optional(), v.tableIdentity())
+  actorId?: TableIdentity;
+
+  @Api.field(
+    v.title($locale('CouponOperation')),
+    v.required(),
+    z.enum(['issue', 'reserve', 'release', 'redeem', 'expire']),
+  )
+  operation: TypeCouponAuditOperation;
+
+  @Api.field(
+    v.title($locale('FromState')),
+    v.optional(),
+    z.enum(['available', 'reserved', 'redeemed', 'expired']),
+  )
+  fromState?: TypeCouponGrantState;
+
+  @Api.field(
+    v.title($locale('ToState')),
+    v.required(),
+    z.enum(['available', 'reserved', 'redeemed', 'expired']),
+  )
+  toState: TypeCouponGrantState;
+
+  @Api.field(v.title($locale('Reason')), v.required(), v.min(1), v.max(255))
+  reason: string;
+
+  @Api.field(v.title($locale('CorrelationId')), v.required(), v.min(1), v.max(100))
+  correlationId: string;
+}