/**
*
*Crea un nuevo documento.
*
* @param id_documento_base int el documento base del cual este documento es instancia
* @param extra_params json
* @param id_empresa int Si pertence a una empresa en especifico, o puede realizarse en cualquier empresa.
* @param id_sucursal int Si pertenece a una sucursal en especifico o puede realizarse en cualquier sucursal.
* @return id_documento int Id del nuevo documento
**/
public static function Nuevo($id_documento_base, $extra_params = null, $id_empresa = null, $id_sucursal = null)
{
$dbase = DocumentoBaseDAO::getByPK($id_documento_base);
if (is_null($dbase)) {
throw new InvalidDataException("This base doc does not exist");
}
$nDoc = new Documento();
$nDoc->setIdDocumentoBase($id_documento_base);
$nDoc->setFolio(0);
$nDoc->setFecha(time());
$nDoc->setIdOperacion(0);
DAO::transBegin();
try {
DocumentoDAO::save($nDoc);
} catch (Exception $e) {
DAO::transRollback();
throw InvalidDatabaseOperationException($e);
}
//test all extra params in base doc are present in $extra_params
$pindb = ExtraParamsEstructuraDao::search(new ExtraParamsEstructura(array("tabla" => "documento_base-" . $id_documento_base)));
foreach ($pindb as $campo) {
if (!array_key_exists($campo->getCampo(), $extra_params)) {
//no existe en extra params
//salir si este parametro es
//obligatorio
if ($campo->getObligatorio()) {
throw new InvalidDataException("El campo " . $campo->getObligatorio() . " es obligatorio");
}
} else {
$valueToStore = $extra_params->{$campo->getCampo()};
$valueToStore = is_null($valueToStore) ? "" : $valueToStore;
$val = new ExtraParamsValores(array("id_extra_params_estructura" => $campo->getIdExtraParamsEstructura(), "id_pk_tabla" => $nDoc->getIdDocumento(), "val" => $valueToStore));
try {
ExtraParamsValoresDAO::save($val);
} catch (Exception $e) {
DAO::transRollback();
throw new InvalidDatabaseOperationException($e);
}
}
}
//foreach
DAO::transEnd();
}
/**
*
*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());
}
/**
*
*Dar por terminada una orden, cuando el cliente satisface el ultimo pago
*
* @param id_orden int Id de la orden a terminar
**/
public static function TerminarOrden($id_orden, $id_venta = null)
{
Logger::log("Terminando orden " . $id_orden . " ");
if (!is_null($id_venta)) {
Logger::log("Asignando orden a id_venta=" . $id_venta);
//que la venta exista
$v = VentaDAO::getByPK($id_venta);
if (is_null($v)) {
throw new InvalidDataException("La venta a la que se quiere asignar no existe.");
}
}
//ver que exista la orden de servicio
$ods = OrdenDeServicioDAO::getByPK($id_orden);
if (is_null($ods)) {
throw new InvalidDataException("La orden de servicio que desea terminar no existe");
}
if (!$ods->getActiva()) {
throw new BusinessLogicException("La orden que quieres terminar ya no esta terminada.");
}
DAO::transBegin();
try {
$ods->setActiva(0);
OrdenDeServicioDAO::save($ods);
} catch (Exception $e) {
throw InvalidDatabaseOperationException($e);
}
if (!is_null($id_venta)) {
$vo = new VentaOrden();
$vo->setIdVenta($id_venta);
$vo->setIdOrdenDeServicio($id_orden);
$vo->setPrecio($ods->getPrecio());
$vo->setDescuento(0);
$vo->setImpuesto(0);
$vo->setRetencion(0);
//Actualizar totales
$ventaVo = VentaDAO::getByPK($id_venta);
try {
VentaOrdenDAO::save($vo);
} catch (Exception $e) {
throw InvalidDatabaseOperationException($e);
}
} else {
//crearle una nueva venta
$venta = new Venta();
$s = SesionController::Actual();
Logger::error("There is plenty of hard-coded stuff here !");
$venta->setIdCompradorVenta($ods->getIdUsuarioVenta());
$venta->setTipoDeVenta("contado");
$venta->setFecha(time());
$venta->setSubtotal(0);
$venta->setEsCotizacion(0);
$venta->setImpuesto(0);
$venta->setTotal(0);
$venta->setIdSucursal($s["id_sucursal"]);
$venta->setIdUsuario($s["id_usuario"]);
$venta->setSaldo(0);
//si hay adelanto se resta al saldo de la venta el adelanto, esta resta se hace al insertar el abono_venta
$venta->setCancelada(false);
$venta->setRetencion(0);
//vamos a ver si este dude tiene suficient credito para esto
try {
Logger::log("Insertando la venta ....");
VentaDAO::save($venta);
} catch (Exception $e) {
DAO::transRollback();
Logger::error($e->getMessage());
throw new InvalidDatabaseOperationException("No se pudo crear la nueva orden de servicio");
}
$venta_orden = new VentaOrden();
$venta_orden->setIdVenta($venta->getIdVenta());
$venta_orden->setIdOrdenDeServicio($ods->getIdOrdenDeServicio());
$venta_orden->setPrecio(0);
$venta_orden->setDescuento(0);
$venta_orden->setImpuesto(0);
$venta_orden->setRetencion(0);
try {
Logger::log("Insertando la orden de venta....");
VentaOrdenDAO::save($venta_orden);
} catch (Exception $e) {
DAO::transRollback();
Logger::error($e->getMessage());
throw new InvalidDatabaseOperationException("No se pudo crear la nueva orden de servicio");
}
$id_venta = $venta->getIdVenta();
}
DAO::transEnd();
Logger::log("La orden de servicio se ha terminado exitosamente");
return array("id_venta" => $id_venta);
}