feat(SPG-347) REST API CUD Tipe Season

src/app.module.ts

@@ -28,6 +28,8 @@ import { VipCodeModule } from './modules/transaction/vip-code/vip-code.module';
 import { VipCodeModel } from './modules/transaction/vip-code/data/models/vip-code.model';
 import { ItemModule } from './modules/item-related/item/item.module';
 import { ItemModel } from './modules/item-related/item/data/models/item.model';
+import { SeasonTypeModule } from './modules/season-related/season-type/season-type.module';
+import { SeasonTypeModel } from './modules/season-related/season-type/data/models/season-type.model';
 
 @Module({
   imports: [
@@ -45,11 +47,12 @@ import { ItemModel } from './modules/item-related/item/data/models/item.model';
       database: process.env.DEFAULT_DB_NAME,
       entities: [
         ...UserPrivilegeModels,
-        UserModel,
-        LogModel,
         ErrorLogModel,
         ItemModel,
         ItemCategoryModel,
+        LogModel,
+        SeasonTypeModel,
+        UserModel,
         VipCategoryModel,
         VipCodeModel,
       ],
@@ -74,6 +77,9 @@ import { ItemModel } from './modules/item-related/item/data/models/item.model';
     // transaction
     VipCategoryModule,
     VipCodeModule,
+
+    // session
+    SeasonTypeModule,
   ],
   controllers: [],
   providers: [

src/core/strings/constants/module.constants.ts

@@ -1,6 +1,7 @@
 export enum MODULE_NAME {
   ITEM = 'items',
   ITEM_CATEGORY = 'item-categories',
+  SEASON_TYPE = 'season-types',
   TENANT = 'tenants',
   USER = 'users',
   USER_PRIVILEGE = 'user-privileges',

src/core/strings/constants/table.constants.ts

@@ -3,6 +3,7 @@ export enum TABLE_NAME {
   ITEM = 'items',
   ITEM_CATEGORY = 'item_categories',
   LOG = 'logs',
+  SEASON_TYPE = 'season_types',
   TENANT = 'tenants',
   USER = 'users',
   USER_PRIVILEGE = 'user_privileges',

src/database/migrations/1718097870787-item.ts

@@ -1,34 +1,67 @@
-import { MigrationInterface, QueryRunner } from "typeorm";
+import { MigrationInterface, QueryRunner } from 'typeorm';
 
 export class Item1718097870787 implements MigrationInterface {
-    name = 'Item1718097870787'
+  name = 'Item1718097870787';
 
-    public async up(queryRunner: QueryRunner): Promise<void> {
+  public async up(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(`CREATE TYPE "public"."items_status_enum" AS ENUM('active', 'cancel', 'confirmed', 'draft', 'expired', 'inactive', 'pending', 'refunded', 'rejected', 'settled', 'waiting')`);
+    await queryRunner.query(
-        await queryRunner.query(`CREATE TYPE "public"."items_item_type_enum" AS ENUM('tiket masuk', 'wahana', 'bundling', 'free gift')`);
+      `CREATE TYPE "public"."items_status_enum" AS ENUM('active', 'cancel', 'confirmed', 'draft', 'expired', 'inactive', 'pending', 'refunded', 'rejected', 'settled', 'waiting')`,
-        await queryRunner.query(`CREATE TYPE "public"."items_limit_type_enum" AS ENUM('no limit', 'time limit', 'qty limit')`);
+    );
-        await queryRunner.query(`CREATE TABLE "items" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "status" "public"."items_status_enum" NOT NULL DEFAULT 'draft', "name" character varying NOT NULL, "image" character varying, "item_type" "public"."items_item_type_enum" NOT NULL DEFAULT 'tiket masuk', "hpp" bigint, "sales_margin" integer, "total_price" bigint, "base_price" bigint, "use_queue" boolean NOT NULL DEFAULT false, "show_to_booking" boolean NOT NULL DEFAULT false, "limit_type" "public"."items_limit_type_enum" NOT NULL DEFAULT 'no limit', "limit_value" integer, "item_category_id" uuid, "tenant_id" uuid, CONSTRAINT "PK_ba5885359424c15ca6b9e79bcf6" PRIMARY KEY ("id"))`);
+    await queryRunner.query(
-        await queryRunner.query(`CREATE TABLE "item_bundlings" ("item_bundling_id" uuid NOT NULL, "item_id" uuid NOT NULL, CONSTRAINT "PK_da8e062f97fe862c3e60ed929b5" PRIMARY KEY ("item_bundling_id", "item_id"))`);
+      `CREATE TYPE "public"."items_item_type_enum" AS ENUM('tiket masuk', 'wahana', 'bundling', 'free gift')`,
-        await queryRunner.query(`CREATE INDEX "IDX_a50e7abf2caba4d0394f3726b8" ON "item_bundlings" ("item_bundling_id") `);
+    );
-        await queryRunner.query(`CREATE INDEX "IDX_edb9c8d945303a725f6b8648a0" ON "item_bundlings" ("item_id") `);
+    await queryRunner.query(
-        await queryRunner.query(`ALTER TABLE "items" ADD CONSTRAINT "FK_205e327d4c1bf3cdc00852845e6" FOREIGN KEY ("item_category_id") REFERENCES "item_categories"("id") ON DELETE CASCADE ON UPDATE CASCADE`);
+      `CREATE TYPE "public"."items_limit_type_enum" AS ENUM('no limit', 'time limit', 'qty limit')`,
-        await queryRunner.query(`ALTER TABLE "items" ADD CONSTRAINT "FK_d7d027b642add7f0e77c36b874f" FOREIGN KEY ("tenant_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE`);
+    );
-        await queryRunner.query(`ALTER TABLE "item_bundlings" ADD CONSTRAINT "FK_a50e7abf2caba4d0394f3726b86" FOREIGN KEY ("item_bundling_id") REFERENCES "items"("id") ON DELETE CASCADE ON UPDATE CASCADE`);
+    await queryRunner.query(
-        await queryRunner.query(`ALTER TABLE "item_bundlings" ADD CONSTRAINT "FK_edb9c8d945303a725f6b8648a00" FOREIGN KEY ("item_id") REFERENCES "items"("id") ON DELETE CASCADE ON UPDATE CASCADE`);
+      `CREATE TABLE "items" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "status" "public"."items_status_enum" NOT NULL DEFAULT 'draft', "name" character varying NOT NULL, "image" character varying, "item_type" "public"."items_item_type_enum" NOT NULL DEFAULT 'tiket masuk', "hpp" bigint, "sales_margin" integer, "total_price" bigint, "base_price" bigint, "use_queue" boolean NOT NULL DEFAULT false, "show_to_booking" boolean NOT NULL DEFAULT false, "limit_type" "public"."items_limit_type_enum" NOT NULL DEFAULT 'no limit', "limit_value" integer, "item_category_id" uuid, "tenant_id" uuid, CONSTRAINT "PK_ba5885359424c15ca6b9e79bcf6" PRIMARY KEY ("id"))`,
-    }
+    );
-
+    await queryRunner.query(
-    public async down(queryRunner: QueryRunner): Promise<void> {
+      `CREATE TABLE "item_bundlings" ("item_bundling_id" uuid NOT NULL, "item_id" uuid NOT NULL, CONSTRAINT "PK_da8e062f97fe862c3e60ed929b5" PRIMARY KEY ("item_bundling_id", "item_id"))`,
-        await queryRunner.query(`ALTER TABLE "item_bundlings" DROP CONSTRAINT "FK_edb9c8d945303a725f6b8648a00"`);
+    );
-        await queryRunner.query(`ALTER TABLE "item_bundlings" DROP CONSTRAINT "FK_a50e7abf2caba4d0394f3726b86"`);
+    await queryRunner.query(
-        await queryRunner.query(`ALTER TABLE "items" DROP CONSTRAINT "FK_d7d027b642add7f0e77c36b874f"`);
+      `CREATE INDEX "IDX_a50e7abf2caba4d0394f3726b8" ON "item_bundlings" ("item_bundling_id") `,
-        await queryRunner.query(`ALTER TABLE "items" DROP CONSTRAINT "FK_205e327d4c1bf3cdc00852845e6"`);
+    );
-        await queryRunner.query(`DROP INDEX "public"."IDX_edb9c8d945303a725f6b8648a0"`);
+    await queryRunner.query(
-        await queryRunner.query(`DROP INDEX "public"."IDX_a50e7abf2caba4d0394f3726b8"`);
+      `CREATE INDEX "IDX_edb9c8d945303a725f6b8648a0" ON "item_bundlings" ("item_id") `,
-        await queryRunner.query(`DROP TABLE "item_bundlings"`);
+    );
-        await queryRunner.query(`DROP TABLE "items"`);
+    await queryRunner.query(
-        await queryRunner.query(`DROP TYPE "public"."items_limit_type_enum"`);
+      `ALTER TABLE "items" ADD CONSTRAINT "FK_205e327d4c1bf3cdc00852845e6" FOREIGN KEY ("item_category_id") REFERENCES "item_categories"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
-        await queryRunner.query(`DROP TYPE "public"."items_item_type_enum"`);
+    );
-        await queryRunner.query(`DROP TYPE "public"."items_status_enum"`);
+    await queryRunner.query(
-    }
+      `ALTER TABLE "items" ADD CONSTRAINT "FK_d7d027b642add7f0e77c36b874f" FOREIGN KEY ("tenant_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "item_bundlings" ADD CONSTRAINT "FK_a50e7abf2caba4d0394f3726b86" FOREIGN KEY ("item_bundling_id") REFERENCES "items"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "item_bundlings" ADD CONSTRAINT "FK_edb9c8d945303a725f6b8648a00" FOREIGN KEY ("item_id") REFERENCES "items"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
 
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "item_bundlings" DROP CONSTRAINT "FK_edb9c8d945303a725f6b8648a00"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "item_bundlings" DROP CONSTRAINT "FK_a50e7abf2caba4d0394f3726b86"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "items" DROP CONSTRAINT "FK_d7d027b642add7f0e77c36b874f"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "items" DROP CONSTRAINT "FK_205e327d4c1bf3cdc00852845e6"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_edb9c8d945303a725f6b8648a0"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_a50e7abf2caba4d0394f3726b8"`,
+    );
+    await queryRunner.query(`DROP TABLE "item_bundlings"`);
+    await queryRunner.query(`DROP TABLE "items"`);
+    await queryRunner.query(`DROP TYPE "public"."items_limit_type_enum"`);
+    await queryRunner.query(`DROP TYPE "public"."items_item_type_enum"`);
+    await queryRunner.query(`DROP TYPE "public"."items_status_enum"`);
+  }
 }

src/database/migrations/1718160037461-season-type.ts

@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class SeasonType1718160037461 implements MigrationInterface {
+  name = 'SeasonType1718160037461';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TYPE "public"."season_types_status_enum" AS ENUM('active', 'cancel', 'confirmed', 'draft', 'expired', 'inactive', 'pending', 'refunded', 'rejected', 'settled', 'waiting')`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "season_types" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "status" "public"."season_types_status_enum" NOT NULL DEFAULT 'draft', "name" character varying NOT NULL, CONSTRAINT "PK_6b441ce8351cb93b9efb636f87e" PRIMARY KEY ("id"))`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "season_types"`);
+    await queryRunner.query(`DROP TYPE "public"."season_types_status_enum"`);
+  }
+}

src/modules/season-related/season-type/data/models/season-type.model.ts

@@ -0,0 +1,13 @@
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import { SeasonTypeEntity } from '../../domain/entities/season-type.entity';
+import { Column, Entity } from 'typeorm';
+import { BaseStatusModel } from 'src/core/modules/data/model/base-status.model';
+
+@Entity(TABLE_NAME.SEASON_TYPE)
+export class SeasonTypeModel
+  extends BaseStatusModel<SeasonTypeEntity>
+  implements SeasonTypeEntity
+{
+  @Column('varchar', { name: 'name' })
+  name: string;
+}

src/modules/season-related/season-type/data/services/season-type-data.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { BaseDataService } from 'src/core/modules/data/service/base-data.service';
+import { SeasonTypeEntity } from '../../domain/entities/season-type.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { SeasonTypeModel } from '../models/season-type.model';
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class SeasonTypeDataService extends BaseDataService<SeasonTypeEntity> {
+  constructor(
+    @InjectRepository(SeasonTypeModel, CONNECTION_NAME.DEFAULT)
+    private repo: Repository<SeasonTypeModel>,
+  ) {
+    super(repo);
+  }
+}

src/modules/season-related/season-type/domain/entities/event/season-type-change-status.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from 'src/core/strings/constants/interface.constants';
+
+export class SeasonTypeChangeStatusEvent {
+  constructor(public readonly data: IEvent) {}
+}

src/modules/season-related/season-type/domain/entities/event/season-type-created.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from 'src/core/strings/constants/interface.constants';
+
+export class SeasonTypeCreatedEvent {
+  constructor(public readonly data: IEvent) {}
+}

src/modules/season-related/season-type/domain/entities/event/season-type-deleted.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from 'src/core/strings/constants/interface.constants';
+
+export class SeasonTypeDeletedEvent {
+  constructor(public readonly data: IEvent) {}
+}

src/modules/season-related/season-type/domain/entities/event/season-type-updated.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from 'src/core/strings/constants/interface.constants';
+
+export class SeasonTypeUpdatedEvent {
+  constructor(public readonly data: IEvent) {}
+}

src/modules/season-related/season-type/domain/entities/season-type.entity.ts

@@ -0,0 +1,5 @@
+import { BaseStatusEntity } from 'src/core/modules/domain/entities/base-status.entity';
+
+export interface SeasonTypeEntity extends BaseStatusEntity {
+  name: string;
+}

src/modules/season-related/season-type/domain/usecases/managers/active-season-type.manager.ts

@@ -0,0 +1,45 @@
+import { Injectable } from '@nestjs/common';
+import { BaseUpdateStatusManager } from 'src/core/modules/domain/usecase/managers/base-update-status.manager';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { SeasonTypeChangeStatusEvent } from '../../entities/event/season-type-change-status.event';
+
+@Injectable()
+export class ActiveSeasonTypeManager extends BaseUpdateStatusManager<SeasonTypeEntity> {
+  getResult(): string {
+    return `Success active data ${this.result.name}`;
+  }
+
+  async validateProcess(): Promise<void> {
+    return;
+  }
+
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeChangeStatusEvent,
+        data: this.data,
+      },
+    ];
+  }
+}

src/modules/season-related/season-type/domain/usecases/managers/batch-active-season-type.manager.ts

@@ -0,0 +1,45 @@
+import { BaseBatchUpdateStatusManager } from 'src/core/modules/domain/usecase/managers/base-batch-update-status.manager';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { SeasonTypeChangeStatusEvent } from '../../entities/event/season-type-change-status.event';
+import { BatchResult } from 'src/core/response/domain/ok-response.interface';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class BatchActiveSeasonTypeManager extends BaseBatchUpdateStatusManager<SeasonTypeEntity> {
+  validateData(data: SeasonTypeEntity): Promise<void> {
+    return;
+  }
+
+  beforeProcess(): Promise<void> {
+    return;
+  }
+
+  afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeChangeStatusEvent,
+      },
+    ];
+  }
+
+  getResult(): BatchResult {
+    return this.result;
+  }
+}

src/modules/season-related/season-type/domain/usecases/managers/batch-confirm-season-type.manager.ts

@@ -0,0 +1,45 @@
+import { BaseBatchUpdateStatusManager } from 'src/core/modules/domain/usecase/managers/base-batch-update-status.manager';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { SeasonTypeChangeStatusEvent } from '../../entities/event/season-type-change-status.event';
+import { BatchResult } from 'src/core/response/domain/ok-response.interface';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class BatchConfirmSeasonTypeManager extends BaseBatchUpdateStatusManager<SeasonTypeEntity> {
+  validateData(data: SeasonTypeEntity): Promise<void> {
+    return;
+  }
+
+  beforeProcess(): Promise<void> {
+    return;
+  }
+
+  afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeChangeStatusEvent,
+      },
+    ];
+  }
+
+  getResult(): BatchResult {
+    return this.result;
+  }
+}

src/modules/season-related/season-type/domain/usecases/managers/batch-delete-season-type.manager.ts

@@ -0,0 +1,45 @@
+import { BaseBatchDeleteManager } from 'src/core/modules/domain/usecase/managers/base-batch-delete.manager';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { SeasonTypeDeletedEvent } from '../../entities/event/season-type-deleted.event';
+import { BatchResult } from 'src/core/response/domain/ok-response.interface';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class BatchDeleteSeasonTypeManager extends BaseBatchDeleteManager<SeasonTypeEntity> {
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+
+  async validateData(data: SeasonTypeEntity): Promise<void> {
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeDeletedEvent,
+      },
+    ];
+  }
+
+  getResult(): BatchResult {
+    return this.result;
+  }
+}

src/modules/season-related/season-type/domain/usecases/managers/batch-inactive-season-type.manager.ts

@@ -0,0 +1,45 @@
+import { BaseBatchUpdateStatusManager } from 'src/core/modules/domain/usecase/managers/base-batch-update-status.manager';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { SeasonTypeChangeStatusEvent } from '../../entities/event/season-type-change-status.event';
+import { BatchResult } from 'src/core/response/domain/ok-response.interface';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class BatchInactiveSeasonTypeManager extends BaseBatchUpdateStatusManager<SeasonTypeEntity> {
+  validateData(data: SeasonTypeEntity): Promise<void> {
+    return;
+  }
+
+  beforeProcess(): Promise<void> {
+    return;
+  }
+
+  afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeChangeStatusEvent,
+      },
+    ];
+  }
+
+  getResult(): BatchResult {
+    return this.result;
+  }
+}

src/modules/season-related/season-type/domain/usecases/managers/confirm-season-type.manager.ts

@@ -0,0 +1,45 @@
+import { Injectable } from '@nestjs/common';
+import { BaseUpdateStatusManager } from 'src/core/modules/domain/usecase/managers/base-update-status.manager';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { SeasonTypeChangeStatusEvent } from '../../entities/event/season-type-change-status.event';
+
+@Injectable()
+export class ConfirmSeasonTypeManager extends BaseUpdateStatusManager<SeasonTypeEntity> {
+  getResult(): string {
+    return `Success active data ${this.result.name}`;
+  }
+
+  async validateProcess(): Promise<void> {
+    return;
+  }
+
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeChangeStatusEvent,
+        data: this.data,
+      },
+    ];
+  }
+}

src/modules/season-related/season-type/domain/usecases/managers/create-season-type.manager.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@nestjs/common';
+import {
+  EventTopics,
+  columnUniques,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { BaseCreateManager } from 'src/core/modules/domain/usecase/managers/base-create.manager';
+import { SeasonTypeCreatedEvent } from '../../entities/event/season-type-created.event';
+
+@Injectable()
+export class CreateSeasonTypeManager extends BaseCreateManager<SeasonTypeEntity> {
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get uniqueColumns(): columnUniques[] {
+    return [{ column: 'name' }];
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeCreatedEvent,
+        data: this.data,
+      },
+    ];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+}

src/modules/season-related/season-type/domain/usecases/managers/delete-season-type.manager.ts

@@ -0,0 +1,45 @@
+import { Injectable } from '@nestjs/common';
+import { BaseDeleteManager } from 'src/core/modules/domain/usecase/managers/base-delete.manager';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { SeasonTypeDeletedEvent } from '../../entities/event/season-type-deleted.event';
+
+@Injectable()
+export class DeleteSeasonTypeManager extends BaseDeleteManager<SeasonTypeEntity> {
+  getResult(): string {
+    return `Success`;
+  }
+
+  async validateProcess(): Promise<void> {
+    return;
+  }
+
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeDeletedEvent,
+        data: this.data,
+      },
+    ];
+  }
+}

src/modules/season-related/season-type/domain/usecases/managers/inactive-season-type.manager.ts

@@ -0,0 +1,45 @@
+import { Injectable } from '@nestjs/common';
+import { BaseUpdateStatusManager } from 'src/core/modules/domain/usecase/managers/base-update-status.manager';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { SeasonTypeChangeStatusEvent } from '../../entities/event/season-type-change-status.event';
+
+@Injectable()
+export class InactiveSeasonTypeManager extends BaseUpdateStatusManager<SeasonTypeEntity> {
+  getResult(): string {
+    return `Success inactive data ${this.result.name}`;
+  }
+
+  async validateProcess(): Promise<void> {
+    return;
+  }
+
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeChangeStatusEvent,
+        data: this.data,
+      },
+    ];
+  }
+}

src/modules/season-related/season-type/domain/usecases/managers/update-season-type.manager.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@nestjs/common';
+import { BaseUpdateManager } from 'src/core/modules/domain/usecase/managers/base-update.manager';
+import { SeasonTypeEntity } from '../../entities/season-type.entity';
+import { SeasonTypeModel } from '../../../data/models/season-type.model';
+import { SeasonTypeUpdatedEvent } from '../../entities/event/season-type-updated.event';
+import {
+  EventTopics,
+  columnUniques,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+
+@Injectable()
+export class UpdateSeasonTypeManager extends BaseUpdateManager<SeasonTypeEntity> {
+  async validateProcess(): Promise<void> {
+    return;
+  }
+
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get uniqueColumns(): columnUniques[] {
+    return [{ column: 'name' }];
+  }
+
+  get entityTarget(): any {
+    return SeasonTypeModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: SeasonTypeUpdatedEvent,
+        data: this.data,
+      },
+    ];
+  }
+}

src/modules/season-related/season-type/domain/usecases/season-type-data.orchestrator.ts

@@ -0,0 +1,118 @@
+import { Injectable } from '@nestjs/common';
+import { CreateSeasonTypeManager } from './managers/create-season-type.manager';
+import { SeasonTypeDataService } from '../../data/services/season-type-data.service';
+import { SeasonTypeEntity } from '../entities/season-type.entity';
+import { DeleteSeasonTypeManager } from './managers/delete-season-type.manager';
+import { UpdateSeasonTypeManager } from './managers/update-season-type.manager';
+import { BaseDataTransactionOrchestrator } from 'src/core/modules/domain/usecase/orchestrators/base-data-transaction.orchestrator';
+import { ActiveSeasonTypeManager } from './managers/active-season-type.manager';
+import { InactiveSeasonTypeManager } from './managers/inactive-season-type.manager';
+import { ConfirmSeasonTypeManager } from './managers/confirm-season-type.manager';
+import { STATUS } from 'src/core/strings/constants/base.constants';
+import { BatchResult } from 'src/core/response/domain/ok-response.interface';
+import { BatchConfirmSeasonTypeManager } from './managers/batch-confirm-season-type.manager';
+import { BatchInactiveSeasonTypeManager } from './managers/batch-inactive-season-type.manager';
+import { BatchActiveSeasonTypeManager } from './managers/batch-active-season-type.manager';
+import { BatchDeleteSeasonTypeManager } from './managers/batch-delete-season-type.manager';
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+
+@Injectable()
+export class SeasonTypeDataOrchestrator extends BaseDataTransactionOrchestrator<SeasonTypeEntity> {
+  constructor(
+    private createManager: CreateSeasonTypeManager,
+    private updateManager: UpdateSeasonTypeManager,
+    private deleteManager: DeleteSeasonTypeManager,
+    private activeManager: ActiveSeasonTypeManager,
+    private confirmManager: ConfirmSeasonTypeManager,
+    private inactiveManager: InactiveSeasonTypeManager,
+    private batchDeleteManager: BatchDeleteSeasonTypeManager,
+    private batchActiveManager: BatchActiveSeasonTypeManager,
+    private batchConfirmManager: BatchConfirmSeasonTypeManager,
+    private batchInactiveManager: BatchInactiveSeasonTypeManager,
+    private serviceData: SeasonTypeDataService,
+  ) {
+    super();
+  }
+
+  async create(data): Promise<SeasonTypeEntity> {
+    this.createManager.setData(data);
+    this.createManager.setService(this.serviceData, TABLE_NAME.SEASON_TYPE);
+    await this.createManager.execute();
+    return this.createManager.getResult();
+  }
+
+  async update(dataId, data): Promise<SeasonTypeEntity> {
+    this.updateManager.setData(dataId, data);
+    this.updateManager.setService(this.serviceData, TABLE_NAME.SEASON_TYPE);
+    await this.updateManager.execute();
+    return this.updateManager.getResult();
+  }
+
+  async delete(dataId): Promise<String> {
+    this.deleteManager.setData(dataId);
+    this.deleteManager.setService(this.serviceData, TABLE_NAME.SEASON_TYPE);
+    await this.deleteManager.execute();
+    return this.deleteManager.getResult();
+  }
+
+  async batchDelete(dataIds: string[]): Promise<BatchResult> {
+    this.batchDeleteManager.setData(dataIds);
+    this.batchDeleteManager.setService(
+      this.serviceData,
+      TABLE_NAME.SEASON_TYPE,
+    );
+    await this.batchDeleteManager.execute();
+    return this.batchDeleteManager.getResult();
+  }
+
+  async active(dataId): Promise<String> {
+    this.activeManager.setData(dataId, STATUS.ACTIVE);
+    this.activeManager.setService(this.serviceData, TABLE_NAME.SEASON_TYPE);
+    await this.activeManager.execute();
+    return this.activeManager.getResult();
+  }
+
+  async batchActive(dataIds: string[]): Promise<BatchResult> {
+    this.batchActiveManager.setData(dataIds, STATUS.ACTIVE);
+    this.batchActiveManager.setService(
+      this.serviceData,
+      TABLE_NAME.SEASON_TYPE,
+    );
+    await this.batchActiveManager.execute();
+    return this.batchActiveManager.getResult();
+  }
+
+  async confirm(dataId): Promise<String> {
+    this.confirmManager.setData(dataId, STATUS.ACTIVE);
+    this.confirmManager.setService(this.serviceData, TABLE_NAME.SEASON_TYPE);
+    await this.confirmManager.execute();
+    return this.confirmManager.getResult();
+  }
+
+  async batchConfirm(dataIds: string[]): Promise<BatchResult> {
+    this.batchConfirmManager.setData(dataIds, STATUS.ACTIVE);
+    this.batchConfirmManager.setService(
+      this.serviceData,
+      TABLE_NAME.SEASON_TYPE,
+    );
+    await this.batchConfirmManager.execute();
+    return this.batchConfirmManager.getResult();
+  }
+
+  async inactive(dataId): Promise<String> {
+    this.inactiveManager.setData(dataId, STATUS.INACTIVE);
+    this.inactiveManager.setService(this.serviceData, TABLE_NAME.SEASON_TYPE);
+    await this.inactiveManager.execute();
+    return this.inactiveManager.getResult();
+  }
+
+  async batchInactive(dataIds: string[]): Promise<BatchResult> {
+    this.batchInactiveManager.setData(dataIds, STATUS.INACTIVE);
+    this.batchInactiveManager.setService(
+      this.serviceData,
+      TABLE_NAME.SEASON_TYPE,
+    );
+    await this.batchInactiveManager.execute();
+    return this.batchInactiveManager.getResult();
+  }
+}

src/modules/season-related/season-type/infrastructure/dto/season-type.dto.ts

@@ -0,0 +1,14 @@
+import { BaseStatusDto } from 'src/core/modules/infrastructure/dto/base-status.dto';
+import { SeasonTypeEntity } from '../../domain/entities/season-type.entity';
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString } from 'class-validator';
+
+export class SeasonTypeDto extends BaseStatusDto implements SeasonTypeEntity {
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: 'high sesason',
+  })
+  @IsString()
+  name: string;
+}

src/modules/season-related/season-type/infrastructure/season-type-data.controller.ts

@@ -0,0 +1,78 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Param,
+  Patch,
+  Post,
+  Put,
+} from '@nestjs/common';
+import { SeasonTypeDataOrchestrator } from '../domain/usecases/season-type-data.orchestrator';
+import { SeasonTypeDto } from './dto/season-type.dto';
+import { MODULE_NAME } from 'src/core/strings/constants/module.constants';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { SeasonTypeEntity } from '../domain/entities/season-type.entity';
+import { BatchResult } from 'src/core/response/domain/ok-response.interface';
+import { BatchIdsDto } from 'src/core/modules/infrastructure/dto/base-batch.dto';
+import { Public } from 'src/core/guards';
+
+@ApiTags(`${MODULE_NAME.SEASON_TYPE.split('-').join(' ')} - data`)
+@Controller(MODULE_NAME.SEASON_TYPE)
+@Public(false)
+@ApiBearerAuth('JWT')
+export class SeasonTypeDataController {
+  constructor(private orchestrator: SeasonTypeDataOrchestrator) {}
+
+  @Post()
+  async create(@Body() data: SeasonTypeDto): Promise<SeasonTypeEntity> {
+    return await this.orchestrator.create(data);
+  }
+
+  @Put('/batch-delete')
+  async batchDeleted(@Body() body: BatchIdsDto): Promise<BatchResult> {
+    return await this.orchestrator.batchDelete(body.ids);
+  }
+
+  @Patch(':id/active')
+  async active(@Param('id') dataId: string): Promise<String> {
+    return await this.orchestrator.active(dataId);
+  }
+
+  @Put('/batch-active')
+  async batchActive(@Body() body: BatchIdsDto): Promise<BatchResult> {
+    return await this.orchestrator.batchActive(body.ids);
+  }
+
+  @Patch(':id/confirm')
+  async confirm(@Param('id') dataId: string): Promise<String> {
+    return await this.orchestrator.confirm(dataId);
+  }
+
+  @Put('/batch-confirm')
+  async batchConfirm(@Body() body: BatchIdsDto): Promise<BatchResult> {
+    return await this.orchestrator.batchConfirm(body.ids);
+  }
+
+  @Patch(':id/inactive')
+  async inactive(@Param('id') dataId: string): Promise<String> {
+    return await this.orchestrator.inactive(dataId);
+  }
+
+  @Put('/batch-inactive')
+  async batchInactive(@Body() body: BatchIdsDto): Promise<BatchResult> {
+    return await this.orchestrator.batchInactive(body.ids);
+  }
+
+  @Put(':id')
+  async update(
+    @Param('id') dataId: string,
+    @Body() data: SeasonTypeDto,
+  ): Promise<SeasonTypeEntity> {
+    return await this.orchestrator.update(dataId, data);
+  }
+
+  @Delete(':id')
+  async delete(@Param('id') dataId: string): Promise<String> {
+    return await this.orchestrator.delete(dataId);
+  }
+}

src/modules/season-related/season-type/infrastructure/season-type-read.controller.ts

@@ -0,0 +1,30 @@
+import { Controller, Get, Param, Query } from '@nestjs/common';
+import { FilterSeasonTypeDto } from './dto/filter-season-type.dto';
+import { Pagination } from 'src/core/response';
+import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
+import { SeasonTypeEntity } from '../domain/entities/season-type.entity';
+import { SeasonTypeReadOrchestrator } from '../domain/usecases/season-type-read.orchestrator';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { MODULE_NAME } from 'src/core/strings/constants/module.constants';
+import { Public } from 'src/core/guards';
+
+@ApiTags(`${MODULE_NAME.SEASON_TYPE.split('-').join(' ')} - read`)
+@Controller(MODULE_NAME.SEASON_TYPE)
+@Public(false)
+@ApiBearerAuth('JWT')
+export class SeasonTypeReadController {
+  constructor(private orchestrator: SeasonTypeReadOrchestrator) {}
+
+  @Get()
+  @Pagination()
+  async index(
+    @Query() params: FilterSeasonTypeDto,
+  ): Promise<PaginationResponse<SeasonTypeEntity>> {
+    return await this.orchestrator.index(params);
+  }
+
+  @Get(':id')
+  async detail(@Param('id') id: string): Promise<SeasonTypeEntity> {
+    return await this.orchestrator.detail(id);
+  }
+}

src/modules/season-related/season-type/season-type.module.ts

@@ -0,0 +1,54 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+import { SeasonTypeDataService } from './data/services/season-type-data.service';
+import { SeasonTypeReadService } from './data/services/season-type-read.service';
+import { SeasonTypeReadController } from './infrastructure/season-type-read.controller';
+import { SeasonTypeReadOrchestrator } from './domain/usecases/season-type-read.orchestrator';
+import { SeasonTypeDataController } from './infrastructure/season-type-data.controller';
+import { SeasonTypeDataOrchestrator } from './domain/usecases/season-type-data.orchestrator';
+import { CreateSeasonTypeManager } from './domain/usecases/managers/create-season-type.manager';
+import { CqrsModule } from '@nestjs/cqrs';
+import { IndexSeasonTypeManager } from './domain/usecases/managers/index-season-type.manager';
+import { DeleteSeasonTypeManager } from './domain/usecases/managers/delete-season-type.manager';
+import { UpdateSeasonTypeManager } from './domain/usecases/managers/update-season-type.manager';
+import { ActiveSeasonTypeManager } from './domain/usecases/managers/active-season-type.manager';
+import { ConfirmSeasonTypeManager } from './domain/usecases/managers/confirm-season-type.manager';
+import { InactiveSeasonTypeManager } from './domain/usecases/managers/inactive-season-type.manager';
+import { DetailSeasonTypeManager } from './domain/usecases/managers/detail-season-type.manager';
+import { BatchDeleteSeasonTypeManager } from './domain/usecases/managers/batch-delete-season-type.manager';
+import { BatchActiveSeasonTypeManager } from './domain/usecases/managers/batch-active-season-type.manager';
+import { BatchConfirmSeasonTypeManager } from './domain/usecases/managers/batch-confirm-season-type.manager';
+import { BatchInactiveSeasonTypeManager } from './domain/usecases/managers/batch-inactive-season-type.manager';
+import { SeasonTypeModel } from './data/models/season-type.model';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    TypeOrmModule.forFeature([SeasonTypeModel], CONNECTION_NAME.DEFAULT),
+    CqrsModule,
+  ],
+  controllers: [SeasonTypeDataController, SeasonTypeReadController],
+  providers: [
+    IndexSeasonTypeManager,
+    DetailSeasonTypeManager,
+    CreateSeasonTypeManager,
+    DeleteSeasonTypeManager,
+    UpdateSeasonTypeManager,
+    ActiveSeasonTypeManager,
+    ConfirmSeasonTypeManager,
+    InactiveSeasonTypeManager,
+    BatchDeleteSeasonTypeManager,
+    BatchActiveSeasonTypeManager,
+    BatchConfirmSeasonTypeManager,
+    BatchInactiveSeasonTypeManager,
+
+    SeasonTypeDataService,
+    SeasonTypeReadService,
+
+    SeasonTypeDataOrchestrator,
+    SeasonTypeReadOrchestrator,
+  ],
+})
+export class SeasonTypeModule {}