/**
*
*Para poder editar un traspaso,este no tuvo que haber sido enviado aun
*
* @param id_traspaso int Id del traspaso a editar
* @param productos json Productos a enviar con sus cantidades
* @param fecha_envio_programada string Fecha de envio programada
**/
public static function EditarTraspasoAlmacen($id_traspaso, $fecha_envio_programada = null, $productos = null)
{
Logger::log("Editando traspaso " . $id_traspaso);
//valida que el traspaso exista, que no haya sido cancelado y que no se hayan efectuado operaciones sobre el.
$validar = self::validarParametrosTraspaso($id_traspaso, null, null, $fecha_envio_programada);
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 editado");
throw new Exception("El traspaso ya ha sido cancelado, no puede ser editado");
}
if ($traspaso->getCompleto() || $traspaso->getEstado() !== "Envio programado") {
Logger::error("No se puede editar el traspaso de almacen pues ya se han realizado acciones sobre el");
throw new Exception("No se puede editar el traspaso de almacen pues ya se han realizado acciones sobre el");
}
//Si se recibe el parametro fecha de envio se toma como actualizacion.
if (!is_null($fecha_envio_programada)) {
$traspaso->setFechaEnvioProgramada($fecha_envio_programada);
}
DAO::transBegin();
try {
TraspasoDAO::save($traspaso);
if (!is_null($productos)) {
$productos = object_to_array($productos);
if (!is_array($productos)) {
throw new Exception("Los productos son invalidos", 901);
}
//Se actualiza la cantidad de cada producto programado para este traspaso, si el producto
//no se encuentra, se verifica que su empresa concuerde con la del almacen de recibo y
//se crea el nuevo registro.
//
//Despues, se recorren los productos que se encuentran actualmente programados a enviarse en el traspaso,
//los productos que no se encuentre en la nueva lista obtenida seran eliminados.
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 no tienen todos los parametros necesarios", 901);
}
$traspaso_producto = TraspasoProductoDAO::getByPK($id_traspaso, $p["id_producto"], $p["id_unidad"]);
if (is_null($traspaso_producto)) {
$almacen_recibe = AlmacenDAO::getByPK($traspaso->getIdAlmacenRecibe());
$productos_empresa = ProductoEmpresaDAO::search(new ProductoEmpresa(array("id_producto" => $p["id_producto"])));
$encontrado = false;
foreach ($productos_empresa as $p_e) {
if ($p_e->getIdEmpresa() == $almacen_recibe->getIdEmpresa()) {
$encontrado = true;
}
}
if (!$encontrado) {
throw new Exception("Se busca enviar un producto que no es de la empresa del almacen que recibe", 901);
}
$traspaso_producto = new TraspasoProducto(array("id_traspaso" => $id_traspaso, "id_producto" => $p["id_producto"], "id_unidad" => $p["id_unidad"], "cantidad_recibida" => 0));
}
$traspaso_producto->setCantidadEnviada($p["cantidad"]);
TraspasoProductoDAO::save($traspaso_producto);
}
/* Fin de foreach de productos*/
$traspasos_producto = TraspasoProductoDAO::search(new TraspasoProducto(array("id_traspaso" => $id_traspaso)));
foreach ($traspasos_producto as $t_p) {
$encontrado = false;
foreach ($productos as $p) {
if ($t_p->getIdProducto() == $p["id_producto"] && $t_p->getIdUnidad() == $p["id_unidad"]) {
$encontrado = true;
}
}
if (!$encontrado) {
TraspasoProductoDAO::delete($t_p);
}
}
/* Fin de foreach de traspaso_producto*/
}
/* Fin de if de productos */
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo editar el traspaso: " . $e);
if ($e->getCode() == 901) {
throw new Exception("No se pudo editar el traspaso: " . $e->getMessage(), 901);
}
throw new Exception("No se pudo editar el traspaso", 901);
}
DAO::transEnd();
Logger::log("Traspaso editado correctamente");
}
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();
}
/**
*
*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());
}
/**
* Entry point for Create a User API
*
* @param Request $r
* @return array
* @throws InvalidDatabaseOperationException
* @throws DuplicatedEntryInDatabaseException
*/
public static function apiCreate(Request $r)
{
// Validate request
Validators::isValidUsername($r['username'], 'username');
Validators::isEmail($r['email'], 'email');
// Check password
$hashedPassword = null;
if (!isset($r['ignore_password'])) {
SecurityTools::testStrongPassword($r['password']);
$hashedPassword = SecurityTools::hashString($r['password']);
}
// Does user or email already exists?
try {
$user = UsersDAO::FindByUsername($r['username']);
$userByEmail = UsersDAO::FindByEmail($r['email']);
} catch (Exception $e) {
throw new InvalidDatabaseOperationException($e);
}
if (!is_null($userByEmail)) {
throw new DuplicatedEntryInDatabaseException('mailInUse');
}
if (!is_null($user)) {
throw new DuplicatedEntryInDatabaseException('usernameInUse');
}
// Prepare DAOs
$user_data = array('username' => $r['username'], 'password' => $hashedPassword, 'solved' => 0, 'submissions' => 0, 'verified' => 0, 'verification_id' => self::randomString(50));
if (isset($r['name'])) {
$user_data['name'] = $r['name'];
}
if (isset($r['facebook_user_id'])) {
$user_data['facebook_user_id'] = $r['facebook_user_id'];
}
if (!is_null(self::$permissionKey) && self::$permissionKey == $r['permission_key']) {
$user_data['verified'] = 1;
} elseif (OMEGAUP_VALIDATE_CAPTCHA) {
// Validate captcha
if (!isset($r['recaptcha'])) {
throw new InvalidParameterException('parameterNotFound', 'recaptcha');
}
$url = 'https://www.google.com/recaptcha/api/siteverify';
$data = array('secret' => OMEGAUP_RECAPTCHA_SECRET, 'response' => $r['recaptcha'], 'remoteip' => $_SERVER['REMOTE_ADDR']);
// use key 'http' even if you send the request to https://...
$options = array('http' => array('header' => "Content-type: application/x-www-form-urlencoded\r\n", 'method' => 'POST', 'content' => http_build_query($data)));
$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);
if ($result === false) {
self::$log->error('POST Request to Google Recaptcha failed.');
throw new CaptchaVerificationFailedException();
}
$resultAsJson = json_decode($result, true);
if (is_null($resultAsJson)) {
self::$log->error('Captcha response was not a json');
self::$log->error('Here is the result:' . $result);
throw new CaptchaVerificationFailedException();
}
if (!(array_key_exists('success', $resultAsJson) && $resultAsJson['success'])) {
self::$log->error('Captcha response said no');
throw new CaptchaVerificationFailedException();
}
}
$user = new Users($user_data);
$email = new Emails(array('email' => $r['email']));
// Save objects into DB
try {
DAO::transBegin();
UsersDAO::save($user);
$email->setUserId($user->getUserId());
EmailsDAO::save($email);
$user->setMainEmailId($email->getEmailId());
UsersDAO::save($user);
DAO::transEnd();
} catch (Exception $e) {
DAO::transRollback();
throw new InvalidDatabaseOperationException($e);
}
$r['user'] = $user;
if (!$user->verified) {
self::$log->info('User ' . $user->getUsername() . ' created, sending verification mail');
self::sendVerificationEmail($r);
} else {
self::$log->info('User ' . $user->getUsername() . ' created, trusting e-mail');
}
return array('status' => 'ok', 'user_id' => $user->getUserId());
}
/**
*
*Edita la informaci?e un abono
*
* @param id_abono int Id del abono a editar
* @param nota string Nota del abono
* @param motivo_cancelacion string Motivo por el cual se cancelo el abono
**/
public static function EditarAbono($id_abono, $compra = null, $motivo_cancelacion = null, $nota = null, $prestamo = null, $venta = null)
{
Logger::log("Editando abono");
//Se validan los parametros
$validar = self::validarParametrosAbono(null, null, $nota, null, $motivo_cancelacion);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar);
}
//verifica si el abono sera de compra, de venta o de prestamo
$abono = null;
$from = 0;
if ($compra) {
$abono = AbonoCompraDAO::getByPK($id_abono);
$from = 1;
} else {
if ($venta) {
$abono = AbonoVentaDAO::getByPK($id_abono);
$from = 2;
} else {
if ($prestamo) {
$abono = AbonoPrestamoDAO::getByPK($id_abono);
$from = 3;
} else {
Logger::error("No se recibio si se editara un abono de compra, venta o prestamo");
throw new Exception("No se recibio si se editara un abono de compra, venta o prestamo");
}
}
}
//valida que el abono exista
if (is_null($abono)) {
$texto = "";
switch ($from) {
case 1:
$texto = "compra";
break;
case 2:
$texto = "venta";
break;
case 3:
$texto = "prestamo";
break;
}
Logger::error("El abono de " . $texto . " con id " . $id_abono . " no existe");
throw new Exception("El abono de " . $texto . " con id " . $id_abono . " no existe");
}
//Los parametros que sean recibidos seran tomados como actalizacion
if (!is_null($nota)) {
$abono->setNota($nota);
}
if ($abono->getCancelado()) {
if (!is_null($motivo_cancelacion)) {
$abono->setMotivoCancelacion($motivo_cancelacion);
}
} else {
if (!is_null($motivo_cancelacion)) {
Logger::warn("No se editara el motivo de cancelacion pues el abono no ha sido cancelado aun");
}
}
//guarda la actualizacion en la tabla correspondiente
DAO::transBegin();
try {
switch ($from) {
case 1:
AbonoCompraDAO::save($abono);
break;
case 2:
AbonoVentaDAO::save($abono);
break;
case 3:
AbonoPrestamoDAO::save($abono);
}
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo editar el abono: " . $e);
throw new Exception("No se pudo editar el abono");
}
DAO::transEnd();
Logger::log("Abono editado exitosamente");
}
/**
*
*Este metodo desactiva un grupo, solo se podra desactivar un grupo si no hay ningun usuario que pertenezca a el.
*
*
* @author Juan Manuel García Carmona <*****@*****.**>
* @param id_rol int Id del grupo a eliminar
**/
public static function EliminarRol($id_rol)
{
//Los roles de administrador (1), gerente (2), cajero(3), cliente (5) y proveedor(6) no pueden ser eliminados
if ($id_rol >= 1 && $id_rol <= 3 || $id_rol >= 5 && $id_rol <= 6) {
Logger::error("El rol predeterminado " . $id_rol . " no puede ser eliminado");
throw new Exception("Los roles predeterminados no pueden ser eliminado", 901);
}
/*
* Se obtiene la lista de usuarios con este rol.
* Si almenos uno aun sigue activo, entonces no se puede eliminar el rol
*/
$usuarios = UsuarioDAO::search(new Usuario(array("id_rol" => $id_rol)));
if (!empty($usuarios)) {
Logger::error("No se puede eliminar este rol pues el usuario " . $usuarios[0]->getNombre() . " lo tiene asignado");
throw new Exception("No se puede eliminar este rol pues hay almenos un usuario asignado a el", 901);
}
DAO::transBegin();
try {
//Se elimina el rol
$to_delete = RolDAO::getByPK($id_rol);
RolDAO::delete($to_delete);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("Error al eliminar el rol: " . $e);
throw new Exception("Error al eliminar el rol, consulte a su administrador de sistema", 901);
}
DAO::transEnd();
Logger::log("Rol eliminado correctamente");
}
/**
*
*Crear un nuevo impuesto.
*
* @param monto_porcentaje float monto o porcentaje que representa este impuesto
* @param nombre string Nombre del impuesto
* @param es_monto bool Si es verdadero, el campo de monto_porcentaje sera tomado como un monto fijo, si es falso, sera tomado como un porcentaje
* @param descripcion string Descripcion del impuesto
* @return id_impuesto int Id del impuesto insertado.
**/
public static function NuevoImpuesto($es_monto, $monto_porcentaje, $nombre, $descripcion = null)
{
Logger::log("Creando un nuevo impuesto");
//Se validan los parametros recibidos
$e = self::validarEsMonto($es_monto);
if (is_string($e)) {
Logger::error($e);
throw new Exception($e);
}
$e = self::validarMontoPorcentaje($monto_porcentaje);
if (is_string($e)) {
Logger::error($e);
throw new Exception($e);
}
$e = self::validarNombre($nombre);
if (is_string($e)) {
Logger::error($e);
throw new Exception($e);
}
if (!is_null($descripcion)) {
$e = self::validarDescripcion($descripcion);
if (is_string($e)) {
Logger::error($e);
throw new Exception($e);
}
}
$impuesto = new Impuesto(array("es_monto" => $es_monto, "monto_porcentaje" => $monto_porcentaje, "nombre" => $nombre, "descripcion" => $descripcion));
DAO::transBegin();
try {
ImpuestoDAO::save($impuesto);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se ha podido crear el nuevo impuesto: " . $e);
throw new Exception("No se ha podido crear al nuevo impuesto, consulte a su administrador de sistema");
}
DAO::transEnd();
Logger::log("Impuesto creado exitosamente");
return array("id_impuesto" => $impuesto->getIdImpuesto());
}
/**
*
*Iniciar una orden de consignaci?n. La fecha sera tomada del servidor.
*
* @param productos json Objeto que contendra los ids de los productos que se daran a consignacion a ese cliente con sus cantidades. Se incluira el id del almacen del cual seran tomados para determinar a que empresa pertenece esta consignacion
* @param id_consignatario int Id del cliente al que se le hace la consignacion
* @return id_consignacion int Id de la consignacion autogenerado por la insercion.
**/
public static function Nueva($fecha_termino, $folio, $id_consignatario, $productos, $tipo_consignacion, $fecha_envio_programada = null)
{
Logger::log("Creando nueva consignacion");
//Se valida al consignatario
$e = self::validarConsignatario($id_consignatario);
if (is_string($e)) {
Logger::error($e);
throw new Exception($e);
}
$consignatario = UsuarioDAO::getByPK($id_consignatario);
//Se obtiene al usuario de la sesion actual
$id_usuario = LoginController::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 el parametro tipo de consignacion
if ($tipo_consignacion != "credito" && $tipo_consignacion != "contado") {
Logger::error("El parametro tipo de consignacion (" . $tipo_consignacion . ") es invalido");
throw new Exception("El parametro tipo de consignacion (" . $tipo_consignacion . ") es invalido");
}
//Si no se recibio fecha de envio, se toma la fecha actual
if (is_null($fecha_envio_programada)) {
$fecha_envio_programada = date("Y-m-d H:i:s");
}
$consignacion = new Consignacion(array("id_cliente" => $id_consignatario, "id_usuario" => $id_usuario, "fecha_creacion" => date("Y-m-d H:i:s"), "activa" => 1, "cancelada" => 0, "folio" => $folio, "fecha_termino" => $fecha_termino, "saldo" => 0, "tipo_consignacion" => $tipo_consignacion));
//Se agrupan los productos que vienen del mismo almacen en subarreglos para
//programar un solo traspaso por almacen.
$productos_por_almacen = array();
$num_productos = count($productos);
for ($i = 0; $i < $num_productos; $i++) {
if ($productos[i] == null) {
continue;
}
$temp = array();
array_push($temp, $productos[i]);
for ($j = $i + 1; $j < $num_productos; $j++) {
if ($productos[$i]["id_almacen"] == $productos[$j]["id_almacen"]) {
array_push($temp, $productos[$j]);
$productos[$j] = null;
}
}
$productos[$i] = null;
array_push($productos_por_almacen, $temp);
}
DAO::transBegin();
try {
ConsignacionDAO::save($consignacion);
$consignacion_producto = new ConsignacionProducto(array("id_consignacion" => $consignacion->getIdConsignacion()));
foreach ($productos_por_almacen as $producto_por_almacen) {
//Se validan los parametros obtenidos del arreglo de productos
foreach ($producto_por_almacen as $producto) {
$validar = self::validarConsignacionProducto($producto["id_producto"], $producto["id_unidad"], $producto["cantidad"], $producto["impuesto"], $producto["descuento"], $producto["retencion"], $producto["precio"]);
if (is_string($validar)) {
throw new Exception($validar);
}
$validar = self::validarAlmacen($producto["id_almacen"]);
if (is_string($validar)) {
throw new Eception($validar);
}
}
/*
* El consignatario puede contar con algún o ningún almacen de tipo consignacion,
* pero solo tendra uno por empresa, esto quiere decir que todos los productos recibidos
* seran repartidos en estos almacenes de acuerdo a la empresa a la que pertenece
* el almacen de donde son extraidos.
*
* Si el consignatario no cuenta con un almacen para la empresa de ese producto, se creara uno
* nuevo y se realizara la transferencia.
*/
//Se obtiene el id de la empresa de la cual vienen los productos
$id_empresa = AlmacenDAO::getByPK($producto_por_almacen[0]["id_almacen"])->getIdEmpresa();
//Se busca el almacen de consignacion de este cliente para esta empresa
$almacen = null;
$almacenes = AlmacenDAO::search(new Almacen(array("id_empresa" => $id_empresa, "nombre" => $consignatario->getCodigoUsuario(), "id_sucursal" => 0)));
//Si no existe, se crea
if (empty($almacenes)) {
$almacen = new Almacen(array("id_sucursal" => 0, "id_empresa" => $id_empresa, "id_tipo_almacen" => 2, "nombre" => $consignatario->getCodigoUsuario(), "descripcion" => "Almacen de consignacion del usuario " . $consignatario->getNombre() . " con clave " . $consignatario->getCodigoUsuario() . " para la empresa " . $id_empresa, "activo" => 1));
AlmacenDAO::save($almacen);
} else {
$almacen = $almacenes[0];
}
//Se prepara el arreglo de productos para crear el traspaso de un almacen a otro
$productos_para_traspaso = array();
foreach ($producto_por_almacen as $producto) {
$p = array("id_producto" => $producto["id_producto"], "id_unidad" => $producto["id_unidad"], "cantidad" => $producto["cantidad"]);
array_push($productos_para_traspaso, $p);
}
//Se programa el traspaso del almacen de donde se tomaron estos productos al almacen de consignacion
SucursalesController::ProgramarTraspasoAlmacen($almacen->getIdAlmacen(), $producto_por_almacen[0]["id_almacen"], $fecha_envio_programada, $productos_para_traspaso);
}
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo crear la nueva consignacion: " . $e);
throw new Exception("No se pudo crear la nueva consignacion");
}
DAO::transEnd();
Logger::log("Consignacion creada exitosamente");
return array("id_consignacion" => $consignacion->getIdConsignacion());
}
/**
*
* Un administrador puede editar una sucursal, incuso si hay puntos de venta con sesiones activas que pertenecen a esa empresa.
*
* @author Juan Manuel García Carmona <*****@*****.**>
* @param id_empresa int Id de la empresa a modificar
* @param cuentas_bancarias json Arreglo que contiene los id de las cuentas bancarias
* @param direccion json { "tipo": "fiscal", "calle": "Francisco I Madero", "numero_exterior": "1009A", "numero_interior": 12, "colonia": "centro", "codigo_postal": "38000", "telefono1": "4611223312", "telefono2": "", "id_ciudad": 3, "referencia": "El local naranja"}
* @param direccion_web string Direccion del sitio de la empresa
* @param email string Correo electronico de la empresa
* @param id_moneda string Id de la moneda base que manejaran las sucursales
* @param impuestos_compra json Impuestos de compra por default que se heredan a las sucursales y estas a su vez a los productos
* @param impuestos_venta json Impuestos de venta por default que se heredan a las sucursales y estas a su vez a los productos
* @param mensaje_morosos string mensaje enviado a los clientes (email) cuando un pago es demorado
* @param razon_social string El nombre de la nueva empresa.
* @param representante_legal string El nombre del representante legal de la nueva empresa.
* @param rfc string RFC de la empresa
* @param uri_logo string url del logo de la empresa
**/
public static function Editar($id_empresa, $cuentas_bancarias = null, $direccion = null, $direccion_web = null, $email = null, $id_moneda = "0", $impuestos_compra = null, $impuestos_venta = null, $mensaje_morosos = null, $razon_social = null, $representante_legal = null, $rfc = null, $uri_logo = null)
{
//se guarda el registro de la empresa y se verifica que este activa
$empresa = EmpresaDAO::getByPK($id_empresa);
if (!$empresa->getActivo()) {
Logger::error("La empresa no esta activa, no se puede editar una empresa desactivada");
throw new Exception("La empresa no esta activa, no se puede editar una empresa desactivada", 901);
}
$empresa->setDireccionWeb($direccion_web);
//TODO : Por que carajos no esta el campo email!!
//$empresa->setEmail($email);
//TODO : No se debe de editar
//$empresa->setIdMoneda($id_moneda);
$empresa->setMensajeMorosos($mensaje_morosos);
$empresa->setRazonSocial($razon_social);
$empresa->setRepresentanteLegal($representante_legal);
$empresa->setRfc($rfc);
//editamos el id del logo
if (!empty($uri_logo)) {
//varificamos si cambio el logo
$_logo = LogoDAO::getByPK($empresa->getIdLogo());
if ($uri_logo !== $_logo->getImagen()) {
$logo = new Logo(array("imagen" => $uri_logo, "tipo" => "-"));
try {
LogoDAO::save($logo);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo crear la empresa, error al crear el logo: " . $e->getMessage());
throw new Exception("No se pudo crear la empresa, consulte a su administrador de sistema", 901);
}
$id_logo = $logo->getIdLogo();
$empresa->setIdLogo($id_logo);
}
}
//lógica para manejar la edicion o agregado de una direccion verificamos si se cambiaron las direcciones
if (!is_null($direccion)) {
if (!is_array($direccion)) {
//Logger::error("Verifique el formato de los datos de las direcciones, se esperaba un array ");
//throw new Exception("Verifique el formato de los datos de las empresas, se esperaba un array ");
$direccion = object_to_array($direccion);
}
$_direccion = new Direccion($direccion);
$d = DireccionDAO::getByPK($empresa->getIdDireccion());
//verificamos si se va a editar una direccion o se va a crear una nueva
if (isset($d->id_direccion)) {
//se edita la direccion
if (!($_direccion = DireccionDAO::getByPK($d->id_direccion))) {
DAO::transRollback();
Logger::error("No se tiene registro de la dirección con id : {$direccion->id_direccion}");
throw new InvalidDataException("No se tiene registro de la dirección con id : {$direccion->id_direccion}");
}
$_direccion->setIdDireccion($d->id_direccion);
//bandera que indica si cambia algun parametro de la direccion
$cambio_direccion = false;
//calle
if (isset($d->calle)) {
$cambio_direccion = true;
$_direccion->setCalle($direccion['calle']);
}
//numero_exterior
if (isset($d->numero_exterior)) {
$cambio_direccion = true;
$_direccion->setNumeroExterior($direccion['numero_exterior']);
}
//numero_interior
if (isset($d->numero_interior)) {
$cambio_direccion = true;
$_direccion->setNumeroInterior($direccion['numero_interior']);
}
//referencia
if (isset($d->referencia)) {
$cambio_direccion = true;
$_direccion->setReferencia($direccion['referencia']);
}
//colonia
if (isset($d->colonia)) {
$cambio_direccion = true;
$_direccion->setColonia($direccion['colonia']);
}
//id_ciudad
if (isset($d->id_ciudad)) {
$cambio_direccion = true;
$_direccion->setIdCiudad($direccion['id_ciudad']);
}
//codigo_postal
if (isset($d->codigo_postal)) {
$cambio_direccion = true;
$_direccion->setCodigoPostal($direccion['codigo_postal']);
}
//telefono
if (isset($d->telefono)) {
$cambio_direccion = true;
$_direccion->setTelefono($direccion['telefono1']);
}
//telefono2
if (isset($d->telefono2)) {
$cambio_direccion = true;
$_direccion->setTelefono2($direccion['telefono2']);
}
//Si cambio algun parametro de direccion, se actualiza el usuario que modifica y la fecha
if ($cambio_direccion) {
DireccionController::EditarDireccion($_direccion);
} else {
DireccionController::NuevaDireccion($calle = isset($d->calle) ? $d->calle : "", $numero_exterior = isset($d->numero_exterior) ? $d->numero_exterior : "", $colonia = isset($d->colonia) ? $d->colonia : "", $id_ciudad = isset($d->id_ciudad) ? $d->id_ciudad : "", $codigo_postal = isset($d->codigo_postal) ? $d->codigo_postal : "", $numero_interior = isset($d->numero_interior) ? $d->numero_interior : "", $referencia = isset($d->referencia) ? $d->referencia : "", $telefono = isset($d->telefono) ? $d->telefono : "", $telefono2 = isset($d->telefono2) ? $d->telefono2 : "");
}
}
}
DAO::transBegin();
try {
//Se guardan los cambios hechos en la empresa
EmpresaDAO::save($empresa);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo modificar la empresa: " . $e);
throw new Exception("No se pudo modificar la empresa");
}
$impuestos_empresa = ImpuestoEmpresaDAO::search(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa())));
//quitamos los impuestos que no estan actualmente
foreach ($impuestos_empresa as $impuesto_empresa) {
$exist_ic = false;
foreach ($impuestos_compra as $impuesto_compra) {
if ($impuesto_compra->getIdImpuesto() == $impuesto_empresa->getIdImpuesto()) {
$exist_ic = true;
}
}
if (!$exist_ic) {
try {
ImpuestoEmpresaDAO::delete($impuesto_empresa);
} catch (Exception $e) {
Logger::warn("Error al eliminar impuesto : " . $e->getMessage());
}
}
}
$impuestos_empresa = ImpuestoEmpresaDAO::search(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa())));
foreach ($impuestos_empresa as $impuesto_empresa) {
$exist_iv = false;
foreach ($impuestos_venta as $impuesto_venta) {
if ($impuesto_venta->getIdImpuesto() == $impuesto_venta->getIdImpuesto()) {
$exist_iv = true;
}
}
if (!$exist_iv) {
try {
ImpuestoEmpresaDAO::delete($impuesto_empresa);
} catch (Exception $e) {
Logger::warn("Error al eliminar impuesto : " . $e->getMessage());
}
}
}
//agregamos los impuestos de compra que no existen
$impuestos_empresa = ImpuestoEmpresaDAO::search(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa())));
if ($impuestos_compra != NULL) {
foreach ($impuestos_compra as $impuesto_compra) {
$exist_ic = false;
foreach ($impuestos_empresa as $impuesto_empresa) {
if ($impuesto_compra->getIdImpuesto() == $impuesto_empresa->getIdImpuesto()) {
$exist_ic = true;
}
}
if (!$exist_ic) {
try {
ImpuestoEmpresaDAO::save(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa(), "id_impuesto" => $impuesto_compra->getIdImpuesto())));
} catch (Exception $e) {
Logger::warn("Error al guardar un impuesto compra : " . $e->getMessage());
}
}
}
}
//agregamos los impuestos de venta que no existen
$impuestos_empresa = ImpuestoEmpresaDAO::search(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa())));
if ($impuestos_venta != NULL) {
foreach ($impuestos_venta as $impuesto_venta) {
$exist_iv = false;
foreach ($impuestos_venta as $impuesto_venta) {
if ($impuesto_venta->getIdImpuesto() == $impuesto_venta->getIdImpuesto()) {
$exist_iv = true;
}
}
if (!$exist_iv) {
try {
ImpuestoEmpresaDAO::save(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa(), "id_impuesto" => $impuesto_venta->getIdImpuesto())));
} catch (Exception $e) {
Logger::warn("Error al guardar un impuesto venta : " . $e->getMessage());
}
}
}
}
if ($cuentas_bancarias != NULL) {
foreach ($cuentas_bancarias as $cuenta_bancarias) {
//Pendiente hasta que se haga el SPEC de cuentas bancarias
}
}
DAO::transEnd();
Logger::log("Empresa editada con exito");
}
/**
*
* Crea una nueva unidad de medida.
*
* @param abreviacion string Abreviacion de la unidad.
* @param descripcion string Nombre de la unidad.
* @param factor_conversion float Equivalencia de esta unidad con respecto a la unidad de medida base obtenida de la
* categoria a la cual pertenece esta unidad. En caso de que se seleccione el valor de tipo_unidad_medida =
* "Referencia UdM para esta categoría" este valor sera igual a uno automáticamente sin posibilidad de ingresar
* otro valor diferente.
* @param id_categoria_unidad_medida int Id de la categoria a la cual pertenece la unidad.
* @param tipo_unidad_medida enum Tipo de unidad cuyo valores son los siguientes: "Referencia UdM para esta categoria"
* (define a esta unidad como la unidad base de referencia de esta categoria, en caso de seleccionar esta opción
* automticamente el factor de conversion sera igual a uno sin posibilidad de ingresar otro valor diferente), "Mayor
* que la UdM de referencia" (indica que esta unidad de medida sera mayor que la unidad de medida base d la
* categoria que se indique) y "Menor que la UdM de referencia" (indica que esta unidad de medida sera menor que la
* unidad de medida base de la categora que se indique). Cuando se defina una nueva unidad de referencia las demás
* unidades de esta categoría se modificarán para establecer los nuevos factores de conversión.
* @return id_unidad_medida int ID de la unidad de medida recién creada.
* @throws BusinessLogicException si abreviacion y/o descripcion ya existen en la categoria, si factor_conversion no es
* mayor que cero o si tipo_unidad_medida no es valido.
* @throws InvalidArgumentException si abreviacion y/o descripcion son cadenas vacias.
* @throws InvalidDatabaseOperationException si la categoria no existe.
**/
public static function NuevaUnidadUdm($abreviacion, $descripcion, $factor_conversion, $id_categoria_unidad_medida, $tipo_unidad_medida)
{
Logger::log("Creando una nueva unidad de medida");
$factor_conversion = self::validarParametrosUnidad($abreviacion, $descripcion, $id_categoria_unidad_medida, $tipo_unidad_medida, $factor_conversion);
$udm = new UnidadMedida(array("abreviacion" => trim($abreviacion), "descripcion" => $descripcion, "factor_conversion" => $factor_conversion, "id_categoria_unidad_medida" => $id_categoria_unidad_medida, "tipo_unidad_medida" => $tipo_unidad_medida, "activa" => 1));
DAO::transBegin();
try {
UnidadMedidaDAO::save($udm);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo crear la unidad de medida: " . $e);
throw new Exception("No se pudo crear la unidad de medida");
}
DAO::transEnd();
Logger::log("Unidad de Medida creada exitosamente");
return array("id_unidad_medida" => (int) $udm->getIdUnidadMedida());
}
/**
*
*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();
}
/**
*
*En algunos servicios, se realiza la venta de productos de manera indirecta, por lo que se tiene que agregar a la orden de servicio.
*
* @param id_orden_de_servicio int Id de la orden de servicio a la cual se le agregaran los productos
* @param productos json Arreglo de objetos con ids de producto, de unidad, sus cantidades, su precio, su impuesto, retencion y descuento.
**/
static function ProductosAgregarOrden($id_orden_de_servicio, $productos)
{
Logger::log("Agregando productos a la orden de servicio " . $id_orden_de_servicio);
//Se valida la orden de servicio
$validar = self::validarParametrosOrdenDeServicio($id_orden_de_servicio);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar, 901);
}
//valida que los productos sean validos
$productos = object_to_array($productos);
if (!is_array($productos)) {
throw new Exception("Los productos son invalidos", 901);
}
//El precio de la orden de servicio se incrementara por cada precio encontrado en los productos
$orden_de_servicio = OrdenDeServicioDAO::getByPK($id_orden_de_servicio);
//Se almacenaran todos los productos obtenidos con us informacion
$producto_orden_de_servicio = new ProductoOrdenDeServicio(array("id_orden_de_servicio" => $id_orden_de_servicio));
DAO::transBegin();
try {
/*
* Por cada producto en el arreglo, se busca en la tabla de productos orden,
* pues puede ser que el usuario haya querido agregar mas producto al que ya habia.
*
* Si no se encuentra en la tabla, simplemente se crea un nuevo registro
*/
foreach ($productos as $producto) {
if (!array_key_exists("id_producto", $producto) || !array_key_exists("id_unidad", $producto) || !array_key_exists("cantidad", $producto) || !array_key_exists("precio", $producto) || !array_key_exists("descuento", $producto) || !array_key_exists("impuesto", $producto) || !array_key_exists("retencion", $producto)) {
throw new Exception("Los productos no contienen los parametros necesarios", 901);
}
$producto_anterior = ProductoOrdenDeServicioDAO::getByPK($id_orden_de_servicio, $producto["id_producto"], $producto["id_unidad"]);
if (!is_null($producto_anterior)) {
$producto_orden_de_servicio = $producto_anterior;
$cantidad_anterior = $producto_orden_de_servicio->getCantidad();
$producto_orden_de_servicio->setCantidad($cantidad_anterior + $producto["cantidad"]);
} else {
$validar = self::validarParametrosProductoOrdenDeServicio($producto["id_producto"], $producto["precio"], $producto["cantidad"], $producto["descuento"], $producto["impuesto"], $producto["retencion"], $producto["id_unidad"]);
if (is_string($validar)) {
throw new Exception($validar, 901);
}
$producto_orden_de_servicio->setCantidad($producto["cantidad"]);
$producto_orden_de_servicio->setDescuento($producto["descuento"]);
$producto_orden_de_servicio->setIdProducto($producto["id_producto"]);
$producto_orden_de_servicio->setIdUnidad($producto["id_unidad"]);
$producto_orden_de_servicio->setImpuesto($producto["impuesto"]);
$producto_orden_de_servicio->setPrecio($producto["precio"]);
$producto_orden_de_servicio->setRetencion($producto["retencion"]);
}
//@TODO
//La linea de codigo siguiente puede causar problemas, pues el precio de un producto puede cmabiar a lo largo del tiempo.
//Si este metodo fue llamado para agregar mas cantidad a uno ya existente para esta orden en un rango de tiempo
//donde el precio del producto cambio de la primera vez que fue agregado a esta, el precio registrado en la tabla
//sera el de la primera vez, pero el producto agregado recientemente ya tiene otro precio.
//
//Si este producto es retirado con el metodo Quitar_productoOrden se tiene que pasar el precio que tenia este
//producto a la hora de agregarlo para que el precio total de la orden de servicio no se vea alterada.
//
$orden_de_servicio->setPrecio($orden_de_servicio->getPrecio() + $producto["cantidad"] * $producto["precio"]);
ProductoOrdenDeServicioDAO::save($producto_orden_de_servicio);
OrdenDeServicioDAO::save($orden_de_servicio);
}
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo agregar el producto a la orden: " . $e);
if ($e->getCode() == 901) {
throw new Exception("No se pudo agregar el producto a la orden: " . $e->getMessage(), 901);
}
throw new Exception("No se pudo agregar el producto a la orden, consulte al administrador del sistema", 901);
}
DAO::transEnd();
Logger::log("Producto agregado exitosamente");
}
//recargar el objeto de cliente
$this_personal = UsuarioDAO::getByPK($_GET["uid"]);
}
$esta_dir = DireccionDAO::getByPK($this_personal->getIdDireccion());
if (is_null($esta_dir)) {
//esta definida pero el registro no existe por alguna razon
Logger::error("user " . $_GET["uid"] . " se supone que tiene id direccion = " . $this_personal->getIdDireccion() . " , pero esta en null ...");
DAO::transBegin();
$this_personal->setIdDireccion(NULL);
try {
UsuarioDAO::save($this_personal);
DireccionController::NuevaDireccionParaUsuario($this_personal->getIdUsuario());
//recargar el objeto de cliente
$this_personal = UsuarioDAO::getByPK($_GET["uid"]);
} catch (Exception $e) {
DAO::transRollback();
throw new Exception("No se pudo crear la direccion: " . $e);
}
DAO::transEnd();
}
$esta_dir = DireccionDAO::getByPK($this_personal->getIdDireccion());
//titulos
$page->addComponent(new TitleComponent("Editar direccion: " . $esta_dir->getColonia()));
//forma de nuevo usuario
$form = new DAOFormComponent($esta_dir);
$form->hideField(array("id_direccion", "id_usuario_ultima_modificacion", "ultima_modificacion"));
$form->sendHidden("id_direccion");
$form->createComboBoxJoin("id_ciudad", "nombre", CiudadDAO::getAll(), $esta_dir->getIdCiudad());
$form->setCaption("id_ciudad", "Ciudad");
$form->addApiCall("api/personal/usuario/editar/");
$form->beforeSend("editar_direccion");
/**
*
*Activa un paquete previamente desactivado
*
* @param id_paquete int Id del paquete a activar
**/
public static function Activar($id_paquete)
{
Logger::log("Activando el paquete " . $id_paquete);
//valida que el paquete exista y este desactivado
$paquete = PaqueteDAO::getByPK($id_paquete);
if (is_null($paquete)) {
Logger::error("El paquete " . $id_paquete . " esta desactivado");
throw new Exception("El paquete " . $id_paquete . " esta desactivado");
}
if ($paquete->getActivo()) {
Logger::warn("El paquete " . $id_paquete . " ya esta activo");
throw new Exception("El paquete " . $id_paquete . " ya esta activo");
}
$paquete->setActivo(1);
DAO::transBegin();
try {
PaqueteDAO::save($paquete);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se ha podido activar el paquete " . $id_paquete . " : " . $e);
throw new Exception("No se ha podudo activar el paquete");
}
DAO::transEnd();
Logger::log("El paquete ha sido activado exitosamente");
}
/**
*
*Desactiva una tarifa. Para poder desactivar una tarifa, esta no tiene que estar asignada como default para ningun usuario. La tarifa default del sistema no puede ser eliminada.
La tarifa instalada por default no puede ser eliminada
*
* @param id_tarifa int Id de la tarifa a eliminar
**/
public static function Desactivar($id_tarifa)
{
Logger::log("Desactivando la tarifa " . $id_tarifa);
//Se valida la tarifa recibida
$validar = self::ValidarParametrosTarifa($id_tarifa);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar);
}
$tarifa = TarifaDAO::getByPK($id_tarifa);
if ($tarifa->getDefault()) {
Logger::error("Se quiere eliminar una tarifa por default");
throw new Exception("Se quiere eliminar una tarifa por default, primero cambie la tarifa default y despues vuelva a intentarlo", 901);
}
$tarifa->setActiva(0);
DAO::transBegin();
try {
TarifaDAO::save($tarifa);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo eliminar la tarifa: " . $e);
throw new Exception("No se pudo eliminar la tarifa, intentelo de nuevo mas tarde o consulte al administrado del sistema", 901);
}
DAO::transEnd();
Logger::log("Tarifa desactivada exitosamente");
}
public static function NuevoCatalogoCuentasEmpresa($id_empresa)
{
$empresa = EmpresaDAO::getByPK($id_empresa);
if (is_null($empresa)) {
throw new InvalidDatabaseOperationException("La empresa con id " . $id_empresa . " no existe");
}
$nuevo_catalogo_cuentas = new CatalogoCuentas();
$nuevo_catalogo_cuentas->setIdEmpresa($id_empresa);
$nuevo_catalogo_cuentas->setDescripcion("Catalogo de cuentas " . $empresa->getRazonSocial());
DAO::transBegin();
try {
CatalogoCuentasDAO::save($nuevo_catalogo_cuentas);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se ha podido guardar la nueva cuenta: " . $e);
throw new Exception("No se ha podido guardar el nuevo catalogo de cuentas|: " . $e->getMessage(), 901);
}
DAO::transEnd();
self::InsertarCatalogoCuentasDefault($nuevo_catalogo_cuentas->getIdCatalogo());
return array("status" => "ok", "id_catalogo_cuentas" => (int) $nuevo_catalogo_cuentas->getIdCatalogo());
}
private static function Cotizar($descuento, $id_comprador_venta, $impuesto, $subtotal, $tipo_venta, $total, $datos_cheque = null, $detalle_orden = null, $detalle_paquete = null, $detalle_venta = null, $id_sucursal = null, $saldo = "0", $tipo_de_pago = null)
{
Logger::log("Cotizando ....");
//Se obtiene el id del usuario actualmente logueado
$aS = SesionController::Actual();
$id_usuario = $aS["id_usuario"];
//Se busca al usuario comprador
$usuario = UsuarioDAO::getByPK($id_comprador_venta);
if (!is_null($id_sucursal)) {
$sucursal = SucursalDAO::getByPK($id_sucursal);
if (is_null($sucursal)) {
Logger::error("La sucursal " . $id_sucursal . " no existe");
throw new InvalidDataException("La sucursal no existe", 901);
}
if (!$sucursal->getActiva()) {
Logger::error("La sucursal " . $id_sucursal . " esta desactivada");
throw new InvalidDataException("La sucursal esta desactivada", 901);
}
}
//Se inicializa la venta con los parametros obtenidos
$venta = new Venta();
$venta->setRetencion(0);
$venta->setEsCotizacion(true);
$venta->setIdCompradorVenta($id_comprador_venta);
$venta->setSubtotal($subtotal);
$venta->setImpuesto($impuesto);
$venta->setTotal($total);
$venta->setDescuento($descuento);
$venta->setTipoDeVenta($tipo_venta);
$venta->setIdCaja(null);
$venta->setIdSucursal($id_sucursal);
$venta->setIdUsuario($id_usuario);
$venta->setIdVentaCaja(NULL);
$venta->setCancelada(0);
$venta->setTipoDePago(null);
$venta->setSaldo(0);
$venta->setFecha(time());
DAO::transBegin();
try {
VentaDAO::save($venta);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo realizar la venta: " . $e);
throw new Exception("No se pudo realizar la venta", 901);
}
//Si el detalle de las ordenes compradas, el detalle de los paquetes y el detalle de los productos
//son nulos, manda error.
if (is_null($detalle_orden) && is_null($detalle_paquete) && is_null($detalle_venta)) {
throw new InvalidDataException("No se recibieron ni paquetes ni productos ni servicios para esta venta", 901);
}
//Por cada detalle, se valida la informacion recibida, se guarda en un registro
//que contiene el id de la venta generada y se guarda el detalle en su respectiva tabla.
if (!is_null($detalle_venta)) {
$detalle_producto = object_to_array($detalle_venta);
if (!is_array($detalle_producto)) {
throw new Exception("El detalle del producto es invalido", 901);
}
foreach ($detalle_producto as $d_p) {
$d_producto = new VentaProducto();
$d_producto->setIdVenta($venta->getIdVenta());
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 del producto es invalido", 901);
}
Logger::log("Insertando venta_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"]);
Logger::log($d_producto);
try {
VentaProductoDAO::save($d_producto);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo realizar la venta: " . $e);
throw new Exception("No se pudo realizar la venta", 901);
}
}
}
/* Fin de if para detalle_producto */
DAO::transEnd();
Logger::log("====== Cotizacion realizada exitosamente ======== ");
return array("id_venta" => $venta->getIdVenta());
}
public function testCatalogoCuentasEmpresa()
{
$dir = new Direccion();
$dir->setIdUsuarioUltimaModificacion(1);
$dir->setUltimaModificacion(mktime());
$dir->setCalle("Calle: " . mktime());
DAO::transBegin();
try {
DireccionDAO::save($dir);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se ha podido guardar la direccion (Desde Unit Tests): " . $e);
if ($e->getCode() == 901) {
throw new Exception("No se ha podido guardar la nueva direccion (desde Unit Test)|: " . $e->getMessage(), 901);
}
throw new Exception("No se ha podido guardar la nueva direccion (Desde Unit Tests)", 901);
}
DAO::transEnd();
$empresa = new Empresa();
$empresa->setRazonSocial("Razon Social - " . time());
$empresa->setRfc(time());
$empresa->setIdDireccion($dir->getIdDireccion());
$empresa->setFechaAlta(mktime());
$empresa->setIdLogo(1);
$empresa->setActivo(1);
DAO::transBegin();
try {
EmpresaDAO::save($empresa);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se ha podido guardar la nueva empresa (Desde Unit Tests): " . $e);
if ($e->getCode() == 901) {
throw new Exception("No se ha podido guardar la nueva empresa (desde Unit Test)|: " . $e->getMessage(), 901);
}
throw new Exception("No se ha podido guardar la nueva empresa (Desde Unit Tests)", 901);
}
DAO::transEnd();
$res = ContabilidadController::NuevoCatalogoCuentasEmpresa($empresa->getIdEmpresa());
//return array("status"=>"ok","id_catalogo_cuentas"=>$nuevo_catalogo_cuentas->getIdCatalogo());
$this->assertSame('ok', $res["status"]);
$this->assertInternalType('int', (int) $res["id_catalogo_cuentas"]);
}
/**
*
* Permite dar conocer al sistema las verdaderas existencias en un almacen, o sucursal.
*
* @param inventario json [{id_producto: 1,id_unidad: 2,cantidad: 0,id_lote : 2}]
* @param id_sucursal int
* */
static function Fisico($inventario, $id_sucursal = "")
{
//POS.API.POST("api/inventario/fisico", {inventario : Ext.JSON.encode([{id_producto:8, id_unidad:1, cantidad:7, id_lote:1}]) } , {callback:function(){}})
$s = SesionController::Actual();
Logger::log("---------- INVENTARIO FISICO SE ENCONTRARON " . count($inventario) . " AJUSTES ----------");
foreach ($inventario as $producto) {
//self::ajustarLoteProducto($producto->id_lote, $producto->id_producto, $producto->id_unidad);
//[{id_producto: 1,id_unidad: 2,cantidad: 0,id_lote : 2}]
$producto->nombre = ProductoDAO::getByPK($producto->id_producto)->getNombreProducto();
Logger::log(" Estamos en {$producto->nombre}, id_unidad {$producto->id_unidad}, {$producto->cantidad} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion() . ", lote {$producto->id_lote}");
try {
//verificamos si el lote indicado existe
if (is_null($producto->id_lote) || strlen($producto->id_lote) == 0) {
throw new InvalidDataException("No selecciono a que lote ira el producto {$producto->id_producto}");
}
//busquemos el id del lote
if (!($lote = LoteDAO::getByPK($producto->id_lote))) {
throw new InvalidDataException("No se tiene registro del lote {$producto->id_lote}");
}
//verificamos que exista la unidad de medida y este activa
if (!UnidadMedidaDAO::getByPK($producto->id_unidad)) {
throw new InvalidDataException("La unidad de medida {$producto->id_unidad} no existe, o no esta activa.");
}
//busquemos si este producto ya existe en este lote
$lote_producto = LoteProductoDAO::getByPK($lote->getIdLote(), $producto->id_producto);
if (is_null($lote_producto)) {
Logger::log("El producto no estaba en el lote, se insertara");
/*
//no existe, insertar
$loteProducto = new LoteProducto(array(
"id_lote" => $lote->getIdLote(),
"id_producto" => $producto->id_producto,
"cantidad" => $producto->cantidad,
"id_unidad" => $producto->id_unidad
));
LoteProductoDAO::save($loteProducto);
Logger::log("Se guardo el LoteProducto : id_lote {$lote->getIdLote()}, id_producto {$producto->id_producto}, cantidad {$producto->cantidad} id_unidad {$producto->id_unidad}");
$loteEntrada = new LoteEntrada(array(
"id_lote" => $lote->getIdLote(),
"id_usuario" => $s['id_usuario'],
"fecha_registro" => time(),
"motivo" => "Entrada por ajuste de inventario"
));
LoteEntradaDAO::save($loteEntrada);
Logger::log("Se guardo el LoteEntrada: id_lote {$lote->getIdLote()}, id_usuario {$s['id_usuario']}, motivo {Entrada por ajuste de inventario}");
*/
AlmacenesController::EntradaLote($lote->getIdLote(), array($producto), "Entrada por ajuste de inventario");
} else {
Logger::log("El producto si estaba en el lote, verificaremos las cantidades");
//revisemos si es de la misma unidad
if ($lote_producto->getIdUnidad() == $producto->id_unidad) {
Logger::log("Se encontro que la unidad enviada es igual a la unidad del lote producto");
Logger::log("Se detecto una merma de {$producto->cantidad} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion() . " de {$producto->nombre}");
//$existencias_lote = ProductoDAO::ExistenciasLote($producto->id_producto, $lote->getIdLote(), $lote_producto->getIdUnidad());
$existencias_lote = ProductoDAO::ExistenciasTotales($producto->id_producto);
Logger::log("Se encontraron {$existencias_lote} existencias en el lote {$lote->getIdLote()} para el producto {$producto->id_producto}");
} else {
Logger::log("Se encontro que la unidad enviada es diferente a la unidad del lote producto, se procede a transformar");
//$existencias_lote = ProductoDAO::ExistenciasLote($producto->id_producto, $lote->getIdLote(), $lote_producto->getIdUnidad());
$existencias_lote = ProductoDAO::ExistenciasTotales($producto->id_producto);
Logger::log("Se encontraron {$existencias_lote} " . UnidadMedidaDAO::getByPK($lote_producto->getIdUnidad())->getAbreviacion() . " en el lote {$lote->getIdLote()} para el producto " . ProductoDAO::getByPK($producto->id_producto)->getNombreProducto() . " , nosotros necesitamos que se transforme en " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion());
//var_dump($producto->id_unidad, $lote_producto->getIdUnidad(), $existencias_lote);
try {
Logger::log("Enviara a transformar unidad base : {$producto->id_unidad}, unidad a transformar : {$lote_producto->getIdUnidad()}, cantidad a transformar : {$existencias_lote}");
$existencias_lote = UnidadMedidaDAO::convertir($lote_producto->getIdUnidad(), $producto->id_unidad, $existencias_lote);
Logger::log("Como producto de la transformacion se obtuvo {$existencias_lote} ");
} catch (BusinessLogicException $ide) {
//no se pudo convertir porque son de
//diferentes categorias
throw $ide;
//mostrar una excpetion mas fresona
}
}
Logger::log("se evaluara {$existencias_lote} - {$producto->cantidad}");
//hacemos el ajuste
$diff = $existencias_lote - $producto->cantidad;
if ($diff > 0) {
//entonces hay una merma y se reporta una salida al lote igual a $diff, especificando en motivo el id del movimiento realizado
//se actualiza la cantidad de producto en lote producto
//AlmacenesController::Salida($l->getIdAlmacen(), $producto, "100");
$diff = abs($diff);
Logger::log("Se detecto una merma de {$diff} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion() . " de {$producto->nombre}");
/*
$lote_salida = new LoteSalida(array(
"id_lote" => $lote->getIdLote(),
"id_usuario" => $s['id_usuario'],
"fecha_registro" => time(),
"motivo" => "Salida de producto por ajuste de inventario (merma)"
));
LoteSalidaDAO::save($lote_salida);
Logger::log("Se creo un lote salida id_lote {$lote->getIdLote()}, id_usuario {$s['id_usuario']}, motivo Salida de producto por ajuste de inventario (merma)");
$lote_salida_producto = new LoteSalidaProducto(array(
"id_lote_salida" => $lote_salida->getIdLoteSalida(),
"id_producto" => $producto->id_producto,
"id_unidad" => $producto->id_unidad,
"cantidad" => $producto->cantidad
));
LoteSalidaProductoDAO::save($lote_salida_producto);
Logger::log("Se creo un lote salida producto con id_lote_salida {$lote_salida->getIdLoteSalida()}, id_producto {$producto->id_producto}, id_unidad {$producto->id_unidad}, cantidad {$producto->cantidad}");
*/
AlmacenesController::SalidaLote($lote->getIdLote(), array(array("id_producto" => $producto->id_producto, "cantidad" => $diff, "id_unidad" => $producto->id_unidad)), "Salida de producto por ajuste de inventario (merma)");
}
if ($diff < 0) {
$diff = abs($diff);
//entonces hay un sobrante y se reporta una entrada al lote igual a $diff, especificando en motivo el id del movimiento realizado
//se actualiza la cantidad de producto en lote producto
//AlmacenesController::Entrada($l->getIdAlmacen(), $producto, "101");
Logger::log("Se detecto una sobrante de {$diff} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion());
/*
$lote_entrada = new LoteEntrada(array(
"id_lote" => $lote->getIdLote(),
"id_usuario" => $s['id_usuario'],
"fecha_registro" => time(),
"motivo" => "Entrada de producto por ajuste de inventario (sobrante)"
));
LoteEntradaDAO::save($lote_entrada);
Logger::log("Se creo un lote entrada id_lote {$lote->getIdLote()}, id_usuario {$s['id_usuario']}, motivo Entrada de producto por ajuste de inventario (sobrante)");
$lote_entrada_producto = new LoteEntradaProducto(array(
"id_lote_entrada" => $lote_entrada->getIdLote(),
"id_producto" => $producto->id_producto,
"id_unidad" => $producto->id_unidad,
"cantidad" => $producto->cantidad
));
LoteEntradaProductoDAO::save($lote_entrada_producto);
Logger::log("Se creo un lote entrada producto con id_lote_entrada {$lote_entrada->getIdLoteEntrada()}, id_producto {$producto->id_producto}, id_unidad {$producto->id_unidad}, cantidad {$producto->cantidad}");
*/
//AlmacenesController::EntradaLote($lote->getIdLote(), array($producto), "Entrada de producto por ajuste de inventario (sobrante)");
AlmacenesController::EntradaLote($lote->getIdLote(), array(array("id_producto" => $producto->id_producto, "cantidad" => $diff, "id_unidad" => $producto->id_unidad)), "Entrada de producto por ajuste de inventario (sobrante)");
}
//TODO:HAY QUE AHCER PRUEBAS EXHAUSTIVAS PARA VER SI ESTE ULTIMO BLOQUE DE CODIGO SE DEBERIA DE ELIMINAR
//actualizamos las existencias de lote producto
if ($diff != 0) {
Logger::log("Se procede a hacer el ajuste del lote producto");
self::ajustarLoteProducto($producto->id_lote, $producto->id_producto, $producto->id_unidad);
} else {
Logger::log("Se detecto que la cantidad en tote producto concuerda con la cantidad inventariada, pero aun asi se llamara al metodo de ajuste de prodcuto");
self::ajustarLoteProducto($producto->id_lote, $producto->id_producto, $producto->id_unidad);
}
}
} catch (InvalidDataException $e) {
Logger::error($e);
DAO::transRollback();
throw $e;
} catch (exception $e) {
Logger::error($e);
DAO::transRollback();
throw new InvalidDatabaseOperationException($e);
}
}
}
/**
*
*Desactiva una moneda
*
* @param id_moneda int Id de la moneda a desactivar
**/
public static function EliminarMoneda($id_moneda)
{
Logger::log("Eliminando la moneda " . $id_moneda);
//Se valida que la moneda exista y que este activa
$validar = self::validarParametrosMoneda($id_moneda);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar);
}
$moneda_base = ConfiguracionDAO::search(new Configuracion(array("descripcion" => "id_moneda_base", "valor" => $id_moneda)));
if (count($moneda_base) > 0) {
Logger::log("La moneda es la moneda base de una empresa, no se puede desactivar ");
throw new BusinessLogicException("La moneda es la moneda base de una empresa, no se puede desactivar");
}
//Si algun billete o usuario tiene asignada esta moneda, no se podra eliminar
$billetes = BilleteDAO::search(new Billete(array("id_moneda" => $id_moneda)));
foreach ($billetes as $billete) {
if ($billete->getActivo()) {
Logger::error("La moneda no puede ser eliminada pues esta asignada al billete " . $billete->getIdBillete());
throw new Exception("La moneda no puede ser eliminada pues esta asignada al billete " . $billete->getIdBillete());
}
}
$usuarios = UsuarioDAO::search(new Usuario(array("id_moneda" => $id_moneda)));
foreach ($usuarios as $usuario) {
if ($usuario->getActivo()) {
Logger::error("La moneda no puede ser eliminada pues esta asignada al usuario " . $usuario->getIdUsuario());
throw new Exception("La moneda no puede ser eliminada pues esta asignada al usuario " . $usuario->getIdUsuario());
}
}
//Se elimina y se guarda
$moneda = MonedaDAO::getByPK($id_moneda);
$moneda->setActiva(0);
DAO::transBegin();
try {
MonedaDAO::save($moneda);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo eliminar la moneda: " . $e);
throw new Exception("No se pudo eliminar la moneda");
}
DAO::transEnd();
Logger::log("La moneda ha sido eliminada exitosamente");
}
/**
*
*Edita la informacion de la clasificacion de cliente
*
* @param id_clasificacion_cliente int Id de la clasificacion del cliente a modificar
* @param impuestos json Ids de los impuestos que afectan a esta clasificacion
* @param descuento float Descuento que se le aplicara a los productos
* @param retenciones json Ids de las retenciones que afectan esta clasificacion
* @param clave_interna string Clave interna de la clasificacion
* @param nombre string Nombre de la clasificacion
* @param descripcion string Descripcion larga de la clasificacion
* @param margen_de_utilidad float Margen de utilidad que se le obtendra a todos los productos al venderle a este tipo de cliente
**/
public static function EditarClasificacion($id_clasificacion_cliente, $clave_interna = null, $descripcion = null, $nombre = null)
{
Logger::log("Editando clasificacion de cliente " . $id_clasificacion_cliente);
//Se validan los parametros recibidos
$validar = self::validarParametrosClasificacionCliente($id_clasificacion_cliente, $clave_interna, $nombre, $descripcion);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar, 901);
}
// $cambio_tarifa_compra = false;
// $cambio_tarifa_venta = false;
//Los parametros que no sean nulos seran tomados como actualizacion
$clasificacion_cliente = ClasificacionClienteDAO::getByPK($id_clasificacion_cliente);
if (!is_null($clave_interna)) {
$clasificacion_cliente->setClaveInterna($clave_interna);
}
if (!is_null($nombre)) {
$clasificacion_cliente->setNombre(trim($nombre));
}
if (!is_null($descripcion)) {
$clasificacion_cliente->setDescripcion($descripcion);
}
// if(!is_null($id_tarifa_compra))
// {
// if($id_tarifa_compra!=$clasificacion_cliente->getIdTarifaCompra())
// {
// $cambio_tarifa_compra=true;
// $clasificacion_cliente->setIdTarifaCompra($id_tarifa_compra);
// }
// }
// if(!is_null($id_tarifa_venta))
// {
// if($id_tarifa_venta!=$clasificacion_cliente->getIdTarifaVenta())
// {
// $cambio_tarifa_venta=true;
// $clasificacion_cliente->setIdTarifaVenta($id_tarifa_venta);
// }
// }
//Se actualiza el registro. Si se recibe una lista de impuestos y/o retenciones, se almacenan los
//registros recibidos, despues, se recorren los registro de la base de datos y se buscan en la lista recibida.
//Aquellos que no sean encontrados seran eliminados
DAO::transBegin();
try {
ClasificacionClienteDAO::save($clasificacion_cliente);
//Si cambia la tarifa de compra o venta de una clasificacion de cliente, todos los clientes
//que tengan esta clasificacion y que hayan obtenido su tarifa de compra o venta de otro que no sea
//de usuario debe actualizar su tarifa de compra o venta
// if($cambio_tarifa_compra || $cambio_tarifa_venta)
// {
// $clientes = UsuarioDAO::getByPK(new Usuario( array( "id_clasificacion_cliente" => $id_clasificacion_cliente ) ));
// foreach($clientes as $c)
// {
// if($cambio_tarifa_compra)
// {
// if($c->getTarifaCompraObtenida()!="usuario")
// {
// $c->setIdTarifaCompra($id_tarifa_compra);
// $c->setTarifaCompraObtenida("cliente");
// }
// }
// if($cambio_tarifa_venta)
// {
// if($c->getTarifaVentaObtenida()!="usuario")
// {
// $c->setIdTarifaVenta($id_tarifa_venta);
// $c->setTarifaVentaObtenida("cliente");
// }
// }
// UsuarioDAO::save($c);
// }
// }
// if(!is_null($impuestos))
// {
//
// $impuestos = object_to_array($impuestos);
//
// if(!is_array($impuestos))
// {
// throw new Exception("Los impuestos son invalidos",901);
// }
//
// $impuesto_clasificacion_cliente = new ImpuestoClasificacionCliente(
// array( "id_clasificacion_cliente" => $clasificacion_cliente->getIdClasificacionCliente() ));
// foreach ($impuestos as $impuesto)
// {
// if(is_null(ImpuestoDAO::getByPK($impuesto)))
// throw new Exception ("El impuesto ".$impuesto." no existe",901);
//
// $impuesto_clasificacion_cliente->setIdImpuesto($impuesto);
// ImpuestoClasificacionClienteDAO::save($impuesto_clasificacion_cliente);
// }
//
// $impuestos_clasificacion_cliente = ImpuestoClasificacionClienteDAO::search(
// new ImpuestoClasificacionCliente( array( "id_clasificacion_cliente" => $id_clasificacion_cliente ) ) );
// foreach($impuestos_clasificacion_cliente as $impuesto_clasificacion_cliente)
// {
// $encontrado = false;
// foreach($impuestos as $impuesto)
// {
// if($impuesto == $impuesto_clasificacion_cliente->getIdImpuesto())
// $encontrado = true;
// }
// if(!$encontrado)
// ImpuestoClasificacionClienteDAO::delete ($impuesto_clasificacion_cliente);
// }
// }/* Fin if de impuestos */
// if(!is_null($retenciones))
// {
//
// $retenciones = object_to_array($retenciones);
//
// if(!is_array($retenciones))
// {
// throw new Exception("Las retenciones son invalidas",901);
// }
//
// $retencion_clasificacion_cliente = new RetencionClasificacionCliente(
// array ( "id_clasificacion_cliente" => $clasificacion_cliente->getIdClasificacionCliente() ) );
// foreach( $retenciones as $retencion )
// {
// if(is_null(RetencionDAO::getByPK($retencion)))
// throw new Exception("La retencion ".$retencion." no existe",901);
//
// $retencion_clasificacion_cliente->setIdRetencion($retencion);
// RetencionClasificacionClienteDAO::save($retencion_clasificacion_cliente);
// }
//
// $retenciones_clasificacion_cliente = RetencionClasificacionClienteDAO::search(
// new RetencionClasificacionCliente( array( "id_clasificacion_cliente" => $id_clasificacion_cliente ) ) );
// foreach($retenciones_clasificacion_cliente as $retencion_clasificacion_cliente)
// {
// $encontrado = false;
// foreach($retenciones as $retencion)
// {
// if($retencion == $retencion_clasificacion_cliente->getIdRetencion())
// $encontrado = true;
// }
// if(!$encontrado)
// RetencionClasificacionClienteDAO::delete ($retencion_clasificacion_cliente);
// }
// }/* Fin if de retenciones */
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se ha podido editar la clasificacion de cliente " . $id_clasificacion_cliente . " : " . $e);
if ($e->getCode() == 901) {
throw new Exception("No se ha podido editar la clasificacion de cliente: " . $e->getMessage());
}
throw new Exception("No se ha podido editar la clasificacion de cliente, consulte a su administrador de sistema");
}
DAO::transEnd();
}
public static function EditarDireccion($direccion)
{
//verificamos si se cambiaron las direcciones
if (!is_null($direccion)) {
Logger::log("\tEditando direccion ...");
if (!is_array($direccion)) {
//Logger::error("Verifique el formato de los datos de las direcciones, se esperaba un array ");
//throw new Exception("Verifique el formato de los datos de las empresas, se esperaba un array ");
$direccion = object_to_array($direccion);
}
$_direccion = new Direccion($direccion);
$d = DireccionDAO::getByPK($_direccion->getIdDireccion());
//verificamos si se va a editar una direccion o se va a crear una nueva
if (isset($d->id_direccion)) {
//se edita la direccion
if (!($_direccion = DireccionDAO::getByPK($d->id_direccion))) {
DAO::transRollback();
Logger::error("No se tiene registro de la dirección con id : {$direccion->id_direccion}");
throw new InvalidDataException("No se tiene registro de la dirección con id : {$direccion->id_direccion}");
}
//bandera que indica si cambia algun parametro de la direccion
$cambio_direccion = false;
//calle
if (array_key_exists('calle', $direccion)) {
$_direccion->setCalle($direccion['calle']);
$cambio_direccion = true;
}
//numero_exterior
if (array_key_exists('numero_exterior', $direccion)) {
$cambio_direccion = true;
$_direccion->setNumeroExterior($direccion['numero_exterior']);
}
//numero_interior
if (array_key_exists('numero_interior', $direccion)) {
$cambio_direccion = true;
$_direccion->setNumeroInterior($direccion['numero_interior']);
}
//referencia
if (array_key_exists('referencia', $direccion)) {
$cambio_direccion = true;
$_direccion->setReferencia($direccion['referencia']);
}
//colonia
if (array_key_exists('colonia', $direccion)) {
$cambio_direccion = true;
$_direccion->setColonia($direccion['colonia']);
}
//id_ciudad
if (array_key_exists('id_ciudad', $direccion)) {
$cambio_direccion = true;
$_direccion->setIdCiudad($direccion['id_ciudad']);
}
//codigo_postal
if (array_key_exists('codigo_postal', $direccion)) {
$cambio_direccion = true;
$_direccion->setCodigoPostal($direccion['codigo_postal']);
}
//telefono
if (array_key_exists('telefono', $direccion)) {
$cambio_direccion = true;
$_direccion->setTelefono($direccion['telefono']);
}
//telefono2
if (array_key_exists('telefono2', $direccion)) {
$cambio_direccion = true;
$_direccion->setTelefono2($direccion['telefono2']);
}
//Si cambio algun parametro de direccion, se actualiza el usuario que modifica y la fecha
if ($cambio_direccion) {
$_direccion->setUltimaModificacion(time());
$id_usuario = SesionController::Actual();
$id_usuario = $id_usuario["id_usuario"];
if (is_null($id_usuario)) {
DAO::transRollback();
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?");
}
$_direccion->setIdUsuarioUltimaModificacion($id_usuario);
//guardamos la direccion
try {
Logger::log("Salvando direccion...");
DireccionDAO::save($_direccion);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo guardar la direccion " . $e);
if ($e->getCode() == 901) {
throw new Exception("Error al guardar direccion de la sucursal {$sucursal->getRazonSocial()}: " . $e->getMessage(), 901);
}
throw new Exception("Error al guardar direccion de la sucursal {$sucursal->getRazonSocial()}", 901);
}
}
//cambio dir
}
//verificacion editar dir
}
// !is_null
}
/**
*
*Edita la informacion de una clasificacion de proveedor
*
* @param id_clasificacion_proveedor int Id de la clasificacion del proveedor a editar
* @param retenciones json Ids de las retenciones de la clasificacion de proveedor
* @param impuestos json Ids de los impuestos de la clasificacion del proveedor
* @param descripcion string Descripcion de la clasificacion del proveedor
* @param nombre string Nombre de la clasificacion del proveedor
**/
public static function EditarClasificacion($id_clasificacion_proveedor, $descripcion = null, $id_tarifa_compra = null, $id_tarifa_venta = null, $impuestos = null, $nombre = null, $retenciones = null)
{
Logger::log("Editando la clasificacion de proveedor " . $id_clasificacion_proveedor);
//valida los parametros recibidos
$validar = self::validarParametrosClasificacionProveedor($id_clasificacion_proveedor, $nombre, $descripcion, null, $id_tarifa_compra, $id_tarifa_venta);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar);
}
//Los parametros que no sean nulos seran tomados como actualizacion
$clasificacion_proveedor = ClasificacionProveedorDAO::getByPK($id_clasificacion_proveedor);
if (!is_null($descripcion)) {
$clasificacion_proveedor->setDescripcion($descripcion);
}
if (!is_null($nombre)) {
$clasificacion_proveedor->setNombre($nombre);
}
$cambio_tarifa_compra = false;
$cambio_tarifa_venta = false;
if (!is_null($id_tarifa_compra)) {
if ($id_tarifa_compra != $clasificacion_proveedor->getIdTarifaCompra()) {
$cambio_tarifa_compra = true;
$clasificacion_proveedor->setIdTarifaCompra($id_tarifa_compra);
}
}
if (!is_null($id_tarifa_venta)) {
if ($id_tarifa_venta != $clasificacion_proveedor->getIdTarifaVenta()) {
$cambio_tarifa_venta = true;
$clasificacion_proveedor->setIdTarifaVenta($id_tarifa_venta);
}
}
//Se actualiza el registro. Si se reciben listas de impuestos y/o registros se guardan los
//que estan en la lista, despues se recorren los registros de la base de datos y aquellos que no
//se encuentren en la lista nueva seran eliminados.
DAO::transBegin();
try {
ClasificacionProveedorDAO::save($clasificacion_proveedor);
//Si se cambia la tarifa de compra o de venta, se actualizan aquellos proveedores
//con etsa clasificacion de proveedor y cuya tarifa haya sido obtenida por el rol
//o por la clasificacion de proveedor.
if ($cambio_tarifa_compra || $cambio_tarifa_venta) {
$proveedores = UsuarioDAO::search(new Usuario(array("id_clasificacion_proveedor" => $id_clasificacion_proveedor)));
foreach ($proveedores as $proveedor) {
if ($cambio_tarifa_compra) {
if ($proveedor->getTarifaCompraObtenida() == "rol" || $proveedor->getTarifaCompraObtenida() == "proveedor") {
$proveedor->setIdTarifaCompra($id_tarifa_compra);
$proveedor->setTarifaCompraObtenida("proveedor");
}
}
if ($cambio_tarifa_venta) {
if ($proveedor->getTarifaVentaObtenida() == "rol" || $proveedor->getTarifaVentaObtenida() == "proveedor") {
$proveedor->setIdTarifaVenta($id_tarifa_venta);
$proveedor->setTarifaVentaObtenida("proveedor");
}
}
UsuarioDAO::save($proveedor);
}
}
if (!is_null($impuestos)) {
$impuestos = object_to_array($impuestos);
if (!is_array($impuestos)) {
throw new Exception("Los impuestos son invalidos");
}
$impuesto_clasificacion_proveedor = new ImpuestoClasificacionProveedor(array("id_clasificacion_proveedor" => $clasificacion_proveedor->getIdClasificacionProveedor()));
foreach ($impuestos as $impuesto) {
if (is_null(ImpuestoDAO::getByPK($impuesto))) {
throw new Exception("El impuesto " . $impuesto . " no existe", 901);
}
$impuesto_clasificacion_proveedor->setIdImpuesto($impuesto);
ImpuestoClasificacionProveedorDAO::save($impuesto_clasificacion_proveedor);
}
$impuestos_clasificacion_proveedor = ImpuestoClasificacionProveedorDAO::search(new ImpuestoClasificacionProveedor(array("id_clasificacion_proveedor" => $id_clasificacion_proveedor)));
foreach ($impuestos_clasificacion_proveedor as $impuesto_clasificacion_proveedor) {
$encontrado = false;
foreach ($impuestos as $impuesto) {
if ($impuesto == $impuesto_clasificacion_proveedor->getIdImpuesto()) {
$encontrado = true;
}
}
if (!$encontrado) {
ImpuestoClasificacionProveedorDAO::delete($impuesto_clasificacion_proveedor);
}
}
}
/* Fin if de impuestos */
if (!is_null($retenciones)) {
$retenciones = object_to_array($retenciones);
if (!is_array($retenciones)) {
throw new Exception("Las retenciones son invalidas", 901);
}
$retencion_clasificacion_proveedor = new RetencionClasificacionProveedor(array("id_clasificacion_proveedor" => $clasificacion_proveedor->getIdClasificacionProveedor()));
foreach ($retenciones as $retencion) {
if (is_null(RetencionDAO::getByPK($retencion))) {
throw new Exception("La retencion " . $retencion . " no existe", 901);
}
$retencion_clasificacion_proveedor->setIdRetencion($retencion);
RetencionClasificacionProveedorDAO::save($retencion_clasificacion_proveedor);
}
$retenciones_clasificacion_proveedor = RetencionClasificacionProveedorDAO::search(new RetencionClasificacionProveedor(array("id_clasificacion_proveedor" => $id_clasificacion_proveedor)));
foreach ($retenciones_clasificacion_proveedor as $retencion_clasificacion_proveedor) {
$encontrado = false;
foreach ($retenciones as $retencion) {
if ($retencion == $retencion_clasificacion_proveedor->getIdRetencion()) {
$encontrado = true;
}
}
if (!$encontrado) {
RetencionClasificacionProveedorDAO::delete($retencion_clasificacion_proveedor);
}
}
}
/* Fin if de retenciones */
} catch (Exception $e) {
DAO::transRollback();
Logger::error("La clasificacion de proveedor no ha podido ser editada: " . $e);
if ($e->getCode() == 901) {
throw new Exception("La clasificacion de proveedor no ha podido ser editada: " . $e->getCode(), 901);
}
throw new Exception("La clasificacion de proveedor no ha podido ser editada", 901);
}
DAO::transEnd();
Logger::log("La clasificacion de proveedor ha sido eeditada exitosamente ");
}
/**
*
*Envia productos fuera del almacen. Ya sea que sea un traspaso de un alamcen a otro o por motivos de inventarios fisicos.
*
* @param id_lote int Id del lote de donde se descontaran los productos.
* @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_lote int ID de la salida del producto
**/
static function SalidaLote($id_lote, $productos, $motivo = null)
{
if (is_null(LoteDAO::getByPK($id_lote))) {
throw new InvalidDataException("este lote no existe");
}
if (!is_array($productos)) {
throw new InvalidDataException("productos no es un array");
}
$sesion = SesionController::Actual();
DAO::transBegin();
$sl = new LoteSalida();
$sl->setIdLote($id_lote);
$sl->setIdUsuario($sesion["id_usuario"]);
$sl->setFechaRegistro(time());
$sl->setMotivo(is_null($motivo) ? "" : $motivo);
try {
LoteSalidaDAO::save($sl);
} catch (Exception $e) {
DAO::transRollback();
throw new InvalidDatabaseOperationException($e);
}
for ($i = 0; $i < sizeof($productos); $i++) {
if (!is_array($productos[$i])) {
throw new InvalidDataException("El producto en la posicion {$i} no es un arreglo como se esperaba");
}
if (!array_key_exists("id_producto", $productos[$i])) {
throw new InvalidDataException("El producto en {$i} no tiene id_prodcuto");
}
if (!array_key_exists("cantidad", $productos[$i])) {
throw new InvalidDataException("El producto en {$i} no tiene cantidad");
}
if (is_null(ProductoDAO::getByPK($productos[$i]["id_producto"]))) {
throw new InvalidDataException("El producto " . $productos[$i]["id_producto"] . " no existe.");
}
$lp = LoteProductoDAO::getByPK($id_lote, $productos[$i]["id_producto"]);
if (is_null($lp)) {
throw new InvalidDataException("El lote {$id_lote} no tiene el producto " . $productos[$i]["id_producto"]);
}
if ($productos[$i]["cantidad"] > $lp->getCantidad()) {
throw new InvalidDataException("Estas intentando sacar mas de lo que hay en el lote.");
}
if (!isset($productos[$i]["id_unidad"])) {
throw new InvalidDataException("El producto " . $productos[$i]["id_producto"] . " proporcionado no tiene id_unidad");
}
$equivalencia = UnidadMedidaDAO::convertir($productos[$i]["id_unidad"], $lp->getIdUnidad(), $productos[$i]["cantidad"]);
if ($equivalencia > $lp->getCantidad()) {
Logger::log("Se Comparara {$equivalencia} > {$lp->getCantidad()}");
throw new InvalidDataException("Estas intentando sacar mas de lo que hay en el lote.");
}
$lp->setCantidad($lp->getCantidad() - $productos[$i]["cantidad"]);
try {
LoteProductoDAO::save($lp);
LoteSalidaProductoDAO::save(new LoteSalidaProducto(array("id_lote_salida" => $sl->getIdLoteSalida(), "id_producto" => $productos[$i]["id_producto"], "id_unidad" => $productos[$i]["id_unidad"], "cantidad" => $productos[$i]["cantidad"])));
Logger::log("Removiendo qty=" . $productos[$i]["cantidad"] . "; prod=" . $productos[$i]["id_producto"] . "; lote=" . $id_lote);
} catch (Exception $e) {
Logger::error($e);
throw new InvalidDatabaseOperationException($e);
}
}
DAO::transEnd();
return array("id_salida_lote" => $sl->getIdLoteSalida());
}
