예제 #1
0
 /**
  *
  *Comprar productos en mostrador. No debe confundirse con comprar productos a un proveedor. Estos productos se agregaran al inventario de esta sucursal de manera automatica e instantanea. La IP ser?omada de la m?ina que realiza la compra. El usuario y la sucursal ser?tomados de la sesion activa. El estado del campo liquidada ser?omado de acuerdo al campo total y pagado.
  *
  * @param retencion float Cantidad sumada por retenciones
  * @param detalle json Objeto que contendr la informacin de los productos comprados, sus cantidades, sus descuentos, y sus precios
  * @param id_vendedor int Id del cliente al que se le compra
  * @param total float Total de la compra despues de impuestos y descuentos
  * @param tipo_compra string Si la compra es a credito o de contado
  * @param subtotal float Total de la compra antes de incluirle impuestos.
  * @param id_empresa int Empresa a nombre de la cual se realiza la compra
  * @param descuento float Cantidad restada por descuento
  * @param impuesto float Cantidad sumada por impuestos
  * @param billetes_pago json Ids de billetes que se usaron para pagar
  * @param billetes_cambio json Ids de billetes que se recibieron como cambio
  * @param tipo_pago string Si el pago ser en efectivo, con tarjeta o con cheque
  * @param saldo float Saldo de la compra
  * @param cheques json Si el tipo de pago es con cheque, se almacena el nombre del banco, el monto y los ultimos 4 numeros del o de los cheques
  * @return id_compra_cliente string Id de la nueva compra
  **/
 public static function ComprarCaja($descuento, $detalle, $id_empresa, $id_vendedor, $impuesto, $retencion, $subtotal, $tipo_compra, $total, $billetes_cambio = null, $billetes_pago = null, $cheques = null, $id_caja = null, $id_compra_caja = null, $id_sucursal = null, $saldo = 0, $tipo_pago = null)
 {
     Logger::log("Realizando la compra");
     //Se obtiene el id del usuario de la sesion actual
     $id_usuario = SesionController::getCurrentUser();
     if (is_null($id_usuario)) {
         Logger::error("No se pudo obtener al usuario de la sesion actual, ya inicio sesion?");
         throw new Exception("No se pudo obtener al usuario de la sesion actual, ya inicio sesion?");
     }
     //Se validan los parametros recibidos
     $validar = self::validarParametrosCompra(null, $id_compra_caja, $id_vendedor, $tipo_compra, $subtotal, $impuesto, $descuento, $total, $id_empresa, $saldo, null, $tipo_pago, $retencion);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     //Se inicializa el usuario con los parametros recibidos.
     $usuario = UsuarioDAO::getByPK($id_vendedor);
     $compra = new Compra();
     $compra->setRetencion($retencion);
     $compra->setIdVendedorCompra($id_vendedor);
     $compra->setSubtotal($subtotal);
     $compra->setImpuesto($impuesto);
     $compra->setTotal($total);
     $compra->setDescuento($descuento);
     $compra->setTipoDeCompra($tipo_compra);
     $compra->setIdCaja(self::getCaja());
     $compra->setIdSucursal(self::getSucursal());
     $compra->setIdUsuario($id_usuario);
     $compra->setIdCompraCaja($id_compra_caja);
     $compra->setCancelada(0);
     $compra->setTipoDePago($tipo_pago);
     $compra->setFecha(time());
     $compra->setIdEmpresa($id_empresa);
     DAO::transBegin();
     try {
         //Si la compra es a contado, se realizan operaciones dependiendo del tipo de pago
         if ($tipo_compra === "contado") {
             //Si se recibe un saldo, se loguea una advertencia indicando que se ignorará
             if (!is_null($saldo)) {
                 Logger::warn("Se recibio un saldo cuando la venta es de contado, el saldo se tomara del total");
             }
             $compra->setSaldo($total);
             CompraDAO::save($compra);
             //Si el tipo de pago es cheque, se crean los nuevos cheques con la informacion obtenida
             //y se almacenan registros por cada cheque para esta compra en la tabla cheque_compra
             if ($tipo_pago === "cheque") {
                 //Si no se recibe informacion de los cheques se lanza una excepcion
                 if (is_null($cheques)) {
                     throw new Exception("El tipo de pago es con cheque pero no se recibio informacion del mismo");
                 }
                 $cheques = object_to_array($cheques);
                 if (!is_array($cheques)) {
                     throw new Exception("Los cheques son invalidos", 901);
                 }
                 $cheque_compra = new ChequeCompra();
                 $cheque_compra->setIdCompra($compra->getIdCompra());
                 foreach ($cheques as $cheque) {
                     $id_cheque = ChequesController::NuevoCheque($cheque["nombre_banco"], $cheque["monto"], $cheque["numero"], 1);
                     $cheque_compra->setIdCheque($id_cheque);
                     ChequeCompraDAO::save($cheque_compra);
                 }
             } else {
                 if ($tipo_pago === "efectivo") {
                     CajasController::modificarCaja($compra->getIdCaja(), 0, $billetes_pago, $total);
                     if (!is_null($billetes_cambio)) {
                         CajasController::modificarCaja($compra->getIdCaja(), 1, $billetes_cambio, 0);
                     }
                 }
             }
         } else {
             if ($tipo_compra == "credito") {
                 if (is_null($saldo)) {
                     Logger::warn("No se recibio un saldo, se tomara 0 como saldo");
                     $saldo = 0;
                 }
                 //El saldo no puede ser mayor que la cantidad a comprar
                 if ($saldo > $total) {
                     throw new Exception("El saldo no puede ser mayor que el total de la compra");
                 }
                 $compra->setSaldo($saldo);
                 CompraDAO::save($compra);
                 $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $total - $saldo);
                 UsuarioDAO::save($usuario);
             }
         }
         //Si se recibio detalle de productos, se agregan al almacen correspondiente a la empresa
         //dentro de esta sucursal. Tambien se guarda el detalle en la tabla compra_producto
         if (!is_null($detalle)) {
             $detalle = object_to_array($detalle);
             if (!is_array($detalle)) {
                 throw new Exception("El detalle del producto es invalido", 901);
             }
             //Se inicializan variables para el almacenamiento de los registros.
             $d_producto = new CompraProducto();
             $d_producto->setIdCompra($compra->getIdCompra());
             //se buscan los almacenes de esta empresa para esta sucursal y se ignoran los de consginacion
             $almacenes = AlmacenDAO::search(new Almacen(array("id_sucursal" => self::getSucursal(), "id_empresa" => $id_empresa)));
             $id_almacen = null;
             foreach ($almacenes as $a) {
                 if ($a->getIdTipoAlmacen() == 2) {
                     continue;
                 }
                 $id_almacen = $a->getIdAlmacen();
             }
             //Si no se encontro un almacen, se arroja una excepcion
             if (is_null($id_almacen)) {
                 throw new Exception("No existe un almacen para esta empresa en esta sucursal");
             }
             //Por cada producto en el detalle se almacena en la tabla compra_producto y se agregan al
             //almacen de la empresa
             foreach ($detalle as $d_p) {
                 if (!array_key_exists("id_producto", $d_p) || !array_key_exists("cantidad", $d_p) || !array_key_exists("precio", $d_p) || !array_key_exists("descuento", $d_p) || !array_key_exists("impuesto", $d_p) || !array_key_exists("retencion", $d_p) || !array_key_exists("id_unidad", $d_p)) {
                     throw new Exception("El detalle de paquete recibido es invalido", 901);
                 }
                 $validar = self::validarParametrosCompraProducto(null, $d_p["id_producto"], $d_p["precio"], $d_p["cantidad"], $d_p["descuento"], $d_p["impuesto"], $d_p["retencion"], $d_p["id_unidad"]);
                 if (is_string($validar)) {
                     throw $validar;
                 }
                 $producto = ProductoDAO::getByPK($d_p["id_producto"]);
                 //Si el producto no puede ser comprado en mostrador arroja una excepcion
                 if (!$producto->getCompraEnMostrador()) {
                     throw new Exception("No se puede comprar el producto con id " . $d_p["id_producto"] . " en mostrador");
                 }
                 //Si el producto no pertenece a la empresa que quiere hacer la compra, arroja una excepcion
                 if (is_null(ProductoEmpresaDAO::getByPK($d_p["id_producto"], $id_empresa))) {
                     throw new Exception("El producto no pertenece a la empresa seleccionada");
                 }
                 //Se incializa ys e guarda el nuevo registro de la tabla compra_producto
                 $d_producto->setCantidad($d_p["cantidad"]);
                 $d_producto->setDescuento($d_p["descuento"]);
                 $d_producto->setIdProducto($d_p["id_producto"]);
                 $d_producto->setIdUnidad($d_p["id_unidad"]);
                 $d_producto->setImpuesto($d_p["impuesto"]);
                 $d_producto->setPrecio($d_p["precio"]);
                 $d_producto->setRetencion($d_p["retencion"]);
                 CompraProductoDAO::save($d_producto);
                 //Se busca el producto en el almacen en la unidad obtenida, si no existe aun
                 //se crea uno nuevo y al final se guarda.
                 $producto_almacen = ProductoAlmacenDAO::getByPK($d_p["id_producto"], $id_almacen, $d_p["id_unidad"]);
                 if (is_null($producto_almacen)) {
                     $producto_almacen = new ProductoAlmacen(array("id_producto" => $d_p["id_producto"], "id_almacen" => $id_almacen, "id_unidad" => $d_p["id_unidad"]));
                 }
                 $producto_almacen->setCantidad($producto_almacen->getCantidad() + $d_p["cantidad"]);
                 ProductoAlmacenDAO::save($producto_almacen);
             }
         } else {
             throw new Exception("No se recibieron productos para esta compra");
         }
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo realizar la compra: " . $e);
         throw new Exception("No se pudo realizar la compra");
     }
     DAO::transEnd();
     Logger::log("compra realizada exitosamente");
     return array("id_compra_cliente" => $compra->getIdCompra());
 }
예제 #2
0
 /**
  *
  *Se crea un  nuevo abono, la caja o sucursal y el usuario que reciben el abono se tomaran de la sesion. La fecha se tomara del servidor
  *
  * @param id_deudor int Id del usuario o la sucursal que realiza el abono, las sucursales seran negativas
  * @param tipo_pago json JSON con la informacion que describe el tipo de pago, si es con cheque, en efectivo o con tarjeta
  * @param monto float monto abonado de la sucursal
  * @param nota string Nota del abono
  * @param id_venta int Id de la venta a la que se le abona
  * @param varios bool True si el monto sera repartido en los prestamos,ventas o compras mas antiguas. Esto se define si se pasa el valor id_venta,id_prestamo o id_compra
  * @param cheques json Se toma el nombre del banco, el monto y los ultimos cuatro numeros del o los cheques usados para este abono
  * @param id_prestamo int Id del prestamo al que se le esta abonando
  * @param id_compra int Id de la compra a la que se abona
  * @return id_abono int El id autogenerado del abono de la sucursal
  **/
 public static function NuevoAbono($id_deudor, $monto, $tipo_pago, $billetes = null, $cheques = null, $id_compra = null, $id_prestamo = null, $id_venta = null, $nota = null)
 {
     Logger::log("Insertando nuevo abono ... ");
     //Se obtiene la sesion del usuario
     $id_usuario = SesionController::getCurrentUser();
     $id_usuario = $id_usuario->getIdUsuario();
     if (is_null($id_usuario)) {
         Logger::error("No se pudo obtener el usuario de la sesion, ya inicio sesion?");
         throw new AccessDeniedException("No se pudo obtener el usuario de la sesion, ya inicio sesion?");
     }
     //Se validan los parametros obtenidos
     $validar = self::validarParametrosAbono($monto, $id_deudor, $nota, $tipo_pago);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     //Si el tipo de pago es con cheque y no se reciben cheques, lanzas una excepcion
     if ($tipo_pago === "cheque" && is_null($cheques)) {
         Logger::error("Se intenta pagar con cheque mas no se envio info de cheques");
         throw new Exception("No se recibio informacion del cheque");
     }
     //Se inicializan las variables de los parametros de las tablas de abonos
     $usuario = UsuarioDAO::getByPK($id_deudor);
     $id_sucursal = self::getSucursal();
     $id_caja = self::getCaja();
     $fecha = time();
     $cancelado = 0;
     $abono = null;
     //Nuevo regitro del abono
     $from = 0;
     //Bandera que indica a que operacion pertenece el abono
     $operacion = null;
     //Objeto de la operacion, puede ser un objeto de venta, de ocmpra o de prestamo
     /*
      * Se valida de que operacion pertenece el abono y de acuerdo a lo obtenido, se realizan 
      * las operaciones necesarias en cada tabla.
      * 
      * Primero se valida que la operacion exista, que sea a credito, que no haya sido cancelada, 
      * que no haya sido saldada y que no se abone mas del total de la operacion.
      * 
      * Despues se inicializa el registro de la tabla correspondiente, se modifica el saldo del deudor
      * y se activa la bandera from
      */
     if (!is_null($id_compra)) {
         /*************************************************************
          * 	abono a compra
          ************************************************************* */
         Logger::log("Abono pertenece a compra, compraid=" . $id_compra);
         $operacion = CompraDAO::getByPK($id_compra);
         if (is_null($operacion)) {
             Logger::error("La compra con id: " . $id_compra . " no existe");
             throw new Exception("La compra con id: " . $id_compra . " no existe");
         }
         if ($operacion->getTipoDeCompra() !== "credito") {
             Logger::error("La compra especificada no es a credito, no se puede abonar a una compra de contado");
             throw new Exception("La compra especificada no es a credito, no se puede abonar a una compra de contado");
         }
         if ($operacion->getCancelada()) {
             Logger::error("La compra ya ha sido cancelada, no se puede abonar a esta compra");
             throw new Exception("La compra ya ha sido cancelada, no se puede abonar a esta compra");
         }
         if ($operacion->getSaldo() > 0) {
             Logger::error("La compra ya ha sido saldada, no se puede abonar a esta compra");
             throw new Exception("La compra ya ha sido saldada, no se puede abonar a esta compra");
         }
         if ($operacion->getSaldo() - $monto < 0) {
             Logger::error("No se puede abonar esta cantidad a esta compra, pues sobrepasa el total de la misma");
             throw new Exception("No se puede abonar esta cantidad a esta compra, pues sobrepasa el total de la misma");
         }
         Logger::log("Insertando abono compra...");
         $abono = new AbonoCompra();
         $abono->setIdCompra($id_compra);
         $abono->setIdReceptor($id_deudor);
         $abono->setIdDeudor($id_usuario);
         $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() - $monto);
         $from = 1;
     } else {
         if (!is_null($id_prestamo)) {
             /*************************************************************
              * abono a prestamo
              ************************************************************* */
             $operacion = PrestamoDAO::getByPK($id_prestamo);
             if (is_null($operacion)) {
                 Logger::error("El prestamo con id: " . $id_prestamo . " no existe");
                 throw new Exception("El prestamo con id: " . $id_prestamo . " no existe");
             }
             if ($operacion->getMonto() <= $operacion->getSaldo()) {
                 Logger::error("El prestamo ya ha sido saldado, no se puede abonar a este prestamo");
                 throw new Exception("El prestamo ya ha sido saldad0, no se puede abonar a este prestamo");
             }
             if ($operacion->getMonto() < $operacion->getSaldo() + $monto) {
                 Logger::error("No se puede abonar esta cantidad a este prestamo, pues sobrepasa el total del mismo");
                 throw new Exception("No se puede abonar esta cantidad a este prestamo, pues sobrepasa el total del mismo");
             }
             $abono = new AbonoPrestamo();
             $abono->setIdPrestamo($id_prestamo);
             $abono->setIdReceptor($id_usuario);
             $abono->setIdDeudor($id_deudor);
             $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $monto);
             $from = 2;
         } else {
             if (!is_null($id_venta)) {
                 /*************************************************************
                  * abono a venta
                  ************************************************************* */
                 $operacion = VentaDAO::getByPK($id_venta);
                 if (is_null($operacion)) {
                     Logger::error("La venta con id: " . $id_venta . " no existe");
                     throw new Exception("La venta con id: " . $id_venta . " no existe");
                 }
                 if ($operacion->getTipoDeVenta() !== "credito") {
                     Logger::error("La ventaa especificada no es a credito, no se puede abonar a una venta de contado");
                     throw new Exception("La venta especificada no es a credito, no se puede abonar a una venta de contado");
                 }
                 if ($operacion->getCancelada()) {
                     Logger::error("La venta ya ha sido cancelada, no se puede abonar a esta venta");
                     throw new Exception("La venta ya ha sido cancelada, no se puede abonar a esta venta");
                 }
                 if ($operacion->getSaldo() <= 0) {
                     Logger::error("La venta ya ha sido saldada, no se puede abonar a esta venta");
                     Logger::log("La venta {$id_venta} tiene un total de " . $operacion->getTotal() . " y un saldo pendiente de " . $operacion->getSaldo() . " por lo tanto ya ha sido saldada.");
                     throw new Exception("La venta ya ha sido saldada, no se puede abonar a esta venta");
                 }
                 if ($operacion->getSaldo() - $monto < 0) {
                     Logger::error("No se puede abonar esta cantidad a esta venta, pues sobrepasa el total de la misma");
                     throw new Exception("No se puede abonar esta cantidad a esta venta, pues sobrepasa el total de la misma");
                 }
                 Logger::log("Insertando AbonoVenta...");
                 $abono = new AbonoVenta();
                 $abono->setIdVenta($id_venta);
                 $abono->setIdReceptor($id_usuario);
                 $abono->setIdDeudor($id_deudor);
                 //(OLD) $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $monto);
                 //Figu: se establece el saldo del cliente restandole la venta y a su vez si tiene adelanto se le incrementa su saldo
                 //$usuario->setSaldoDelEjercicio(  ( $usuario->getSaldoDelEjercicio() - $operacion->getTotal()  ) + $monto );
                 $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $monto);
                 $from = 3;
             } else {
                 Logger::error("No se recibio si el abono sera para una venta, una compra o un prestamo, no se hace nada");
                 throw new Exception("No se recibio si el abono sera para una venta, una compra o un prestamo, no se hace nada");
             }
         }
     }
     //Una vez hecho los cambios particulaes, se realizan los cambios generales
     $operacion->setSaldo($operacion->getSaldo() - $monto);
     $abono->setCancelado($cancelado);
     $abono->setIdCaja($id_caja);
     $abono->setFecha($fecha);
     $abono->setIdSucursal($id_sucursal);
     $abono->setMonto($monto);
     $abono->setNota($nota);
     $abono->setTipoDePago($tipo_pago);
     $id_cheques = array();
     $id_abono = null;
     DAO::transBegin();
     try {
         //Si se reciben cheques y el tipo de pago es cheque, se genera el nuevo cheque y
         //se va almacenando su id en el arreglo id_cheques
         if ($tipo_pago === "cheque" && !is_null($cheques)) {
             foreach ($cheques as $cheque) {
                 array_push($id_cheques, ChequesController::NuevoCheque($cheque["nombre_banco"], $cheque["monto"], $cheque["numero"], $cheque["expedido"]));
             }
         }
         //Dependiendo de que operacion se realizo se van guardando los cheques, los abonos y las operaciones
         //pues todas cambiaron.
         //Si se recibieron cheques, no se modifica la caja.
         //En el caso de las ventas, al final se busca la venta en la tabla venta_empresa y se pone como saldada
         //si ese ha sido el caso
         switch ($from) {
             case 1:
                 AbonoCompraDAO::save($abono);
                 CompraDAO::save($operacion);
                 $id_abono = $abono->getIdAbonoCompra();
                 $cheque_abono_compra = new ChequeAbonoCompra();
                 $cheque_abono_compra->setIdAbonoCompra($id_abono);
                 if (!is_null($id_caja) && empty($id_cheques)) {
                     CajasController::modificarCaja($id_caja, 0, $billetes, $monto);
                 }
                 foreach ($id_cheques as $id_cheque) {
                     $cheque_abono_compra->setIdCheque($id_cheque);
                     ChequeAbonoCompraDAO::save($cheque_abono_compra);
                 }
                 break;
             case 2:
                 AbonoPrestamoDAO::save($abono);
                 PrestamoDAO::save($operacion);
                 $id_abono = $abono->getIdAbonoPrestamo();
                 $cheque_abono_prestamo = new ChequeAbonoPrestamo();
                 $cheque_abono_prestamo->setIdAbonoPrestamo($id_abono);
                 if (!is_null($id_caja) && empty($id_cheques)) {
                     CajasController::modificarCaja($id_caja, 1, $billetes, $monto);
                 }
                 foreach ($id_cheques as $id_cheque) {
                     $cheque_abono_prestamo->setIdCheque($id_cheque);
                     ChequeAbonoPrestamoDAO::save($cheque_abono_prestamo);
                 }
                 break;
             case 3:
                 AbonoVentaDAO::save($abono);
                 VentaDAO::save($operacion);
                 $id_abono = $abono->getIdAbonoVenta();
                 $cheque_abono_venta = new ChequeAbonoVenta();
                 $cheque_abono_venta->setIdAbonoVenta($id_abono);
                 if (!is_null($id_caja) && empty($id_cheques)) {
                     CajasController::modificarCaja($id_caja, 1, $billetes, $monto);
                 }
                 foreach ($id_cheques as $id_cheque) {
                     $cheque_abono_venta->setIdCheque($id_cheque);
                     ChequeAbonoVentaDAO::save($cheque_abono_venta);
                 }
                 if ($operacion->getSaldo() >= $operacion->getTotal()) {
                     $ventas_empresa = VentaEmpresaDAO::search(new VentaEmpresa(array("id_venta" => $operacion->getIdVenta())));
                     foreach ($ventas_empresa as $venta_empresa) {
                         $venta_empresa->setSaldada(1);
                         VentaEmpresaDAO::save($venta_empresa);
                     }
                 }
         }
         /* Fin switch de from */
         UsuarioDAO::save($usuario);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("Error al crear el abono: " . $e);
         throw new Exception("Error al crear el abono");
     }
     DAO::transEnd();
     Logger::log("Abono creado exitosamente");
     return array("id_abono" => $id_abono);
 }