Merge pull request #97 from ES2-UFPI/samuel#87#88

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

@@ -1,6 +1,17 @@
 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> {
@@ -16,6 +27,22 @@ class ClientController {
             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

@@ -1,4 +1,5 @@
 import { Request, Response } from 'express'
+import { ProfessionalService } from '../services/ProfessionalService';
 import { UserService } from '../services/UserService';
 
 class ProfessionalController {
@@ -13,10 +14,26 @@ class ProfessionalController {
 
             return response.status(200).json({ message:"Profissional criado com sucesso!"});
         } catch (error) {
-            return response.status(400).json({ error: 'Um erro inesperado ocorreu. Tente novamente!',error_dev:error.message });
+            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/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,7 +18,7 @@ import { EmotionalReaction } from './EmotionalReaction';
     @Column()
     user_id:string;
 
-    @Column()
+    @Column({nullable:true})
     professional_id:string;
 
     @JoinColumn({name:"user_id"})

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

@@ -11,9 +11,11 @@ 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 }

backend/src/services/UserService.ts

@@ -15,6 +15,14 @@ interface UserInterface{
     speciality?:string;
 }
 
+interface UpdateUserInterface{
+    email?:string;
+    password?:string;
+    id:string;
+}
+
+
+
 class UserService {
     private userRepository: Repository<User>;
     private clientService:ClientService;
@@ -29,7 +37,7 @@ class UserService {
     }
 
     async createUser({name,email,password,type,phone,crm_crp,speciality}:UserInterface) {
-        console.log(name)
+
         const userRegistered = await this.userRepository.findOne({ where: { email } });
 
         if(userRegistered){
@@ -57,6 +65,24 @@ class UserService {
         }
     }
 
+
+    async updateUser({id,...values}:UpdateUserInterface){
+
+        const userRegistered = await this.userRepository.findOne({ where: { id } });
+
+        if(userRegistered){
+
+            await this.userRepository.save({
+                ...userRegistered,
+                ...values
+            })
+        }
+        else{
+            throw new Error("Usuário não encontrado!")
+        }
+
+    }
+
 }
 
 export { UserService }