eigen
/
pos-be
12
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 295 Wiki Activity

feat(SPG-347) REST API CUD Tipe Season

pull/2/head
ashar 2024-06-12 09:46:43 +07:00
parent 50cbaa38c1
commit 446295ee16
29 changed files with 888 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/app.module.ts
View File

@ -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: [

1
src/core/strings/constants/module.constants.ts
View File

@ -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',

1
src/core/strings/constants/table.constants.ts
View File

@ -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',

91
src/database/migrations/1718097870787-item.ts
View File

@ -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> {
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(`CREATE TYPE "public"."items_item_type_enum" AS ENUM('tiket masuk', 'wahana', 'bundling', 'free gift')`);
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(`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(`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(`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(`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"`);
}
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(
`CREATE TYPE "public"."items_item_type_enum" AS ENUM('tiket masuk', 'wahana', 'bundling', 'free gift')`,
);
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(
`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(
`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(
`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(
`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"`);
}
}

19
src/database/migrations/1718160037461-season-type.ts Normal file
View File

@ -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"`);
}
}

0
src/modules/season-related/season-type/constants.ts Normal file
View File

13
src/modules/season-related/season-type/data/models/season-type.model.ts Normal file
View File

@ -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;
}

17
src/modules/season-related/season-type/data/services/season-type-data.service.ts Normal file
View File

@ -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);
}
}

5
src/modules/season-related/season-type/domain/entities/event/season-type-change-status.event.ts Normal file
View File

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

5
src/modules/season-related/season-type/domain/entities/event/season-type-created.event.ts Normal file
View File

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

5
src/modules/season-related/season-type/domain/entities/event/season-type-deleted.event.ts Normal file
View File

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

5
src/modules/season-related/season-type/domain/entities/event/season-type-updated.event.ts Normal file
View File

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

5
src/modules/season-related/season-type/domain/entities/season-type.entity.ts Normal file
View File

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

45
src/modules/season-related/season-type/domain/usecases/managers/active-season-type.manager.ts Normal file
View File

@ -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,
},
];
}
}

45
src/modules/season-related/season-type/domain/usecases/managers/batch-active-season-type.manager.ts Normal file
View File

@ -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;
}
}

45
src/modules/season-related/season-type/domain/usecases/managers/batch-confirm-season-type.manager.ts Normal file
View File

@ -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;
}
}

45
src/modules/season-related/season-type/domain/usecases/managers/batch-delete-season-type.manager.ts Normal file
View File

@ -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;
}
}

45
src/modules/season-related/season-type/domain/usecases/managers/batch-inactive-season-type.manager.ts Normal file
View File

@ -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;
}
}

45
src/modules/season-related/season-type/domain/usecases/managers/confirm-season-type.manager.ts Normal file
View File

@ -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,
},
];
}
}

42
src/modules/season-related/season-type/domain/usecases/managers/create-season-type.manager.ts Normal file
View File

@ -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;
}
}

45
src/modules/season-related/season-type/domain/usecases/managers/delete-season-type.manager.ts Normal file
View File

@ -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,
},
];
}
}

45
src/modules/season-related/season-type/domain/usecases/managers/inactive-season-type.manager.ts Normal file
View File

@ -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,
},
];
}
}

46
src/modules/season-related/season-type/domain/usecases/managers/update-season-type.manager.ts Normal file
View File

@ -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,
},
];
}
}

118
src/modules/season-related/season-type/domain/usecases/season-type-data.orchestrator.ts Normal file
View File

@ -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();
}
}

0
src/modules/season-related/season-type/index.ts Normal file
View File

14
src/modules/season-related/season-type/infrastructure/dto/season-type.dto.ts Normal file
View File

@ -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;
}

78
src/modules/season-related/season-type/infrastructure/season-type-data.controller.ts Normal file
View File

@ -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);
}
}

30
src/modules/season-related/season-type/infrastructure/season-type-read.controller.ts Normal file
View File

@ -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);
}
}

54
src/modules/season-related/season-type/season-type.module.ts Normal file
View File

@ -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 {}