Método que realiza la firma del DTE cedido
@param Firma objeto que representa la Firma Electrónca
@return =true si el DTE pudo ser fimado o =false si no se pudo firmar
@author Esteban De La Fuente Rubio, DeLaF (esteban[at]sasco.cl)
@version 2016-12-10
19827
public function firmar(\sasco\LibreDTE\FirmaElectronica $Firma)
    {
        $xml = $Firma->signXML($this->xml, '#LibreDTE_DTECedido', 'DocumentoDTECedido');
        if (!$xml) {
            \sasco\LibreDTE\Log::write(
                \sasco\LibreDTE\Estado::DTE_ERROR_FIRMA,
                \sasco\LibreDTE\Estado::get(\sasco\LibreDTE\Estado::DTE_ERROR_FIRMA, '#LibreDTE_DTECedido')
            );
            return false;
        }
        $this->xml = $xml;
        return true;
    }
1028957
def AgregarCompraAsociada(self, tipo_cbte, pto_vta, nro_cbte, cant_asoc, nro_item):
        ""
        d = {'tipoComprobante': tipo_cbte, 
             'puntoVenta': pto_vta,
             'nroComprobante': nro_cbte, 
             'nroItem': nro_item,
             'cantidadAsociada': cant_asoc}
        if 'itemDetalleLiquidacion' in self.solicitud:
            item_liq = self.solicitud['itemDetalleLiquidacion'][-1]
            item_liq['liquidacionCompraAsociada'].append(d)
        else:
            item_liq = self.solicitud['itemDetalleAjusteLiquidacion'][-1]
            item_liq['ajusteCompraAsociada'].append(d)
        return True
501806
public function filaAtendimento(
        Unidade $unidade,
        Usuario $usuario,
        array $servicosUsuario,
        $tipoFila = self::TIPO_TODOS,
        $maxResults = 0
    ) {
        $ids = [];
        foreach ($servicosUsuario as $servico) {
            if ($servico->getUsuario()->getId() === $usuario->getId()) {
                $ids[]   = $servico->getServico()->getId();
            }
        }
        
        if (empty($ids)) {
            return [];
        }
        
        $builder = $this
            ->builder()
            ->join(
                ServicoUsuario::class,
                'servicoUsuario',
                'WITH',
                'servicoUsuario.servico = servico AND servicoUsuario.usuario = :usuario'
            )
            ->andWhere('(atendimento.usuario IS NULL OR atendimento.usuario = :usuario)')
            ->andWhere('atendimento.status = :status')
            ->andWhere('atendimento.unidade = :unidade')
            ->andWhere('servico.id IN (:servicos)');
        
        // se nao atende todos, filtra pelo tipo de atendimento
        switch ($tipoFila) {
            case self::TIPO_NORMAL:
            case self::TIPO_PRIORIDADE:
                $s = ($tipoFila === self::TIPO_NORMAL) ? '=' : '>';
                $where = "prioridade.peso $s 0";
                $builder->andWhere($where);
                break;
            case self::TIPO_AGENDAMENTO:
                $builder->andWhere("atendimento.dataAgendamento IS NOT NULL");
                break;
        }
        
        $params = [
            'status'   => AtendimentoService::SENHA_EMITIDA,
            'unidade'  => $unidade,
            'usuario'  => $usuario,
            'servicos' => $ids,
        ];
        
        $this->applyOrders($builder, $unidade, $usuario);

        $query = $builder
            ->setParameters($params)
            ->getQuery();

        if ($maxResults > 0) {
            $query->setMaxResults($maxResults);
        }

        return $query->getResult();
    }
457861
public function tryToLogin($formData)
    {
        $login    = array_key_exists($this->loginColumn, $formData) ? trim($formData[$this->loginColumn])
                : '';
        $password = array_key_exists($this->passwordColumn, $formData) ? trim($formData[$this->passwordColumn])
                : '';
        if (!$login) {
            $this->addStatusMessage(_('missing login'), 'error');

            return;
        }
        if (!$password) {
            $this->addStatusMessage(_('missing password'), 'error');

            return;
        }

        $result = $this->kontakt->authenticate($login, $password);
        if ($result === true) {
            $this->kontakt->defaultUrlParams['detail'] = 'full';
            $contactId                                 = $this->kontakt->loadFromFlexiBee([
                $this->loginColumn => $login]);
            if (is_array($contactId)) {
                $this->addStatusMessage(sprintf(_('Multiplete ContactID'),
                        serialize($contactId)), 'warning');
                $contactId = current($contactId);
                $this->addStatusMessage(_('Using the first one'));
            }

            $firma = $this->kontakt->getDataValue('firma');
            $this->adresar->loadFromFlexiBee(['id' => $firma]);

            $this->addStatusMessage($firma.' '.$this->adresar->getDataValue('nazev'));

            $result = $this->loginSuccess();
        }
        return $result;
    }
257117
def AnalizarAjusteCredito(self):
        ""
        liq = {}
        if hasattr(self, "liquidacion") and self.liquidacion:
            liq.update(self.liquidacion)
        if hasattr(self, "ajuste") and 'ajusteCredito' in self.ajuste:
            liq.update(self.ajuste['ajusteCredito'])
        if self.__ajuste_credito:
            liq.update(self.__ajuste_credito)
            self.AnalizarLiquidacion(aut=self.__ajuste_credito, liq=liq, ajuste=True)
            self.AnalizarAjuste(self.__ajuste_base, base=False)  # datos generales
        return True
790097
def AjustarLiquidacionContrato(self):
        ""
        
        # limpiar arrays no enviados:
        if not self.ajuste['ajusteBase']['certificados']:
            del self.ajuste['ajusteBase']['certificados']
        for k1 in ('ajusteCredito', 'ajusteDebito'):
            for k2 in ('retenciones', 'deducciones'):
                if not self.ajuste[k1][k2]:
                    del self.ajuste[k1][k2]

        ret = self.client.liquidacionAjustarContrato(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        **self.ajuste
                        )
        ret = ret['ajusteContratoReturn']
        self.__analizar_errores(ret)
        if 'ajusteContrato' in ret:
            aut = ret['ajusteContrato']
            self.AnalizarAjuste(aut)
        return True
464600
public function isMultiton($identifier)
    {
        $result = false;
        $class  = $this->getClass($identifier);

        if($class) {
            $result = array_key_exists(__NAMESPACE__.'\ObjectMultiton', class_implements($class));
        }

        return $result;

    }
377264
def ConsultarTipoCertificadoDeposito(self, sep="||"):
        ""
        ret = self.client.tipoCertificadoDepositoConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoCertDepReturn']
        self.__analizar_errores(ret)
        array = ret.get('tiposCertDep', [])
        return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
690353
public function isOk()
    {
        if (null === $this->multiplicity) {
            return false;
        }
        $relName = $this->relationName;
        if (null === $relName || !is_string($relName) || empty($relName)) {
            return false;
        }
        $keyField = $this->keyField;
        if (null === $keyField || !is_string($keyField) || empty($keyField)) {
            return false;
        }
        $baseType = $this->baseType;
        if (null === $baseType || !is_string($baseType) || empty($baseType)) {
            return false;
        }
        $targType = $this->targType;
        if ($this instanceof AssociationStubMonomorphic && null === $targType) {
            return false;
        }
        if (null !== $targType && (!is_string($targType) || empty($targType))) {
            return false;
        }
        $foreignField = $this->foreignField;
        if (null !== $targType && (null === $foreignField || !is_string($foreignField) || empty($foreignField))) {
            return false;
        }
        return (null === $targType) === (null === $foreignField);
    }
386904
public function ejecutar()
    {
        // Validamos la sentencia a ejecutar
        if (empty($this->sentencia)) {
            if ($this->arrojarExcepciones) {
                throw new \InvalidArgumentException('La sentencia a ejecutar se encuentra vacia.');
            }

            return false;
        }

        // Ejecutamos la sentencia
        $resultado = $this->pdo->exec($this->sentencia);

        if ($resultado === false) {
            if ($this->arrojarExcepciones) {
                $error_info = $this->pdo->errorInfo();
                throw new Excepcion($error_info[2], [
                    'sentencia' => $this->sentencia,
                    'error_codigo' => $error_info[0],
                ], $error_info[1]);
            }

            return false;
        }

        return $resultado;
    }
852592
public static function getContribuyentes(\sasco\LibreDTE\FirmaElectronica $Firma, $ambiente = null, $dia = null)
    {
        // solicitar token
        $token = \sasco\LibreDTE\Sii\Autenticacion::getToken($Firma);
        if (!$token)
            return false;
        // definir ambiente y servidor
        $ambiente = self::getAmbiente($ambiente);
        $servidor = self::$config['servidor'][$ambiente];
        // preparar consulta curl
        $curl = curl_init();
        $header = [
            'User-Agent: Mozilla/4.0 (compatible; PROG 1.0; LibreDTE)',
            'Referer: https://'.$servidor.'.sii.cl/cvc/dte/ee_empresas_dte.html',
            'Cookie: TOKEN='.$token,
            'Accept-Encoding' => 'gzip, deflate, sdch',
        ];
        $dia = $dia===null ? date('Ymd') : str_replace('-', '', $dia);
        $url = 'https://'.$servidor.'.sii.cl/cvc_cgi/dte/ce_empresas_dwnld?NOMBRE_ARCHIVO=ce_empresas_dwnld_'.$dia.'.csv';
        curl_setopt($curl, CURLOPT_HTTPHEADER, $header);
        curl_setopt($curl, CURLOPT_URL, $url);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        // si no se debe verificar el SSL se asigna opción a curl, además si
        // se está en el ambiente de producción y no se verifica SSL se
        // generará un error de nivel E_USER_NOTICE
        if (!self::$verificar_ssl) {
            if ($ambiente==self::PRODUCCION) {
                $msg = Estado::get(Estado::ENVIO_SSL_SIN_VERIFICAR);
                \sasco\LibreDTE\Log::write(Estado::ENVIO_SSL_SIN_VERIFICAR, $msg, LOG_WARNING);
            }
            curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
        }
        // realizar consulta curl
        $response = curl_exec($curl);
        if (!$response)
            return false;
        // cerrar sesión curl
        curl_close($curl);
        // entregar datos del archivo CSV
        ini_set('memory_limit', '1024M');
        $lines = explode("\n", $response);
        $n_lines = count($lines);
        $data = [];
        for ($i=1; $i<$n_lines; $i++) {
            $row = str_getcsv($lines[$i], ';', '');
            unset($lines[$i]);
            if (!isset($row[5]))
                continue;
            for ($j=0; $j<6; $j++)
                $row[$j] = trim($row[$j]);
            $row[1] = utf8_decode($row[1]);
            $row[4] = strtolower($row[4]);
            $row[5] = strtolower($row[5]);
            $data[] = $row;
        }
        return $data;
    }
1355144
def CTGsPendientesResolucion(self):
        ""
        ret = self.client.CTGsPendientesResolucion(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                            ))['response']
        self.__analizar_errores(ret)
        if ret:
            self.DatosCTG = ret
            return True
        else:
            self.DatosCTG = {}
        return False
814802
def AutorizarLiquidacion(self):
        ""
        
        # limpio los elementos que no correspondan por estar vacios:
        if not self.liquidacion['certificados']:
            del self.liquidacion['certificados']
        if not self.retenciones:
            self.retenciones = None
        if not self.deducciones:
            self.deducciones = None
        if not self.percepciones:
            self.percepciones = None
        else:
            # ajustar los nombres de campos que varian entre LPG y LSG
            for it in self.percepciones:
                per = it['percepcion']
                per['descripcion'] = per.pop("detalleAclaratoria")
                del per['baseCalculo']
                del per['alicuota']
        
        # llamo al webservice:
        ret = self.client.liquidacionAutorizar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        liquidacion=self.liquidacion,
                        retenciones=self.retenciones,
                        deducciones=self.deducciones,
                        percepciones=self.percepciones,
                        )

        # analizo la respusta
        ret = ret['liqReturn']
        self.__analizar_errores(ret)
        self.AnalizarLiquidacion(ret.get('autorizacion'), self.liquidacion)
        return True
456323
def LeerDatosCTG(self, clave='', pop=True):
        ""
                
        if clave and self.DatosCTG:
            # obtengo la lista por estado pendiente de resolución ("array")
            datos = self.DatosCTG[clave]
        else:
            # uso directamente la lista devuelta por la consulta
            datos = self.DatosCTG
        if datos:
            # extraigo el primer item
            if pop:
                datos = datos.pop(0)
            else:
                datos = datos[0]
            for det in ('datosConsultarCTG', 'detalleConsultaCTGRechazado', 
                          'detalleConsultaCTGActivo'):
                if det in datos:
                    datos_ctg = datos[det]
                    break
            else:
                # elemento del array no encontrado:
                return ""
            self.CartaPorte = str(datos_ctg['cartaPorte'])
            self.NumeroCTG = str(datos_ctg['ctg'])
            self.Estado = unicode(datos_ctg.get('estado', ""))
            self.ImprimeConstancia = str(datos_ctg.get('imprimeConstancia', ""))
            for campo in ("fechaRechazo", "fechaEmision", "fechaSolicitud",
                          "fechaConfirmacionArribo"):
                if campo in datos_ctg:
                    self.FechaHora = str(datos_ctg.get(campo))
            self.Destino = datos_ctg.get("destino", "")
            self.Destinatario = datos_ctg.get("destinatario", "")
            self.Observaciones = datos_ctg.get("observaciones", "")
            self.Patente = datos_ctg.get("patente")
            self.PesoNeto = datos_ctg.get("pesoNeto")
            self.FechaVencimiento = datos_ctg.get("fechaVencimiento")
            self.UsuarioSolicitante = datos_ctg.get("usuarioSolicitante")
            self.UsuarioReal = datos_ctg.get("usuarioReal")
            self.CtcCodigo = datos_ctg.get("ctcCodigo")
            self.Turno = datos_ctg.get("turno")
            return self.NumeroCTG
        else:
            return ""
1100390
public static function create($obj)
    {
        $nomeTabela        = FuncoesReflections::pegaNomeClasseObjeto($obj);
        $atributosTabela   = FuncoesReflections::pegaAtributosDoObjeto($obj);
        $annotationsTabela = Annotations::getAnnotation($obj);
        $arrFormatado      = [];
        $stringSql = "C" . "REATE TABLE IF NOT EXISTS `" . strtolower($nomeTabela) . "` (";

        for ($i = 0; $i < count($atributosTabela); $i++) {

            $stringSql .= $atributosTabela[$i] . " ";
            for ($j = 0; $j < count($annotationsTabela[$atributosTabela[$i]]); $j++) {

                $arrAtual = explode("=", $annotationsTabela[$atributosTabela[$i]][$j]);
                for ($k = 0; $k < count($arrAtual) - 1; $k++) {
                    $arrFormatado[FuncoesString::substituiOcorrenciasDeUmaString($arrAtual[$k], "@_", "")] = $arrAtual[$k + 1];
                }
            }
            if (array_key_exists('type', $arrFormatado)) {
                $stringSql .= " " . $arrFormatado['type'] . "";

            } else {
                $stringSql .= "";
            }

            if (array_key_exists('size', $arrFormatado)) {
                if ($arrFormatado['size'] != 'none') {
                    $stringSql .= "(" . $arrFormatado['size'] . ") ";
                }

            } else {
                $stringSql .= "";
            }

            /**
             * @todo NOT NULL AQUI
             */

            if (array_key_exists('notNull', $arrFormatado)) {
                if ($arrFormatado['notNull'] === "true") {
                    $stringSql .= " NOT NULL ";
                } else {
                    $stringSql .= "";
                };
            } else {
                $stringSql .= "";
            }

            if (array_key_exists('primaryKey', $arrFormatado)) {
                if ($arrFormatado['primaryKey'] === "true") {
                    $stringSql .= " PRIMARY KEY ";
                } else {
                    $stringSql .= "";
                };
            } else {
                $stringSql .= "";
            }

            if (array_key_exists('autoIncrement', $arrFormatado)) {
                if ($arrFormatado['autoIncrement'] === "true") {
                    $stringSql .= " AUTO_INCREMENT ";
                } else {
                    $stringSql .= "";
                };
            } else {
                $stringSql .= "";
            }

            if ($i != count($atributosTabela) - 1) {

                $stringSql .= " , ";
            }
        }

        $stringSql .= ") ENGINE = InnoDB;";
        
        echo $stringSql;
        if (JsonReader::read(BASE_DIR . "/phiber_config.json")->phiber->code_sync == 1 ? true : false) {
            $pdo = self::getConnection()->prepare($stringSql);
            if ($pdo->execute()) {
                return true;
            };
        } else {
            return $stringSql;
        }
        
        return false;
    }
916240
def CrearAjusteBase(self, 
               pto_emision=1, nro_orden=None,       # unificado, contrato, papel
               coe_ajustado=None,                   # unificado
               nro_contrato=None,                   # contrato
               tipo_formulario=None,                # papel
               nro_formulario=None,                 # papel
               actividad=None,                      # contrato / papel
               cod_grano=None,                      # contrato / papel
               cuit_vendedor=None,                  # contrato / papel
               cuit_comprador=None,                 # contrato / papel
               cuit_corredor=None,                  # contrato / papel
               nro_ing_bruto_vendedor=None,         # papel
               nro_ing_bruto_comprador=None,        # papel
               nro_ing_bruto_corredor=None,         # papel
               tipo_operacion=None,                 # papel
               precio_ref_tn=None,                  # contrato
               cod_grado_ent=None,                  # contrato
               val_grado_ent=None,                  # contrato
               precio_flete_tn=None,                # contrato
               cod_puerto=None,                     # contrato
               des_puerto_localidad=None,           # contrato
               cod_provincia=None,                  # unificado, contrato, papel
               cod_localidad=None,                  # unificado, contrato, papel
               comision_corredor=None,              # papel
               **kwargs
               ):
        ""

        # ajusto nombre de campos para compatibilidad hacia atrás (encabezado):
        if 'cod_localidad_procedencia' in kwargs:
            cod_localidad = kwargs['cod_localidad_procedencia']
        if 'cod_provincia_procedencia' in kwargs:
            cod_provincia = kwargs['cod_provincia_procedencia']
        if 'nro_act_comprador' in kwargs:
            actividad = kwargs['nro_act_comprador']
        if 'cod_tipo_operacion' in kwargs:
            tipo_operacion = kwargs['cod_tipo_operacion']
            
        # limpio los campos especiales (segun validaciones de AFIP)
        if val_grado_ent == 0:
            val_grado_ent = None
        # borrando datos si no corresponden
        if cuit_corredor and int(cuit_corredor) == 0:
            cuit_corredor = None
            comision_corredor = None
            nro_ing_bruto_corredor = None
               
        if cod_puerto and int(cod_puerto) != 14:
            des_puerto_localidad = None             # validacion 1630

        # limpio los campos opcionales para no enviarlos si no corresponde:
        if cod_grado_ent == "":
            cod_grado_ent = None
        if val_grado_ent == 0:
            val_grado_ent = None

        # creo el diccionario con los campos generales del ajuste base:
        self.ajuste = { 'ajusteBase': {
                            'ptoEmision': pto_emision,
                            'nroOrden': nro_orden,
                            'coeAjustado': coe_ajustado,
                            'nroContrato': nro_contrato,
                            'tipoFormulario': tipo_formulario,
                            'nroFormulario': nro_formulario,
                            'actividad': actividad,
                            'codGrano': cod_grano,
                            'cuitVendedor': cuit_vendedor,
                            'cuitComprador': cuit_comprador,
                            'cuitCorredor': cuit_corredor,
                            'nroIngBrutoVendedor': nro_ing_bruto_vendedor,
                            'nroIngBrutoComprador': nro_ing_bruto_comprador,
                            'nroIngBrutoCorredor': nro_ing_bruto_corredor,
                            'tipoOperacion': tipo_operacion,
                            'codPuerto': cod_puerto,
                            'desPuertoLocalidad': des_puerto_localidad,
                            'comisionCorredor': comision_corredor,
                            'precioRefTn': precio_ref_tn,
                            'codGradoEnt': cod_grado_ent,
                            'valGradoEnt': val_grado_ent,
                            'precioFleteTn': precio_flete_tn,
                            'codLocalidad': cod_localidad,
                            'codProv': cod_provincia,
                            'certificados': [],
                            }
                        }
        # para compatibilidad con AgregarCertificado
        self.liquidacion = self.ajuste['ajusteBase']
        # inicializar temporales
        self.__ajuste_base = None
        self.__ajuste_debito = None
        self.__ajuste_credito = None
        return True
740529
def AutorizarAnticipo(self):
        ""

        # extraer y adaptar los campos para el anticipo
        anticipo = {"liquidacion": self.liquidacion}
        liq = anticipo["liquidacion"] 
        liq["campaniaPpal"] = self.liquidacion["campaniaPPal"]
        liq["codLocProcedencia"] = self.liquidacion["codLocalidadProcedencia"]
        liq["descPuertoLocalidad"] = self.liquidacion["desPuertoLocalidad"]
        
        if self.opcionales:
            liq['opcionales'] = self.opcionales

        if self.retenciones:
            anticipo['retenciones'] = self.retenciones

        if self.deducciones:
            anticipo['deducciones'] = self.deducciones
        
        # llamo al webservice:
        ret = self.client.lpgAutorizarAnticipo(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        anticipo=anticipo,
                        )

        # analizo la respusta
        ret = ret['liqReturn']
        self.__analizar_errores(ret)
        self.AnalizarLiquidacion(ret.get('autorizacion'), self.liquidacion)
        return True