Esempio n. 1
0
 public static function aplicarReglas(array $reglas, VO $obj, $cantidad = null, $id_unidad = null)
 {
     //Logger::log("aplicando reglas de tarifa");
     //Logger::log( sizeof($reglas) . " reglas.");
     //Logger::log( $cantidad . " unidades de idunidad="  .$id_unidad );
     $precio_base = 0;
     if (!$obj instanceof Paquete) {
         if ($obj->getMetodoCosteo() == "costo") {
             $precio_base = $obj->getCostoEstandar();
         } else {
             if ($obj->getMetodoCosteo() == "precio") {
                 $precio_base = $obj->getPrecio();
             } else {
                 $precio_base = $obj->getPrecio();
                 //throw new Exception("El producto o servicio tiene un metodo de costeo invalido", 901);
             }
         }
     } else {
         $precio_base = $obj->getPrecio();
     }
     $precio_final = 0;
     $regla = new Regla();
     foreach ($reglas as $regla) {
         if (!$regla instanceof VO) {
             Logger::error("La regla recibida no es un VO valido");
             throw new Exception("La regla recibida no es un VO valido");
         }
         Logger::log("procesando regla..." . $regla->getIdRegla());
         //Si la regla especifica que actuara sobre algun tipo especial, se evalua si el objeto recibido entra en esa clasificacion
         if (!is_null($regla->getIdClasificacionProducto()) || !is_null($regla->getIdClasificacionServicio()) || !is_null($regla->getIdPaquete()) || !is_null($regla->getIdProducto()) || !is_null($regla->getIdRegla()) || !is_null($regla->getIdServicio())) {
             $encontrado = false;
             //Bandera que indicara si se encontro que la regla es aplicable o no
             //Si la regla especifica una clasificacion de producto y el objeto es un producto,
             //entonces se busca la clasificacion especificada por la regla en las clasificaciones del producto.
             //Si es encontrada se cambia a verdadero la bandera.
             if (!is_null($regla->getIdClasificacionProducto()) && $obj instanceof Producto) {
                 Logger::log("Si la regla especifica una clasificacion de producto y el objeto es un producto");
                 $clasificaciones_producto = ProductoClasificacionDAO::search(new ProductoClasificacion(array("id_producto" => $obj->getIdProducto())));
                 foreach ($clasificaciones_producto as $clasificacion_producto) {
                     if ($clasificacion_producto->getIdClasificacionProducto() == $regla->getIdClasificacionProducto()) {
                         $encontrado = true;
                         break;
                     }
                 }
             }
             //Si aun no esta activa la bandera, la regla especifica una clasificacion de servicio y el objeto es un servicio,
             //entonces se busca la clasificacion esecificada por la regla en las clasificaciones del servicio.
             //Si es encontrada se cambia a verdadero la bandera
             if (!$encontrado && !is_null($regla->getIdClasificacionServicio()) && $obj instanceof Servicio) {
                 Logger::log("la regla especifica una clasificacion de servicio y el objeto es un servicio,");
                 $clasificaciones_servicio = ServicioClasificacionDAO::search(new ServicioClasificacion(array("id_servicio" => $obj->getIdServicio())));
                 foreach ($clasificaciones_servicio as $clasificacion_servicio) {
                     if ($clasificacion_servicio->getIdClasificacionServicio() == $regla->getIdClasificacionServicio()) {
                         $encontrado = true;
                         break;
                     }
                 }
             }
             //Si aun no esta activa la bandera, la regla especifica un producto y el objeto es un producto,
             //entonces se compara el id especificado por la regla con el id del producto. Si son iguales,
             //verifica si la regla especifica una unidad. De ser asi, verifica que la unidad especificada
             //por la regla sea igual a la obtenida, si lo son, entonces se cambia la bandera a verdadero.
             //Si no se especifica una unidad en la regla, entonces se cambia la bandera a verdadero
             if (!$encontrado && !is_null($regla->getIdProducto()) && $obj instanceof Producto) {
                 Logger::log("la regla especifica un producto y el objeto es un producto");
                 if ($obj->getIdProducto() == $regla->getIdProducto()) {
                     if (!is_null($regla->getIdUnidad())) {
                         if ($regla->getIdUnidad() == $id_unidad) {
                             $encontrado = true;
                         }
                     } else {
                         $encontrado = true;
                     }
                 }
             }
             //Si la bandera aun no esta activa, la regla especifica un servicio y el objeto es un servicio,
             //entonces se verifica que el id especificado por la regla sea igual al del servicio. Si son
             //iguales entonces se cambia la bandera a verdadero.
             if (!$encontrado && !is_null($regla->getIdServicio()) && $obj instanceof Servicio) {
                 Logger::log("la regla especifica un servicio y el objeto es un servicio,");
                 if ($obj->getIdServicio() == $regla->getIdServicio()) {
                     $encontrado = true;
                 }
             }
             //Si la bandera aun no esta activa, la regla especifica un paquete y el objeto es un paquete,
             //entonces se verifica que el id especificado por al regla sea igual al del paquete. Si son
             //iguales entonces se cambia la bandera a verdadero.
             if (!$encontrado && !is_null($regla->getIdPaquete()) && $obj instanceof Paquete) {
                 Logger::log("la regla especifica un paquete y el objeto es un paquete,");
                 if ($obj->getIdPaquete() == $regla->getIdPaquete()) {
                     $encontrado = true;
                 }
             }
             if ($encontrado) {
                 Logger::log("Encontre un filtro especifico, saliendo de este pedo... ");
                 continue;
             }
         }
         //if
         Logger::log("No encontre un filtro especifico, continuando... ");
         Logger::log("precio_final = precio_base * ( 1 +  (regla->getPorcentajeUtilidad()/100 ));");
         $precio_final = $precio_base * (1 + $regla->getPorcentajeUtilidad() / 100);
         Logger::log("{$precio_final} = {$precio_base} * ( 1 +  (" . $regla->getPorcentajeUtilidad() . "/100 ));");
         $metodo_redondeo = $regla->getMetodoRedondeo();
         /*
          * Para saber el precio final despues del redondeo se utilizan dos valores de redondeo,
          * un redoden superior y un redonde inferior. Por ejemplo, si el valor de precio final
          * es 57 y el metodo de redondeo es 10, existen dos posibles redondeos, 50 y 60, siendo 50
          * el redondeo inferior y 60 el redondeo superior.
          * 
          * Para calcula estos redondeos se usa la siguiente formula
          * 
          *    residuo = precio_final % metodo_redondeo
          * 
          * El residuo es lo que le sobra al precio final para ser un multiplo del metodo de redondeo,
          * entonces el redondeo inferior siempre sera el precio final menos el residuo. En nuestro ejemplo
          * 
          *   precio_final - residuo = 57 - 7 = 50
          * 
          * El redondeo superior es el precio final mas la resta del metodo de redondeo con el residuo. En
          * nuestro ejemplo
          * 
          *  precio_final + ( metodo_redondeo - residuo) = 57 + ( 10 - 7) = 60
          */
         if ($metodo_redondeo > 0) {
             $redondeo_superior = $precio_final + $metodo_redondeo - $precio_final % $metodo_redondeo;
             $redondeo_inferior = $precio_final - $precio_final % $metodo_redondeo;
             if ($redondeo_superior - $precio_final < $precio_final - $redondeo_inferior) {
                 $precio_final = $redondeo_superior;
             } else {
                 $precio_final = $redondeo_inferior;
             }
         }
         //Si el precio final es menor que el margen minimo y el margen minimo esta especificado
         //( No es cero), entonces se sobreescribe el precio final con el del margen minimo
         $precio_final += $regla->getUtilidadNeta();
         if ($precio_final < $regla->getMargenMin() && $regla->getMargenMin() != 0) {
             $precio_final = $regla->getMargenMin();
         }
         //Si el precio final es mayor que el margen maximo y el margen maximo esta especificado
         //( No es cero), entonces se sobreescribe el precio final con el del margen maximo
         if ($precio_final > $regla->getMargenMax() && $regla->getMargenMax() != 0) {
             $precio_final = $regla->getMargenMax();
         }
         $precio_base = $precio_final;
     }
     //Logger::log("El precio despues de todas las reglas es ".$precio_base);
     return $precio_base;
 }
Esempio n. 2
0
 /**
  *
  *Edita la informaci?n de un producto
  *
  * @param id_producto int Id del producto a editar
  * @param clasificaciones json Uno o varios id_clasificacion de este producto, esta clasificacion esta dada por el usuario
  * @param codigo_de_barras string El Codigo de barras para este producto
  * @param codigo_producto string Codigo del producto
  * @param compra_en_mostrador bool Verdadero si este producto se puede comprar en mostrador, para aquello de compra-venta
  * @param control_de_existencia int 00000001 = Unidades. 00000010 = Caractersticas. 00000100 = Series. 00001000 = Pedimentos. 00010000 = Lote
  * @param costo_estandar float Valor del costo estndar del producto.
  * @param costo_extra_almacen float Si este producto produce un costo extra por tenerlo en almacen
  * @param descripcion_producto string Descripcion larga del producto
  * @param empresas json arreglo de ids de empresas a las que pertenece este producto
  * @param foto_del_producto string url a una foto de este producto
  * @param garantia int Numero de meses de garantia con los que cuenta esta categoria de producto
  * @param id_unidad int La unidad preferente de este producto
  * @param id_unidad_compra int El id de la unidad de medida en la que se adquiere el producto al comprarlo
  * @param impuestos json array de ids de impuestos que tiene este producto
  * @param metodo_costeo string Puede ser "precio" o "costo" e indican si el precio final sera tomado a partir del costo del producto o del precio del mismo
  * @param nombre_producto string Nombre del producto
  * @param peso_producto float el peso de este producto en KG
  * @param precio int El precio de este producto
  * @param visible_en_vc bool Verdadero si este producto sera visible a los clientes.
  **/
 static function Editar($id_producto, $clasificaciones = null, $codigo_de_barras = null, $codigo_producto = null, $compra_en_mostrador = null, $control_de_existencia = null, $costo_estandar = null, $costo_extra_almacen = null, $descripcion_producto = null, $empresas = null, $foto_del_producto = null, $garantia = null, $id_unidad = null, $id_unidad_compra = null, $impuestos = null, $metodo_costeo = null, $nombre_producto = null, $peso_producto = null, $precio = null, $visible_en_vc = null)
 {
     Logger::log("== Editando producto " . $id_producto . " ==");
     //se validan los parametros recibidos
     $validar = self::validarParametrosProducto($id_producto, $compra_en_mostrador, $metodo_costeo, null, $codigo_producto, $nombre_producto, $garantia, $costo_estandar, $control_de_existencia, $descripcion_producto, $foto_del_producto, $costo_extra_almacen, $codigo_de_barras, $peso_producto, $id_unidad, $precio);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     //is_string($validar)
     $producto = ProductoDAO::getByPK($id_producto);
     //Los parametros que no sean nulos seran tomados como una actualizacion
     if (!is_null($compra_en_mostrador)) {
         $producto->setCompraEnMostrador($compra_en_mostrador);
     }
     //!is_null($compra_en_mostrador)
     if (!is_null($descripcion_producto)) {
         $producto->setDescripcion($descripcion_producto);
     }
     //!is_null($descripcion_producto)
     if (!is_null($metodo_costeo)) {
         $producto->setMetodoCosteo($metodo_costeo);
     }
     //!is_null($metodo_costeo)
     if (!is_null($codigo_producto)) {
         $producto->setCodigoProducto(trim($codigo_producto));
     }
     //!is_null($codigo_producto)
     if (!is_null($nombre_producto)) {
         $producto->setNombreProducto(trim($nombre_producto));
     }
     //!is_null($nombre_producto)
     if (!is_null($garantia)) {
         $producto->setGarantia($garantia);
     }
     //!is_null($garantia)
     if (!is_null($costo_estandar)) {
         $costo_estandar = $metodo_costeo == "costo" ? $costo_estandar : null;
         //sólo en caso de que se haya seleccionado metodo_costeo == 'costo' tomar en cuenta este valor ver API
         $producto->setCostoEstandar($costo_estandar);
     }
     //!is_null($costo_estandar)
     if (!is_null($control_de_existencia)) {
         $producto->setControlDeExistencia($control_de_existencia);
     }
     //!is_null($control_de_existencia)
     if (!is_null($foto_del_producto)) {
         $producto->setFotoDelProducto($foto_del_producto);
     }
     //!is_null($foto_del_producto)
     if (!is_null($costo_extra_almacen)) {
         $producto->setCostoExtraAlmacen($costo_extra_almacen);
     }
     //!is_null($costo_extra_almacen)
     if (!is_null($codigo_de_barras)) {
         $producto->setCodigoDeBarras(trim($codigo_de_barras));
     }
     //!is_null($codigo_de_barras)
     if (!is_null($peso_producto)) {
         $producto->setPesoProducto($peso_producto);
     }
     //!is_null($peso_producto)
     if (!is_null($id_unidad)) {
         $producto->setIdUnidad($id_unidad);
     }
     //!is_null($id_unidad)
     if (!is_null($id_unidad_compra)) {
         $producto->setIdUnidadCompra($id_unidad_compra);
     }
     //!is_null($id_unidad_compra)
     if (!is_null($precio)) {
         $producto->setPrecio($precio);
     }
     //!is_null($precio)
     if (!is_null($visible_en_vc)) {
         $producto->setVisibleEnVc($visible_en_vc);
     }
     if ($metodo_costeo == "precio" && is_null($producto->getPrecio())) {
         Logger::error("Se intenta registrar un producto con metodo de costeo precio sin especificar un precio");
         throw new Exception("Se intenta registrar un producto con metodo de costeo precio sin especificar un precio", 901);
     } else {
         if ($metodo_costeo == "costo" && is_null($producto->getCostoEstandar())) {
             Logger::error("Se intenta registrar un producto con metodo de costeo costo sin especificar un costo estandar");
             throw new Exception("Se intenta registrar un producto con metodo de costeo costo sin especificar un costo estandar", 901);
         }
     }
     //$metodo_costeo == "costo" && is_null($producto->getCostoEstandar())
     DAO::transBegin();
     try {
         ProductoDAO::save($producto);
         //Si se reciben empresas, clasificaciones y/o impuestos se modifican en sus respectivas tablas
         //
         //Primero se guardan o actualizan los registros pasados en la lista, despues se recorren los registros
         //actuales y si alguno no se encuentra en la lista se elimina.
         if (!is_null($empresas)) {
             $empresas = object_to_array($empresas);
             if (!is_array($empresas)) {
                 throw new Exception("Las empresas fueron enviadas incorrectamente", 901);
             }
             //!is_array($empresas)
             $producto_empresa = new ProductoEmpresa(array("id_producto" => $id_producto));
             foreach ($empresas as $empresa) {
                 $validar = self::validarParametrosProductoEmpresa($empresa);
                 if (is_string($validar)) {
                     throw new Exception($validar, 901);
                 }
                 $producto_empresa->setIdEmpresa($empresa);
                 ProductoEmpresaDAO::save($producto_empresa);
             }
             //$empresas as $empresa
             $productos_empresa = ProductoEmpresaDAO::search(new ProductoEmpresa(array("id_producto" => $id_producto)));
             foreach ($productos_empresa as $p_e) {
                 $encontrado = false;
                 foreach ($empresas as $empresa) {
                     if ($empresa == $p_e->getIdEmpresa()) {
                         $encontrado = true;
                     }
                     //$empresa == $p_e->getIdEmpresa()
                 }
                 //$empresas as $empresa
                 if (!$encontrado) {
                     ProductoEmpresaDAO::delete($p_e);
                 }
             }
             //$productos_empresa as $p_e
         }
         //!is_null($empresas)
         /* Fin if de empresas */
         if (!is_null($clasificaciones)) {
             $clasificaciones = object_to_array($clasificaciones);
             if (!is_array($clasificaciones)) {
                 throw new Exception("Las clasificaciones fueron recibidas incorrectamente", 901);
             }
             //!is_array($clasificaciones)
             $producto_clasificacion = new ProductoClasificacion(array("id_producto" => $id_producto));
             foreach ($clasificaciones as $clasificacion) {
                 $c = ClasificacionProductoDAO::getByPK($clasificacion);
                 if (is_null($c)) {
                     throw new Exception("La clasificacion de producto con id " . $clasificacion . " no existe", 901);
                 }
                 if (!$c->getActiva()) {
                     throw new Exception("La clasificaicon de producto con id " . $clasificacion . " no esta activa", 901);
                 }
                 $producto_clasificacion->setIdClasificacionProducto($clasificacion);
                 ProductoClasificacionDAO::save($producto_clasificacion);
             }
             //$clasificaciones as $clasificacion
             $productos_clasificacion = ProductoClasificacionDAO::search(new ProductoClasificacion(array("id_producto" => $id_producto)));
             foreach ($productos_clasificacion as $p_c) {
                 $encontrado = false;
                 foreach ($clasificaciones as $clasificacion) {
                     if ($clasificacion == $p_c->getIdClasificacionProducto()) {
                         $encontrado = true;
                     }
                     //$clasificacion == $p_c->getIdClasificacionProducto()
                 }
                 //$clasificaciones as $clasificacion
                 if (!$encontrado) {
                     ProductoClasificacionDAO::delete($p_c);
                 }
             }
             //$productos_clasificacion as $p_c
         }
         //!is_null($clasificaciones)
         /* Fin if de clasificaciones */
         if (!is_null($impuestos)) {
             $impuestos = object_to_array($impuestos);
             if (!is_array($impuestos)) {
                 throw new Exception("Los impuestos fueron recibidos incorrectamente", 901);
             }
             //!is_array($impuestos)
             $impuesto_producto = new ImpuestoProducto(array("id_producto" => $producto->getIdProducto()));
             foreach ($impuestos as $impuesto) {
                 if (is_null(ImpuestoDAO::getByPK($impuesto))) {
                     throw new Exception("El impuesto con id " . $impuesto . " no existe", 901);
                 }
                 $impuesto_producto->setIdImpuesto($impuesto);
                 ImpuestoProductoDAO::save($impuesto_producto);
             }
             //$impuestos as $impuesto
             $impuestos_producto = ImpuestoProductoDAO::search(new ImpuestoProducto(array("id_producto" => $id_producto)));
             foreach ($impuestos_producto as $i_p) {
                 $encontrado = false;
                 foreach ($impuestos as $impuesto) {
                     if ($impuesto == $i_p->getIdImpuesto()) {
                         $encontrado = true;
                     }
                     //$impuesto == $i_p->getIdImpuesto()
                 }
                 //$impuestos as $impuesto
                 if (!$encontrado) {
                     ImpuestoProductoDAO::delete($i_p);
                 }
             }
             //$impuestos_producto as $i_p
         }
         //!is_null($impuestos)
         /* Fin if de impuestos */
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("El producto no pudo ser editado: " . $e);
         if ($e->getCode() == 901) {
             throw new Exception("El producto no pudo ser editado: " . $e->getMessage(), 901);
         }
         throw new Exception("El producto no pudo ser editado", 901);
     }
     DAO::transEnd();
     Logger::log("Producto editado exitosamente");
 }