appServer cerateed

.eslintrc.js

@@ -20,5 +20,6 @@ module.exports = {
     '@typescript-eslint/explicit-function-return-type': 'off',
     '@typescript-eslint/explicit-module-boundary-types': 'off',
     '@typescript-eslint/no-explicit-any': 'off',
+    'prettier/prettier': 0,
   },
 };

package.json

@@ -24,9 +24,15 @@
     "@nestjs/common": "^7.6.15",
     "@nestjs/core": "^7.6.15",
     "@nestjs/platform-express": "^7.6.15",
+    "@nestjs/typeorm": "^7.1.5",
+    "class-transformer": "^0.4.0",
+    "class-validator": "^0.13.1",
+    "cors": "^2.8.5",
+    "pg": "^8.6.0",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",
-    "rxjs": "^6.6.6"
+    "rxjs": "^6.6.6",
+    "typeorm": "^0.2.34"
   },
   "devDependencies": {
     "@nestjs/cli": "^7.6.0",

src/app.module.ts

 import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
-import { TasksModule } from './tasks/tasks.module';
+import { typeOrmConfig } from './config/typeorm.config';
+import { UserModule } from './user/user.module';
+
 
 @Module({
-  imports: [TasksModule],
+  imports: [
+    TypeOrmModule.forRoot(typeOrmConfig),
+    UserModule
+    
+  ],
   controllers: [AppController],
   providers: [AppService],
 })

src/config/typeorm.config.ts

+import { TypeOrmModuleOptions } from '@nestjs/typeorm';
+
+export const typeOrmConfig: TypeOrmModuleOptions = {
+  type: 'postgres',
+  host: 'localhost',
+  port: 5432,
+  username: 'postgres',
+  password: '9092303688',
+  database: 'Que_db',
+  entities: [__dirname + '/../**/*.entity{.ts,.js}'],
+  synchronize: true,
+};

src/main.ts

@@ -3,6 +3,7 @@ import { AppModule } from './app.module';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
-  await app.listen(3000);
+  app.enableCors();
+  await app.listen(8888);
 }
 bootstrap();

src/tasks/task.model.ts

-export interface Task{
-    id:string;
-    title:string;
-    description:string;
-    status:TaskStatus;
-}
-export enum TaskStatus{
-    OPEN = 'OPEN',
-    IN_PROGRESS = 'IN_PROGRESS',
-    DONE='DONE',
-}
\ No newline at end of file

src/tasks/tasks.controller.ts

-import { Controller, Get } from '@nestjs/common';
-import { get } from 'http';
-import { Task } from './task.model';
-import { TasksService } from './tasks.service';
-
-@Controller('tasks')
-export class TasksController {
-    constructor(private tasksService:TasksService){}
-    @Get()
-    getAllTasks():Task[]{
-        return this.tasksService.getAllTasks();
-    }
-}

src/tasks/tasks.module.ts

-import { Module } from '@nestjs/common';
-import { TasksController } from './tasks.controller';
-import { TasksService } from './tasks.service';
-
-@Module({
-  controllers: [TasksController],
-  providers: [TasksService],
-})
-export class TasksModule {}

src/tasks/tasks.service.ts

-import { Injectable } from '@nestjs/common';
-import { Task } from './task.model';
-
-@Injectable()
-export class TasksService {
-    private tasks:Task[]=[];
-    getAllTasks():Task[]{
-        return this.tasks;
-    }
-}

src/user/dto/create.dto.ts

+export class CreateUserDto {
+    name:string;
+    lastname:string;
+    tel:string;
+    email:string;
+    typeq:string;
+    locationq:string;
+    date:string;
+    dec:string;
+    fdate:string;
+    edate:string;
+}
\ No newline at end of file

src/user/dto/registerSick.dto.ts

+export class RegisterSick{
+    id:number;
+    date:string;
+}
\ No newline at end of file

src/user/user.controller.ts

+import { User } from './user.entity';
+import { CreateUserDto } from './dto/create.dto';
+import { UserService } from './user.service';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  ParseIntPipe,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { RegisterSick } from './dto/registerSick.dto';
+
+@Controller('api/user')
+export class UserController {
+  constructor(private userServes: UserService) {}
+  @Get()
+  getUsers() {
+    return this.userServes.getUsers();
+  }
+  @Get('/:srh')
+  getUserSrh(@Param('srh') srh: string) {
+    return this.userServes.getUserSearched(srh);
+  }
+  @Post()
+  createUser(@Body() createUserDto: CreateUserDto) {
+    return this.userServes.createUser(createUserDto);
+  }
+
+  @Get('/:id')
+  getUserById(@Param('id', ParseIntPipe) id: number) {
+    return this.userServes.chengeUserStatus(id);
+  }
+
+  @Post('/:registerSick')
+  registerSick(@Body() registerSick: RegisterSick) {
+    return this.userServes.registerSick(registerSick);
+  }
+}

src/user/user.entity.ts

+import { BaseEntity, Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+
+@Entity()
+export class User extends BaseEntity {
+ @PrimaryGeneratedColumn()
+ id:number;
+
+ @Column()
+ name:string;
+
+ @Column()
+ lastname:string;
+
+ @Column()
+ tel:string;
+
+ @Column()
+ email:string;
+ 
+ @Column()
+ typeq:string;
+
+ @Column()
+ locationq:string;
+
+ @Column()
+ date:string;
+
+ @Column()
+ dec:string;
+
+ @Column()
+ perioddate:string;
+
+ @Column()
+ state:number;
+
+ @Column()
+ dateq:string;
+
+
+}
\ No newline at end of file

src/user/user.module.ts

+import { UserRepository } from './user.repositoty';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Module } from '@nestjs/common';
+import { UserController } from './user.controller';
+import { UserService } from './user.service';
+
+@Module({
+  imports:[TypeOrmModule.forFeature([UserRepository])],
+  controllers: [UserController],
+  providers: [UserService]
+})
+export class UserModule {}

src/user/user.repositoty.ts

+import { CreateUserDto } from './dto/create.dto';
+import { EntityRepository, Repository } from 'typeorm';
+import { User } from './user.entity';
+
+@EntityRepository(User)
+export class UserRepository extends Repository<User> {
+
+
+
+
+  async getUsers(): Promise<User[]> {
+    const query = this.createQueryBuilder('user');
+    const users = await query.getMany();
+    return users;
+  }
+
+
+
+
+
+  async getUserSearched(search: string):Promise<User[]> {
+    const query = this.createQueryBuilder('user');
+    if (search) {
+      query.andWhere('(user.name LIKE :search OR user.lastname LIKE :search)', {
+        search: `%${search}%`,
+      });
+    }
+    const users = await query.getMany();
+    return users;
+  }
+
+
+
+ 
+
+
+  async createUser(createUserDot: CreateUserDto): Promise<User> {
+    const {
+      name,
+      lastname,
+      tel,
+      email,
+      typeq,
+      dec,
+      date,
+      edate,
+      fdate,
+      locationq,
+    } = createUserDot;
+    const user = new User();
+    user.name = name;
+    user.lastname = lastname;
+    user.tel = tel;
+    user.dec = dec;
+    user.date = date;
+    user.email = email;
+    user.locationq = locationq;
+    user.typeq = typeq;
+    user.state = 1;
+    user.dateq = 'qwwq';
+    if (fdate == edate || fdate == null || edate == null) {
+      user.perioddate = '0';
+    } else {
+      user.perioddate = fdate + '-' + edate;
+    }
+
+    await user.save();
+    return user;
+  }
+
+
+
+
+}

src/user/user.service.ts

+import { User } from './user.entity';
+import { CreateUserDto } from './dto/create.dto';
+import { UserRepository } from './user.repositoty';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { RegisterSick } from './dto/registerSick.dto';
+
+@Injectable()
+export class UserService {
+  constructor(
+    @InjectRepository(UserRepository) private userRepository: UserRepository,
+  ) {}
+
+  async createUser(createUserDto: CreateUserDto): Promise<User> {
+    return this.userRepository.createUser(createUserDto);
+  }
+
+  async getUsers(): Promise<User[]> {
+    return this.userRepository.getUsers();
+  }
+
+  async getUserSearched(srh: string): Promise<User[]> {
+    return this.userRepository.getUserSearched(srh);
+  }
+  async getUserId(id: number): Promise<User> {
+    const found = await this.userRepository.findOne(id);
+    if (!found) {
+      throw new NotFoundException(`User with id "${id}" not found.`);
+    }
+    return found;
+  }
+
+  async chengeUserStatus(id: number): Promise<User[]> {
+    const user = await this.getUserId(id);
+    switch (user.state) {
+      case 1:
+        user.state = 2;
+        break;
+
+      case 2:
+        user.state = 3;
+        break;
+
+      case 3:
+        this.userRepository.delete(id);
+        break;
+    }
+    await user.save();
+    return this.getUsers();
+  }
+  async registerSick(registerSick: RegisterSick): Promise<User[]> {
+    const { id, date } = registerSick;
+    const user = this.getUserId(id);
+    (await user).dateq = date;
+    (await user).state = 2;
+    (await user).save();
+    return this.getUsers();
+  }
+}