Agrega el detalle de item de la liquidación
423034
def AgregarItemDetalle(self, cuit_cliente, cod_categoria, tipo_liquidacion,
                           cantidad, precio_unitario, alicuota_iva, cod_raza,
                           cantidad_cabezas=None, nro_tropa=None, 
                           cod_corte=None, cantidad_kg_vivo=None,
                           precio_recupero=None, detalle_raza=None,
                           nro_item=None,
                           **kwargs):
        ""
        d = {'cuitCliente': cuit_cliente,
             'codCategoria': cod_categoria,
             'tipoLiquidacion': tipo_liquidacion, 
             'cantidad': cantidad,
             'precioUnitario': precio_unitario, 
             'alicuotaIVA': alicuota_iva, 
             'cantidadCabezas': cantidad_cabezas, 
             'raza': {'codRaza': cod_raza, 'detalle': detalle_raza}, 
             'nroTropa': nro_tropa, 
             'codCorte': cod_corte, 
             'cantidadKgVivo': cantidad_kg_vivo, 
             'precioRecupero': precio_recupero,
             'liquidacionCompraAsociada': [],
             'nroItem': nro_item,
            }
        self.solicitud['itemDetalleLiquidacion'].append(d)
        return True
614300
public function agregarGalleta($nombre, $valor, $expira = 0, $camino = '/', $dominio = null, $seguro = false, $soloHttp = false)
    {
        $extras = '';
        if ($expira) {
            $extras .= ';Expires=' . gmdate('D, d M Y H:i:s \G\M\T', $expira);
        }
        if ($camino) {
            $extras .= ';Path=' . $camino;
        }
        if ($dominio) {
            $extras .= ';Domain=' . $dominio;
        }
        if ($seguro) {
            $extras .= ';Secure';
        }
        if ($soloHttp) {
            $extras .= ';HttpOnly';
        }

        $this->agregarCabecera('Set-Cookie', "{$nombre}={$valor}{$extras}");
    }
1334167
def AjustarLiquidacion(self):
        ""
        
        # renombrar la clave principal de la estructura
        if 'liquidacion' in self.solicitud:
            liq = self.solicitud.pop('liquidacion')
            self.solicitud["liquidacionAjuste"] = liq
        
        # llamar al webservice:
        ret = self.client.ajustarLiquidacion(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        solicitud=self.solicitud,
                        )
        # analizo la respusta
        ret = ret['respuesta']
        self.__analizar_errores(ret)
        liqs = ret.get('liquidacion', [])
        liq = liqs[0] if liqs else None
        self.AnalizarLiquidacion(liq)
        return True
721404
function removeThis()
    {
        $exportItems = $this->fetchItems();

        $db = eZDB::instance();
        $db->begin();
        foreach ( $exportItems as $item )
        {
            $item->remove();
        }
        $this->remove();
        $db->commit();
    }
1301160
public function reverseTransaction($buyOrder) {

        try {

            $oneClickReverseInput = new oneClickReverseInput();

            $oneClickReverseInput->buyorder = $buyOrder;

            $codeReverseOneClickResponse = $this->_codeReverseOneClick(
                    array("oneClickReverseInput" => $oneClickReverseInput)
            );

            /** Validación de firma del requerimiento de respuesta enviado por Webpay */
            $xmlResponse = $this->soapClient->__getLastResponse();
            $soapValidation = new SoapValidation($xmlResponse, $this->config->getWebpayCert());
            $validationResult = $soapValidation->getValidationResult();

            if ($validationResult === TRUE) {

                $oneClickReverseOutput = $codeReverseOneClickResponse->return;
                return $oneClickReverseOutput;

            } else {

                $error["error"] = "Error validando conexi&oacute;n a Webpay (Verificar que la informaci&oacute;n del certificado sea correcta)";
                $error["detail"] = "No se pudo completar la conexi&oacute;n con Webpay";
            }

        } catch (\Exception $e) {

            $error["error"] = "Error conectando a Webpay (Verificar que la informaci&oacute;n del certificado sea correcta)";

            $replaceArray = array('<!--' => '', '-->' => '');
            $error["detail"] = str_replace(array_keys($replaceArray), array_values($replaceArray), $e->getMessage());

        }
    }
550123
public function getResumen()
    {
        $totales = [];
        // agregar resumen de detalles
        foreach ($this->detalles as &$d) {
            if (!isset($totales[$d['TpoDoc']])) {
                $totales[$d['TpoDoc']] = array_merge($this->total_default, ['TpoDoc'=>$d['TpoDoc']]);
            }
            // contabilizar cantidad de documentos y montos (exento, neto, iva y total)
            $totales[$d['TpoDoc']]['TotDoc']++;
            $totales[$d['TpoDoc']]['TotMntExe'] += $d['MntExe'];
            $totales[$d['TpoDoc']]['TotMntNeto'] += $d['MntNeto'];
            if (!empty($d['MntIVA'])) {
                $totales[$d['TpoDoc']]['TotMntIVA'] += $d['MntIVA'];
            }
            $totales[$d['TpoDoc']]['TotMntTotal'] += $d['MntTotal'];
            // contabilizar documentos anulados
            if (!empty($d['Anulado']) and $d['Anulado']=='A') {
                $totales[$d['TpoDoc']]['TotAnulado']++;
            }
            // si hay activo fijo se contabiliza
            if (!empty($d['MntActivoFijo'])) {
                $totales[$d['TpoDoc']]['TotMntActivoFijo'] += $d['MntActivoFijo'];
            }
            if (!empty($d['MntIVAActivoFijo'])) {
                $totales[$d['TpoDoc']]['TotMntIVAActivoFijo'] += $d['MntIVAActivoFijo'];
            }
            // si hay iva no recuperable se contabiliza
            if (!empty($d['IVANoRec'])) {
                foreach ($d['IVANoRec'] as $IVANoRec) {
                    if (!isset($totales[$d['TpoDoc']]['TotIVANoRec'][$IVANoRec['CodIVANoRec']])) {
                        $totales[$d['TpoDoc']]['TotIVANoRec'][$IVANoRec['CodIVANoRec']] = [
                            'CodIVANoRec' => $IVANoRec['CodIVANoRec'],
                            'TotOpIVANoRec' => 0,
                            'TotMntIVANoRec' => 0,
                        ];
                    }
                    $totales[$d['TpoDoc']]['TotIVANoRec'][$IVANoRec['CodIVANoRec']]['TotOpIVANoRec']++;
                    $totales[$d['TpoDoc']]['TotIVANoRec'][$IVANoRec['CodIVANoRec']]['TotMntIVANoRec'] += $IVANoRec['MntIVANoRec'];
                }
            }
            // si hay IVA de uso común se contabiliza
            if (!empty($d['FctProp'])) {
                $totales[$d['TpoDoc']]['TotIVAUsoComun'] += $d['IVAUsoComun'];
                $totales[$d['TpoDoc']]['FctProp'] = $d['FctProp']/100;
                $totales[$d['TpoDoc']]['TotCredIVAUsoComun'] += round($d['IVAUsoComun'] * ($d['FctProp']/100));
                unset($d['FctProp']); // se quita el factor de proporcionalidad del detalle ya que no es parte del XML
            }
            // contabilizar IVA fuera de plazo
            if (!empty($d['IVAFueraPlazo'])) {
                $totales[$d['TpoDoc']]['TotIVAFueraPlazo'] += $d['IVAFueraPlazo'];
            }
            // si hay otro tipo de impuesto se contabiliza
            if (!empty($d['OtrosImp'])) {
                foreach ($d['OtrosImp'] as $OtrosImp) {
                    if (!isset($totales[$d['TpoDoc']]['TotOtrosImp'][$OtrosImp['CodImp']])) {
                        $totales[$d['TpoDoc']]['TotOtrosImp'][$OtrosImp['CodImp']] = [
                            'CodImp' => $OtrosImp['CodImp'],
                            'TotMntImp' => 0,
                        ];
                    }
                    $totales[$d['TpoDoc']]['TotOtrosImp'][$OtrosImp['CodImp']]['TotMntImp'] += $OtrosImp['MntImp'];
                }
            }
            // contabilizar impuesto sin derecho a crédito
            if (!empty($d['MntSinCred'])) {
                $totales[$d['TpoDoc']]['TotImpSinCredito'] += $d['MntSinCred'];
            }
            // contabilidad IVA retenido total
            if (!empty($d['IVARetTotal'])) {
                $totales[$d['TpoDoc']]['TotIVARetTotal'] += $d['IVARetTotal'];
            }
            // contabilizar IVA retenido parcial
            if (!empty($d['IVARetParcial'])) {
                $totales[$d['TpoDoc']]['TotIVARetParcial'] += $d['IVARetParcial'];
            }
            // contabilizar IVA no retenido
            if (!empty($d['IVANoRetenido'])) {
                $totales[$d['TpoDoc']]['TotIVANoRetenido'] += $d['IVANoRetenido'];
            }
            // contabilidar impuesto vehículos
            if (!empty($d['ImpVehiculo'])) {
                $totales[$d['TpoDoc']]['TotImpVehiculo'] += $d['ImpVehiculo'];
            }
        }
        // agregar resumenes pasados que no se hayan generado por los detalles
        foreach ($this->resumen as $tipo => $resumen) {
            if (!isset($totales[$tipo])) {
                $totales[$tipo] = array_merge($this->total_default, $resumen);
            }
        }
        // entregar resumen
        ksort($totales);
        return $totales;
    }
739481
public function remove()
    {
        $key = $this->request->param('ID');
        $title = "";

        if (!empty($key)) {
            foreach ($this->items as $item) {
                if ($item->Key == $key) {
                    $title = $item->Title;
                    $this->items->remove($item);
                }
            }

            $this->save();
            
            if ($title) {
                $this->setSessionMessage(
                    "bad",
                    _t(
                        "Checkout.RemovedItem",
                        "Removed '{title}' from your cart",
                        "Message to tell user they removed an item",
                        array("title" => $title)
                    )
                );
            }
        }

        return $this->redirectBack();
    }
365278
protected function agregarSubTotal(array $detalle, $x = 10) {
        $subtotal = 0;
        if (!isset($detalle[0])) {
            $detalle = [$detalle];
        }
        foreach($detalle as  &$d) {
            if (!empty($d['MontoItem'])) {
                $subtotal += $d['MontoItem'];
            }
        }
        if ($this->papelContinuo) {
            $this->Texto('Subtotal: '.$this->num($subtotal), $x);
        } else {
            $this->Texto('Subtotal:', 77, null, 'R', 100);
            $this->Texto($this->num($subtotal), 177, null, 'R', 22);
        }
        $this->Ln();
    }
652757
def AsociarLiquidacionSecundariaAContrato(self, coe=None, nro_contrato=None, 
                                          cuit_comprador=None, 
                                          cuit_vendedor=None,
                                          cuit_corredor=None,
                                          cod_grano=None,
                                    **kwargs):
        ""
        
        ret = self.client.lsgAsociarAContrato(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        nroContrato=nro_contrato,
                        cuitComprador=cuit_comprador,
                        cuitVendedor=cuit_vendedor,
                        cuitCorredor=cuit_corredor,
                        codGrano=cod_grano,
                        )
        ret = ret['oReturn']
        self.__analizar_errores(ret)
        if 'liquidacion' in ret:
            # analizo la respusta
            liq = ret['liquidacion']
            aut = ret['autorizacion']
            self.AnalizarLiquidacion(aut, liq)
        return True
205336
def AgregarAjusteFisico(self, cantidad, cantidad_cabezas=None, 
                            cantidad_kg_vivo=None, **kwargs):
        ""
        d = {'cantidad': cantidad,
             'cantidadCabezas': cantidad_cabezas, 
             'cantidadKgVivo': cantidad_kg_vivo, 
            }
        item_liq = self.solicitud['itemDetalleAjusteLiquidacion'][-1]
        item_liq['ajusteFisico'] = d
        return True
1328371
public function orderItemRemoveAction(Request $request)
    {
        $session = $request->getSession();

        $productOrderService = $this->get("amulen.shop.order");
        $productOrderItemService = $this->get("amulen.shop.order.item");

        $productOrderId = $session->get('productOrderId');
        $productOrder = $productOrderService->getProductOrder($productOrderId);
        if (!$productOrderId || !$productOrder) {
            /* No hay order en session redirect a listado de productos */
            return $this->redirectToRoute('products_index');
        }
        if ($itemId = $request->get('item')) {
            $item = $productOrderItemService->findById($itemId);
            $productOrderItemService->delete($item);
            $productOrder->removeItem($item);
            $productOrderService->update($productOrder);
            $productOrderService->updateOrderAmount($productOrder);
        }

        $session->set('productOrderCount', $productOrder->getItemTotalCount());

        return $this->redirectToRoute('order');
    }
480618
def AgregarPercepcion(self, codigo_concepto=None, detalle_aclaratoria=None,
                               base_calculo=None, alicuota=None, importe_final=None,
                               **kwargs):
        ""
        # liquidación secundaria (sin importe final)
        self.percepciones.append(dict(
                                percepcion=dict(
                                    detalleAclaratoria=detalle_aclaratoria,
                                    baseCalculo=base_calculo,
                                    alicuota=alicuota,
                                    importeFinal=importe_final,
                                ))
                        )            
        return True
1190504
function capture($authorizationCode, $captureAmount, $buyOrder) {

        try {

            $CaptureInput = new CaptureInput();

            /** Código de autorización de la transacción que se requiere capturar */
            $CaptureInput->authorizationCode = $authorizationCode; // string

            /** Orden de compra de la transacción que se requiere capturar */
            $CaptureInput->buyOrder = $buyOrder; // string

            /** Monto que se desea capturar */
            $CaptureInput->captureAmount = $captureAmount; // decimal

            /** Código de comercio o tienda mall que realizó la transacción */
            $CaptureInput->commerceId = floatval($this->config->getCommerceCode());

            $captureResponse = $this->_capture(
                array("captureInput" => $CaptureInput)
            );

            /** Validación de firma del requerimiento de respuesta enviado por Webpay */
            $xmlResponse = $this->soapClient->__getLastResponse();
            $soapValidation = new SoapValidation($xmlResponse, $this->config->getWebpayCert());
            $validationResult = $soapValidation->getValidationResult();

            /** Valida conexion a Webpay */
            if ($validationResult === TRUE) {

                $wsCaptureOutput = $captureResponse->return;
                return $wsCaptureOutput;

            } else {
                $error["error"] = "Error validando conexión a Webpay";
                $error["error"] = "No se pudo completar la conexión con Webpay";
            }
        } catch (\Exception $e) {

            $error["error"] = "Error conectando a Webpay (Verificar que la informaci&oacute;n del certificado sea correcta)";

            $replaceArray = array('<!--' => '', '-->' => '');
            $error["detail"] = str_replace(array_keys($replaceArray), array_values($replaceArray), $e->getMessage());

        }

        return $error;
    }
673569
function getDetalleAsistenciaSala (asistenciaGeneral, senador, periodo) {
  assert.equal(typeof asistenciaGeneral, 'object', '[senadores-asistencia]: La asistencia general ingresada debe ser un objeto.')
  assert.equal(typeof senador, 'object', '[senadores-asistencia]: El senador general ingresada debe ser un objeto.')
  assert.equal(typeof periodo, 'object', '[senadores-asistencia]: El periodo general ingresada debe ser un objeto.')

  let url = URL_ASISTENCIA_SALA_DETALLE.replace(/:periodo:/, periodo.legislatura)
  url = url.replace(/:senador-id:/, senador.id)

  return scraperjs.StaticScraper.create()
    .get(url)
    .scrape($ => {
      const detalle = $('table:last-child tr:not(:first-child)').map(function () {
        const str = $(this).find('td:last-child a').text()
        // console.log(str, periodo)
        const data = str.match(/(-{0,1}\d*) ([\s\S]*), [\s\S]* (\d*) de (\w*) de (\d*)/)
        const sesion = data[1]
        const tipo = data[2]
                      // año, mes, día
        const fecha = new Date(parseInt(data[5]), clMonthToMonth(data[4]), parseInt(data[3]))
        const asiste = $(this).find('td:first-child').has('img').length > 0
        return {
          sesion,
          tipo,
          fecha,
          asiste
        }
      }).get()
      return Object.assign(asistenciaGeneral, { detalle })
    })
}
1120
protected function processOfferAfterDelete()
    {
        $obOfferList = $this->obElement->offer;
        if ($obOfferList->isEmpty()) {
            return;
        }

        foreach ($obOfferList as $obOffer) {
            $obOffer->active = false;
            $obOffer->save();
        }
    }
1308392
def CrearLiqSecundariaBase(self, pto_emision=1, nro_orden=None, 
            nro_contrato=None,
            cuit_comprador=None, nro_ing_bruto_comprador=None,
            cod_puerto=None, des_puerto_localidad=None, 
            cod_grano=None, cantidad_tn=None,
            cuit_vendedor=None, nro_act_vendedor=None,  # nuevo!!
            nro_ing_bruto_vendedor=None,
            actua_corredor=None, liquida_corredor=None, cuit_corredor=None,
            nro_ing_bruto_corredor=None, 
            fecha_precio_operacion=None, precio_ref_tn=None,
            precio_operacion=None, alic_iva_operacion=None, campania_ppal=None,
            cod_localidad_procedencia=None, cod_prov_procedencia=None,
            datos_adicionales=None,
            **kwargs):
        ""
 
        # creo el diccionario con los campos generales de la liquidación:
        self.liquidacion = dict(
            ptoEmision=pto_emision, nroOrden=nro_orden,
            numeroContrato=nro_contrato or None, cuitComprador=cuit_comprador, 
            nroIngBrutoComprador=nro_ing_bruto_comprador,
            codPuerto=cod_puerto, desPuertoLocalidad=des_puerto_localidad,
            codGrano=cod_grano, cantidadTn=cantidad_tn,
            cuitVendedor=cuit_vendedor, nroActVendedor=nro_act_vendedor,
            nroIngBrutoVendedor=nro_ing_bruto_vendedor,
            actuaCorredor=actua_corredor, liquidaCorredor=liquida_corredor,
            cuitCorredor=cuit_corredor or None, 
            nroIngBrutoCorredor=nro_ing_bruto_corredor or None,
            fechaPrecioOperacion=fecha_precio_operacion,
            precioRefTn=precio_ref_tn, precioOperacion=precio_operacion,
            alicIvaOperacion=alic_iva_operacion or None, 
            campaniaPPal=campania_ppal,
            codLocalidad=cod_localidad_procedencia, 
            codProvincia=cod_prov_procedencia,
            datosAdicionales=datos_adicionales,
            )
        # inicializo las listas que contentran las retenciones y deducciones:
        self.deducciones = []
        self.percepciones = []
        self.opcionales = []
        self.factura_papel = None
        return True
1062581
def AgregarDeduccion(self, codigo_concepto=None, detalle_aclaratorio=None,
                               dias_almacenaje=None, precio_pkg_diario=None,
                               comision_gastos_adm=None, base_calculo=None,
                               alicuota=None, **kwargs):
        ""
        # limpiar campo según validación (comision_gastos_adm puede ser 0.00!)
        if codigo_concepto != "CO" and comision_gastos_adm is not None \
            and float(comision_gastos_adm) == 0:
            comision_gastos_adm = None
        # no enviar campos para prevenir errores AFIP 1705, 1707, 1708
        if base_calculo is not None:
            if codigo_concepto == "AL":
                base_calculo = None
            if codigo_concepto == "CO" and float(base_calculo) == 0:
                base_calculo = None         # no enviar, por retrocompatibilidad
        if codigo_concepto != "AL":
            dias_almacenaje = None
            precio_pkg_diario = None
        self.deducciones.append(dict(
                                    deduccion=dict(
                                        codigoConcepto=codigo_concepto,
                                        detalleAclaratorio=detalle_aclaratorio,
                                        diasAlmacenaje=dias_almacenaje,
                                        precioPKGdiario=precio_pkg_diario,
                                        comisionGastosAdm=comision_gastos_adm,
                                        baseCalculo=base_calculo,
                                        alicuotaIva=alicuota, 
                                    ))
                            )
        return True