Guarda los datos de la sesión actual para luego cerrarla.
490642
public function escribirCerrar()
    {
        if (!$this->iniciado) {
            throw new \RuntimeException('La sesión no fue iniciada previamente.');
        }

        if (!$this->adaptador->escribir($this->id, $this->datos)) {
            throw new \RuntimeException('Hubo un error escribiendo la sesión.');
        }

        $this->adaptador->cerrar();
        $this->iniciado = false;

        return true;
    }
529104
private function normalizar_transporte(array &$datos)
    {
        if (!empty($datos['Encabezado']['Transporte'])) {
            $datos['Encabezado']['Transporte'] = array_merge([
                'Patente' => false,
                'RUTTrans' => false,
                'Chofer' => false,
                'DirDest' => false,
                'CmnaDest' => false,
                'CiudadDest' => false,
                'Aduana' => false,
            ], $datos['Encabezado']['Transporte']);
        }
    }
578023
def ConsultarCTGActivosPorPatente(self, patente="ZZZ999"):
        ""
        ret = self.client.consultarCTGActivosPorPatente(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        patente=patente,
                            ))['response']
        self.__analizar_errores(ret)
        datos = ret.get('arrayConsultarCTGActivosPorPatenteResponse')
        if datos:
            self.DatosCTG = datos
            self.LeerDatosCTG(pop=False)
            return True
        else:
            self.DatosCTG = []
        return False
62469
def analisar(retorno):
        
        resposta = analisar_retorno(forcar_unicode(retorno),
                funcao='EnviarDadosVenda',
                classe_resposta=RespostaCancelarUltimaVenda,
                campos=(
                        ('numeroSessao', int),
                        ('EEEEE', unicode),
                        ('CCCC', unicode),
                        ('mensagem', unicode),
                        ('cod', unicode),
                        ('mensagemSEFAZ', unicode),
                        ('arquivoCFeBase64', unicode),
                        ('timeStamp', as_datetime),
                        ('chaveConsulta', unicode),
                        ('valorTotalCFe', Decimal),
                        ('CPFCNPJValue', unicode),
                        ('assinaturaQRCODE', unicode),
                    ),
                campos_alternativos=[
                        # se a venda falhar apenas os primeiros seis campos
                        # especificados na ER deverão ser retornados...
                        (
                                ('numeroSessao', int),
                                ('EEEEE', unicode),
                                ('CCCC', unicode),
                                ('mensagem', unicode),
                                ('cod', unicode),
                                ('mensagemSEFAZ', unicode),
                        ),
                        # por via das dúvidas, considera o padrão de campos,
                        # caso não haja nenhuma coincidência...
                        RespostaSAT.CAMPOS,
                    ]
            )
        if resposta.EEEEE not in ('07000',):
            raise ExcecaoRespostaSAT(resposta)
        return resposta
1330418
def AnularCTG(self, carta_porte, ctg):
        ""
        response = self.client.anularCTG(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        datosAnularCTG={
                            'cartaPorte': carta_porte,
                            'ctg': ctg, }))['response']
        datos = response.get('datosResponse')
        self.__analizar_errores(response)
        if datos:
            self.CartaPorte = str(datos['cartaPorte'])
            self.NumeroCTG = str(datos['ctg'])
            self.FechaHora = str(datos['fechaHora'])
            self.CodigoOperacion = str(datos['codigoOperacion'])
1310831
def Buscar(self, nro_doc, tipo_doc=80):
        ""
        # cuit: codigo único de identificación tributaria del contribuyente
        #       (sin guiones)
        self.cursor.execute("SELECT * FROM padron WHERE "
                            " tipo_doc=? AND nro_doc=?", [tipo_doc, nro_doc])
        row = self.cursor.fetchone()
        for key in [k for k, l, t, d in FORMATO]:
            if row:
                val = row[key]
                if not isinstance(val, basestring):
                    val = str(row[key])
                setattr(self, key, val)
            else:
                setattr(self, key, '')
        if self.tipo_doc == 80:
            self.cuit = self.nro_doc
        elif self.tipo_doc == 96:
            self.dni = self.nro_doc
        # determinar categoría de IVA (tentativa)
        try:
            cat_iva = int(self.cat_iva)
        except ValueError:
            cat_iva = None
        if cat_iva:
            pass
        elif self.imp_iva in ('AC', 'S'):
            self.cat_iva = 1  # RI
        elif self.imp_iva == 'EX':
            self.cat_iva = 4  # EX
        elif self.monotributo:
            self.cat_iva = 6  # MT
        else:
            self.cat_iva = 5  # CF
        return True if row else False
877542
public function getResultados()
    {
        if (!$this->esResultadoDTE())
            return false;
        // si no hay respustas se deben crear
        if (!$this->respuesta_documentos) {
            // si no está creado el arrelgo con los datos error
            if (!$this->arreglo) {
                return false;
            }
            // crear repuestas a partir del arreglo
            $Resultados = $this->arreglo['RespuestaDTE']['Resultado']['ResultadoDTE'];
            if (!isset($Resultados[0]))
                $Resultados = [$Resultados];
            foreach ($Resultados as $Resultado) {
                $this->respuesta_documentos[] = $Resultado;
            }
        }
        // entregar recibos
        return $this->respuesta_documentos;
    }
1120274
def ConsultarCTGRechazados(self):
        ""
        ret = self.client.consultarCTGRechazados(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                            ))['response']
        self.__analizar_errores(ret)
        datos = ret.get('arrayConsultarCTGRechazados')
        if datos:
            self.DatosCTG = datos
            self.LeerDatosCTG(pop=False)
            return True
        else:
            self.DatosCTG = []
        return False
646706
def LeerDatosLiquidacion(self, pop=True):
        ""
        
        if self.DatosLiquidacion:
            # extraigo el primer item
            if pop:
                datos_liq = self.DatosLiquidacion.pop(0)
            else:
                datos_liq = self.DatosLiquidacion[0]
            self.COE = str(datos_liq['coe'])
            self.Estado = unicode(datos_liq.get('estado', ""))
            return self.COE
        else:
            return ""
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
314118
def leer(linea, formato, expandir_fechas=False):
    ""
    dic = {}
    comienzo = 1
    for fmt in formato:    
        clave, longitud, tipo = fmt[0:3]
        dec = (len(fmt)>3 and isinstance(fmt[3], int)) and fmt[3] or 2
        valor = linea[comienzo-1:comienzo-1+longitud].strip()
        try:
            if chr(8) in valor or chr(127) in valor or chr(255) in valor:
                valor = None        # nulo
            elif tipo == N:
                if valor:
                    valor = long(valor)
                else:
                    valor = 0
            elif tipo == I:
                if valor:
                    try:
                        if '.' in valor:
                                valor = float(valor)
                        else:
                            valor = valor.strip(" ")
                            if valor[0] == "-":
                                sign = -1
                                valor = valor[1:] 
                            else:
                                sign = +1
                            valor = sign * float(("%%s.%%0%sd" % dec) % (long(valor[:-dec] or '0'), int(valor[-dec:] or '0')))
                    except ValueError:
                        raise ValueError("Campo invalido: %s = '%s'" % (clave, valor))
                else:
                    valor = 0.00
            elif expandir_fechas and clave.lower().startswith("fec") and longitud <= 8:
                if valor:
                    valor = "%s-%s-%s" % (valor[0:4], valor[4:6], valor[6:8])
                else:
                    valor = None
            else:
                valor = valor.decode("ascii","ignore")
            if not valor and clave in dic and len(linea) <= comienzo:
                pass    # ignorar - compatibilidad hacia atrás (cambios tamaño)
            else:
                dic[clave] = valor
            comienzo += longitud
        except Exception, e:
            raise ValueError("Error al leer campo %s pos %s val '%s': %s" % (
                clave, comienzo, valor, str(e)))
    return dic
826775
public function run()
    {
        DB::table('ctrystore_administrative_areas')->delete();

        $today = date('Y-m-d H:i:s');
        $data = [
            ['name' => 'Tarapacá', 'code' => 'TA', 'tag' => 'I'],
            ['name' => 'Antofagasta', 'code' => 'AN', 'tag' => 'II'],
            ['name' => 'Atacama', 'code' => 'AT', 'tag' => 'III'],
            ['name' => 'Coquimbo', 'code' => 'CO', 'tag' => 'IV'],
            ['name' => 'Valparaíso', 'code' => 'VS', 'tag' => 'V'],
            [
                'name' => "Libertador Gral. Bernardo O'higgins",
                'code' => 'LI',
                'tag' => 'VI'
            ],
            ['name' => 'Maule', 'code' => 'ML', 'tag' => 'VII'],
            ['name' => 'BioBio', 'code' => 'BI', 'tag' => 'VIII'],
            ['name' => 'Araucania', 'code' => 'AR', 'tag' => 'IX'],
            ['name' => 'Los Lagos', 'code' => 'LL', 'tag' => 'X'],
            [
                'name' => 'Aysén del Gral. Carlos Ibáñez del Campo',
                'code' => 'AI',
                'tag' => 'XI'
            ],
            ['name' => 'Magallanes', 'code' => 'MA', 'tag' => 'XII'],
            ['name' => 'Metropolitana', 'code' => 'RM', 'tag' => 'XIII'],
            ['name' => 'Los Ríos', 'code' => 'LR', 'tag' => 'XIV'],
            ['name' => 'Arica y Parinacota', 'code' => 'AP', 'tag' => 'XV'],
            ['name' => 'Ñuble', 'code' => '', 'tag' => 'XVI']
        ];

        foreach ($data as $i => $ad) {
            DB::table('ctrystore_administrative_areas')->insert([
                'id' => $i + 1,
                'country_id' => 152,
                'name' => $ad['name'],
                'code' => $ad['code'],
                'tag' => $ad['tag'],
                'admin_division_id' => 1,
                'created_at' => $today,
                'updated_at' => $today,
            ]);
        }
    }
1177701
def ConsultarOperaciones(self, sep="||"):
        ""
        ret = self.client.consultarOperaciones(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('operacion', []) + ret.get('operacionPorcina', []) 
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
1282117
function(input) {

			var temp;

			// Si no hay parámetros

			if (!arguments.length) {

				// Construimos la URL con los atributos y la devolvemos como cadena de texto

				return Public.build(this._attributes, this.location);

			// Si el parámetro es `null`

			} else if (input === null) {

				// Vaciamos los atributos

				this._attributes = {};

			// Si el parámetro es una cadena de texto o un objecto

			} else if ((temp = typeof input) === 'string' || (input && temp === 'object')) {

				// Desmontamos la URL y guardamos su información en forma de objeto

				this._attributes = Public.unbuild(input, this.location);

			}

			return this;

		}
860285
private function obtenerDatos($atributo, $valor){
        $referencia = strtolower($valor);
        $filtro = "(&($atributo=$referencia)(objectClass=$this->objeto))";
        $datos = $this->busqueda($this->cfgDominio['base'][$this->objeto], $filtro, $this->atributos);
        if (!$datos) {
            $this->existe = false;
            $this->esUnico = true;
        }elseif (count($datos) === 1 ) {
            $this->existe = true;
            $this->esUnico = true;
            $this->dnObjeto = $datos[0]['dn'];
            return $datos[0];
        }else{
            $this->esUnico = false;
            // TODO: Acaso no es acà que deberìas configurar un mensaje de error a enviar
//            throw new \ErrorException("El atributo $atributo debe ser único en el árbol LDAP");
        }
    }
344928
def ConsultarCTG(self, numero_carta_de_porte=None, numero_ctg=None, 
                     patente=None, cuit_solicitante=None, cuit_destino=None,
                     fecha_emision_desde=None, fecha_emision_hasta=None):
        ""
        ret = self.client.consultarCTG(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        consultarCTGDatos=dict(
                            cartaPorte=numero_carta_de_porte, 
                            ctg=numero_ctg,
                            patente=patente,
                            cuitSolicitante=cuit_solicitante,
                            cuitDestino=cuit_destino,
                            fechaEmisionDesde=fecha_emision_desde,
                            fechaEmisionHasta=fecha_emision_hasta,
                            )))['response']
        self.__analizar_errores(ret)
        datos = ret.get('arrayDatosConsultarCTG')
        if datos:
            self.DatosCTG = datos
            self.LeerDatosCTG(pop=False)
            return True
        else:
            self.DatosCTG = []
        return ''
683769
public function getDetalle()
    {
        if ($this->caratula['TipoOperacion']=='VENTA') {
            $omitir = [35, 38, 39, 41, 105, 500, 501, 919, 920, 922, 924];
            $detalles = [];
            foreach ($this->detalles as $d) {
                if (!in_array($d['TpoDoc'], $omitir)) {
                    $detalles[] = $d;
                }
            }
            return $detalles;
        }
        return $this->detalles;
    }