add/air-table

Author: huongdang0208

src/app.module.ts

@@ -19,6 +19,8 @@ import { FileModule } from "./modules/file/file.module";
 import { AppController } from "./app.controller";
 import { ContactModule } from "./modules/contact/contact.module";
 import { ApiModule } from "./modules/api/api.module";
+import { AirMonitorModule } from './modules/air-monitor/air-monitor.module';
+import { DeviceModule } from './modules/device/device.module';
 
 @Module({
     imports: [
@@ -64,6 +66,8 @@ import { ApiModule } from "./modules/api/api.module";
         FileModule,
         ContactModule,
         ApiModule,
+        AirMonitorModule,
+        DeviceModule,
     ],
     controllers: [AppController],
     providers: [],

src/modules/air-monitor/air-monitor.module.ts

@@ -0,0 +1,10 @@
+import { Module } from "@nestjs/common";
+import { ApiModule } from "../api/api.module";
+import { AirMonitorResolver } from "./air-monitor.resolver";
+import { AirMonitorService } from "./air-monitor.service";
+
+@Module({
+    providers: [AirMonitorService, AirMonitorResolver],
+    imports: [ApiModule],
+})
+export class AirMonitorModule {}

src/modules/air-monitor/air-monitor.resolver.ts

@@ -0,0 +1,27 @@
+import { UseGuards } from "@nestjs/common";
+import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+import { Roles } from "../../decorators/roles/roles.decorator";
+import { Role } from "../../utils/types/role.enum";
+import { JwtAuthGuard } from "../../guards/auth/auth.guard";
+import { AirMonitorService } from "./air-monitor.service";
+import { AirMonitorDataResponse } from "./entities/air-monitor.entity";
+import { AirMonitorInput } from "./dto/input.dto";
+import { AirMonitorsResponse } from "./entities/air-monitors.entity";
+import { QueryInput } from "./dto/query.dto";
+
+@Resolver()
+export class AirMonitorResolver {
+    constructor(private readonly airMonitorService: AirMonitorService) {}
+
+    @Query(() => AirMonitorsResponse)
+    async allMonitors(@Args("filter", { nullable: true }) filter?: QueryInput) {
+        return this.airMonitorService.allData(filter);
+    }
+
+    @Mutation(() => AirMonitorDataResponse)
+    @UseGuards(JwtAuthGuard)
+    @Roles(Role.Admin)
+    async create_monitor(@Args("input") input: AirMonitorInput) {
+        return this.airMonitorService.create(input);
+    }
+}

src/modules/air-monitor/air-monitor.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from "@nestjs/common";
+import { AirMonitorApiService } from "../api/air-monitor.service";
+import { AirMonitorInput } from "./dto/input.dto";
+import { GraphQLError } from 'graphql';
+import { AirMonitorsResponse } from "./entities/air-monitors.entity";
+
+@Injectable()
+export class AirMonitorService {
+    constructor(private readonly airMonitorApi: AirMonitorApiService) {}
+
+    async create(input: AirMonitorInput) {
+        try {
+            const data = await this.airMonitorApi.createMonitorApi(input);
+            if (data) {
+                return data;
+            }
+        } catch (err) {
+            throw new Error(err);
+        }
+    }
+
+    async allData(filter: { page: number; perPage: number }): Promise<AirMonitorsResponse> {
+        try {
+            const data = await this.airMonitorApi.queryAllAirMonitorData(filter) as AirMonitorsResponse;
+            console.log('***', data)
+            if (data) return data;
+        } catch (err) {
+            throw new GraphQLError(err)
+        }
+    }
+}

src/modules/air-monitor/dto/input.dto.ts

@@ -0,0 +1,55 @@
+
+import { Field, InputType } from '@nestjs/graphql';
+import { IsNumber, IsOptional, IsString } from 'class-validator';
+@InputType()
+export class AirMonitorInput {
+    @Field(() => String)
+    @IsString()
+    @IsOptional()
+    serial_num: string;
+
+    @Field(() => Number)
+    @IsNumber()
+    @IsOptional()
+    co2: number;
+
+    @Field(() => Number)
+    @IsNumber()
+    @IsOptional()
+    aqi: number;
+
+    @Field(() => Number)
+    @IsNumber()
+    @IsOptional()
+    humid: number;
+
+    @Field(() => Number)
+    @IsNumber()
+    @IsOptional()
+    pm1: number;
+
+    @Field(() => Number)
+    @IsNumber()
+    @IsOptional()
+    pm25: number;
+
+    @Field(() => Number)
+    @IsNumber()
+    @IsOptional()
+    pm10: number;
+
+    @Field(() => Number)
+    @IsNumber()
+    @IsOptional()
+    tvoc: number;
+
+    @Field(() => Number)
+    @IsNumber()
+    @IsOptional()
+    tem: number;
+
+    @Field(() => Number)
+    @IsNumber()
+    @IsOptional()
+    hcho: number;
+}

src/modules/air-monitor/dto/query.dto.ts

@@ -0,0 +1,10 @@
+import { Field, InputType, Int } from "@nestjs/graphql";
+
+@InputType()
+export class QueryInput {
+    @Field(() => Int)
+    page: number;
+
+    @Field(() => Int)
+    perPage: number;
+}

src/modules/air-monitor/entities/air-monitor.entity.ts

@@ -0,0 +1,41 @@
+import { Field, ObjectType } from "@nestjs/graphql";
+import { IsDate, IsString } from "class-validator";
+@ObjectType()
+export class AirMonitorDataResponse {
+    @Field(() => Number, { nullable: false })
+    id: number;
+
+    @Field(() => String)
+    @IsString()
+    serial_num: string;
+
+    @Field(() => String, { nullable: true })
+    created_date: string;
+
+    @Field(() => Number, { nullable: true })
+    co2: number;
+
+    @Field(() => Number, { nullable: true })
+    aqi: number;
+
+    @Field(() => Number, { nullable: true })
+    humid: number;
+
+    @Field(() => Number, { nullable: true })
+    pm1: number;
+
+    @Field(() => Number, { nullable: true })
+    pm25: number;
+
+    @Field(() => Number, { nullable: true })
+    pm10: number;
+
+    @Field(() => Number, { nullable: true })
+    tvoc: number;
+
+    @Field(() => Number, { nullable: true })
+    tem: number;
+
+    @Field(() => Number, { nullable: true })
+    hcho: number;
+}

src/modules/air-monitor/entities/air-monitors.entity.ts

@@ -0,0 +1,12 @@
+import { Field, ObjectType } from "@nestjs/graphql";
+import { PaginateInfo } from "../../../common/dto/paginateInfo.response";
+import { AirMonitorDataResponse } from "./air-monitor.entity";
+
+@ObjectType()
+export class AirMonitorsResponse {
+    @Field(() => [AirMonitorDataResponse], {nullable: true})
+    devices: AirMonitorDataResponse[];
+
+    @Field(() => PaginateInfo, { nullable: true })
+    paginateInfo: PaginateInfo;
+}

src/modules/api/air-monitor.service.ts

@@ -0,0 +1,39 @@
+import { HttpService } from "@nestjs/axios";
+import { Injectable } from "@nestjs/common";
+import { catchError, firstValueFrom } from "rxjs";
+import { ConfigService } from "@nestjs/config";
+import { AxiosError } from "axios";
+import { AirMonitorDataResponse } from "../air-monitor/entities/air-monitor.entity";
+import { AirMonitorInput } from "../air-monitor/dto/input.dto";
+import { AirMonitorsResponse } from "../air-monitor/entities/air-monitors.entity";
+
+@Injectable()
+export class AirMonitorApiService {
+    constructor(
+        private readonly httpService: HttpService,
+        private config: ConfigService,
+    ) {}
+    private readonly base_url = this.config.get("API_BASE_URL");
+
+    async createMonitorApi(params: AirMonitorInput): Promise<AirMonitorDataResponse> {
+        const { data } = await firstValueFrom(
+            this.httpService.post(`${this.base_url}/air-monitor/create`, params).pipe(
+                catchError((err: AxiosError) => {
+                    throw err;
+                }),
+            ),
+        );
+        return data;
+    }
+
+    async queryAllAirMonitorData(filter: { page: number; perPage: number }): Promise<AirMonitorsResponse> {
+        const { data } = await firstValueFrom(
+            this.httpService.get(`${this.base_url}/air-monitor/all`, { params: { filter } }).pipe(
+                catchError((err: AxiosError) => {
+                    throw err;
+                }),
+            ),
+        );
+        return data;
+    }
+}

src/modules/api/api.module.ts

@@ -6,10 +6,12 @@ import { BlogApiService } from "./blog-api.service";
 import { ProductApiService } from "./product-api.service";
 import { OrderApiService } from "./order-api.service";
 import { ContactApiService } from "./contact-api.service";
+import { AirMonitorApiService } from "./air-monitor.service";
+import { DeviceApiService } from "./device.service";
 
 @Module({
-    providers: [AuthApiService, BlogApiService, ProductApiService, OrderApiService, ContactApiService],
+    providers: [AuthApiService, BlogApiService, ProductApiService, OrderApiService, ContactApiService, AirMonitorApiService, DeviceApiService],
     imports: [HttpModule],
-    exports: [AuthApiService, BlogApiService, ProductApiService, OrderApiService, ContactApiService],
+    exports: [AuthApiService, BlogApiService, ProductApiService, OrderApiService, ContactApiService, AirMonitorApiService, DeviceApiService],
 })
 export class ApiModule {}

src/modules/api/device.service.ts

@@ -0,0 +1,50 @@
+import { HttpService } from "@nestjs/axios";
+import { Injectable } from "@nestjs/common";
+import { catchError, firstValueFrom } from "rxjs";
+import { ConfigService } from "@nestjs/config";
+import { AxiosError } from "axios";
+import { DeviceResponse } from "../device/entities/device.entity";
+import { CreateItemInput, UpdateItemInput } from "../device/dto/input.dto";
+import { DevicesResponse } from "../device/dto/response.dto";
+
+@Injectable()
+export class DeviceApiService {
+    constructor(
+        private readonly httpService: HttpService,
+        private config: ConfigService,
+    ) {}
+    private readonly base_url = this.config.get("API_BASE_URL");
+
+    async allDevices(filter: { page: number; perPage: number }): Promise<DevicesResponse> {
+        const { data } = await firstValueFrom(
+            this.httpService.get(`${this.base_url}/item/all-items`, { params: { filter } }).pipe(
+                catchError((err: AxiosError) => {
+                    throw err;
+                }),
+            ),
+        );
+        return data;
+    }  
+
+    async createDevice(params: CreateItemInput): Promise<DeviceResponse> {
+        const { data } = await firstValueFrom(
+            this.httpService.post(`${this.base_url}/item/create`, params).pipe(
+                catchError((err: AxiosError) => {
+                    throw err;
+                }),
+            ),
+        );
+        return data;
+    }
+
+    async updateBlogApi(params: UpdateItemInput, deviceID: number): Promise<DeviceResponse> {
+        const { data } = await firstValueFrom(
+            this.httpService.patch(`${this.base_url}/item/${deviceID}`, params).pipe(
+                catchError((err: AxiosError) => {
+                    throw err;
+                }),
+            ),
+        );
+        return data;
+    }
+}

src/modules/authenticate/authenticate.service.ts

@@ -46,8 +46,10 @@ export class AuthenticateService {
             const res = await this.authApiService.register(registerAuthenticateInput);
             if (!res) {
             }
+            console.log(res)
             return res;
         } catch (error) {
+            console.log(error)
             throw error;
         }
     }

src/modules/device/device.module.ts

@@ -0,0 +1,10 @@
+import { Module } from "@nestjs/common";
+import { ApiModule } from "../api/api.module";
+import { DeviceResolver } from "./device.resolver";
+import { DeviceService } from "./device.service";
+
+@Module({
+    providers: [DeviceResolver, DeviceService],
+    imports: [ApiModule],
+})
+export class DeviceModule {}

src/modules/device/device.resolver.ts

@@ -0,0 +1,35 @@
+import { UseGuards } from "@nestjs/common";
+import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+import { Roles } from "../../decorators/roles/roles.decorator";
+import { JwtAuthGuard } from "../../guards/auth/auth.guard";
+import { Role } from "../../utils/types/role.enum";
+import { DeviceService } from "./device.service";
+import { CreateItemInput, UpdateItemInput } from "./dto/input.dto";
+import { DeviceQueryInput } from "./dto/query.dto";
+import { DevicesResponse } from "./dto/response.dto";
+import { DeviceResponse } from "./entities/device.entity";
+
+@Resolver()
+export class DeviceResolver {
+    constructor(private deviceService: DeviceService) {}
+
+    @Query(() => DevicesResponse)
+    async all_devices(@Args("filter", { nullable: true }) filter?: DeviceQueryInput) {
+        const data = await this.deviceService.all(filter);
+        return data || [];
+    }
+
+    @Mutation(() => DeviceResponse)
+    @UseGuards(JwtAuthGuard)
+    @Roles(Role.Admin)
+    async create_device (@Args("input") input: CreateItemInput) {
+        return this.deviceService.create(input);
+    }
+
+    @Mutation(() => DeviceResponse)
+    @Roles(Role.Admin)
+    @UseGuards(JwtAuthGuard)
+    async update_device (@Args("id") id: number, @Args("input") input: UpdateItemInput) {
+        return this.deviceService.update(input, id);
+    }
+}