Expanda la librería con código personalizado

Agregará un método al OrdersService Clase Java para reducir el stock cada vez que se coloca un nuevo artículo pedido.

1. Agregue el siguiente código a su OrdersService Clase Java y asegúrese de Salvar el archivo:

   @Autowired
   PersistenceService db;
   
   @Before(event = CdsService.EVENT_CREATE, entity = "OrdersService.OrderItems")
   public void validateBookAndDecreaseStock(List<OrderItems> items) {
       for (OrderItems item : items) {
           String bookId = item.getBookId();
           Integer amount = item.getAmount();
   
           // check if the book that should be ordered is existing
           CqnSelect sel = Select.from(Books_.class).columns(b -> b.stock()).where(b -> b.ID().eq(bookId));
           Books book = db.run(sel).first(Books.class)
                   .orElseThrow(() -> new ServiceException(ErrorStatuses.NOT_FOUND, "Book does not exist"));
   
           // check if order could be fulfilled
           int stock = book.getStock();
           if (stock < amount) {
               throw new ServiceException(ErrorStatuses.BAD_REQUEST, "Not enough books on stock");
           }
   
           // update the book with the new stock, means minus the order amount
           book.setStock(stock - amount);
           CqnUpdate update = Update.entity(Books_.class).data(book).where(b -> b.ID().eq(bookId));
           db.run(update);
       }
   }
   
   @Before(event = CdsService.EVENT_CREATE, entity = "OrdersService.Orders")
   public void validateBookAndDecreaseStockViaOrders(List<Orders> orders) {
       for (Orders order : orders) {
           if (order.getItems() != null) {
               validateBookAndDecreaseStock(order.getItems());
           }
       }
   }
   

2. Coloque las siguientes declaraciones de importación encima del OrdersService Clase Java y asegúrese de Salvar el archivo:

   import java.util.List;
   import org.springframework.beans.factory.annotation.Autowired;
   
   import com.sap.cds.ql.Select;
   import com.sap.cds.ql.Update;
   import com.sap.cds.ql.cqn.CqnSelect;
   import com.sap.cds.ql.cqn.CqnUpdate;
   import com.sap.cds.services.ErrorStatuses;
   import com.sap.cds.services.ServiceException;
   import com.sap.cds.services.cds.CdsService;
   import com.sap.cds.services.handler.annotations.Before;
   import com.sap.cds.services.persistence.PersistenceService;
   
   import cds.gen.ordersservice.OrderItems;
   import cds.gen.ordersservice.Orders;
   import cds.gen.sap.capire.bookstore.Books;
   import cds.gen.sap.capire.bookstore.Books_;
   import java.math.BigDecimal;
   import cds.gen.sap.capire.bookstore.OrderItems_;
   
   import com.sap.cds.services.handler.annotations.After;
   

Analicemos lo que está sucediendo:

• El método validateBookAndDecreaseStock registrado usando el @Before anotación. Esto significa que el método se llama antes de OrderItems que siguen las entidades. La nota también establece que el método debe llamarse en cualquier momento OrderItems es creado.

• El método tiene un parámetro items, que da acceso a la lista de OrderItems. El CAP de Java genera la interfaz utilizada aquí. Genera un Interfaz POJO para cada entidad definida en el modelo CDS.

• El es CqnSelect sel una variable define una consulta de base de datos para recuperar el libro al que se hace referencia en la sección de comandos. Se realiza la consulta y se accede a los datos de la entidad restaurada utilizando una interfaz POJO para Books.

• A continuación, se compara el stock disponible en el libro con la cantidad del pedido. Si hay suficiente stock disponible, el stock del libro se reduce y el libro se actualiza en la base de datos.

• Como un pedido, los artículos pueden ser creados por un insertar profundo sobre el Orders entidad, la validateBookAndDecreaseStockViaOrders método.

Es importante tener en cuenta que CAP Java SDK se encarga automáticamente de todas las consultas y combina las actualizaciones de la base de datos en una sola transacción. Esto significa que si por alguna razón falla la creación del artículo pedido, el stock del libro no se reducirá.

El conjunto CommandsService.java el archivo ahora debería tener el siguiente formato:

package com.sap.cap.bookstore.handlers;

import com.sap.cds.services.handler.EventHandler;
import com.sap.cds.services.handler.annotations.ServiceName;

import org.springframework.stereotype.Component;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;

import com.sap.cds.ql.Select;
import com.sap.cds.ql.Update;
import com.sap.cds.ql.cqn.CqnSelect;
import com.sap.cds.ql.cqn.CqnUpdate;
import com.sap.cds.services.ErrorStatuses;
import com.sap.cds.services.ServiceException;
import com.sap.cds.services.cds.CdsService;
import com.sap.cds.services.handler.annotations.Before;
import com.sap.cds.services.persistence.PersistenceService;

import cds.gen.ordersservice.OrderItems;
import cds.gen.ordersservice.Orders;
import cds.gen.sap.capire.bookstore.Books;
import cds.gen.sap.capire.bookstore.Books_;
import java.math.BigDecimal;
import cds.gen.sap.capire.bookstore.OrderItems_;

import com.sap.cds.services.handler.annotations.After;

@Component
@ServiceName("OrdersService")
public class OrdersService implements EventHandler {

  @Autowired
  PersistenceService db;

  @Before(event = CdsService.EVENT_CREATE, entity = "OrdersService.OrderItems")
  public void validateBookAndDecreaseStock(List<OrderItems> items) {
      for (OrderItems item : items) {
          String bookId = item.getBookId();
          Integer amount = item.getAmount();

          // check if the book that should be ordered is existing
          CqnSelect sel = Select.from(Books_.class).columns(b -> b.stock()).where(b -> b.ID().eq(bookId));
          Books book = db.run(sel).first(Books.class)
                  .orElseThrow(() -> new ServiceException(ErrorStatuses.NOT_FOUND, "Book does not exist"));

          // check if order could be fulfilled
          int stock = book.getStock();
          if (stock < amount) {
              throw new ServiceException(ErrorStatuses.BAD_REQUEST, "Not enough books on stock");
          }

          // update the book with the new stock, means minus the order amount
          book.setStock(stock - amount);
          CqnUpdate update = Update.entity(Books_.class).data(book).where(b -> b.ID().eq(bookId));
          db.run(update);
      }
  }

  @Before(event = CdsService.EVENT_CREATE, entity = "OrdersService.Orders")
  public void validateBookAndDecreaseStockViaOrders(List<Orders> orders) {
      for (Orders order : orders) {
          if (order.getItems() != null) {
              validateBookAndDecreaseStock(order.getItems());
          }
      }
  }
}