public function aprova($p)
{
$this->sql = "UPDATE vsites_fin_compra_proposta SET aprovada=? WHERE id_proposta=? ";
$this->values = array($p->aprovada, $p->id_proposta);
$this->exec();
if ($p->aprovada == 1) {
echo "CONCLUIDA\n";
$compraDAO = new CompraDAO();
$compraDAO->atualizaStatus($p, 'Concluída', $id_empresa);
}
$this->exec();
}
/**
*
* Lista todas las compras de una sucursal.
*
* @param id_sucursal int Id de la sucursal de la cual se listaran sus compras
* @return compras json Arreglo de objetos que tendr� las compras de la sucursal
* */
public static function Compras_sucursal($id_sucursal)
{
Logger::log("Listando las compras de la sucursal " . $id_sucursal);
$compras = CompraDAO::search(new Compra(array("id_sucursal" => $id_sucursal)));
Logger::log("Se listan " . count($compras) . " compras");
return $compras;
}
/**
*
*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());
}
<?php
define("BYPASS_INSTANCE_CHECK", false);
require_once "../../../server//bootstrap.php";
function funcion_producto($id_producto)
{
return ProductoDAO::getByPK($id_producto) ? ProductoDAO::getByPK($id_producto)->getNombreProducto() : "---------";
}
$page = new GerenciaComponentPage();
//
// Requerir parametros
//
$page->requireParam("cid", "GET", "Esta compra no existe.");
$esta_compra = CompraDAO::getByPK($_GET["cid"]);
if ($esta_compra === null) {
$page->addComponent("<p>Esta compra no existe</p>");
$page->render(0);
exit;
}
//
// Titulo de la pagina
//
$page->addComponent(new TitleComponent("Detalles de la compra " . $esta_compra->getIdCompra(), 2));
//
// Menu de opciones
//
if (!$esta_compra->getCancelada()) {
$menu = new MenuComponent();
if ($esta_compra->getTipoDeCompra() == "credito") {
$menu->addItem("Abonar a esta compra", "cargos_y_abonos.nuevo.abono.php?cid=" . $_GET["cid"] . "&did=" . $esta_compra->getIdVendedorCompra());
}
/**
*
*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());
}
$error = '<ul>';
if ($id_departamento == "" || $produto == "" || $quantidade == "") {
if ($id_departamento == "") {
$errors['id_departamento'] = 1;
}
if ($produto == "") {
$errors['produto'] = 1;
}
if ($quantidade == "") {
$errors['quantidade'] = 1;
}
$error .= "<li><b>Os campos com * são obrigatórios.</b></li>";
}
$error .= '</ul>';
if (count($errors) == 0) {
$compraDAO = new CompraDAO();
$compraDAO->inserir($c);
//alterado 01/04/2011
$titulo = 'Adicionar Solicitação';
$perg = 'Inserir outra solicitação?';
$resp1 = 'compra_add.php';
$resp2 = 'compra.php';
$funcJs = "openConfirmBox('" . $titulo . "','" . $perg . "','" . $resp1 . "','" . $resp2 . "');";
echo '<img src="../images/null.gif" class="nulo" onload="' . $funcJs . '" />';
}
} else {
$usuarioDAO = new UsuarioDAO();
$solicitante = $usuarioDAO->selectPorId($controle_id_usuario);
$c->solicitante = $solicitante->nome;
$c->status = 'Em Aberto';
}
function funcion_vendedor($id_vendedor)
{
return UsuarioDAO::getByPK($id_vendedor) ? UsuarioDAO::getByPK($id_vendedor)->getNombre() : "-----";
}
$tabla->addColRender("id_vendedor_compra", "funcion_vendedor");
$tabla->addColRender("fecha", "FormatTime");
$tabla->addColRender("subtotal", "FormatMoney");
$tabla->addColRender("impuesto", "FormatMoney");
$tabla->addColRender("total", "FormatMoney");
$tabla->addColRender("saldo", "FormatMoney");
$tabla->convertToExtJs(false);
$tabla->addOnClick("id_compra", "(function(a){ window.location = 'compras.detalle.php?cid=' + a; })");
$page->addComponent($tabla);
$page->nextTab("Canceladas");
$page->addComponent(new MessageComponent("Lista de compras canceladas"));
$compras_no_activas = CompraDAO::search(new Compra(array("cancelada" => 1)), "fecha", "desc");
$tabla2 = new TableComponent(array("id_vendedor_compra" => "Proveedor", "tipo_de_compra" => "Tipo de compra", "subtotal" => "Subtotal", "impuesto" => "Impuesto", "total" => "Total", "saldo" => "Saldo", "fecha" => "Fecha"), $compras_no_activas);
$tabla2->addColRender("id_vendedor_compra", "funcion_vendedor");
$tabla2->addColRender("fecha", "FormatTime");
$tabla2->addColRender("subtotal", "FormatMoney");
$tabla2->addColRender("impuesto", "FormatMoney");
$tabla2->addColRender("total", "FormatMoney");
$tabla2->addColRender("saldo", "FormatMoney");
$tabla2->addOnClick("id_compra", "(function(a){ window.location = 'compras.detalle.php?cid=' + a; })");
$page->addComponent($tabla2);
/*
$t2 = clone $tabla;
$t2-> setRows($compras_no_activas);
$page->addComponent($t2);
<input type="submit" name="submit" class="button_busca" value="Buscar" />
</form>
<div style="clear: both"><br />
<a href="compra_add.php">
<h3><img src="../images/botao_add.png" border="0" /> Adicionar novo registro</h3>
</a></div>
<?php
if ($submit == 'Buscar') {
$b->busca = $busca;
if (in_array($id_departamento, $id_departamentos)) {
$b->id_departamento = $id_departamento;
} else {
$b->id_departamento = $id_departamentos[0];
}
$b->status = $status;
$compraDAO = new CompraDAO();
$compras = $compraDAO->busca($b, $controle_id_empresa, $pagina);
?>
<br />
<table width="100%" cellpadding="4" cellspacing="1"
class="result_tabela">
<tr>
<td colspan="9" class="barra_busca"><?php
$compraDAO->QTDPagina();
?>
</td>
</tr>
<tr>
<td align="center" width="40" class="result_menu"><b>Editar</b></td>
<td class="result_menu"><b>Produto</b></td>
<td class="result_menu"><b>Departamento</b></td>
echo '<br><br><strong>Você não tem permissão para acessar essa página</strong>';
exit;
}
?>
<h1 class="tit"><img src="../images/tit/tit_cliente.png" alt="Título" />Solicitação
de Compra</h1>
<a href="#" class="topo">topo</a>
<hr class="tit" />
</div>
<div id="meio"><?php
pt_register("POST", "submit_compra");
pt_register("POST", "submit_proposta");
pt_register("POST", "submit_aprova");
pt_register("GET", "submit_compra_reprovar");
pt_register("GET", "id_compra");
$compraDAO = new CompraDAO();
$propostaDAO = new CompraPropostaDAO();
$submit = 'atualizar';
$c = $compraDAO->buscaPorId($id_compra, $controle_id_empresa);
pt_register('POST', 'submit_compra_status');
if ($submit_compra_status != '') {
try {
$error = $compraDAO->atualizaStatus($c, $submit_compra_status, $controle_id_empresa);
$c->status = $submit_compra_status;
} catch (Exception $e) {
echo '<div class="erro">' . $e->getMessage() . '</div>';
}
} else {
if ($submit_proposta != '') {
pt_register("POST", "id_fornecedor");
pt_register("POST", "valor");
/**
*
*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);
}
/*
SucursalesController::DescontarDeAlmacenes( $d_producto, $id_sucursal );
SucursalesController::IncrementarDeAlmacenes( $d_producto, $id_sucursal );
*/
/*
TRUNCATE `lote_entrada`;
TRUNCATE `lote_entrada_producto`;
TRUNCATE `lote_producto`;
TRUNCATE `lote_salida`;
TRUNCATE `lote_salida_producto`;
*/
if (!isset($_GET["GO"])) {
exit;
}
//listemos las compras
$compras = CompraDAO::getAll();
for ($i = 0; $i < sizeof($compras); $i++) {
//buscar sus productos
$productos = CompraProductoDAO::search(new CompraProducto(array("id_compra" => $compras[$i]->getIdCompra())));
for ($p = 0; $p < sizeof($productos); $p++) {
$d_producto = $productos[$p]->asArray();
$id_sucursal = 7;
echo ".";
try {
SucursalesController::IncrementarDeAlmacenes($d_producto, $id_sucursal);
} catch (Exception $e) {
echo "e";
}
}
}
$ventas = VentaDAO::getAll();
/**
*
* Configura el numero de decimales que se usaran para ciertas operaciones del sistema, como precios de venta, costos, tipos de cambio, entre otros
*
* @param cambio int Tipos de Cambio
* @param cantidades int Cantidades
* @param costos int Costos y Precio de Compra
* @param ventas int Precio de Venta
* @return status string ok
**/
public static function DecimalesConfiguracion($cambio, $cantidades, $costos, $ventas)
{
//validamos que los valores enviados sean numericos
if (!ctype_digit($cambio) || !ctype_digit($cantidades) || !ctype_digit($costos) || !ctype_digit($ventas)) {
Logger::error("Los valores ingresados deben de ser Numeros Enteros");
return array("status" => "failure", "message" => "Los valores ingresados deben de ser Numeros Enteros");
}
//buscamos la configuracion de decimales
$configuraciones = ConfiguracionDAO::search(new Configuracion(array("descripcion" => "decimales")));
if (empty($configuraciones)) {
Logger::error("No se tiene registro de la configuracion 'decimales' en la tabla de configuraciones");
return array("status" => "failure", "message" => "No se tiene registro de la configuracion 'decimales' en la tabla de configuraciones");
} else {
$decimales = $configuraciones[0];
$config = json_decode($decimales->getValor());
}
//verificamos que la configuracion contenga todos los parametros
if (!isset($config->cambio)) {
Logger::error("No se encontro la configuracion de \"cambio\" en el JSON");
return array("status" => "failure", "message" => "No se encontro la configuracion de \"cambio\" en el JSON");
}
if (!isset($config->cantidades)) {
Logger::error("No se encontro la configuracion de \"cantidades\" en el JSON");
return array("status" => "failure", "message" => "No se encontro la configuracion de \"cantidades\" en el JSON");
}
if (!isset($config->costos)) {
Logger::error("No se encontro la configuracion de \"costos\" en el JSON");
return array("status" => "failure", "message" => "No se encontro la configuracion de \"costos\" en el JSON");
}
if (!isset($config->ventas)) {
Logger::error("No se encontro la configuracion de \"ventas\" en el JSON");
return array("status" => "failure", "message" => "No se encontro la configuracion de \"ventas\" en el JSON");
}
//en caso de haber registrado compras de producto ya no se puede bajar el numero de decimales en "costo" y "cantidades"
if (count(CompraDAO::getAll()) > 0) {
if ($config->costos > $costos) {
Logger::error("El valor de \"costos\" no puede ser menor que el valor actual, debido a que ya se cuenta con movimientos.");
return array("status" => "failure", "message" => "El valor de \"costos\" no puede ser menor que el valor actual, debido a que ya se cuenta con movimientos.");
} else {
$config->costos = $costos;
}
if ($config->cantidades > $cantidades) {
Logger::error("El valor de \"cantidades\" no puede ser menor que el valor actual, debido a que ya se cuenta con movimientos.");
return array("status" => "failure", "message" => "El valor de \"cantidades\" no puede ser menor que el valor actual, debido a que ya se cuenta con movimientos.");
} else {
$config->cantidades = $cantidades;
}
} else {
$config->costos = $costos;
$config->cantidades = $cantidades;
}
//en caso de que haya ventas el valor de "ventas" no puede ser menor que el actual
if (count(VentaDAO::getAll()) > 0) {
if ($config->ventas > $ventas) {
Logger::error("El valor de \"ventas\" no puede ser menor que el valor actual, debido a que ya se cuenta con movimientos.");
return array("status" => "failure", "message" => "El valor de \"ventas\" no puede ser menor que el valor actual, debido a que ya se cuenta con movimientos.");
} else {
$config->ventas = $ventas;
}
} else {
$config->ventas = $ventas;
}
//TODO : En el caso de la configuracion de cambio aun esta por definir las reglas de negocio
$config->cambio = $cambio;
//modificamos el valor de la configuracion de decimales
$decimales->setValor(json_encode($config));
//intentamos guardar los cambios
try {
ConfiguracionDAO::save($decimales);
} catch (Exception $e) {
Logger::error("Error {$e}");
return array("status" => "failure", "message" => $e->getMessage());
}
//termino con exito
return array("status" => "okay");
}
