feat(SPG-320) REST API CUD User Privileges

src/modules/user-related/user-privilege/data/service/user-privilege-data.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from "@nestjs/common";
+import { BaseDataService } from "src/core/modules/data/service/base-data.service";
+import { UserPrivilegeEntity } from "../../domain/entities/user-privilege.entity";
+import { InjectRepository } from "@nestjs/typeorm";
+import { UserPrivilegeModel } from "../model/user-privilege.model";
+import { CONNECTION_NAME } from "src/core/strings/constants/base.constants";
+import { Repository } from "typeorm";
+
+@Injectable()
+export class UserPrivilegeDataService extends BaseDataService<UserPrivilegeEntity> {
+
+    constructor(
+        @InjectRepository(UserPrivilegeModel, CONNECTION_NAME.DEFAULT)
+        private repo: Repository<UserPrivilegeModel>,
+    ) {
+    super(repo);
+    }
+
+}

src/modules/user-related/user-privilege/domain/entities/event/user-privilege-change-status.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from "@nestjs/cqrs";
+
+export class UserPrivilegeChangeStatusEvent {
+    constructor(public readonly data: IEvent) {}
+}

src/modules/user-related/user-privilege/domain/entities/event/user-privilege-created.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from "@nestjs/cqrs";
+
+export class UserPrivilegeCreatedEvent {
+    constructor(public readonly data: IEvent) {}
+}

src/modules/user-related/user-privilege/domain/entities/event/user-privilege-deleted.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from "@nestjs/cqrs";
+
+export class UserPrivilegeDeletedEvent {
+    constructor(public readonly data: IEvent) {}
+}

src/modules/user-related/user-privilege/domain/entities/event/user-privilege-updated.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from "@nestjs/cqrs";
+
+export class UserPrivilegeUpdatedEvent {
+    constructor(public readonly data: IEvent) {}
+}

src/modules/user-related/user-privilege/domain/entities/user-privilege.entity.ts

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

src/modules/user-related/user-privilege/domain/usecases/managers/active-user-privilege.manager.ts

@@ -0,0 +1,39 @@
+import { Injectable } from "@nestjs/common";
+import { BaseUpdateStatusManager } from "src/core/modules/domain/usecase/managers/base-update-status.manager";
+import { UserPrivilegeEntity } from "../../entities/user-privilege.entity";
+import { EventTopics } from "src/core/strings/constants/interface.constants";
+import { UserPrivilegeModel } from "../../../data/model/user-privilege.model";
+import { UserPrivilegeChangeStatusEvent } from "../../entities/event/user-privilege-change-status.event";
+
+@Injectable()
+export class ActiveUserPrivilegeManager extends BaseUpdateStatusManager<UserPrivilegeEntity> {
+
+    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 entityTarget(): any {
+        return UserPrivilegeModel;
+    }
+
+    get eventTopics(): EventTopics[] {
+        return [
+            {
+                topic: UserPrivilegeChangeStatusEvent,
+                data: this.data,
+            }
+        ];
+    }
+}

src/modules/user-related/user-privilege/domain/usecases/managers/confirm-user-privilege.manager.ts

@@ -0,0 +1,39 @@
+import { Injectable } from "@nestjs/common";
+import { BaseUpdateStatusManager } from "src/core/modules/domain/usecase/managers/base-update-status.manager";
+import { UserPrivilegeEntity } from "../../entities/user-privilege.entity";
+import { EventTopics } from "src/core/strings/constants/interface.constants";
+import { UserPrivilegeModel } from "../../../data/model/user-privilege.model";
+import { UserPrivilegeChangeStatusEvent } from "../../entities/event/user-privilege-change-status.event";
+
+@Injectable()
+export class ConfirmUserPrivilegeManager extends BaseUpdateStatusManager<UserPrivilegeEntity> {
+
+    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 entityTarget(): any {
+        return UserPrivilegeModel;
+    }
+
+    get eventTopics(): EventTopics[] {
+        return [
+            {
+                topic: UserPrivilegeChangeStatusEvent,
+                data: this.data,
+            }
+        ];
+    }
+}

src/modules/user-related/user-privilege/domain/usecases/managers/create-user-privilege.manager.ts

@@ -0,0 +1,35 @@
+import { BaseCreateManager } from "src/core/modules/domain/usecase/managers/base-create.manager";
+import { UserPrivilegeEntity } from "../../entities/user-privilege.entity";
+import { Injectable } from "@nestjs/common";
+import { UserPrivilegeModel } from "../../../data/model/user-privilege.model";
+import { EventTopics } from "src/core/strings/constants/interface.constants";
+import { UserPrivilegeCreatedEvent } from "../../entities/event/user-privilege-created.event";
+
+@Injectable()
+export class CreateUserPrivilegeManager extends BaseCreateManager<UserPrivilegeEntity> {
+    
+    async validateProcess(): Promise<void> {
+        return;
+    }
+
+    async beforeProcess(): Promise<void> {
+        return;
+    }
+
+    async afterProcess(): Promise<void> {
+        return;
+    }
+    
+    get eventTopics(): EventTopics[] {
+        return [
+            {
+                topic: UserPrivilegeCreatedEvent,
+                data: this.data,
+            }
+        ];
+    }
+
+    get entityTarget(): any {
+        return UserPrivilegeModel;
+    }
+}

src/modules/user-related/user-privilege/domain/usecases/managers/delete-user-privilege.manager.ts

@@ -0,0 +1,39 @@
+import { Injectable } from "@nestjs/common";
+import { BaseDeleteManager } from "src/core/modules/domain/usecase/managers/base-delete.manager";
+import { UserPrivilegeEntity } from "../../entities/user-privilege.entity";
+import { EventTopics } from "src/core/strings/constants/interface.constants";
+import { UserPrivilegeModel } from "../../../data/model/user-privilege.model";
+import { UserPrivilegeDeletedEvent } from "../../entities/event/user-privilege-deleted.event";
+
+@Injectable()
+export class DeleteUserPrivilegeManager extends BaseDeleteManager<UserPrivilegeEntity> {
+
+    getResult(): string {
+        return `Success`;
+    }
+
+    async validateProcess(): Promise<void> {
+        return;
+    }
+
+    async beforeProcess(): Promise<void> {
+        return;
+    }
+
+    async afterProcess(): Promise<void> {
+        return;
+    }
+
+    get entityTarget(): any {
+        return UserPrivilegeModel;
+    }
+
+    get eventTopics(): EventTopics[] {
+        return [
+            {
+                topic: UserPrivilegeDeletedEvent,
+                data: this.data,
+            }
+        ];
+    }
+}

src/modules/user-related/user-privilege/domain/usecases/managers/update-user-privilege.manager.ts

@@ -0,0 +1,35 @@
+import { Injectable } from "@nestjs/common";
+import { BaseUpdateManager } from "src/core/modules/domain/usecase/managers/base-update.manager";
+import { UserPrivilegeEntity } from "../../entities/user-privilege.entity";
+import { EventTopics } from "src/core/strings/constants/interface.constants";
+import { UserPrivilegeModel } from "../../../data/model/user-privilege.model";
+import { UserPrivilegeUpdatedEvent } from "../../entities/event/user-privilege-updated.event";
+
+@Injectable()
+export class UpdateUserPrivilegeManager extends BaseUpdateManager<UserPrivilegeEntity> {
+    
+    async validateProcess(): Promise<void> {
+        return;
+    }
+
+    async beforeProcess(): Promise<void> {
+        return;
+    }
+
+    async afterProcess(): Promise<void> {
+        return;
+    }
+
+    get entityTarget(): any {
+        return UserPrivilegeModel;
+    }
+
+    get eventTopics(): EventTopics[] {
+        return [
+            {
+                topic: UserPrivilegeUpdatedEvent,
+                data: this.data,
+            }
+        ];
+    }
+}

src/modules/user-related/user-privilege/domain/usecases/user-privilege-data.orchestrator.ts

@@ -0,0 +1,69 @@
+import { Injectable } from "@nestjs/common";
+import { CreateUserPrivilegeManager } from "./managers/create-user-privilege.manager";
+import { UserPrivilegeDataService } from "../../data/service/user-privilege-data.service";
+import { UserPrivilegeEntity } from "../entities/user-privilege.entity";
+import { DeleteUserPrivilegeManager } from "./managers/delete-user-privilege.manager";
+import { UpdateUserPrivilegeManager } from "./managers/update-user-privilege.manager";
+import { BaseDataTransactionOrchestrator } from "src/core/modules/domain/usecase/orchestrators/base-data-transaction.orchestrator";
+import { ActiveUserPrivilegeManager } from "./managers/active-user-privilege.manager";
+import { InactiveUserPrivilegeManager } from "./managers/inactive-user-privilege.manager";
+import { ConfirmUserPrivilegeManager } from "./managers/confirm-user-privilege.manager";
+import { STATUS } from "src/core/strings/constants/base.constants";
+
+@Injectable()
+export class UserPrivilegeDataOrchestrator extends BaseDataTransactionOrchestrator<UserPrivilegeEntity> {
+
+    constructor(
+        private createManager: CreateUserPrivilegeManager,
+        private updateManager: UpdateUserPrivilegeManager,
+        private deleteManager: DeleteUserPrivilegeManager,
+        private activeManager: ActiveUserPrivilegeManager,
+        private confirmManager: ConfirmUserPrivilegeManager,
+        private inactiveManager: InactiveUserPrivilegeManager,
+        private serviceData: UserPrivilegeDataService,
+    ) {
+        super();
+    }
+
+    async create(data): Promise<UserPrivilegeEntity> {
+        this.createManager.setData(data);
+        this.createManager.setService(this.serviceData);
+        await this.createManager.execute()
+        return this.createManager.getResult();
+    }
+
+    async update(dataId, data): Promise<UserPrivilegeEntity> {
+        this.updateManager.setData(dataId, data);
+        this.updateManager.setService(this.serviceData);
+        await this.updateManager.execute();
+        return this.updateManager.getResult();
+    }
+
+    async delete(dataId): Promise<String> {
+        this.deleteManager.setData(dataId);
+        this.deleteManager.setService(this.serviceData);
+        await this.deleteManager.execute();
+        return this.deleteManager.getResult();
+    }
+
+    async active(dataId): Promise<String> {
+        this.activeManager.setData(dataId, STATUS.ACTIVE)
+        this.activeManager.setService(this.serviceData);
+        await this.activeManager.execute();
+        return this.activeManager.getResult();
+    }
+
+    async confirm(dataId): Promise<String> {
+        this.confirmManager.setData(dataId, STATUS.ACTIVE)
+        this.confirmManager.setService(this.serviceData);
+        await this.confirmManager.execute();
+        return this.confirmManager.getResult();
+    }
+
+    async inactive(dataId): Promise<String> {
+        this.inactiveManager.setData(dataId, STATUS.INACTIVE)
+        this.inactiveManager.setService(this.serviceData);
+        await this.inactiveManager.execute();
+        return this.inactiveManager.getResult();
+    }
+}

src/modules/user-related/user-privilege/infrastructure/dto/create-user-privilege.dto.ts

@@ -0,0 +1,10 @@
+import { BaseStatusDto } from "src/core/modules/infrastructure/dto/base-status.dto";
+import { UserPrivilegeEntity } from "../../domain/entities/user-privilege.entity";
+import { ApiProperty } from "@nestjs/swagger";
+import { IsString } from "class-validator";
+
+export class CreateUserPrivilegeDto extends BaseStatusDto implements UserPrivilegeEntity {
+    @ApiProperty({ name: 'name', required: true })
+    @IsString()
+    name: string;
+}

src/modules/user-related/user-privilege/infrastructure/user-privilege-data.controller.ts

@@ -0,0 +1,102 @@
+import { Body, Controller, Delete, Param, Patch, Post, Put } from "@nestjs/common";
+import { UserPrivilegeDataOrchestrator } from "../domain/usecases/user-privilege-data.orchestrator";
+import { CreateUserPrivilegeDto } from "./dto/create-user-privilege.dto";
+import { MODULE_NAME } from "src/core/strings/constants/module.constants";
+import { ApiTags } from "@nestjs/swagger";
+import { Unprotected } from "src/core/guards";
+import * as Nano  from 'nano'
+import { UserPrivilegeEntity } from "../domain/entities/user-privilege.entity";
+
+@ApiTags(`${MODULE_NAME.USER_PRIVILEGE.split('-').join(' ')} - data`)
+@Controller(MODULE_NAME.USER_PRIVILEGE)
+@Unprotected()
+export class UserPrivilegeDataController {
+    constructor(
+        private orchestrator: UserPrivilegeDataOrchestrator
+    ) {}
+
+    @Post()
+    async create(
+        @Body() data: CreateUserPrivilegeDto,
+    ): Promise<UserPrivilegeEntity> {
+        return await this.orchestrator.create(data);
+    }
+
+    @Put(':id')
+    async update(
+        @Param('id') dataId: string,
+        @Body() data: CreateUserPrivilegeDto,
+    ): Promise<UserPrivilegeEntity> {
+        return await this.orchestrator.update(dataId, data);
+    }
+
+    @Delete(':id')
+    async delete(
+        @Param('id') dataId: string,
+    ): Promise<String> {
+        return await this.orchestrator.delete(dataId);
+    }
+
+    @Patch(':id/active')
+    async active(
+        @Param('id') dataId: string,
+    ): Promise<String> {
+        return await this.orchestrator.active(dataId);
+    }
+    
+    @Patch(':id/confirm')
+    async confirm(
+        @Param('id') dataId: string,
+    ): Promise<String> {
+        return await this.orchestrator.confirm(dataId);
+    }
+
+    @Patch(':id/inactive')
+    async inactive(
+        @Param('id') dataId: string,
+    ): Promise<String> {
+        return await this.orchestrator.inactive(dataId);
+    }
+
+
+    // @Post('pouch')
+    // async createDoc(
+    //     @Body() entity: CreateUserPrivilegeDto
+    // ) {
+    //     try {
+    //         let n = Nano('http://admin:secret@127.0.0.1:5984')
+    //         let db = await n.db.create('people')
+    //     } catch (error) {
+    //         console.log(error, 'dsa')
+    //     }
+    // }
+
+    // @Post('pouch/doc')
+    // async createDocs(
+    //     @Body() entity: CreateUserPrivilegeDto
+    // ) {
+    //     try {
+    //         let n = Nano('http://admin:secret@127.0.0.1:5984')
+    //         const people = n.use('people');
+    //         const data = {
+    //             id: '1212',
+    //             name: 'dsadas'
+    //         }
+    //         return await people.insert({'_id': 'dsa', '_rev': JSON.stringify({'dsa': 'dsa'})})
+    //     } catch (error) {
+    //         console.log(error, 'dsa')
+    //     }
+    // }
+
+    // @Get('pouch')
+    // async getDoc(
+    // ) {
+    //     try {
+    //         let n = Nano('http://admin:secret@127.0.0.1:5984')
+    //         const people = n.use('people');
+    //         // return people.get();
+    //     } catch (error) {
+    //         console.log(error, 'dsa')
+    //     }
+    // }
+}