Desenvolvendo as issues #87 e #88 (Rotas de atualização de usuários)

backend/__tests__/Client.test.ts

@@ -2,6 +2,7 @@ import { createConnection, getConnection, getRepository } from "typeorm";
 import { Client } from "../src/entities/Client";
 import { Professional } from "../src/entities/Professional";
 import { User } from "../src/entities/User";
+import { ClientService } from "../src/services/ClientService";
 import { UserService } from "../src/services/UserService";
 
 
@@ -44,3 +45,38 @@ test("store a Client and fetch it", async () => {
 
   expect(joe.name).toBe("Joe");
 });
+
+
+test("store a Client and update it", async () => {
+
+  const newClient = {
+      name: "Joe",
+      email:"joe2@gmail.com",
+      phone:"(86)8988-8989",
+      password:"doidinho123",
+      type:0
+  }
+
+  const userService = new UserService();
+
+  await userService.createUser(newClient)
+
+  let joe = await getRepository(Client).findOne({
+      where: {
+        name:"Joe"
+      }
+  });
+
+  const clientService = new ClientService();
+
+  await clientService.update({id:joe.id, name:"Joe Atualizado",phone:"(98)8988-8989"});
+
+  let joe2 = await getRepository(Client).findOne({
+    where: {
+      name:"Joe Atualizado"
+    }
+});
+
+
+  expect(joe2.phone).toBe("(98)8988-8989");
+});

backend/__tests__/Professional.test.ts

@@ -2,6 +2,7 @@ import { createConnection, getConnection, getRepository } from "typeorm";
 import { Client } from "../src/entities/Client";
 import { Professional } from "../src/entities/Professional";
 import { User } from "../src/entities/User";
+import { ProfessionalService } from "../src/services/ProfessionalService";
 import { UserService } from "../src/services/UserService";
 
 
@@ -45,3 +46,41 @@ test("store a Professional and fetch it", async () => {
 
   expect(joe.name).toBe("Joe");
 });
+
+
+test("store a Client and update it", async () => {
+
+  const newProfessional = {
+    name: "Joe",
+    email:"joe2@gmail.com",
+    speciality:"psicologia forense",
+    crm_crp:"071.122.811-79",
+    password:"joepsicologia",
+    type:1
+  }
+
+
+  const userService = new UserService();
+
+  await userService.createUser(newProfessional);
+
+
+  let joe = await getRepository(Professional).findOne({
+      where: {
+        crm_crp:"071.122.811-79"
+      }
+  });
+
+  const professionalService = new ProfessionalService();
+
+  await professionalService.update({id:joe.id, name:"Joe Atualizado",});
+
+  let joe2 = await getRepository(Professional).findOne({
+    where: {
+      id:joe.id
+    }
+});
+
+
+  expect(joe2.name).toBe("Joe Atualizado");
+});

backend/src/controllers/ClientController.ts

@@ -0,0 +1,48 @@
+import { Request, Response } from 'express'
+import { ClientService } from '../services/ClientService';
+import { UserService } from '../services/UserService';
+
+
+interface ClientInterface{
+    name?:string;
+    email?:string;
+    password?:string;
+    phone?:string;
+    professional_id?:string;
+    id:string;
+}
+
+class ClientController {
+
+    async create(request: Request, response: Response): Promise<Response> {
+        try {
+            const {name,phone,email,password} = request.body;
+
+            const clientService = new UserService();
+
+            await clientService.createUser({name,phone,type:0,email,password})
+
+            return response.status(200).json({ message:"Cliente criado com sucesso!"});
+        } catch (error) {
+            return response.status(400).json({ message:error.message });
+        }
+    }
+
+    async update(request: Request, response: Response){
+        try{
+            const {name,phone,email,password,professional_id,id} = request.body as ClientInterface;
+
+            const clientService = new ClientService();
+
+            await clientService.update({name,phone,email,password,professional_id,id})
+
+            return response.status(200).json({ message:"Cliente atualizado com sucesso!"});
+
+        }catch(error){
+            return response.status(400).json({ message:error.message });
+        }
+
+    }
+}
+
+export { ClientController }

backend/src/controllers/ProfessionalController.ts

@@ -0,0 +1,39 @@
+import { Request, Response } from 'express'
+import { ProfessionalService } from '../services/ProfessionalService';
+import { UserService } from '../services/UserService';
+
+class ProfessionalController {
+
+    async create(request: Request, response: Response): Promise<Response> {
+        try {
+            const {name,crm_crp,speciality,email,password} = request.body;
+
+            const professionalService = new UserService();
+
+            await professionalService.createUser({name,crm_crp,speciality,type:1,email,password})
+
+            return response.status(200).json({ message:"Profissional criado com sucesso!"});
+        } catch (error) {
+            return response.status(400).json({message:error.message });
+        }
+    }
+
+    async update(request: Request, response: Response){
+        try{
+            const {name,email,password,crm_crp,speciality,id,association_code} = request.body;
+
+            const professionalService = new ProfessionalService();
+
+            await professionalService.update({name,crm_crp,speciality,email,password,association_code,id})
+
+            return response.status(200).json({ message:"Profissional atualizado com sucesso!"});
+
+        }catch(error){
+            return response.status(400).json({ message:error.message });
+        }
+
+    }
+
+}
+
+export { ProfessionalController }

backend/src/database/index.ts

@@ -1,6 +1,5 @@
 import {createConnection} from 'typeorm'
 
-//const connection = async() => await createConnection();
-
 createConnection();
+
 console.log("Database Connected");

backend/src/database/migrations/1624500289158-UpdateUserFieldEmail.ts

@@ -0,0 +1,18 @@
+import {MigrationInterface, QueryRunner, TableColumn} from "typeorm";
+
+export class UpdateUserFieldEmail1624500289158 implements MigrationInterface {
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.changeColumn("users","email",
+        new TableColumn({
+            name:"email",
+            type:"varchar",
+            isUnique:true
+        }))
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.dropTable("users")
+    }
+
+}

backend/src/entities/Client.ts

@@ -18,11 +18,14 @@ import { EmotionalReaction } from './EmotionalReaction';
     @Column()
     user_id:string;
 
+    @Column({nullable:true})
+    professional_id:string;
+
     @JoinColumn({name:"user_id"})
     @OneToOne(()=> User)
     user:User;
 
-    @JoinColumn()
+    @JoinColumn({name:"professional_id"})
     @ManyToOne(()=> Professional)
     professional:Professional;
 

backend/src/entities/User.ts

@@ -7,7 +7,7 @@ import {Entity, Column, PrimaryGeneratedColumn,} from 'typeorm';
       @PrimaryGeneratedColumn('uuid', { name: 'id' })
       id:string;
 
-      @Column()
+      @Column({unique:true})
       email:string;
 
       @Column()

backend/src/routes.ts

@@ -1,9 +1,21 @@
 import {Router} from 'express';
+import { ClientController } from './controllers/ClientController';
 import { EmotionalReactionController } from './controllers/EmotionalRecordController';
+import { ProfessionalController } from './controllers/ProfessionalController';
 
 const routes = Router(); 
 
 const emotionalReactionController = new EmotionalReactionController();
+const professionalController = new ProfessionalController();
+const clientController = new ClientController();
+
+
+routes.post("/professionals",professionalController.create);
+routes.post("/professionals/update",professionalController.update);
+
+
+routes.post("/clients",clientController.create);
+routes.post("/clients/update",clientController.update);
 
 
 routes.get("/reactions/:client_id",emotionalReactionController.index);

backend/src/services/ClientService.ts

@@ -1,5 +1,6 @@
 import { getRepository, Repository } from 'typeorm';
 import { Client } from "../entities/Client";
+import { UserService } from './UserService';
 
 
 interface ClientInterface{
@@ -8,6 +9,15 @@ interface ClientInterface{
     user_id:string;
 }
 
+interface UpdateClientInterface{
+    name?:string;
+    phone?:string;
+    email?:string;
+    password?:string;
+    professional_id?:string;
+    id:string;
+}
+
 
 class ClientService {
     private clientRepository: Repository<Client>;
@@ -22,6 +32,28 @@ class ClientService {
         await this.clientRepository.save(newClient);
     }
 
+    async update({id,email,password,name,professional_id,phone}:UpdateClientInterface){
+
+        const client =  await this.clientRepository.findOne({where:[{id}],relations:['user']})
+        const client_new_values = {name,professional_id,phone}
+
+        if(client){
+            await this.clientRepository.save({
+                ...client
+                ,...client_new_values});
+
+            const userService = new UserService();
+
+            await userService.updateUser({
+                id:client.user_id,
+                email,
+                password
+            })
+        }else
+            throw new Error(`Cliente não encontrado`)
+
+    }
+
 }
 
 export { ClientService }

backend/src/services/ProfessionalService.ts

@@ -1,5 +1,6 @@
 import { getRepository, Repository } from 'typeorm';
 import { Professional } from "../entities/Professional";
+import { UserService } from './UserService';
 
 interface ProfessionalInterface{
     name:string;
@@ -9,6 +10,16 @@ interface ProfessionalInterface{
     user_id:string;
 }
 
+interface UpdateClientInterface{
+    name?:string;
+    crm_crp?:string;
+    speciality?:string;
+    association_code?:string;
+    email?:string;
+    password?:string;
+    id:string;
+}
+
 class ProfessionalService {
     private professionalRepository: Repository<Professional>;
 
@@ -27,6 +38,28 @@ class ProfessionalService {
         await this.professionalRepository.save(newProfessional);
 
     }
+
+    async update({name,crm_crp,speciality,association_code,email,password,id}:UpdateClientInterface){
+
+        const professional =  await this.professionalRepository.findOne({where:[{id}],relations:['user']})
+        const professional_new_values = {name,crm_crp,speciality,association_code}
+
+        if(professional){
+            await this.professionalRepository.save({
+                ...professional
+                ,...professional_new_values});
+
+            const userService = new UserService();
+
+            await userService.updateUser({
+                id:professional.user_id,
+                email,
+                password
+            })
+        }else
+            throw new Error(`Profissional não encontrado`)
+
+    }
 }
 
 export { ProfessionalService }