.

src/app.module.ts

@@ -13,7 +13,10 @@ import { FileModule } from './file/file.module'
 import { SysConfigModule } from './sys-config/sys-config.module'
 import { AllExceptionsFilter } from './filters/all-exceptions-filter.filter'
 import { ScheduleModule } from '@nestjs/schedule'
-import { RcsModule } from './rcs/rcs.module';
+import { RcsNumberModule } from './rcs-number/rcs-number.module'
+import { TaskModule } from './task/task.module'
+import { PhoneListModule } from './phone-list/phone-list.module'
+import { DeviceModule } from './device/device.module'
 
 @Module({
     imports: [
@@ -67,7 +70,10 @@ import { RcsModule } from './rcs/rcs.module';
         AuthModule,
         FileModule,
         SysConfigModule,
-        RcsModule,
+        RcsNumberModule,
+        TaskModule,
+        PhoneListModule,
+        DeviceModule
     ],
     controllers: [],
     providers: [

src/device/device.controller.ts

@@ -0,0 +1,19 @@
+import { Body, Controller, Delete, Param, Post } from '@nestjs/common'
+import { DeviceService } from './device.service'
+import { PageRequest } from 'src/common/dto/page-request'
+import { Device } from './entities/device.entity'
+
+@Controller('device')
+export class DeviceController {
+    constructor(private readonly deviceService: DeviceService) {}
+
+    @Post('/')
+    async findAllDevice(@Body() page: PageRequest<Device>) {
+        return await this.deviceService.findAllDevice(page)
+    }
+
+    @Delete('/:id')
+    async deviceDisconnect(@Param('id') id: string) {
+        return await this.deviceService.deleteDevice(id)
+    }
+}

src/device/device.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common'
+import { DeviceService } from './device.service'
+import { DeviceController } from './device.controller'
+import { TypeOrmModule } from '@nestjs/typeorm'
+import { Device } from './entities/device.entity'
+
+@Module({
+    imports: [TypeOrmModule.forFeature([Device])],
+    providers: [DeviceService],
+    controllers: [DeviceController],
+    exports: [DeviceService]
+})
+export class DeviceModule {}

src/device/device.service.ts

@@ -0,0 +1,67 @@
+import { Injectable } from '@nestjs/common'
+import { PageRequest } from '../common/dto/page-request'
+import { Device } from './entities/device.entity'
+import { Pagination, paginate } from 'nestjs-typeorm-paginate'
+import { InjectRepository } from '@nestjs/typeorm'
+import { Repository } from 'typeorm'
+
+@Injectable()
+export class DeviceService {
+    constructor(
+        @InjectRepository(Device)
+        private deviceRepository: Repository<Device>
+    ) {}
+
+    async findAllDevice(req: PageRequest<Device>): Promise<Pagination<Device>> {
+        return await paginate<Device>(this.deviceRepository, req.page, req.search)
+    }
+
+    async deleteDevice(id: string) {
+        await this.deviceRepository.delete(id)
+    }
+
+    async deviceConnect(id: string, socketId: string, model: string, name?: string, canSend: boolean = false) {
+        let device = await this.deviceRepository.findOneBy({ id })
+        if (!device) {
+            device = new Device()
+        }
+        device.id = id
+        device.socketId = socketId
+        device.model = model
+        device.name = name
+        device.online = true
+        device.canSend = canSend
+        device.busy = false
+        await this.deviceRepository.save(device)
+    }
+
+    async deviceDisconnect(id: string) {
+        const device = await this.deviceRepository.findOneBy({ id })
+        if (device) {
+            device.online = false
+            device.busy = false
+            device.canSend = false
+            await this.deviceRepository.save(device)
+        }
+    }
+
+    async updateDevice(socketId: string, data: any) {
+        const device = await this.deviceRepository.findOneBy({ socketId })
+        if (device) {
+            Object.assign(device, data)
+            await this.deviceRepository.save(device)
+        }
+    }
+
+    async findAvailableDevice() {
+        return await this.deviceRepository.findOneBy({ online: true, busy: false, canSend: true })
+    }
+
+    async setBusy(id: string, busy: boolean) {
+        const device = await this.deviceRepository.findOneBy({ id })
+        if (device) {
+            device.busy = busy
+            await this.deviceRepository.save(device)
+        }
+    }
+}

src/events/events.gateway.ts

@@ -1,4 +1,4 @@
-import { Inject, Injectable, Logger, forwardRef } from '@nestjs/common'
+import { Inject, Logger, forwardRef } from '@nestjs/common'
 import {
     MessageBody,
     OnGatewayConnection,
@@ -9,9 +9,7 @@ import {
     WebSocketServer
 } from '@nestjs/websockets'
 import { Server, Socket } from 'socket.io'
-import { RcsService } from '../rcs/rcs.service'
-import { randomUUID } from 'crypto'
-import { string } from 'yup'
+import { DeviceService } from '../device/device.service'
 
 export interface Message {
     id: string
@@ -32,10 +30,7 @@ export class EventsGateway implements OnGatewayInit, OnGatewayConnection, OnGate
 
     private callbacks: { [key: string]: any } = {}
 
-    constructor(
-        @Inject(forwardRef(() => RcsService))
-        private readonly rcsService: RcsService
-    ) {}
+    constructor(private readonly deviceService: DeviceService) {}
 
     afterInit(server: any) {
         Logger.log('Initialized!', 'EventsGateway')
@@ -47,7 +42,7 @@ export class EventsGateway implements OnGatewayInit, OnGatewayConnection, OnGate
         const name = client.handshake.query.name as string
         const canSend = client.handshake.query.canSend === 'true'
         Logger.log(`Client connected: id=${id}, model=${model}, name=${name}`, 'EventsGateway')
-        this.rcsService.deviceConnect(id, client.id, model, name, canSend)
+        this.deviceService.deviceConnect(id, client.id, model, name, canSend)
     }
 
     handleDisconnect(client: any) {
@@ -55,14 +50,14 @@ export class EventsGateway implements OnGatewayInit, OnGatewayConnection, OnGate
         const model = client.handshake.query.model
         const name = client.handshake.query.name
         Logger.log(`Client disconnected: id=${id}, model=${model}, name=${name}`, 'EventsGateway')
-        this.rcsService.deviceDisconnect(client.handshake.query.id as string)
+        this.deviceService.deviceDisconnect(client.handshake.query.id as string)
     }
 
     @SubscribeMessage('message')
     handleEvent(client: Socket, data: any) {
         Logger.log(`Client ${client.id} sent: ${JSON.stringify(data)}`, 'EventsGateway')
         if ('updateDevice' === data.action) {
-            this.rcsService.updateDevice(client.id, data.data)
+            this.deviceService.updateDevice(client.id, data.data)
         }
     }
 

src/events/events.module.ts

@@ -1,9 +1,9 @@
-import { Module, forwardRef } from '@nestjs/common'
+import { Module } from '@nestjs/common'
 import { EventsGateway } from './events.gateway'
-import { RcsModule } from '../rcs/rcs.module'
+import { DeviceModule } from 'src/device/device.module'
 
 @Module({
-    imports: [forwardRef(() => RcsModule)],
+    imports: [DeviceModule],
     providers: [EventsGateway],
     exports: [EventsGateway]
 })

src/phone-list/phone-list.controller.ts

@@ -0,0 +1,53 @@
+import { Body, Controller, Delete, Param, Post, Put, Req, UploadedFile, UseInterceptors } from '@nestjs/common'
+import { PageRequest } from 'src/common/dto/page-request'
+import { PhoneList } from './entities/phone-list.entity'
+import { Phone } from './entities/phone.entity'
+import { PhoneListService } from './phone-list.service'
+import { FileInterceptor } from '@nestjs/platform-express'
+
+@Controller('phone-list')
+export class PhoneListController {
+    constructor(private readonly phoneListService: PhoneListService) {}
+
+    @Post('/')
+    async findAllPhoneList(@Body() page: PageRequest<PhoneList>) {
+        return await this.phoneListService.findAllPhoneList(page)
+    }
+
+    @Put('/')
+    async createPhoneList(@Req() req) {
+        return await this.phoneListService.createPhoneList(req.body)
+    }
+
+    @Post('/phone')
+    async findAllPhone(@Body() page: PageRequest<Phone>) {
+        return await this.phoneListService.findAllPhone(page)
+    }
+
+    @Put('/phone')
+    async createPhone(@Req() req) {
+        return await this.phoneListService.createPhone(req.body)
+    }
+
+    @Delete('/phone/:id')
+    async delPhone(@Param('id') id: string) {
+        return await this.phoneListService.delPhone(parseInt(id))
+    }
+
+    @Delete('/:id')
+    async delPhoneList(@Param('id') id: string) {
+        return await this.phoneListService.delPhoneList(parseInt(id))
+    }
+
+    @Post('/:id/import')
+    @UseInterceptors(FileInterceptor('file'))
+    async importPhoneList(@Param('id') id: string, @UploadedFile() file: Express.Multer.File) {
+        const { buffer } = file
+        const phones = buffer
+            .toString()
+            .replaceAll('\r\n', '\n')
+            .split('\n')
+            .filter((phone) => phone.length > 0)
+        await this.phoneListService.importList(parseInt(id), phones)
+    }
+}

src/phone-list/phone-list.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common'
+import { PhoneListController } from './phone-list.controller'
+import { PhoneListService } from './phone-list.service'
+import { TypeOrmModule } from '@nestjs/typeorm'
+import { PhoneList } from './entities/phone-list.entity'
+import { Phone } from './entities/phone.entity'
+
+@Module({
+    imports: [TypeOrmModule.forFeature([PhoneList, Phone])],
+    controllers: [PhoneListController],
+    providers: [PhoneListService],
+    exports: [PhoneListService]
+})
+export class PhoneListModule {}

src/phone-list/phone-list.service.ts

@@ -0,0 +1,56 @@
+import { Injectable } from '@nestjs/common'
+import { InjectRepository } from '@nestjs/typeorm'
+import { PhoneList } from './entities/phone-list.entity'
+import { Repository } from 'typeorm'
+import { Phone } from './entities/phone.entity'
+import { PageRequest } from '../common/dto/page-request'
+import { Pagination, paginate } from 'nestjs-typeorm-paginate'
+
+@Injectable()
+export class PhoneListService {
+    constructor(
+        @InjectRepository(PhoneList)
+        private phoneListRepository: Repository<PhoneList>,
+        @InjectRepository(Phone)
+        private phoneRepository: Repository<Phone>
+    ) {}
+
+    async findAllPhoneList(req: PageRequest<PhoneList>): Promise<Pagination<PhoneList>> {
+        return await paginate<PhoneList>(this.phoneListRepository, req.page, req.search)
+    }
+
+    async findAllPhone(req: PageRequest<Phone>): Promise<Pagination<Phone>> {
+        return await paginate<Phone>(this.phoneRepository, req.page, req.search)
+    }
+
+    async createPhoneList(phoneList: PhoneList): Promise<PhoneList> {
+        return await this.phoneListRepository.save(phoneList)
+    }
+
+    async importList(listId: number, phones: string[]): Promise<Phone[]> {
+        return await this.phoneRepository.save(
+            phones.map((number) => {
+                const phone = new Phone()
+                phone.listId = listId
+                phone.number = number
+                return phone
+            })
+        )
+    }
+
+    async createPhone(phone: Phone): Promise<Phone> {
+        return await this.phoneRepository.save(phone)
+    }
+
+    async delPhoneList(id: number): Promise<void> {
+        await this.phoneListRepository.delete(id)
+    }
+
+    async delPhone(id: number): Promise<void> {
+        await this.phoneRepository.delete(id)
+    }
+
+    async findPhoneByListId(listId: number): Promise<Phone[]> {
+        return await this.phoneRepository.findBy({ listId })
+    }
+}

src/rcs/entities/number-request.entity.ts → src/rcs-number/entities/rcs-number.entity.ts

@@ -1,19 +1,20 @@
 import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn } from 'typeorm'
 import { JsonTransformer } from '../../transformers/json.transformer'
 
-export enum NumberRequestStatus {
+export enum RcsNumberStatus {
     PENDING = 'pending',
-    RECEIVED = 'received',
+    SUCCESS = 'success',
     EXPIRED = 'expired',
     ERROR = 'error'
 }
 
-export enum NumberRequestFrom {
-    USACODE = 'usacode'
+export enum RcsNumberSource {
+    usacode = 'usacode',
+    mwze167 = 'mwze167'
 }
 
 @Entity()
-export class NumberRequest {
+export class RcsNumber {
     @PrimaryGeneratedColumn()
     id: number
 
@@ -23,21 +24,21 @@ export class NumberRequest {
     @Column()
     expiryTime: Date
 
-    @Column({ type: 'enum', enum: NumberRequestFrom, nullable: false })
+    @Column({ type: 'enum', enum: RcsNumberSource, nullable: false })
     from: string
 
     @Column({ nullable: false })
     number: string
 
-    @Column()
+    @Column({ type: 'text' })
     message: string
 
-    @Column({ type: 'enum', enum: NumberRequestStatus, nullable: false, default: NumberRequestStatus.PENDING })
-    status: NumberRequestStatus
+    @Column({ type: 'enum', enum: RcsNumberStatus, nullable: false, default: RcsNumberStatus.PENDING })
+    status: RcsNumberStatus
 
     @Column({ type: 'text', transformer: new JsonTransformer() })
     extra: any
 
     @Column()
-    device: string
+    deviceId: string
 }

src/rcs-number/rcs-number.controller.ts

@@ -0,0 +1,24 @@
+import { Body, Controller, Post, Put } from '@nestjs/common'
+import { RcsNumberService } from './rcs-number.service'
+import { PageRequest } from '../common/dto/page-request'
+import { RcsNumber } from './entities/rcs-number.entity'
+
+@Controller('rcs-number')
+export class RcsNumberController {
+    constructor(private readonly rcsNumberService: RcsNumberService) {}
+
+    @Post('/')
+    async findAll(@Body() page: PageRequest<RcsNumber>) {
+        return await this.rcsNumberService.findAll(page)
+    }
+
+    @Put('/')
+    async create(@Body() rcsNumber: RcsNumber) {
+        return await this.rcsNumberService.create(rcsNumber)
+    }
+
+    @Post('/delete')
+    async delete(@Body() id: number) {
+        return await this.rcsNumberService.delete(id)
+    }
+}

src/rcs-number/rcs-number.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common'
+import { RcsNumberService } from './rcs-number.service'
+import { RcsNumberController } from './rcs-number.controller'
+import { TypeOrmModule } from '@nestjs/typeorm'
+import { RcsNumber } from './entities/rcs-number.entity'
+
+@Module({
+    imports: [TypeOrmModule.forFeature([RcsNumber])],
+    providers: [RcsNumberService],
+    controllers: [RcsNumberController],
+    exports: [RcsNumberService]
+})
+export class RcsNumberModule {}

src/rcs-number/rcs-number.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common'
+import { InjectRepository } from '@nestjs/typeorm'
+import { RcsNumber } from './entities/rcs-number.entity'
+import { PageRequest } from '../common/dto/page-request'
+import { Pagination, paginate } from 'nestjs-typeorm-paginate'
+import { Repository } from 'typeorm'
+import { USACodeApiService } from './usacode-api-service'
+
+@Injectable()
+export class RcsNumberService {
+    constructor(
+        @InjectRepository(RcsNumber)
+        private rcsNumberRepository: Repository<RcsNumber>
+    ) {}
+
+    async findAll(req: PageRequest<RcsNumber>): Promise<Pagination<RcsNumber>> {
+        return await paginate<RcsNumber>(this.rcsNumberRepository, req.page, req.search)
+    }
+
+    async create(data: RcsNumber): Promise<RcsNumber> {
+        return await this.rcsNumberRepository.save(data)
+    }
+
+    async delete(id: number): Promise<void> {
+        await this.rcsNumberRepository.delete(id)
+    }
+}

src/rcs/usacode-api-service.ts → src/rcs-number/usacode-api-service.ts

@@ -1,7 +1,6 @@
 import { Inject, Logger, OnModuleInit, forwardRef } from '@nestjs/common'
 import axios from 'axios'
 import * as WebSocket from 'ws'
-import { RcsService } from './rcs.service'
 import { Subject, takeUntil } from 'rxjs'
 import { randomUUID } from 'crypto'
 
@@ -16,8 +15,7 @@ export class USACodeApiService implements OnModuleInit {
     private readonly messageSubject = new Subject<any>()
 
     constructor(
-        @Inject(forwardRef(() => RcsService))
-        private readonly rcsService: RcsService
+   
     ) {}
 
     onModuleInit() {

src/rcs/rcs.controller.ts

@@ -1,92 +0,0 @@
-import { Body, Controller, Delete, Get, Param, Post, Put, Req, UploadedFile, UseInterceptors } from '@nestjs/common'
-import { RcsService } from './rcs.service'
-import { PageRequest } from '../common/dto/page-request'
-import { TaskItem } from './entities/task-item.entity'
-import { Task } from './entities/task.entity'
-import { Phone } from './entities/phone.entity'
-import { PhoneList } from './entities/phone-list.entity'
-import { Device } from './entities/device.entity'
-import { FileInterceptor } from '@nestjs/platform-express'
-import { Public } from 'src/auth/public.decorator'
-
-@Controller('rcs')
-export class RcsController {
-    constructor(private readonly rcsService: RcsService) {}
-
-    @Post('/phone-list')
-    async findAllPhoneList(@Body() page: PageRequest<PhoneList>) {
-        return await this.rcsService.findAllPhoneList(page)
-    }
-
-    @Post('/phone')
-    async findAllPhone(@Body() page: PageRequest<Phone>) {
-        return await this.rcsService.findAllPhone(page)
-    }
-
-    @Post('/task')
-    async findAllTask(@Body() page: PageRequest<Task>) {
-        return await this.rcsService.findAllTask(page)
-    }
-
-    @Post('/task-item')
-    async findAllTaskItem(@Body() page: PageRequest<TaskItem>) {
-        return await this.rcsService.findAllTaskItem(page)
-    }
-
-    @Put('/phone-list')
-    async createPhoneList(@Req() req) {
-        return await this.rcsService.createPhoneList(req.body)
-    }
-
-    @Put('/phone')
-    async createPhone(@Req() req) {
-        return await this.rcsService.createPhone(req.body)
-    }
-
-    @Put('/task')
-    async createTask(@Req() req) {
-        return await this.rcsService.createTask(req.body)
-    }
-
-    @Delete('/phone-list/:id')
-    async delPhoneList(@Param('id') id: string) {
-        return await this.rcsService.delPhoneList(parseInt(id))
-    }
-
-    @Post('/phone-list/:id/import')
-    @UseInterceptors(FileInterceptor('file'))
-    async importPhoneList(@Param('id') id: string, @UploadedFile() file: Express.Multer.File) {
-        const { buffer } = file
-        const phones = buffer
-            .toString()
-            .replaceAll('\r\n', '\n')
-            .split('\n')
-            .filter((phone) => phone.length > 0)
-        await this.rcsService.importList(parseInt(id), phones)
-    }
-
-    @Delete('/phone/:id')
-    async delPhone(@Param('id') id: string) {
-        return await this.rcsService.delPhone(parseInt(id))
-    }
-
-    @Delete('/task/:id')
-    async delTask(@Param('id') id: string) {
-        return await this.rcsService.delTask(parseInt(id))
-    }
-
-    @Post('/task/:id/start')
-    async startTask(@Param('id') id: string) {
-        return await this.rcsService.startTask(parseInt(id))
-    }
-
-    @Post('/task/:id/pause')
-    async pauseTask(@Param('id') id: string) {
-        return await this.rcsService.pauseTask(parseInt(id))
-    }
-
-    @Post('/device')
-    async findAllDevice(@Body() page: PageRequest<Device>) {
-        return await this.rcsService.findAllDevice(page)
-    }
-}

src/rcs/rcs.module.ts

@@ -1,23 +0,0 @@
-import { Module, forwardRef } from '@nestjs/common'
-import { RcsService } from './rcs.service'
-import { RcsController } from './rcs.controller'
-import { TypeOrmModule } from '@nestjs/typeorm'
-import { PhoneList } from './entities/phone-list.entity'
-import { Phone } from './entities/phone.entity'
-import { Task } from './entities/task.entity'
-import { TaskItem } from './entities/task-item.entity'
-import { EventsModule } from '../events/events.module'
-import { USACodeApiService } from './usacode-api-service'
-import { Device } from './entities/device.entity'
-import { NumberRequest } from './entities/number-request.entity'
-
-@Module({
-    imports: [
-        TypeOrmModule.forFeature([PhoneList, Phone, Task, TaskItem, Device, NumberRequest]),
-        forwardRef(() => EventsModule)
-    ],
-    providers: [RcsService, USACodeApiService],
-    controllers: [RcsController],
-    exports: [RcsService]
-})
-export class RcsModule {}

src/task/task.controller.ts

@@ -0,0 +1,40 @@
+import { Body, Controller, Delete, Param, Post, Put, Req } from '@nestjs/common'
+import { PageRequest } from 'src/common/dto/page-request'
+import { Task } from './entities/task.entity'
+import { TaskService } from './task.service'
+import { TaskItem } from './entities/task-item.entity'
+
+@Controller('task')
+export class TaskController {
+    constructor(private readonly taskService: TaskService) {}
+
+    @Post('/')
+    async findAllTask(@Body() page: PageRequest<Task>) {
+        return await this.taskService.findAllTask(page)
+    }
+
+    @Put('/')
+    async createTask(@Req() req) {
+        return await this.taskService.createTask(req.body)
+    }
+
+    @Delete('/:id')
+    async delTask(@Param('id') id: string) {
+        return await this.taskService.delTask(parseInt(id))
+    }
+
+    @Post('/:id/start')
+    async startTask(@Param('id') id: string) {
+        return await this.taskService.startTask(parseInt(id))
+    }
+
+    @Post('/:id/pause')
+    async pauseTask(@Param('id') id: string) {
+        return await this.taskService.pauseTask(parseInt(id))
+    }
+
+    @Post('/item')
+    async findAllTaskItem(@Body() page: PageRequest<TaskItem>) {
+        return await this.taskService.findAllTaskItem(page)
+    }
+}

src/task/task.module.ts

@@ -0,0 +1,22 @@
+import { Module, forwardRef } from '@nestjs/common'
+import { TaskController } from './task.controller'
+import { TaskService } from './task.service'
+import { TypeOrmModule } from '@nestjs/typeorm'
+import { Task } from './entities/task.entity'
+import { TaskItem } from './entities/task-item.entity'
+import { EventsModule } from '../events/events.module'
+import { DeviceModule } from '../device/device.module'
+import { PhoneListModule } from '../phone-list/phone-list.module'
+
+@Module({
+    imports: [
+        TypeOrmModule.forFeature([Task, TaskItem]),
+        forwardRef(() => EventsModule),
+        PhoneListModule,
+        DeviceModule
+    ],
+    controllers: [TaskController],
+    providers: [TaskService],
+    exports: [TaskService]
+})
+export class TaskModule {}

src/rcs/rcs.service.ts → src/task/task.service.ts

@@ -1,55 +1,34 @@
+import { PhoneListService } from './../phone-list/phone-list.service'
 import { Inject, Injectable, Logger, OnModuleInit, forwardRef } from '@nestjs/common'
 import { InjectRepository } from '@nestjs/typeorm'
-import { PhoneList } from './entities/phone-list.entity'
-import { Repository } from 'typeorm'
-import { Phone } from './entities/phone.entity'
 import { Task, TaskStatus } from './entities/task.entity'
+import { Repository } from 'typeorm'
 import { TaskItem, TaskItemStatus } from './entities/task-item.entity'
-import { PageRequest } from 'src/common/dto/page-request'
+import { PageRequest } from '../common/dto/page-request'
 import { Pagination, paginate } from 'nestjs-typeorm-paginate'
-import { EventsGateway } from 'src/events/events.gateway'
-import axios from 'axios'
-import { USACodeApiService } from './usacode-api-service'
-import { Device } from './entities/device.entity'
-import { NumberRequest } from './entities/number-request.entity'
+import { EventsGateway } from '../events/events.gateway'
 import { randomUUID } from 'crypto'
 import { setTimeout } from 'timers/promises'
+import { DeviceService } from '../device/device.service'
 
 @Injectable()
-export class RcsService implements OnModuleInit {
+export class TaskService implements OnModuleInit {
     constructor(
-        @InjectRepository(PhoneList)
-        private phoneListRepository: Repository<PhoneList>,
-        @InjectRepository(Phone)
-        private phoneRepository: Repository<Phone>,
         @InjectRepository(Task)
         private taskRepository: Repository<Task>,
         @InjectRepository(TaskItem)
         private taskItemRepository: Repository<TaskItem>,
-        @InjectRepository(Device)
-        private deviceRepository: Repository<Device>,
-        @InjectRepository(NumberRequest)
-        private numberRequestRepository: Repository<NumberRequest>,
         @Inject(forwardRef(() => EventsGateway))
         private readonly eventsGateway: EventsGateway,
-        @Inject(forwardRef(() => USACodeApiService))
-        private readonly USACodeApiService: USACodeApiService
+        private readonly phoneListService: PhoneListService,
+        private readonly deviceService: DeviceService
     ) {}
 
-    private taskControllers: { [key: number]: AbortController } = {}
-
     onModuleInit() {
-        this.deviceRepository.update({}, { online: false, busy: false })
         this.taskRepository.update({ status: TaskStatus.PENDING }, { status: TaskStatus.IDLE })
     }
 
-    async findAllPhoneList(req: PageRequest<PhoneList>): Promise<Pagination<PhoneList>> {
-        return await paginate<PhoneList>(this.phoneListRepository, req.page, req.search)
-    }
-
-    async findAllPhone(req: PageRequest<Phone>): Promise<Pagination<Phone>> {
-        return await paginate<Phone>(this.phoneRepository, req.page, req.search)
-    }
+    private taskControllers: { [key: number]: AbortController } = {}
 
     async findAllTask(req: PageRequest<Task>): Promise<Pagination<Task>> {
         return await paginate<Task>(this.taskRepository, req.page, req.search)
@@ -59,28 +38,9 @@ export class RcsService implements OnModuleInit {
         return await paginate<TaskItem>(this.taskItemRepository, req.page, req.search)
     }
 
-    async createPhoneList(phoneList: PhoneList): Promise<PhoneList> {
-        return await this.phoneListRepository.save(phoneList)
-    }
-
-    async importList(listId: number, phones: string[]): Promise<Phone[]> {
-        return await this.phoneRepository.save(
-            phones.map((number) => {
-                const phone = new Phone()
-                phone.listId = listId
-                phone.number = number
-                return phone
-            })
-        )
-    }
-
-    async createPhone(phone: Phone): Promise<Phone> {
-        return await this.phoneRepository.save(phone)
-    }
-
     async createTask(task: Task): Promise<Task> {
         task = await this.taskRepository.save(task)
-        const phones = await this.phoneRepository.findBy({ listId: task.listId })
+        const phones = await this.phoneListService.findPhoneByListId(task.listId)
         await this.taskItemRepository.save(
             phones.map((phone) => {
                 const taskItem = new TaskItem()
@@ -94,14 +54,6 @@ export class RcsService implements OnModuleInit {
         return task
     }
 
-    async delPhoneList(id: number): Promise<void> {
-        await this.phoneListRepository.delete(id)
-    }
-
-    async delPhone(id: number): Promise<void> {
-        await this.phoneRepository.delete(id)
-    }
-
     async delTask(id: number): Promise<void> {
         await this.taskRepository.delete(id)
     }
@@ -156,9 +108,7 @@ export class RcsService implements OnModuleInit {
                         Logger.log('Task aborted', 'RcsService')
                         return
                     }
-                    device = await this.deviceRepository.findOne({
-                        where: { online: true, canSend: true, busy: false }
-                    })
+                    device = await this.deviceService.findAvailableDevice()
                     if (device === null) {
                         Logger.log('No device available, waiting...', 'RcsService')
                         await setTimeout(2000)
@@ -167,8 +117,7 @@ export class RcsService implements OnModuleInit {
                 taskItems.forEach((taskItem) => {
                     taskItem.status = TaskItemStatus.PENDING
                 })
-                device.busy = true
-                await this.deviceRepository.save(device)
+                await this.deviceService.setBusy(device.id, true)
                 await this.taskItemRepository.save(taskItems)
                 Logger.log(`Send task to device ${device.id}(${device.model})`, 'RcsService')
                 Promise.race([
@@ -213,43 +162,4 @@ export class RcsService implements OnModuleInit {
 
         this.taskControllers[task.id] = null
     }
-
-    async findAllDevice(req: PageRequest<Device>): Promise<Pagination<Device>> {
-        return await paginate<Device>(this.deviceRepository, req.page, req.search)
-    }
-
-    async deviceConnect(id: string, socketId: string, model: string, name?: string, canSend: boolean = false) {
-        let device = await this.deviceRepository.findOneBy({ id })
-        if (!device) {
-            device = new Device()
-        }
-        device.id = id
-        device.socketId = socketId
-        device.model = model
-        device.name = name
-        device.online = true
-        device.canSend = canSend
-        device.busy = false
-        await this.deviceRepository.save(device)
-    }
-
-    async deviceDisconnect(id: string) {
-        const device = await this.deviceRepository.findOneBy({ id })
-        if (device) {
-            device.online = false
-            device.busy = false
-            device.canSend = false
-            await this.deviceRepository.save(device)
-        }
-    }
-
-    async updateDevice(socketId: string, data: any) {
-        const device = await this.deviceRepository.findOneBy({ socketId })
-        if (device) {
-            Object.assign(device, data)
-            await this.deviceRepository.save(device)
-        }
-    }
-
-    async requestNumber(device: string) {}
 }