public function testBootstrap()
{
$r = SesionController::Iniciar(123, 1, true);
$this->assertEquals($r["login_succesful"], true);
$r = SesionController::getCurrentUser();
$this->assertEquals($r->getIdUsuario(), 1);
}
<?php
define("BYPASS_INSTANCE_CHECK", false);
require_once "../../../server/bootstrap.php";
$page = new GerenciaComponentPage();
EfectivoController::NuevoCorte();
$page->render();
return;
//
// Parametros necesarios
//
$page->requireParam("cid", "GET", "Esta caja no existe.");
$esta_caja = CajaDAO::getByPK($_GET["cid"]);
$page->addComponent(new TitleComponent("Corte a la caja " . $esta_caja->getDescripcion() . ". El saldo esperado es de: " . $esta_caja->getSaldo(), 3));
//
// Forma de producto
//
$form = new DAOFormComponent(new CorteDeCaja());
$form->addApiCall("api/sucursal/caja/corte", "GET");
$form->onApiCallSuccessRedirect("sucursales.lista.caja.php");
$form->hideField(array("id_corte_de_caja", "saldo_esperado", "id_caja", "fecha"));
$form->makeObligatory(array("saldo_real", "saldo_final"));
$form->createComboBoxJoinDistintName("id_cajero", "id_usuario", "nombre", UsuarioDAO::search(new Usuario(array("id_rol" => 3, "activo" => 1), SesionController::getCurrentUser())));
$form->createComboBoxJoinDistintName("id_cajero_nuevo", "id_usuario", "nombre", UsuarioDAO::search(new Usuario(array("id_rol" => 3, "activo" => 1), SesionController::getCurrentUser())));
$form->setValueField("id_caja", $_GET["cid"]);
$form->sendHidden("id_caja");
$page->addComponent($form);
$page->render();
/**
*
*Metodo que cancela una venta
*
* @param id_venta string Id de la venta a cancelar
**/
public static function Cancelar($id_venta, $billetes = null, $id_caja = null)
{
Logger::log("======= Cancenlando venta " . $id_venta . " ===========");
//valida que la venta exista y que este activa
$venta = VentaDAO::getByPK($id_venta);
if ($venta == null) {
Logger::error("La venta con id: " . $id_venta . " no existe");
throw new Exception("La venta con id: " . $id_venta . " no existe");
}
if ($venta->getCancelada()) {
Logger::warn("La venta ya ha sido cancelada");
return;
}
//Deja la venta como cancelada y la guarda.
$venta->setCancelada(1);
//Obtiene al usuario al que se le vendio
$usuario = UsuarioDAO::getByPK($venta->getIdCompradorVenta());
if ($usuario == null) {
Logger::error("FATAL!!! Esta venta apunta a un usuario que no existe");
throw new Exception("FATAL!!! Esta venta apunta a un usuario que no existe");
}
DAO::transBegin();
// regresar de almacenes
// obtener los productos que se vendieron
// insertalos como neuvo ingreso
$detalle = VentaProductoDAO::search(new VentaProducto(array("id_venta" => $id_venta)));
for ($detalleIterator = 0; $detalleIterator < sizeof($detalle); $detalleIterator++) {
//por cada producto
// --- procesos ---
// -insertar en productoempresa
// -insertar en loteproducto
// -insertar en entradalote
// -si el tipo de precio de venta es costo, actualizar
// -insertar compra producto
$p = $detalle[$detalleIterator];
try {
/*
ProductoEmpresaDAO::save( new ProductoEmpresa( array(
"id_empresa" => $id_empresa,
"id_producto" => $p->getIdProducto()
) ) );
if(is_null($p->lote)){
throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
}
if(strlen($p->lote) == 0){
throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
}
*/
//busquemos el id del lote
$l = LoteDAO::getByPk(1);
//busquemos la unidad que nos mandaron
$uResults = UnidadMedidaDAO::search(new UnidadMedida(array("id_unidad_medida" => $p->getIdUnidad(), "activa" => 1)));
if (sizeof($uResults) != 1) {
throw new InvalidDataException("La unidad de medida `" . $p->id_unidad . "` no existe, o no esta activa.");
}
//busequemos si este producto ya existe en este lote
$lp = LoteProductoDAO::getByPK($l->getIdLote(), $p->getIdProducto());
if (is_null($lp)) {
//no existe, insertar
$loteProducto = new LoteProducto(array("id_lote" => $l->getIdLote(), "id_producto" => $p->getIdProducto(), "cantidad" => $p->getCantidad(), "id_unidad" => $p->getIdUnidad()));
LoteProductoDAO::save($loteProducto);
} else {
//ya existe, sumar
//revisemos si es de la misma unidad
if ($lp->getIdUnidad() == $p->getIdUnidad()) {
//es igual, solo hay que sumar
$lp->setCantidad($lp->getCantidad() + $p->getCantidad());
} else {
//no es igual, hay que convertir
try {
$r = UnidadMedidaDAO::convertir($p->getIdUnidad(), $lp->getIdUnidad(), $p->getCantidad());
} catch (BusinessLogicException $ide) {
//no se pudo convertir porque son de
//diferentes categorias
throw $ide;
//mostrar una excpetion mas fresona
}
$lp->setCantidad($lp->getCantidad() + $r);
}
//$lp->setCantidad( $lp->getCantidad() + $p->cantidad );
LoteProductoDAO::save($lp);
}
$s = SesionController::getCurrentUser();
$loteEntrada = new LoteEntrada(array("id_lote" => $l->getIdLote(), "id_usuario" => $s->getIdUsuario(), "fecha_registro" => time(), "motivo" => "Venta (" . $id_venta . ") Cancelada"));
LoteEntradaDAO::save($loteEntrada);
LoteEntradaProductoDAO::save(new LoteEntradaProducto(array("id_lote_entrada" => $loteEntrada->getIdLoteEntrada(), "id_producto" => $p->getIdProducto(), "id_unidad" => $p->getIdUnidad(), "cantidad" => $p->getCantidad())));
/*
$compraProducto = new CompraProducto(array(
"id_compra" => $compra->getIdCompra(),
"id_producto" => $p->id_producto,
"cantidad" => $p->cantidad,
"precio" => $p->precio,
"descuento" => 0,
"impuesto" => 0,
"id_unidad" => $p->id_unidad,
"retencion" => 0
) );
CompraProductoDAO::save ( $compraProducto);
*/
} catch (InvalidDataException $e) {
Logger::error($e);
DAO::transRollback();
throw $e;
} catch (exception $e) {
Logger::error($e);
DAO::transRollback();
throw new InvalidDatabaseOperationException($e);
}
}
try {
VentaDAO::save($venta);
//Si la venta fue a credito, se cancelan todos los abonos hechos al mismo y el dinero se queda a cuenta del usuario.
if ($venta->getTipoDeVenta() == "credito") {
$abono_venta = new AbonoVenta();
$abono_venta->setIdVenta($id_venta);
$abonos = AbonoVentaDAO::search($abono_venta);
foreach ($abonos as $abono) {
if (!$abono->getCancelado()) {
CargosYAbonosController::EliminarAbono($abono->getIdAbonoVenta(), "Venta cancelada", 0, 1, 0, null, null);
}
}
$usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $venta->getTotal());
UsuarioDAO::save($usuario);
} else {
if ($venta->getTipoDeVenta() == "contado" && !is_null($id_caja)) {
CajasController::modificarCaja($id_caja, 1, $billetes, $venta->getTotal());
}
}
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo cancelar la venta: " . $e);
throw new Exception("No se pudo cancelar la venta");
}
DAO::transEnd();
Logger::log("Venta cancelada exitosamente");
}
/**
*
*Cambia el estado de un traspaso a recibido. La bandera de completo se prende si los productos enviados son los mismos que los recibidos. La fecha de recibo es tomada del servidor. El usuario que recibe sera tomada de la sesion actual.
*
* @param productos json Productos que se reciben con sus cantidades
* @param id_traspaso int Id del traspaso que se recibe
**/
public static function RecibirTraspasoAlmacen($id_traspaso, $productos)
{
Logger::log("Recibiendo traspaso " . $id_traspaso);
//Se obtiene al usuario de la sesion
$id_usuario = SesionController::getCurrentUser();
if (is_null($id_usuario)) {
Logger::error("El usuario no puede ser obtenido de la sesion, ya inicio sesion?");
throw new Exception("El usuario no puede ser obtenido de la sesion, ya inicio sesion?");
}
//Valida que el traspaso exista, que no haya sido cancelado ni completado y que su estado sea el de enviado
$validar = self::validarParametrosTraspaso($id_traspaso);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar);
}
$traspaso = TraspasoDAO::getByPK($id_traspaso);
if ($traspaso->getCancelado()) {
Logger::error("El traspaso ya ha sido cancelado, no puede ser recibido");
throw new Exception("El traspaso ya ha sido cancelado, no puede ser recibido");
}
if ($traspaso->getCompleto()) {
Logger::error("El traspaso ya ha sido completado, no puede volver a ser recibido");
throw new Exception("El traspaso ya ha sido completado, no puede volver a ser recibido");
}
if ($traspaso->getEstado() !== "Enviado") {
Logger::error("El traspaso no ha sido enviado");
throw new Exception("El traspaso no ha sido enviado");
}
//Actualiza el registro de traspaso
$traspaso->setIdUsuarioRecibe($id_usuario);
$traspaso->setFechaRecibo(time());
$traspaso->setEstado("Recibido");
$traspaso->setCompleto(1);
DAO::transBegin();
try {
//Guarda el traspaso e inserta los productos en el almacen que recibe
TraspasoDAO::save($traspaso);
$productos = object_to_array($productos);
if (!is_array($productos)) {
throw new Exception("Los productos son invalidos", 901);
}
foreach ($productos as $p) {
if (!array_key_exists("id_producto", $p) || !array_key_exists("id_unidad", $p) || !array_key_exists("cantidad", $p)) {
}
$producto_traspaso = TraspasoProductoDAO::getByPK($id_traspaso, $p["id_producto"], $p["id_unidad"]);
//Si el producto que recibe no esta en el registro de productos enviados, se crea su registro
if (is_null($producto_traspaso)) {
$producto_traspaso = new TraspasoProducto(array("id_traspaso" => $id_traspaso, "id_producto" => $p["id_producto"], "id_unidad" => $p["id_unidad"], "cantidad_enviada" => 0));
}
//Se busca el producto que sera isnertado en el almacen, si no existe se crea su registro
$producto_almacen = ProductoAlmacenDAO::getByPK($p["id_producto"], $traspaso->getIdAlmacenRecibe(), $p["id_unidad"]);
if (is_null($producto_almacen)) {
$producto_almacen = new ProductoAlmacen(array("id_producto" => $p_t->getIdProducto(), "id_almacen" => $traspaso->getIdAlmacenEnvia(), "id_unidad" => $p_t->getIdUnidad(), "cantidad" => 0));
}
//Se incrementa la cantidad del producto y se guarda el registro.
$producto_almacen->setCantidad($producto_almacen->getCantidad() + $p["cantidad"]);
$producto_traspaso->setCantidadRecibida($p["cantidad"]);
ProductoAlmacenDAO::save($producto_almacen);
TraspasoProductoDAO::save($producto_traspaso);
}
/* Fin de foreach */
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo recibir el traspaso: " . $e);
throw new Exception("No se pudo recibir el traspaso");
}
DAO::transEnd();
Logger::log("El traspaso ha sido recibido exitosamente");
}
/**
*
*Registra una nueva compra fuera de caja, puede usarse para que el administrador haga directamente una compra. El usuario y al sucursal seran tomados de la sesion. La fecha sera tomada del servidor. La empresa sera tomada del almacen del cual fueron tomados los productos.
*
* @param descuento float Monto descontado por descuentos
* @param subtotal float Total de la compra antes de impuestos y descuentos.
* @param detalle json Objeto que contendr el arreglo de id productos, cantidad, precio, descuento, id de unidad y procesado que involucran esta compra.
* @param impuesto float Monto agregado por impuestos
* @param tipo_compra string Si la compra es a credito o de contado
* @param retencion float Monto agregado por retenciones
* @param id_usuario_compra int Id usuario al que se le compra, si es a una sucursal, se pone el id en negativo
* @param id_empresa int Id de la empresa a nombre de la cual se hace la compra
* @param total float Total 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
* @param saldo float Cantidad pagada de la
* @param tipo_de_pago string Si el pago sera en efectivo, con cheque o tarjeta
* @return id_compra int Id autogenerado por la inserci�n de la compra
**/
public static function Nueva($descuento, $detalle, $id_empresa, $id_usuario_compra, $impuesto, $retencion, $subtotal, $tipo_compra, $total, $cheques = null, $id_sucursal = null, $saldo = 0, $tipo_de_pago = null)
{
Logger::log(" ===== Creando nueva compra... ===== ");
//validemos al comprador
$proveedor = UsuarioDAO::getByPK($id_usuario_compra);
if (is_null($proveedor)) {
Logger::error("el provedor {$id_usuario_compra} no exite");
throw new InvalidDataException("El proveedor no existe");
}
if ($proveedor->getActivo() == false) {
throw new BusinessLogicException("No se puede comprar de un proveedor no activo.");
}
//validemos la empresa
$empresa = EmpresaDAO::getByPK($id_empresa);
if (is_null($empresa)) {
Logger::error("La empresa {$id_empresa} no existe");
throw new InvalidDataException("La empresa que compra no existe.");
}
if ($empresa->getActivo() == false) {
throw new BusinessLogicException("Una empresa inactiva no puede hacer compras.");
}
//validemos los valores conocidos
//( 0 >= descuento > 100, subtotal > 0, total >= subtotal, etc etc)
//validemos sucursal
$sucursal = null;
if (!is_null($id_sucursal) && strlen($id_sucursal) > 0) {
$sucursal = SucursalDAO::getByPK($id_sucursal);
if (is_null($sucursal)) {
Logger::error("La sucursal {$id_sucursal} no existe");
//throw new InvalidDataException("La sucural que se envio no existe.");
}
}
//validemos detalles de compra
//debe traer
// -id_producto
// -cantidad
// -precio
// -lote
if (!is_array($detalle)) {
throw InvalidDataException("El detalle no es un arreglo");
}
for ($detalleIterator = 0; $detalleIterator < sizeof($detalle); $detalleIterator++) {
//por cada producto
// -debe existir
// -si se lo compro a un proveedor no hay pedo
// si se lo compro a un cliente, debe de tener comprar_caja = 1
// -debe tener cantidad mayor a 0
// -que exista el lote a donde va a ir
$p = $detalle[$detalleIterator];
if (!isset($p->precio)) {
throw new InvalidArgumentException("No se envio el precio");
}
if (!isset($p->id_producto)) {
throw new InvalidArgumentException("No se envio el id_producto");
}
if (!isset($p->cantidad)) {
throw new InvalidArgumentException("No se envio la cantidad");
}
if (!isset($p->lote)) {
throw new InvalidArgumentException("No se envio el lote");
}
$producto = ProductoDAO::getByPK($p->id_producto);
if (is_null($producto)) {
throw new InvalidArgumentException("El producto a comprar no existe");
}
if ($p->cantidad <= 0) {
throw new InvalidArgumentException("No puedes comprar 0 unidades");
}
}
$s = SesionController::getCurrentUser();
//terminaron las validaciones
$compra = new Compra();
$compra->setIdVendedorCompra($id_usuario_compra);
$compra->setTipoDeCompra($tipo_compra);
$compra->setFecha(time());
$compra->setSubtotal($subtotal);
$compra->setImpuesto($impuesto);
$compra->setDescuento($descuento);
$compra->setTotal($subtotal + $impuesto);
$compra->setIdUsuario($s->getIdUsuario());
$compra->setIdEmpresa($id_empresa);
$compra->setSaldo(0);
$compra->setCancelada(false);
$compra->setTipoDePago($tipo_de_pago);
$compra->setRetencion(0);
try {
DAO::transBegin();
CompraDAO::save($compra);
} catch (Exception $e) {
DAO::transRollback();
throw InvalidDatabaseOperationException($e);
}
for ($detalleIterator = 0; $detalleIterator < sizeof($detalle); $detalleIterator++) {
//por cada producto
// --- procesos ---
// -insertar en productoempresa
// -insertar en loteproducto
// -insertar en entradalote
// -si el tipo de precio de venta es costo, actualizar
// -insertar compra producto
$p = $detalle[$detalleIterator];
try {
ProductoEmpresaDAO::save(new ProductoEmpresa(array("id_empresa" => $id_empresa, "id_producto" => $p->id_producto)));
if (is_null($p->lote)) {
throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
}
if (strlen($p->lote) == 0) {
throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
}
//busquemos el id del lote
$l = LoteDAO::search(new Lote(array("folio" => $p->lote)));
$l = $l[0];
//busquemos la unidad que nos mandaron
$uAbreviacion = $p->id_unidad;
$uResults = UnidadMedidaDAO::search(new UnidadMedida(array("abreviacion" => $uAbreviacion, "activa" => 1)));
if (sizeof($uResults) != 1) {
throw new InvalidDataException("La unidad de medida `" . $p->id_unidad . "` no existe, o no esta activa.");
} else {
$p->id_unidad = $uResults[0]->getIdUnidadMedida();
}
//busequemos si este producto ya existe en este lote
$lp = LoteProductoDAO::getByPK($l->getIdLote(), $p->id_producto);
if (is_null($lp)) {
//no existe, insertar
$loteProducto = new LoteProducto(array("id_lote" => $l->getIdLote(), "id_producto" => $p->id_producto, "cantidad" => $p->cantidad, "id_unidad" => $p->id_unidad));
LoteProductoDAO::save($loteProducto);
} else {
//ya existe, sumar
//revisemos si es de la misma unidad
if ($lp->getIdUnidad() == $p->id_unidad) {
//es igual, solo hay que sumar
$lp->setCantidad($lp->getCantidad() + $p->cantidad);
} else {
//no es igual, hay que convertir
try {
$r = UnidadMedidaDAO::convertir($p->id_unidad, $lp->getIdUnidad(), $p->cantidad);
} catch (BusinessLogicException $ide) {
//no se pudo convertir porque son de
//diferentes categorias
throw $ide;
//mostrar una excpetion mas fresona
}
$lp->setCantidad($lp->getCantidad() + $r);
}
//$lp->setCantidad( $lp->getCantidad() + $p->cantidad );
LoteProductoDAO::save($lp);
}
$loteEntrada = new LoteEntrada(array("id_lote" => $l->getIdLote(), "id_usuario" => $s->getIdUsuario(), "fecha_registro" => time(), "motivo" => "Compra a Proveedor"));
LoteEntradaDAO::save($loteEntrada);
LoteEntradaProductoDAO::save(new LoteEntradaProducto(array("id_lote_entrada" => $loteEntrada->getIdLoteEntrada(), "id_producto" => $p->id_producto, "id_unidad" => $p->id_unidad, "cantidad" => $p->cantidad)));
$compraProducto = new CompraProducto(array("id_compra" => $compra->getIdCompra(), "id_producto" => $p->id_producto, "cantidad" => $p->cantidad, "precio" => $p->precio, "descuento" => 0, "impuesto" => 0, "id_unidad" => $p->id_unidad, "retencion" => 0));
CompraProductoDAO::save($compraProducto);
} catch (InvalidDataException $e) {
Logger::error($e);
DAO::transRollback();
throw $e;
} catch (exception $e) {
Logger::error($e);
DAO::transRollback();
throw new InvalidDatabaseOperationException($e);
}
}
//for
try {
DAO::transEnd();
} catch (Exception $e) {
throw InvalidDatabaseOperationException($e);
}
Logger::log("===== COMPRA " . $compra->getIdCompra() . " EXITOSA ===== ");
return array("id_compra" => $compra->getIdCompra());
}
public static function NuevoCheque($nombre_banco, $monto, $numero, $expedido, $id_usuario = null)
{
Logger::log("creando cheque");
//Se validan los parametros obtenidos
$validar = self::validarParametrosCheque(null, $nombre_banco, $monto, $numero, $expedido);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar);
}
$cheque = new Cheque();
$cheque->setNombreBanco($nombre_banco);
$cheque->setMonto($monto);
$cheque->setNumero($numero);
$cheque->setExpedido($expedido);
if ($expedido) {
$id_usuario = SesionController::getCurrentUser();
if (is_null($id_usuario)) {
Logger::error("No se pudo obtener el usuario de la sesion, ya inicio sesion?");
throw new Exception("No se pudo obtener el usuario de la sesion, ya inicio sesion?");
}
}
$cheque->setIdUsuario($id_usuario);
DAO::transBegin();
try {
ChequeDAO::save($cheque);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo crear el cheque: " . $e);
throw "No se pudo crear el cheque";
}
DAO::transEnd();
Logger::log("Cheque creado exitosamente");
return $cheque->getIdCheque();
}
/**
*
*Actualizar? los tipo de cambio con respecto a la moneda base de la empresa.
*
* @param id_empresa int El id de la empresa
* @param monedas json Los valores de las equivalencias de las monedas activas con respecto a la moneda base
* @param moneda_base string El codigo de la moneda base, una cadena de tres caracteres: "MXN"
**/
public static function ActualizarTiposCambio($id_empresa, $monedas, $moneda_base, $servicios)
{
$json_guardar = array();
$json_guardar["servicio"] = $servicios;
$json_guardar["fecha"] = time();
$json_guardar["moneda_origen"] = $moneda_base;
$json_guardar["tipos_cambio"] = array();
foreach ($monedas as $moneda) {
if (!is_numeric($moneda->equivalencia)) {
Logger::Log("La moneda {$moneda} no tiene un valor numerico asignado");
throw new BusinessLogicException("La moneda {$moneda} no tiene un valor numerico asignado");
} else {
$obj = new stdClass();
$obj->moneda = $moneda->codigo;
$obj->equivalencia = $moneda->equivalencia;
$obj->conversion = "1 {$moneda_base} = " . $moneda->equivalencia . " " . $moneda->codigo;
array_push($json_guardar["tipos_cambio"], $obj);
}
}
$json_almacenar = json_encode($json_guardar);
$c = new Configuracion();
$s = SesionController::getCurrentUser();
$c->setDescripcion("tipo_cambio");
$conf = ConfiguracionDAO::search($c);
//se crea el registro de configuracion tipo_cambio
if (count($conf) < 1) {
$c->setValor($json_almacenar);
$c->setFecha(time());
$c->setIdUsuario($s->getIdUsuario());
try {
ConfiguracionDAO::save($c);
$c_e = new ConfiguracionEmpresa();
$c_e->setIdConfiguracionEmpresa($c->getIdConfiguracion());
$c_e->setIdEmpresa($id_empresa);
ConfiguracionEmpresaDAO::save($c_e);
} catch (Exception $e) {
Logger::error("No se pudo crear la configuracion de monedas: " . $e->getMessage());
throw new InvalidDatabaseOperationException("No se pudo crear la configuracion de monedas " . $e->getMessage());
}
} else {
$editar = $conf[0];
$editar->setValor($json_almacenar);
$editar->setFecha(time());
$editar->setIdUsuario($s->getIdUsuario());
try {
ConfiguracionDAO::save($editar);
} catch (Exception $e) {
Logger::error("No se pudo crear la configuracion de monedas: " . $e->getMessage());
throw new InvalidDatabaseOperationException("No se pudo crear la configuracion de monedas " . $e->getMessage());
}
}
$monedabase = new Moneda();
$monedabase->setSimbolo($moneda_base);
$mb = MonedaDAO::search($monedabase);
$historial_tc = new HistorialTipoCambio();
$historial_tc->setFecha(time());
$historial_tc->setJsonEquivalencias($json_almacenar);
$historial_tc->setIdEmpresa($id_empresa);
$historial_tc->setIdMonedaBase($mb[0]->getIdMoneda());
try {
HistorialTipoCambioDAO::save($historial_tc);
} catch (Exception $e) {
Logger::error("No se pudo guardar el historial tipo cambio: " . $e->getMessage());
throw new InvalidDatabaseOperationException("No se pudo guardar el historial tipo cambio: " . $e->getMessage());
}
return array("status" => "ok");
}
/**
*
*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);
}
/**
*
*Envia productos fuera del almacen. Ya sea que sea un traspaso de un alamcen a otro o por motivos de inventarios fisicos.
*
* @param id_almacen int Id del almacen del cual se hace el movimiento
* @param productos json Objeto que contendra los ids de los productos que seran sacados del alamcen con sus cantidades y sus unidades
* @param motivo string Motivo de la salida del producto
* @return id_salida int ID de la salida del producto
**/
static function Salida($id_almacen, $productos, $motivo = null)
{
Logger::log("Registrando salida de almacen");
//Se obtiene al usuario de la sesion
$id_usuario = SesionController::getCurrentUser();
if (is_null($id_usuario)) {
Logger::error("No se pudo obtener al usuario de la sesion, ya inicio sesion?");
throw new Exception("No se pudo obtener al usuario de la sesion, ya inicio sesion?");
}
//valida si el almacen existe y si esta activo
$almacen = AlmacenDAO::getByPK($id_almacen);
if (is_null($almacen)) {
Logger::error("El almacen con id: " . $id_almacen . " no existe");
throw new Exception("El almacen con id: " . $id_almacen . " no existe");
}
if (!$almacen->getActivo()) {
Logger::error("El almacen no esta activo, no puede salir producto de el");
throw new Exception("El almacen no esta activo, no puede salir producto de el");
}
//Valida que el motivo sea un string valido
if (!is_null($motivo)) {
$validar = self::validarString($motivo, 255, "motivo");
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar);
}
}
//Se inicializa el registro de la tabla salida_almacen
$salida_almacen = new SalidaAlmacen(array("id_almacen" => $id_almacen, "id_usuario" => $id_usuario, "fecha_registro" => time(), "motivo" => $motivo));
DAO::transBegin();
try {
//Se guarda el registro de la salida almacen y se sacan los productos solicitados
//del almacen
SalidaAlmacenDAO::save($salida_almacen);
$producto_salida_almacen = new ProductoSalidaAlmacen(array("id_salida_almacen" => $salida_almacen->getIdSalidaAlmacen()));
$productos = object_to_array($productos);
if (!is_array($productos)) {
throw new Exception("Los productos son invalidos", 901);
}
foreach ($productos as $p) {
if (!array_key_exists("id_producto", $p) || !array_key_exists("id_unidad", $p) || !array_key_exists("cantidad", $p)) {
throw new Exception("Los productos son invalidos", 901);
}
//Se busca en el almacen el producto solicitado, si no es encontrado, se manda una excepcion
$producto_almacen = ProductoAlmacenDAO::getByPK($p["id_producto"], $id_almacen, $p["id_unidad"]);
if (is_null($producto_almacen)) {
throw new Exception("El producto: " . $p["id_producto"] . " en la unidad: " . $p["id_unidad"] . "\n no se encuentra en el almacen: " . $id_almacen . ". No se puede registrar la salida");
}
//Se analiza la cantidad actual del producto en el almacen. Si la solicitada
//es mayor que la cantidad actual, se arroja una excepcion.
$cantidad_actual = $producto_almacen->getCantidad();
if ($cantidad_actual < $p["cantidad"]) {
throw new Exception("Se busca sacar mas cantidad de producto de la que hay actualmente. Actual: " . $cantidad_actual . " - Salida: " . $p["cantidad"]);
}
$producto_almacen->setCantidad($cantidad_actual - $p["cantidad"]);
$producto_salida_almacen->setIdProducto($p["id_producto"]);
$producto_salida_almacen->setIdUnidad($p["id_unidad"]);
$producto_salida_almacen->setCantidad($p["cantidad"]);
ProductoAlmacenDAO::save($producto_almacen);
ProductoSalidaAlmacenDAO::save($producto_salida_almacen);
}
/* Fin de foreach */
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo registrar la salida de producto: " . $e);
throw new Exception("No se pudo registrar la salida de producto");
}
DAO::transEnd();
Logger::log("Salida de almacen registrada correctamente");
return array("id_salida" => $salida_almacen->getIdSalidaAlmacen());
}
