PHP DAO::transBegin方法代码示例

 public static function NuevaDireccion($calle, $numero_exterior, $colonia, $id_ciudad, $codigo_postal, $numero_interior = null, $referencia = null, $telefono = null, $telefono2 = null)
 {
     $direccion = new Direccion();
     $id_usuario = SesionController::Actual();
     $id_usuario = $id_usuario["id_usuario"];
     if ($id_usuario == null) {
         Logger::error("SesionController::Actual() regreso null");
         throw new Exception("No se pudo obtener la sesion del usuario, ya inicio sesion?", 901);
     }
     if (!self::validarDireccion($direccion)) {
         throw new InvalidDataException();
     }
     $direccion->setCalle($calle);
     $direccion->setNumeroExterior($numero_exterior);
     $direccion->setColonia($colonia);
     $direccion->setIdCiudad($id_ciudad);
     $direccion->setCodigoPostal($codigo_postal);
     $direccion->setNumeroInterior($numero_interior);
     $direccion->setReferencia($referencia);
     $direccion->setTelefono($telefono);
     $direccion->setTelefono2($telefono2);
     $direccion->setUltimaModificacion(time());
     $direccion->setIdUsuarioUltimaModificacion($id_usuario);
     DAO::transBegin();
     try {
         DireccionDAO::save($direccion);
     } catch (Exception $e) {
         DAO::transRollback();
         throw new Exception("No se pudo crear la direccion: " . $e);
     }
     DAO::transEnd();
     Logger::log("Direccion creada exitosamente, id=" . $direccion->getIdDireccion());
     return $direccion->getIdDireccion();
 }

 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"]);
 }

 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());
 }

 /**
  *
  *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");
 }

 /**
  	 *
  	 *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 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();
 }

//.........这里部分代码省略.........
             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();

// Parametros necesarios
//
$page->requireParam("uid", "GET", "Esta usuario no existe.");
$this_personal = UsuarioDAO::getByPK($_GET["uid"]);
if (is_null($this_personal->getIdDireccion())) {
    //no existe direccion
    Logger::log("El uid=" . $_GET["uid"] . " no tiene direccion. Insertando.");
    DireccionController::NuevaDireccionParaUsuario($_GET["uid"]);
    //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()));

 /**
  *
  *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");
 }

 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());
 }

 /**
  *
  *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) {
//.........这里部分代码省略.........

//.........这里部分代码省略.........
             //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;
             }

 /**
  *
  *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();
 }

 /**
  *
  * 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());
 }