/**
   * Este metodo esta encargado de validar que los campos Compra/Venta, Titulos y Precio sean en
   * formato correcto antes de enviarse al store VALIDA_EQUITIES.
   *
   * @param validaCapVO Bean con la info a validar
   * @return Error En caso de ocurrir un error manda la cadena de error, de lo contrario regresa
   *     null
   * @throws Exception
   */
  private void validaValores(ValidaCapitalesVO validaCapVO) throws Exception {
    if (validaCapVO.getPs() != null && validaCapVO.getPs().trim().length() > 0) {
      if (!validaCapVO.getPs().equals("P") && !validaCapVO.getPs().equals("S")) {
        validaCapVO.setMsgError("PURCHASE/SALE INVALIDO.");
      }
    } else {
      validaCapVO.setMsgError("PURCHASE/SALE INVALIDO.");
    }

    if (validaCapVO.getOrigqtyCarga() != null
        && validaCapVO.getOrigqtyCarga().trim().length() > 0) {
      validaCapVO.setOrigqtyCarga(validaCapVO.getOrigqtyCarga().replace('´', ','));
      if (!validaCapVO.getOrigqtyCarga().equals("0.0")) {
        if (Formateador.dobleSeguro(validaCapVO.getOrigqtyCarga()) == 0.0) {
          validaCapVO.setMsgError("CANTIDAD DE TITULOS NO VÁLIDA.");
        }
      }
    } else {
      // validaCapVO.setMsgError("CANTIDAD DE TITULOS NO VÁLIDA.");
    }
    if (validaCapVO.getPriceCarga() != null && validaCapVO.getPriceCarga().trim().length() > 0) {
      if (Formateador.dobleSeguro(validaCapVO.getPriceCarga()) == 0.0) {
        validaCapVO.setMsgError("PRECIO NO VÁLIDO.");
      }
    }

    if (validaCapVO.getPriceIndCarga() != null
        && validaCapVO.getPriceIndCarga().trim().length() > 0) {
      if (!validaCapVO.getPriceIndCarga().equals("L")
          && !validaCapVO.getPriceIndCarga().equals("M")) {
        validaCapVO.setMsgError("INDICADOR DE PRECIO NO VALIDO");
      }
    } else {
      validaCapVO.setMsgError("INDICADOR DE PRECIO NO VALIDO");
    }
    validaCapVO.setOrigqty(new BigDecimal(Formateador.dobleSeguro(validaCapVO.getOrigqtyCarga())));
    /* Se comenta esta linea porque solo son operaciones a precio de mercado */
    validaCapVO.setPrice(new BigDecimal(Formateador.dobleSeguro(validaCapVO.getPriceCarga())));
    // validaCapVO.setPrice(null);
    log.info(
        "*************************************************PRICE LIMIT********************************:     |"
            + validaCapVO.getPriceIndCarga()
            + "|");
    if (validaCapVO.getPriceIndCarga().equals("L")) {
      validaCapVO.setPriceLimit(1);
    } else {
      validaCapVO.setPriceLimit(0);
    }
  }
 /**
  * Metodo encargado de poblar el bean que sera procesado por el store SPP_PROCESA_EQUITIES.
  *
  * @param procesaVO Bean a poblar
  * @param cargaJson Bean con la informacion origen
  * @throws Exception Arroja una excepcion si ocurre un error
  */
 private void populaBeanProcesar(
     final CargaMasivaVO cargaVO, final CargaMasivaJson cargaJson, final String formatoFecha)
     throws Exception {
   cargaVO.setBranchId(cargaJson.getBranchId());
   cargaVO.setAccount(cargaJson.getAccount());
   cargaVO.setCno(cargaJson.getCno());
   cargaVO.setTrad(cargaJson.getTrad());
   cargaVO.setOper(cargaJson.getOper());
   cargaVO.setPs(cargaJson.getPs());
   cargaVO.setCcy(cargaJson.getCcy());
   cargaVO.setOrigQty(preadminService.toBigDecimal(cargaJson.getOrigqty()));
   cargaVO.setSecid(cargaJson.getSecid());
   cargaVO.setCouponNo(cargaJson.getCouponNo());
   cargaVO.setSeries(cargaJson.getSeries());
   cargaVO.setSymbolid(cargaJson.getSymbolid());
   cargaVO.setOrderType(cargaJson.getOrderType());
   cargaVO.setBrPrcinpDate(preadminService.toDate(cargaJson.getBrPrcinpDate(), formatoFecha));
   cargaVO.setDealDate(preadminService.toDate(cargaJson.getDealDate(), formatoFecha));
   cargaVO.setHoraIni(cargaJson.getHoraIni());
   cargaVO.setHoraFin(cargaJson.getHoraFin());
   cargaVO.setPrice(preadminService.toBigDecimal(cargaJson.getPrice()));
   cargaVO.setExtPrice(
       preadminService.toBigDecimal(
           Double.toString(Formateador.dobleSeguro(cargaJson.getExtPrice()))));
   cargaVO.setCommAmt(preadminService.toBigDecimal(cargaJson.getCommAmt()));
   cargaVO.setVatAmt(preadminService.toBigDecimal(cargaJson.getVatAmt()));
   cargaVO.setCommRate(preadminService.toBigDecimal(cargaJson.getCommRate()));
   cargaVO.setVatRate(preadminService.toBigDecimal(cargaJson.getVatRate()));
   cargaVO.setShortPosInd(cargaJson.getShortPosInd());
   cargaVO.setSettDays(cargaJson.getSettDays());
   cargaVO.setPropInd(cargaJson.getPropInd());
   cargaVO.setLotInd(cargaJson.getLotInd());
   cargaVO.setTriggerPrice(preadminService.toBigDecimal(cargaJson.getTriggerPrice()));
   cargaVO.setExpirTerm(preadminService.toBigDecimal(cargaJson.getExpirTerm()));
   if (cargaJson.getPriceInd().equals("L")) {
     cargaVO.setPriceLimit(1);
   } else {
     cargaVO.setPriceLimit(0);
   }
   cargaVO.setExpirDate(preadminService.toDate(cargaJson.getExpirDate(), formatoFecha));
   cargaVO.setOrderClass(cargaJson.getOrderClass());
   cargaVO.setOrderTerm(preadminService.toBigDecimal(cargaJson.getOrderTerm()));
   cargaVO.setCitizFlag(cargaJson.getCitizFlag());
   cargaVO.setBrokOper(cargaJson.getBrokOper());
   cargaVO.setPort(cargaJson.getPort());
   cargaVO.setCtpeId(cargaJson.getCtpeId());
   cargaVO.setInitTime(cargaJson.getIniTime());
   cargaVO.setEndTime(cargaJson.getEndTime());
   cargaVO.setOrderInst(cargaJson.getOrderInst());
   cargaVO.setBranchId(cargaJson.getBranchId());
   cargaVO.setType(cargaJson.getType());
   cargaVO.setPorcentaje(preadminService.toBigDecimal(cargaJson.getPorcentaje()));
   cargaVO.setPriceInd(cargaJson.getPriceInd());
   cargaVO.setStatus(cargaJson.getStatus());
   cargaVO.setFileName(cargaJson.getFileName());
 }
Beispiel #3
0
  // 'Luis Gachuz, 29/Mar/2003
  // 'Modificaciòn para recibir el nuevo paràmetro ic_Trad
  public final RespuestaFondosVO calculaMontoFondos(
      final ParFondosVO fondosVO, final SantanderSecurityContext sc) throws Exception {
    /*
     * '15032002 GSP.
     * Calcula el monto de la operación si se proporcionan los títulos
     * 'Se regresa una cadena con el monto calculado
     */

    String rateCode = "";
    String strCountry = "";
    String strFundPrice = "";
    String icCon = "";
    String branch = "";
    String ctaContrato = "";
    String user = "";
    String vatrate = "";
    double dblComision = 0.0;
    double dblIva = 0.0;
    double dblMontoBruto = 0.0;
    double dblMontoNeto = 0.0;
    double dblCalcQty = 0.0;
    ValidaContratoVO contratoVO = new ValidaContratoVO();
    RespuestaFondosVO clientInformationVO = new RespuestaFondosVO();
    RespuestaFondosVO issuingVO = new RespuestaFondosVO();
    RespuestaFondosVO commRateVO = new RespuestaFondosVO();
    RespuestaFondosVO respFondosVO = new RespuestaFondosVO();

    /*
     * Se llama al método de validaContrato para obtener
     * valores que se necesitan
     * pasar como parametros para otros metodos.
     */
    branch = fondosVO.getBranch();
    ctaContrato = fondosVO.getContrato();
    user = sc.getPrivilegiosUsuario().getTrad();

    contratoVO = commonDAO.validaContrato(branch, ctaContrato, user);

    icCon = contratoVO.getCno();

    /*===================================================================*/
    /*             Obtenemos la información del cliente.                 */
    /*===================================================================*/
    clientInformationVO = capturaFondosDAO.readClientInformation(icCon.trim());
    if (clientInformationVO != null) {
      if (clientInformationVO.getStatus() != 0) {
        respFondosVO.setError(String.valueOf(clientInformationVO.getStatus()));
        if (!fondosVO.isBlError()) {
          return respFondosVO;
        }
      }
    } else {
      respFondosVO.setError(
          "Error al ejecutar el Store Procedure:" + "\n" + "SPS_READ_CLIENT_INFORMATION. ");
      if (!fondosVO.isBlError()) {
        return respFondosVO;
      }
    }

    log.debug("clientInformationVO[0]" + clientInformationVO.getStrClientInfo()[0]);
    log.debug("clientInformationVO[1]" + clientInformationVO.getStrClientInfo()[1]);

    /*===================================================================*/
    /*         Obtenemos la ciudad a la que corresponde el branch.       */
    /*===================================================================*/
    strCountry = capturaFondosDAO.readBranchCountry(branch);
    if (strCountry.trim().equals("Error")) {
      respFondosVO.setError("Error al obtener la ciudad del branch.");
      if (!fondosVO.isBlError()) {
        return respFondosVO;
      }
    } else if (strCountry == null) {
      strCountry = "";
    } else {
      strCountry = strCountry.trim();
    }
    log.debug("strCountry " + strCountry);
    /*===================================================================*/
    /*                  Valida la moneda de la emisora.                  */
    /*===================================================================*/
    issuingVO = validateIssuing(fondosVO.getEmisora(), fondosVO.getMoneda());
    DatosTabulares dt = null;

    if (issuingVO.getError() == null || issuingVO.getError().trim().length() == 0) {
      dt = issuingVO.getResp();
    } else {
      respFondosVO.setError(issuingVO.getError());
      if (!fondosVO.isBlError()) {
        return respFondosVO;
      }
    }

    /*===================================================================*/
    /*             Se obtiene el precio del fondo de inversión.          */
    /*===================================================================*/
    strFundPrice = capturaFondosDAO.readFundPrice(fondosVO.getBranch(), fondosVO.getEmisora());

    if (strFundPrice.trim().equals("Error")) {
      log.debug("No se encontro el precio del Fondo de Inversión.");
      respFondosVO.setError(ErrorKeys.ERR_NO_ENCONTRO_PRECIO_FONDO);
      if (!fondosVO.isBlError()) {
        return respFondosVO;
      }
    } else if (strFundPrice == null) {
      strFundPrice = "";
    }

    log.debug("strFundPrice " + strFundPrice);

    String ccode = "";

    if (clientInformationVO.getStrClientInfo()[1] != null) {
      ccode = clientInformationVO.getStrClientInfo()[1].trim();
    }

    /*===================================================================*/
    /*                          Obtenemos el IVA                         */
    /*===================================================================*/
    vatrate =
        capturaFondosDAO.getClientesVatRate(
            fondosVO.getBranch(), fondosVO.getContrato(), contratoVO.getCno(), ccode, strCountry);

    log.debug("==== vatrate " + vatrate);

    if (vatrate == null) {
      vatrate = "";
      // vatrate = "10";
    } else if (vatrate.trim().equals("Error")) {
      respFondosVO.setError("Error al ejecutar el Store Procedure SPS_OBTIENE_IVA.");
      if (!fondosVO.isBlError()) {
        return respFondosVO;
      }
    }
    // 'Luis Gachuz, 29/Mar/2003
    // 'Se le envìan nuevos paràmetros ic_Secid, ic_Trad
    /*===================================================================*/
    /*                      Obtenemos la comision.                       */
    /*===================================================================*/

    String product;
    String prodType;

    if (dt == null) {
      product = "";
      prodType = "";
    } else {
      product = dt.get(0, colProduct).toString().trim();
      prodType = dt.get(0, colProdType).toString().trim();
    }

    log.debug("product " + product);
    log.debug("prodType " + prodType);
    log.debug("Vatrate " + vatrate);

    commRateVO =
        capturaFondosDAO.getClientCommission(
            sc,
            fondosVO.getBranch(),
            fondosVO.getContrato(),
            product,
            prodType,
            rateCode,
            fondosVO.getTitulos(),
            fondosVO.getMonto(),
            vatrate,
            fondosVO.getCompraVenta(),
            fondosVO.getEmisora(),
            fondosVO.getPromotor());
    if (commRateVO != null) {
      if (commRateVO.getStatus() != 0 || commRateVO.getError() != null) {
        respFondosVO.setError(commRateVO.getError());
        if (!fondosVO.isBlError()) {
          return respFondosVO;
        }
      }
    } else {
      commRateVO.setOnCommrate(null);
    }

    log.debug("IVA " + commRateVO.getOnCommrate());
    /*===================================================================*/
    /*                         Se calcula el monto                       */
    /*===================================================================*/
    double fundPrice = 0;
    double dblCommrate = 0;
    double dblVatrate = 0;

    if (!strFundPrice.equals("") && !strFundPrice.equals("Error")) {
      fundPrice = Double.parseDouble(strFundPrice);
    }
    if (commRateVO.getOnCommrate() != null) {
      dblCommrate = Double.parseDouble(commRateVO.getOnCommrate());
    }
    if (!vatrate.equals("") && !vatrate.equals("Error")) {
      dblVatrate = Double.parseDouble(vatrate);
    }

    if (fondosVO.getTitulos() != 0) {
      dblComision = Math.abs((fondosVO.getTitulos() * fundPrice * dblCommrate) / 100);
      dblComision = Formateador.formatoDouble(dblComision, fondosVO.getDecimalsMoneda()) * (-1);
      dblIva = ((dblComision * dblVatrate) / 100);
      dblIva = Formateador.formatoDouble(dblIva, fondosVO.getDecimalsMoneda());
      dblMontoBruto =
          Formateador.formatoDouble(
              (fondosVO.getTitulos() * fundPrice), fondosVO.getDecimalsMoneda());
      dblMontoNeto = dblMontoBruto + dblComision + dblIva;
      dblCalcQty = fondosVO.getTitulos();

      log.debug("dblComision " + dblComision);
      log.debug("dblIva " + dblIva);
      log.debug("dblMontoBruto " + dblMontoBruto);
      log.debug("dblCalcQty " + dblCalcQty);

    } else if (fondosVO.getMonto() != 0) {
      if (fondosVO.getCompraVenta().equals("P")) {
        dblCalcQty =
            (fondosVO.getMonto()
                    / (fundPrice * (1 + dblCommrate / 100 + dblCommrate / 100 * dblVatrate / 100)))
                * (-1);
      } else {
        dblCalcQty =
            (fondosVO.getMonto()
                / (fundPrice * (1 - dblCommrate / 100 - dblCommrate / 100 * dblVatrate / 100))
                * (-1));
      }
      dblComision = Math.abs((dblCalcQty * fundPrice * dblCommrate) / 100);
      dblComision = Formateador.formatoDouble(dblComision, fondosVO.getDecimalsMoneda()) * (-1);
      dblIva = (dblComision * dblVatrate) / 100;
      dblIva = Formateador.formatoDouble(dblIva, fondosVO.getDecimalsMoneda());
      dblMontoBruto = (dblCalcQty * fundPrice) * (-1);
      dblMontoBruto = Formateador.formatoDouble(dblMontoBruto, fondosVO.getDecimalsMoneda());
      dblMontoNeto = dblMontoBruto + dblComision + dblIva;
    }

    dblComision = Math.abs(dblComision);

    /* Se debe formatear dblMontoNeto al
     * número de decimales de la moneda. */
    respFondosVO.setDblMontoNeto(
        Formateador.formatoDouble(dblMontoNeto, fondosVO.getDecimalsMoneda()));

    log.debug("dblMontoNeto VO " + respFondosVO.getDblMontoNeto());

    return respFondosVO;
  }
Beispiel #4
0
  /**
   * Método para hacer una operación de un fondo de inversión.
   *
   * @param fondosVO Parametros para hacer la validación de la operación que se desea realizar.
   * @param sc Contexto de seguridad.
   * @param efectivoVO Parametros para hacer operaciones de Efectivo
   * @return RespuestaFondosVO Regresa los valores que se muestran en la pantalla de confirmación ó
   *     el número de operación.
   * @throws Exception Encaso de que ocurra un error.
   */
  public final RespuestaFondosVO procesamientoDatosFondos(
      final ParFondosVO fondosVO,
      final SantanderSecurityContext sc,
      final ParametrosEfectivoVO efectivoVO)
      throws Exception {

    String brContrato = "";
    String ctaContrato = "";
    String user = "";
    String contrapartesCom = "";
    String contrapartesIva = "";
    String perfil = "";

    ValidaContratoVO contratoVO = new ValidaContratoVO();
    RespuestaFondosVO respFondosVOConf = new RespuestaFondosVO();
    RespuestaFondosVO respProcesaFondos = new RespuestaFondosVO();
    RespuestaFondosVO respFondos = new RespuestaFondosVO();

    brContrato = fondosVO.getBranch();
    ctaContrato = fondosVO.getContrato();
    user = sc.getPrivilegiosUsuario().getTrad();

    contrapartesCom = getCommonService().contrapartes(brContrato, "COMM");
    contrapartesIva = getCommonService().contrapartes(brContrato, "IVA");

    /*
    if (contrapartesCom.equals("") || contrapartesIva.equals("")) {
    			log.debug("No se encontrarón definiciones"
    					+ " de las contrapartes para el sistema.");
    		}
    */

    try {
      contratoVO = commonDAO.validaContrato(brContrato, ctaContrato, user);

      respFondosVOConf =
          capturaFondosDAO.procesaFondosConfirmacion(
              fondosVO.getBranch(),
              fondosVO.getContrato(),
              contratoVO.getCno(),
              fondosVO.getEmisora(),
              fondosVO.getMoneda(),
              fondosVO.getMonto(),
              fondosVO.getTitulos(),
              fondosVO.getCompraVenta(),
              fondosVO.getFechaProc(),
              fondosVO.getPromotor(),
              contratoVO.getNostrovostro(),
              sc);

      if (respFondosVOConf != null) {

        if ((respFondosVOConf.getError() == null
                || respFondosVOConf.getError().trim().length() == 0)
            && respFondosVOConf.getStatus() == 0) {

          int decimales = fondosVO.getDecimalsMoneda();
          String strDec = "";
          for (int iter = 0; iter < decimales; iter++) {
            strDec = strDec + "0";
          }
          String pattern = "#,###,##0." + strDec;

          // Compra / Venta
          if (respFondosVOConf.getCompraVenta().equals("S")) {
            respFondos.setCompraVenta("Venta");
          } else {
            respFondos.setCompraVenta("Compra");
          }
          // Emisora
          respFondos.setEmisora(respFondosVOConf.getEmisora());
          // Moneda
          respFondos.setMoneda(respFondosVOConf.getMoneda());
          // Titulos
          respFondos.setStrCalcQty(
              Formateador.format(String.valueOf(respFondosVOConf.getDblCalcQty()), pattern));
          // Precio
          String patternPrice = "#,###,##0.########";
          respFondos.setStrFundPrice(
              Formateador.format(String.valueOf(respFondosVOConf.getStrFundPrice()), patternPrice));
          // Monto Neto
          // Se valida regla: Importes inferiores a 100,000
          Integer montoValue = Mensajes.MAX_MONTO_DEFAULT;
          if (capturaCapitalesDAO != null) {
            montoValue = capturaCapitalesDAO.getMontoInferior();
          }
          if (fondosVO.getEjecucion() != null
              && Ejecucion.formatString(fondosVO.getEjecucion())
                  .equalsIgnoreCase(Ejecucion.formatString(Ejecucion.EXCEPCIONES.getName()))
              && (montoUnsigned(respFondosVOConf.getDblMontoNeto()) >= montoValue)) {
            if (fondosVO.getBranch() == null
                || fondosVO.getContrato() == null
                || !capturaCapitalesDAO.isContratoDiscrecional(
                    fondosVO.getBranch(), fondosVO.getContrato())) {
              if (respFondos.getCompraVenta().equals("Venta")
                  || respFondosVOConf.getEmisora() == null
                  || respFondosVOConf.getEmisora().equals("")
                  || !capturaCapitalesDAO.existEmisora(respFondosVOConf.getEmisora())) {
                String serr = Mensajes.ERR_EJECUCION;
                log.error(serr);
                respFondos.setError(serr);
                throw new CondicionesInconsistentesException(respFondos.getError());
              }
            }
          }
          respFondos.setStrMontoNeto(
              Formateador.format(String.valueOf(respFondosVOConf.getDblMontoNeto()), pattern));
          // Porcentaje Comisión.
          if (!respFondosVOConf.getOnCommrate().equals("")) {
            respFondos.setOnCommrate(
                Formateador.formatCCY(respFondosVOConf.getOnCommrate(), decimales));
          } else {
            respFondos.setOnCommrate("0.00");
          }
          // Comisión
          String strComision = String.valueOf(respFondosVOConf.getDblComision());
          if (!strComision.equals("")) {
            respFondos.setStrComision(Formateador.formatCCY(strComision, decimales));
          } else {
            respFondos.setStrComision("0.00");
          }
          // IVA
          String strIva =
              Formateador.stringWithOutComma(String.valueOf(respFondosVOConf.getDblIva()));
          if (!strIva.equals("")) {
            respFondos.setStrIva(Formateador.formatCCY(strIva, decimales));
          } else {
            respFondos.setStrIva("0.00");
          }
          // Fecha de liquidación
          if (respFondosVOConf.getSettDate() != null) {
            respFondos.setFechaLiq(
                Formateador.formateaFechaDisplay(respFondosVOConf.getSettDate()));
          } else {
            respFondos.setFechaLiq("");
          }
          // Plazo de permanencia
          respFondos.setOcMinTerms(respFondosVOConf.getOcMinTerms());
          // Fecha de recompra
          if (respFondosVOConf.getExpirdate() != null) {
            respFondos.setFechaExpira(FechaUtils.dateToString(respFondosVOConf.getExpirdate()));
          } else {
            respFondos.setFechaExpira("");
          }
          // Producto.
          if (respFondosVOConf.getOcProduct() != null) {
            respFondos.setOcProduct(respFondosVOConf.getOcProduct());
          } else {
            respFondos.setOcProduct("");
          }
          // Tipo de Producto.
          if (respFondosVOConf.getOcProdType() != null) {
            respFondos.setOcProdType(respFondosVOConf.getOcProdType());
          } else {
            respFondos.setOcProdType("");
          }

          /*
           * Perfil.
           */
          perfil =
              getCommonService()
                  .validaPerfilContrato(
                      fondosVO.getBranch(),
                      fondosVO.getContrato(),
                      getCommonService().MDO_FONDOS,
                      fondosVO.getMoneda(),
                      fondosVO.getEmisora(),
                      fondosVO.getMonto(),
                      "", // Producto
                      "", // TipoProducto
                      getCommonService().CICLO_ANTES_DE_VALIDAR,
                      null);

          log.debug("Perfil '" + perfil + "'");

          respFondos.setPerfil(perfil);

        } else if (respFondosVOConf.getStatus() != 0) {
          log.debug("Status en respFondosVOConf");
          respFondos.setStatus(respFondosVOConf.getStatus());
          return respFondos; // ANZ OCT 2011
          // ANZ OCT 2011. Se comenta para que no mande Exception
          // throw new CondicionesInconsistentesException(
          //		String.valueOf(respFondos.getStatus()));
        } else {
          log.debug("Mensaje de error en respFondosVOConf " + respFondosVOConf.getError());
          respFondos.setError(respFondosVOConf.getError());
          return respFondos; // ANZ OCT 2011
          // ANZ OCT 2011. Se comenta para que no mande Exception
          // throw new CondicionesInconsistentesException(
          //		respFondos.getError());
        }

        /*
         * Se ejecuta cuando se le da click en aceptar
         * a la pantalla de Confirmación.
         */

        if (fondosVO.isConfirmacion()) {
          respProcesaFondos =
              capturaFondosDAO.procesaFondos(
                  fondosVO, contratoVO, respFondosVOConf, contrapartesCom, contrapartesIva, sc);
          if (respProcesaFondos != null) {
            if ((respProcesaFondos.getError() == null
                    || respProcesaFondos.getError().trim().length() == 0)
                && respProcesaFondos.getStatus() == 0) {
              respFondos.setOperacion(respProcesaFondos.getOperacion());
              log.info("Número de operación " + respProcesaFondos.getOperacion());

              /** Bitacora */
              log.debug("Bitacora " + fondosVO.getBitacora());
              getBitacoraService()
                  .registraFondos(
                      respProcesaFondos.getOperacion(),
                      fondosVO.getBranch(),
                      fondosVO.getBitacora(),
                      fondosVO.getEjecucion(),
                      fondosVO.getFolio(),
                      null,
                      FCBitacoraService.MODO_NUEVA_OPERACION,
                      sc);

              if (fondosVO.isEfectivo()) {
                RespuestaDepRet respbean = new RespuestaDepRet();
                try {
                  efectivoVO.setOperacion(respFondos.getOperacion().trim());
                  log.info(
                      "Entre a la operacion de efectivo. Operacion="
                          + efectivoVO.getOperacion()
                          + "; datos para efectivo ="
                          + efectivoVO.getDataList());
                  log.info("COMENZANDO A PROCESAR EFECTIVO");

                  respbean = capturaEfectivoService.procesaEfectivo(efectivoVO, sc);
                  respFondos.setOperacionEfe(respbean.getSemfyield());
                } catch (Exception e) {
                  String serr = "No se termino la operación " + "de fondos con efectivo";
                  if (e instanceof CondicionesInconsistentesException) {
                    log.error(serr, e);
                    respFondos.setError(e.getMessage());
                    throw new CondicionesInconsistentesException(respFondos.getError());
                  } else {
                    log.error(serr, e);
                    respFondos.setError(ErrorKeys.ERR_EFECTIVO);
                    throw new CondicionesInconsistentesException(respFondos.getError());
                  }
                }
              }

            } else if (respProcesaFondos.getStatus() != 0) {
              respFondos.setStatus(respProcesaFondos.getStatus());
              return respFondos; // ANZ OCT 2011
              // ANZ OCT 2011. Se comenta para que no mande Exception
              // throw new CondicionesInconsistentesException(
              //		String.valueOf(respFondos.getStatus()));
            } else {
              respFondos.setError(respProcesaFondos.getError());
              return respFondos; // ANZ OCT 2011
              // ANZ OCT 2011. Se comenta para que no mande Exception
              // throw new CondicionesInconsistentesException(
              //		respFondos.getError());
            }
          }
        }
      }
    } catch (Exception e) {
      log.error("ERROR", e);
      respFondos.setError(ErrorKeys.ERR_EFECTIVO);
      if (e instanceof CondicionesInconsistentesException) {
        throw e;
      } else {
        throw new CondicionesInconsistentesException(ErrorKeys.ERR_EFECTIVO);
      }
    }
    return respFondos;
  }