Reglas de descuento, enfoque desde la POO - https://es.stackoverflow.com/q/590762/29967, Php

Language: Layout:

<?php
//Modelo de datos AMPLIADO para Orden y Productos: https://es.stackoverflow.com/q/590762/29967
/*
  Clase para productos (en vez de artículos, porque se suele usar más "Productos")
  Añadiremos una nueva propiedad "category"
  la cual nos ayudará a diferenciar los artículos para la estrategia de descuento. 
  Esto será útil a la hora de saber qué descuentos aplicar.
  "category" será un valor numérico, en y la clase "Category" tendremos la descripción
  y otras propiedades. Lo que estamos haciendo aquí es modelando lo que habría 
  en tu base de datos, donde tendrías una tabla "Product" y una tabla "Category".
  Como ves, en la POO, las clases pueden irse adaptando según las necesidades.
  Imaginemos que haya que aplicar descuentos por marcas del producto,
  pues convendría tener una propiedad "marca" en la clase "Product" 
  y sin duda una clase "Brand" para manejar las marcas de productos.
  */
class Product {
  private $id;
  private $name;
  private $category;  
  private $price;
  
  public function __construct($id,$name,$category,$price) {
      $this->id=$id;
      $this->name=$name;
      $this->category=$category;
      $this->price=$price;
  }
    
  public function getId() {
      return $this->id;
  }   
    
  public function getName() {
      return $this->name;
  }

public function getCategory() {
      return $this->category;
  }   
    
  public function getPrice() {
      return $this->price;
  }
}

/*
  La nueva clase para categorías de productos.
  Por el momento esta clase no tiene mucha utilidad, 
  para no perdernos en demasiados detalles.
  Pero si quieres mostrar las categorias por su nombre
  convendría usar esta clase, porque en "Producto" sólo pusimos el id de la categoría
  y así debe ser, no poner nunca el nombre de la categoría en las clases derivadas 
*/
class Category {
  private $id;
  private $name;
  
  public function __construct($id,$name) {
      $this->id=$id;
      $this->name=$name;
  }
    
  public function getId() {
      return $this->id;
  }   
    
  public function getName() {
      return $this->name;
  }      
    
}

/*
  Clase para órdenes
  Seguimos ampliando el modelo. Tendremos por una parte la clase "Order"
  y por otra parte una nueva clase llamada "OrderDetail" en la cual
  podremos modificar el precio final del artículo según el descuento que aplique
  para más detalles puedes este modelo: 
  https://www.oreilly.com/library/view/sql-queries-for/9780321444431/9780321444431_app02lev1sec1.html
   
*/
    
class Order {
  private $orderId;  
  private $orderDate;
  private $orderDetail;
  
  public function __construct($orderId,$orderDate) {
      $this->orderId=$orderId;
      $this->orderDate=new \DateTime($orderDate);
  }
  public function addOrderDetail(OrderDetail $orderDetail) {
      $this->orderDetail=$orderDetail;
  }   
}

/*
  Clase para Detalles de Ordenes
  Esta clase es la que maneja toda la lógica
  cuando se van agregando productos. 
  Verifica por ejemplo qué nuevos descuentos aplicar, etc.
  Por brevedad, no he puesto por ejemplo un método para 
  quitar productos, en cuyo caso se debe de nuevo verificar
  qué descuentos permanecen vigentes según las nuevas cantidades
  de productos en la canasta, sus categorías, etc. 
*/
class OrderDetail {
  private $allProducts=array();
  private $categoryGroup=array();    
  private $product;
  private $discount;  
    
  public function __construct() {
      $this->allProducts=array();
      $this->discount=new Discount();
  }

/*
      Este método agrega uno o más productos a la Orden
      Y verifica qué descuentos aplican según la cantidad,
      las categorías, etc. LLamando a los métodos de la clase Discount
  */
  public function addProduct($p,$qty=1) {
      $idCategory=$p->getCategory();
      if (!in_array($idCategory, array_column($this->categoryGroup, 'idCategory'))){
          $this->categoryGroup[$idCategory]=array('idCategory'=>$idCategory,'counter'=>$qty);
      }else{
          $this->categoryGroup[$idCategory]['counter']+=$qty;
      }
      
      $idProduct=$p->getId();
      if (!in_array($idProduct, array_column($this->allProducts, 'idProduct'))){
          $this->allProducts[$idProduct]=array(
              'idProduct'=>$idProduct,
              'qty'=>$qty, 
              'product'=>$p,
              'discount'=>0,
              'total'=>$p->getPrice()*$qty);
      }else{
          $this->allProducts[$idProduct]['qty']+=$qty;
          $this->allProducts[$idProduct]['total']+=$p->getPrice()*$qty;
      }
      
      #Verifica si aplica el % por cada 12
      #Hace una actualización del discount de ese producto solamente
      $data=$this->discount->checkByTwelve($idCategory,$qty);
      if($data) {
          $this->allProducts[$idProduct]['discount']=$data['discount'];          
      }
      
      #Verifica si aplica el descuento por cantidad
      #Lanza una actualización excluyente
      $data=$this->discount->checkByQuantity($idCategory,$qty,$this->categoryGroup);
      if($data) {
          $this->updateDiscountExclude($data);
      }              
  }

/*
      Actualización incluyente, es decir, actualiza sólo los productos
      de una determinada categoría, según las reglas de descuento definidas
      en la clase Discount
  */
  public function updateDiscountInclude($data) {
      foreach ($this->allProducts as &$item) {
          $p=$item['product'];
          if (in_array($p->getCategory(),$data['include'])) {
              $item['discount']=$data['discount'];
          }
      }    
  }
    
  /*
      Actualización excluyente, es decir, actualiza los productos
      que no sean de una determinada categoría, según las reglas de descuento 
      definidas en la clase Discount
  */    
  public function updateDiscountExclude($data) {
      foreach ($this->allProducts as &$item) {
          $p=$item['product'];
          if (!in_array($p->getCategory(),$data['exclude'])) {
              $item['discount']=$data['discount'];
          }
      }    
  }      
   
  public function getAllProducts() {
      return $this->allProducts;
  }  
       
  public function getCategoryGroup() {
      return $this->categoryGroup;
  }     
 
  /*
      Este método imprime el estado actual de la orden
  */

public function print(){ 
        printf("%s %s %-20s %s %-5s %s %-1s %-5s %5s %s\n",
               'Cant.','','Producto','Total','','Precio final','','% desc','','Categoría');
              
      foreach ($this->allProducts as $item) {
          $p=$item['product'];
          $finalPrice = ($item['discount']>0) ?  $item['total'] * (1 - ($item['discount'] / 100)) : $item['total'];
          printf("%d %5s %-20s %.2f %-5s %.2f %-10s %s %-10s %s\n",
               $item['qty'],'',$p->getName(),$item['total'],'',$finalPrice,'',$item['discount'],'',$p->getCategory());
      } 
    }   
}

/*
    Y vamos a crear una clase para manejar los descuentos
    Tomando lo que has dicho en la pregunta, reflejaremos aquí:
    a. Descuentos de: 5% x cada 10; 10% x cada 20 y de 15% x cada 30
    b. Pero, que esos descuentos no se apliquen a ciertas categorías,
       he puesto aquí como ejemplo las categorías 3,4,5 las cuales entran
       en un descuento particular del 8% por cada 12 artículos comprados
       (no sé si entendí bien tu comentario en ese sentido, es sólo un ejemplo)
    c. Que por cada 12 productos de la(s) categoria(s) N se aplique 8% de descuento,
       he puesto como ejemplo que esta regla se aplique a los productos con categorías 3, 4 y 5
    d. Cualquier otra estrategia la defines en esta clase "Discount"
*/

class Discount {
  private $orderDetail;
  private $categoryGroup=array();
  private $productGroup=array();    
  private $order;
  private $rulesByQuantity=array(
          'ruleByTen'=>array(
              'exclude'=>array(3,4,5),
              'minCategory'=>2,
               'rules'=>array(
                   array('max'=>10, 'percent'=>5), 
                   array('max'=>20, 'percent'=>10), 
                   array('max'=>30, 'percent'=>15))));
  private $rulesByCategory=array(
           'ruleMax12'=>
              array('max'=>12, 'percent'=>8,'include'=>array(3,4,5)));
    
  public function __construct() {
      $this->sortData();
  }
    
  /*
      Este método verifica si se cumple la regla
      de descuento del 8% por cada 12 productos
      Devuelve null o un array con el descuento a aplicar
      y los ids de categoría a los que se aplicará
      para fines de actualizar el detalle de la orden
  */
  public function checkByTwelve($categoryId, $qty) {      
      $rule=$this->rulesByCategory['ruleMax12'];
      if(in_array($categoryId,$rule['include'])) { 
          if ($qty >= $rule['max']) {
              return array ('discount'=>$rule['percent'], 'include'=>$rule['include']);         
          }
      }
      return null;
  }

/*
      Este método verifica si se cumple la regla
      de descuento por cantidad de productos comprados
      Devuelve null o un array con el descuento a aplicar
      y los ids de categoría a los que no se aplicará
      para fines de actualizar el detalle de la orden
  */    
  public function checkByQuantity($categoryId, $qty, $categoryGroup) {            
      $ruleByTen=$this->rulesByQuantity['ruleByTen'];
      $data=array('counter'=>0,'qty'=>$qty, 'ids'=>$ruleByTen['exclude'], 'minCategory'=>$ruleByTen['minCategory'],'group'=>$categoryGroup);
      if(!in_array($categoryId,$ruleByTen['exclude'])) {
          foreach ($ruleByTen['rules'] as $rule){
            $data['rules']=$rule;
            if ($this->sumByCategory($data)){
                if ($this->checkCountConstraint($data)){
                    return array ('discount'=>$rule['percent'], 'exclude'=>$ruleByTen['exclude']);
                    break;
                } 
            } 
          }
      } 
      return null;
  }
     
  public function sortData() {
      array_multisort(array_column($this->rulesByQuantity['ruleByTen']['rules'], 'max'), SORT_DESC, $this->rulesByQuantity['ruleByTen']['rules']);
  }

/*
      Este método verifica la cantidad de productos comprados
      de una categoría dada, para determinar qué descuento aplica
      cuando se deba tener en cuenta el total de productos comprados
      de un rango de categorías únicamente.
      Devuelve un booleano que verifica si el tota de productos comprados
      es mayor o igual a máximo indicado en la regla de descuento
  */    
    
  public function checkCountConstraint($data) {
      array_walk( 
          $data['group'], 
          function( &$value, $key) use ( &$data ){              
              if(!in_array($value['idCategory'],$data['ids'])) {
                  $data['counter']+=$value['counter'];
              }
          }
      );
      $isDiscountable=($data['counter']>=$data['rules']['max']);
      return $isDiscountable;       
  } 
    
  /*
      Este método suma todas las categorías de un posible descuento aplicable.
      Por ejemplo, sirve para verificar que checkByQuantity()
      si la cantidad de productos no son de más de 2 categorías, 
      el descuento no aplique.
      Devuelve un booleano que verifica esa condición.
      Se ha puesto el valor 2 como ejemplo, para hacerlo más dinámico,
      ese valor se puede definir en la regla.en verifica la cantidad de productos comprados
      de una categoría dada, para determinar qué descuento aplica
      cuando se deba tener en cuenta el total de productos comprados
      de un rango de categorías únicamente.
      Devuelve un booleano que verifica si el tota de productos comprados
      es mayor o igual a máximo indicado en la regla de descuento
  */    
    public function sumByCategory($data){
        $sumArray = array();
        foreach ($data['group'] as $k=>$item) {
            if(!isset($sumArray[$item['idCategory']])){
                $sumArray[]=$item['idCategory'];
            }
        }
        return count($sumArray)>$data['minCategory'];
    }

}

/*
   Datos de prueba que representan
   los productos que vendes
*/
$testData = array(
    array('id'=>1, 'name'=>"Televisor",        'category'=>1,'price'=>19.10),
    array('id'=>2, 'name'=>"Radio",            'category'=>1,'price'=>10.99),
    array('id'=>3, 'name'=>"Lavadora",         'category'=>3,'price'=>40.99),    
    array('id'=>4, 'name'=>"Abanico",          'category'=>4,'price'=>12.99),    
    array('id'=>5, 'name'=>"Frigorífico",      'category'=>2,'price'=>70.10),    
    array('id'=>6, 'name'=>"Licuadora",        'category'=>5,'price'=>6.50),    
    array('id'=>7, 'name'=>"A. Acondic.",      'category'=>4,'price'=>20.99),    
    array('id'=>8, 'name'=>"Tostadora",        'category'=>5,'price'=>5.99),    
    array('id'=>9, 'name'=>"Componente",       'category'=>1,'price'=>43.99),    
    array('id'=>10,'name'=>"Aspirador",        'category'=>3,'price'=>14.10),    
    array('id'=>11,'name'=>"Congelador",       'category'=>2,'price'=>80.00),

);

/*
    Las reglas de descuento definidas son las siguientes:
      a. Por cantidad incremental
        - Si se compran 5+  productos que NO sean de las categorías 3,4, 5: 5%  descuento
        - Si se compran 20+ productos que NO sean de las categorías 3,4, 5: 10% descuento
        - Si se compran 30+ productos que NO sean de las categorías 3,4, 5: 15% descuento
        - PERO la suma 5, 20 ó 30 tiene que ser de productos de más de dos categorías
        
      b. Por cada 12 productos
        - Si se compran más de 12 productos que sean de las categorías 3,4,5 un 8% descuento
      
      Creamos un set de datos a mano, para verificar si el código funciona
*/

$oneOrder=new Order(1,"20230424");

$orderDetail=new OrderDetail($oneOrder);
addTestData($testData[3],13,$orderDetail);
addTestData($testData[2],4,$orderDetail);
addTestData($testData[3],4,$orderDetail);
addTestData($testData[4],4,$orderDetail);
addTestData($testData[5],4,$orderDetail);
addTestData($testData[6],4,$orderDetail);
addTestData($testData[7],4,$orderDetail);
addTestData($testData[9],4,$orderDetail);
addTestData($testData[0],21,$orderDetail);
addTestData($testData[2],4,$orderDetail);
addTestData($testData[5],14,$orderDetail);

$oneOrder->addOrderDetail($orderDetail);
$orderDetail->print();

/*
    Esta función es sólo de prueba,
    para meter datos y probar el funcionamiento de las clases
*/
function addTestData($arr,$qty,$orderDetail){
    $oneProduct=new Product($arr['id'],$arr['name'],$arr['category'],$arr['price']);
    $orderDetail->addProduct($oneProduct,$qty);
}

[ + ] Show input
Absolute running time: 0.27 sec, cpu time: 0.03 sec, memory peak: 25 Mb, absolute service time: 0,36 sec

Reglas de descuento, enfoque desde la POO - https://es.stackoverflow.c...