problème delete en spring boot et angular

Bonjour tout le monde,

cela fait un moment que je galère avec ma méthode delete et je me suis donc permis de vous poser la question.

Je travail avec intellij pour spring boot et visual studio code pour angular.

En fait nous travaillons à deux sur ce projet dans le cadre d'un cours mon binôme m'à l'air plutôt doué avec ces langages avec les quels il travail régulièrement , mais il ne me répond jamais et j'ai quelques difficultés à le suivre.

j'ai eu plusieurs problème qui on mené à une solution qui n'est pas encore finie.

pour commencer, j'ais vu qu'il existait deux manière de faire le delete.

soit par l'id que je n'arrives pas à récupérer dans angular qui est déclaré comme undifined.(l'affichage à été fait par mon collegue mais l'id n'a pas été mis en place je ne sais pour quelle raison)

soit par un objet de type order défini dans le dao. mais je ne sais pas si dans ce cas, une partie du dao est suffisante, que ce passerait il si j'essaye de faire le delete sans l'id par exemple mais que les autres champs sont définis ?

pour solutionner ce problème j'ai temporairement triché en envoyant l'id depuis la partie service d'angular. plutot que par la vue qui ne l'a reçois pas.

afin de pouvoir au moins arriver à supprimer cette ligne de la base de donnée.

cela serait très sympa, si vous aviez des suggestions ou si vous pouviez m'apporter une aide.

j’espère que quelqu'un pourra m'aider, cette partie est nettement plus compliquée que ce que je met en place d'habitude.

merci d'avance

voici les fichiers qui me sont utiles pour résoudre ce problème.

la vue depuis la partie angular

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
 
<div class="example-container mat-elevation-z8">
    <div class="example-loading-shade" *ngIf="isLoadingResults">
        <mat-spinner *ngIf="isLoadingResults"></mat-spinner>
    </div>
    <div class="mat-elevation-z8">
        <table mat-table [dataSource]="orders" class="example-table">
 
            <ng-container matColumnDef="id">
                <th mat-header-cell *matHeaderCellDef>{{ 'COMPONENTS.PRODUCTS.MY_PRODUCTS_ORDERS.ORDER_ID' | translate }}</th>
                    <td mat-cell *matCellDef="let row">{{row.id}}</td>
                </ng-container>
 
            <ng-container matColumnDef="orderUuid">
            <th mat-header-cell *matHeaderCellDef>{{ 'COMPONENTS.PRODUCTS.MY_PRODUCTS_ORDERS.ORDER_ID' | translate }}</th>
                <td mat-cell *matCellDef="let row">{{row.uuid}}</td>
            </ng-container>
 
<!-- boutton d'annulation de commande -->
            <ng-container matColumnDef="orderButton">
                <th mat-header-cell *matHeaderCellDef>{{ 'COMPONENTS.PRODUCTS.MY_PRODUCTS_ORDERS.ID_LIVREUR' | translate }}</th>
                <td mat-cell *matCellDef="let row">
                    <button class="btn btn-primary" (click)="delete()">
                        <span>{{ 'COMPONENTS.PRODUCTS.CANCEL' | translate }}</span>
                    </button>
                </td>
            </ng-container>
            <tr mat-header-row *matHeaderRowDef="displayedColumns"></tr>
            <tr mat-row *matRowDef="let row; columns: displayedColumns;"></tr>
        </table>
    </div>
</div>

le component depuis la partie angular

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
 
import { Component, OnInit } from '@angular/core';
import { FormGroup } from '@angular/forms';
import { take } from 'rxjs/operators';
import { Order } from 'src/app/models/order.model';
import { OrderService } from './../../../../services/order.service';
 
class FormProperties {
    public static readonly ORDER_ID = 'id';
}
 
@Component({
  selector: 'app-my-products-orders',
  templateUrl: './my-products-orders.component.html',
  styleUrls: ['./my-products-orders.component.scss']
})
export class MyProductsOrdersComponent implements OnInit {
 
    public orders: Order[] = [];
 
    public displayedColumns: string[] = [
        'id',
        'orderUuid',
        'deliveryCity',
        'mass',
        'volume',
        'price',
        'deliveryManID',
        'orderButton'
    ];
 
    public isLoadingResults = true;
 
    public form: FormGroup;
 
    constructor(private orderService: OrderService) { }
 
    ngOnInit() {
        this.orderService.getMyOrders()
            .pipe(take(1))
            .subscribe(res => {
                this.orders = res.map(e => Order.fromDto(e));
              console.log("test test test test test test");
                console.log("this.orders = " + this.orders[0].id);
                console.log("test test test test test test");
              this.isLoadingResults = false;
            });
    }
public delete() {
 
 
        this.orderService.deleteOrder('1')
            .pipe(take(1))
            .subscribe(res => {
                this.orders = res.map(e => Order.fromDto(e));
                this.isLoadingResults = false;
            });
    }
}

le service depuis la partie angular

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import { HttpParams } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { catchError, tap } from 'rxjs/operators';
import { PackInterface } from 'src/app/models/interfaces/pack.interface';
import { environment } from './../../environments/environment';
import { OrderInterface } from './../models/interfaces/order.interface';
import { BaseWebService } from './base.web.service';
import { Order } from '../models/order.model';
 
@Injectable()
export class OrderService extends BaseWebService {
/*
    protected _post(url: string, data: any, headers: { [name: string]: string } = {}): Observable<any> {
        return this.http.post(url, data, { headers: this.getDefaultHeaders(headers) });
    }
    */
 
    public postOrderProduct(rideId: string, order: OrderInterface, pack: PackInterface, stripeToken: string) {
        return this._post(`${environment.baseUrl}/order/${rideId}`,
                { orderDto: order, packageDto: pack, stripeToken }
            ).pipe(
                tap(_ => this.log('fetched Order response')),
                catchError(this.handleError('postOrder', []))
            );
    }
 
    public getMyOrders(): Observable<OrderInterface[]> {
        return this._get(`${environment.baseUrl}/order/my-orders`)
            .pipe(
                tap(_ => this.log('fetched my orders')),
                catchError(this.handleError('getMyOrders', []))
            );
    }
 
    /*
    protected _delete(url: string, params?: HttpParams): Observable<any> {
        return this.http.delete(url, { headers: this.getDefaultHeaders(), params: params });
    }
    */
 
    public deleteOrder(orderId: string) {
        console.log("!!! deleteOrder !!! deleteOrder !!! deleteOrder !!!");
 
        return this._delete(`${environment.baseUrl}/order/delete/${orderId}`)
        .pipe(
            tap(_ => this.log('fetched Order response')),
            catchError(this.handleError('deleteOrder', []))
        );
    }
 
}

le modele (d’après ce que j'ais compris, cela serait une sorte d'entity mais ce que j'ai un peu de mal à comprendre, c'est pourquoi il y a deux entity le premier ici et le deuxième dans la partie spring boot)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
import { OrderStatus } from './enums/order-status.enum';
import { OrderInterface } from './interfaces/order.interface';
import { Ride } from './ride.model';
 
export class Order {
 
    public id?: number;
    public uuid?: string;
    public mass?: number;
    public volume?: number;
    public calculatedPrice?: number;
    public deliveryAddress?: string;
    public deliveryCity?: string;
    public deliveryZipCode?: string;
    public deliveryCountry?: string;
    public comment?: string;
    public paid?: boolean; // INUTILE
    public status?: OrderStatus;
    public validated?: boolean; // INUTILE SI STATUS VALIDATED
    public validationComment?: string;
    public validationSecretCode?: string;
    // public userUuid?: string;
    public ride?: Ride;
 
    constructor(obj?: Partial<Order>) {
        Object.assign(this, obj);
    }
 
    public static fromDto(dto: OrderInterface) {
        const obj = new Order();
        Object.assign(obj, {
            id: dto.id,
            uuid: dto.uuid,
            mass: (dto.mass / 100).toFixed(2),
            volume: (dto.volume / 100).toFixed(2),
            calculatedPrice: dto.calculatedPrice,
            deliveryAddress: dto.deliveryAddress,
            deliveryCity: dto.deliveryCity,
            deliveryZipCode: dto.deliveryZipCode,
            deliveryCountry: dto.deliveryCountry,
            comment: dto.comment,
            paid: dto.paid,
            status: dto.status,
            validated: dto.validated,
            validationComment: dto.validationComment,
            validationSecretCode: dto.validationSecretCode,
            // userUuid: obj.userUuid,
            ride: dto.ride ? Ride.fromDto(dto.ride) : null
        });
        return obj;
    }
 
}

le controller de la partie spring boot

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
 
package be.isl.gestionlivraisons.controller;
 
import be.isl.gestionlivraisons.exception.BadRequestException;
import be.isl.gestionlivraisons.model.Order;
import be.isl.gestionlivraisons.model.Ride;
import be.isl.gestionlivraisons.model.dto.OrderPackageDto;
import be.isl.gestionlivraisons.security.CurrentUser;
import be.isl.gestionlivraisons.security.UserPrincipal;
import be.isl.gestionlivraisons.service.OrderService;
import com.stripe.model.Charge;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
 
import java.util.List;
@RestController
public class OrderController {
 
private final OrderService orderService;
 
@DeleteMapping(value = "/order/delete/{orderId}")
public void deleteById(@CurrentUser UserPrincipal userPrincipal,@PathVariable("orderId") Long orderId)
throws Exception {
if (userPrincipal == null
) {
throw new BadRequestException("Cannot order order with id");
}
orderService.deleteById(orderId);
}

le repository de la partie spring boot

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
package be.isl.gestionlivraisons.repository;
 
import be.isl.gestionlivraisons.model.Order;
import be.isl.gestionlivraisons.model.Ride;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
 
import java.util.List;
 
@Repository
public interface OrderRepository extends CrudRepository<Order, String> {
 
 Order findByRide(Ride ride);
 
List<Order> findByUserId(Long id);
 
 void deleteById(Long orderId);
}

le service de la partie spring boot

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
 
package be.isl.gestionlivraisons.service;
 
import be.isl.gestionlivraisons.exception.BadRequestException;
import be.isl.gestionlivraisons.model.Order;
import be.isl.gestionlivraisons.model.Package;
import be.isl.gestionlivraisons.model.Ride;
import be.isl.gestionlivraisons.model.User;
import be.isl.gestionlivraisons.model.dto.OrderDto;
import be.isl.gestionlivraisons.model.dto.OrderPackageDto;
import be.isl.gestionlivraisons.model.dto.PackageDto;
import be.isl.gestionlivraisons.model.enums.OrderStatus;
import be.isl.gestionlivraisons.repository.OrderRepository;
import be.isl.gestionlivraisons.repository.PackageRepository;
import be.isl.gestionlivraisons.repository.RideRepository;
import be.isl.gestionlivraisons.repository.UserRepository;
import be.isl.gestionlivraisons.service.component.StripeClient;
import com.stripe.model.Charge;
import org.springframework.stereotype.Service;
 
import java.util.List;
import java.util.Objects;
import java.util.UUID;
 
@Service
public class OrderService {
 
private final OrderRepository orderRepository;
 private final RideRepository rideRepository;
 private final PackageRepository packageRepository;
 private final StripeClient stripeClient;
 private final UserRepository userRepository;
 
 public OrderService(
final OrderRepository orderRepository,
 final RideRepository rideRepository,
 final PackageRepository packageRepository,
 final StripeClient stripeClient,
 final UserRepository userRepository
 ) {
this.orderRepository = orderRepository;
 this.rideRepository = rideRepository;
 this.packageRepository = packageRepository;
 this.stripeClient = stripeClient;
 this.userRepository = userRepository;
}
 
public void deleteById(Long orderId) {orderRepository.deleteById(orderId);}

et pour finir voici le probleme qui est affiché lors de l'exécution dans intellij

Code:

javax.persistence.TransactionRequiredException: No EntityManager with actual transaction available for current thread - cannot reliably process 'remove' call

et dans le navigateur

Pièce jointe 554124