l10n-ar-api 2.8.3__py3-none-any.whl

l10n_ar_api/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import absolute_import
+from . import documents
+from . import afip_webservices
+from . import anmat_webservices
+from . import arba_webservices
+from . import presentations
+from . import padron

l10n_ar_api/afip_webservices/__init__.py

@@ -0,0 +1,8 @@
+from __future__ import absolute_import
+from . import wsaa
+from . import wsbfe
+from . import wsfe
+from . import wsfex
+from . import config
+from . import wsct
+from . import wstesimbrefiscal

l10n_ar_api/afip_webservices/config.py

@@ -0,0 +1,19 @@
+authorization_urls = dict(
+    homologation='https://wsaahomo.afip.gov.ar/ws/services/LoginCms?wsdl',
+    production='https://wsaa.afip.gov.ar/ws/services/LoginCms?wsdl',
+)
+
+service_urls = dict(
+    wstesimbrefiscal_homologation='https://wsaduhomoext.afip.gob.ar/diav2/wgestimbrefiscalelectronico/wgestimbrefiscalelectronico.asmx?WSDL',
+    wstesimbrefiscal_production='https://wswadu.afip.gob.ar/DIAV2/wgestimbrefiscalelectronico/wgestimbrefiscalelectronico.asmx?WSDL',
+    wsct_homologation='https://fwshomo.afip.gov.ar/wsct/CTService?WSDL',
+    wsct_production='https://serviciosjava.afip.gob.ar/wsct/CTService?WSDL',
+    wsbfev1_homologation='https://wswhomo.afip.gov.ar/wsbfev1/service.asmx?WSDL',
+    wsbfev1_production='https://servicios1.afip.gov.ar/wsbfev1/service.asmx?WSDL',
+    wsfev1_homologation='https://wswhomo.afip.gov.ar/wsfev1/service.asmx?wsdl',
+    wsfev1_production='https://servicios1.afip.gov.ar/wsfev1/service.asmx?wsdl',
+    wsfexv1_homologation='https://wswhomo.afip.gov.ar/wsfexv1/service.asmx?wsdl',
+    wsfexv1_production='https://servicios1.afip.gov.ar/wsfexv1/service.asmx?wsdl',
+    ws_sr_padron_a5_homologation='https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA5?WSDL',
+    ws_sr_padron_a5_production='https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA5?WSDL',
+)

l10n_ar_api/afip_webservices/ws_sr_padron/__init__.py

@@ -0,0 +1 @@
+from . import ws_sr_padron

l10n_ar_api/afip_webservices/ws_sr_padron/ws_sr_padron.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+# Segun RG 2485 – Proyecto FE v2.8 - 12/09/2016
+import sys
+sys.path.append("..")
+from zeep import Client
+from .. import config
+
+
+class InvalidIdException(Exception):
+    def __init__(self, msg):
+        super(Exception, self).__init__(msg)
+
+
+class WsSrPadron(object):
+    """
+    Consulta Padron A5.
+    
+    :param access_token: AccessToken - Token de acceso
+    :param cuit: Cuit de la empresa
+    :param homologation: Homologacion si es True
+    :param url: Url de servicios para WsSrPadron
+    """
+        
+    def __init__(self, access_token, cuit, homologation=True, url=None):
+        if not url:
+            self.url = config.service_urls.get('ws_sr_padron_a5_homologation') if homologation\
+                else config.service_urls.get('ws_sr_padron_a5_production')
+        else:
+            self.url = url
+        
+        self.accessToken = access_token
+        self.cuit = cuit
+
+    def get_partner_data(self, vat):
+        """
+        :param vat: Numero de documentos a consultar
+        :returns str: Respuesta de AFIP sobre el numero de documento
+        """
+
+        try:
+            response = Client(self.url).service.getPersona(
+                token=self.accessToken.token,
+                sign=self.accessToken.sign,
+                cuitRepresentada=self.cuit,
+                idPersona=vat
+            )
+        except Exception as e:
+            if e.args[0] == 'No existe persona con ese Id':
+                raise InvalidIdException("El numero de documento {} es inexistente.".format(vat))
+            if e.args[0] == 'El Id de la persona no es valido':
+                raise InvalidIdException("El numero de documento {} no es valido.".format(vat))
+            raise Exception(e.args[0])
+        return response

l10n_ar_api/afip_webservices/wsaa/__init__.py

@@ -0,0 +1,3 @@
+from . import certificate
+from . import tokens
+from . import wsaa

l10n_ar_api/afip_webservices/wsaa/certificate.py

@@ -0,0 +1,54 @@
+from OpenSSL import crypto
+
+
+class WsaaCertificate(object):
+
+    def __init__(self, key):
+        self.key = key
+        self.country_code = None
+        self.state_name = None
+        self.company_name = None
+        self.company_vat = None
+
+    def validate_values(self):
+        """ Validamos que esten todos los campos necesarios seteados """
+        values = vars(self)
+        for value in values:
+            if not values.get(value):
+                raise AttributeError('Falta configurar alguno de los siguientes campos:\n'
+                                     'Codigo de pais, Provincia, Nombre de la empresa o CUIT')
+
+    def generate_certificate_request(self, hash_sign='sha256', ou='odoo'):
+
+        self.validate_values()
+
+        # Utilizamos la libreria de crypto para generar el pedido de certificado
+        req = crypto.X509Req()
+        req.get_subject().C = self.country_code
+        req.get_subject().ST = self.state_name
+        req.get_subject().O = self.company_name
+        req.get_subject().OU = ou
+        req.get_subject().CN = self.company_name
+        req.get_subject().serialNumber = 'CUIT {}'.format(self.company_vat)
+
+        # Validamos el formato de la key
+        key = crypto.load_privatekey(crypto.FILETYPE_PEM, self.key)
+        self.key = crypto.dump_privatekey(crypto.FILETYPE_PEM, key)
+
+        # Firmamos con la key y el hash el certificado
+        req.set_pubkey(key)
+        req.sign(key, hash_sign)
+
+        return crypto.dump_certificate_request(crypto.FILETYPE_PEM, req)
+
+
+class WsaaPrivateKey(object):
+
+    def __init__(self, length=2048):
+        self.length = length
+        self.key = None
+
+    def generate_rsa_key(self):
+        pkey = crypto.PKey()
+        pkey.generate_key(crypto.TYPE_RSA, self.length)
+        self.key = crypto.dump_privatekey(crypto.FILETYPE_PEM, pkey)

l10n_ar_api/afip_webservices/wsaa/tokens.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+import pytz
+from datetime import datetime
+import time
+from lxml import etree
+from M2Crypto import BIO, SMIME
+import sys
+
+
+class AccessRequerimentToken(object):
+    
+    def __init__(self, service, tz=pytz.utc):
+        self._service = service
+        self._timezone = tz
+
+    def _create_tra(self):
+        """
+        uniqueId: Entero de 32 bits sin signo que junto con generationTime identifica el
+        requerimiento.
+        
+        generationTime: Momento en que fue generado el requerimiento. La tolerancia de aceptacion
+        sera de hasta 24 horas previas al requerimiento de acceso
+        
+        expirationTime: Momento en el que expira la solicitud. La tolerancia de aceptacion sera de
+        hasta 24 horas posteriores al requerimiento de acceso.  
+        
+        service: Identificacion del WSN para el cual se solicita el TA.
+        
+        :return: Ticket de Requerimiento de Acceso
+        """
+        
+        ticket_request = etree.Element('loginTicketRequest')
+        ticket_request.set('version', '1.0')
+        header = etree.SubElement(ticket_request, 'header')
+
+        # uniqueId
+        uniqueid = etree.SubElement(header, 'uniqueId')
+        # Traemos la fecha actual
+        timestamp = int(time.mktime(datetime.now().timetuple()))
+        uniqueid.text = str(timestamp)
+        
+        # generationTime
+        # Generamos el token con media hora atrasada
+        tsgen = datetime.fromtimestamp(timestamp-1800)
+        tsgen = pytz.utc.localize(tsgen).astimezone(self.timezone)
+        gentime = etree.SubElement(header, 'generationTime')
+        gentime.text = tsgen.isoformat()    
+
+        # expirationTime
+        # El token vence 4.5 horas despues
+        tsexp = datetime.fromtimestamp(timestamp+14400)
+        tsexp = pytz.utc.localize(tsexp).astimezone(self.timezone)
+        exptime = etree.SubElement(header, 'expirationTime')
+        exptime.text = tsexp.isoformat()
+        exptime.tail = None
+
+        # service
+        serv = etree.SubElement(ticket_request, 'service')
+        serv.text = self.service
+
+        return etree.tostring(ticket_request)
+
+    def sign_tra(self, private_key, certificate):
+
+        smime = SMIME.SMIME()
+        ks = BIO.MemoryBuffer(private_key.encode('ascii'))
+        cs = BIO.MemoryBuffer(certificate.encode('ascii'))
+        bf = BIO.MemoryBuffer(self._create_tra().decode('ascii').encode('ascii'))
+        out = BIO.MemoryBuffer()
+
+        try:
+            smime.load_key_bio(ks, cs)
+        except Exception:
+            raise Exception('Error en el formato del certificado o clave privada')
+
+        sbf = smime.sign(bf)
+        smime.write(out, sbf)
+
+        head, body, end = out.read().split(b'\n\n')
+        return body
+    
+    @property
+    def service(self):
+        return self._service
+
+    @property
+    def timezone(self):
+        return self._timezone
+
+
+class AccessToken(object):
+    
+    """ Ejemplo de token:
+    
+    <?xml version="1.0" encoding="UTF8"?>
+    <loginTicketResponse version="1.0">
+    <header>
+        <source>cn=wsaa,o=afip,c=ar,serialNumber=CUIT 33693450239</source>
+        <destination>cn=srv1,ou=facturacion,o=empresa s.a.,c=ar,serialNumber=CUIT 30123456789</destination>
+        <uniqueId>383953094</uniqueId>
+        <generationTime>20011231T12:00:0203:00</generationTime>
+        <expirationTime>20020101T00:00:0203:00</expirationTime>
+    </header>
+    <credentials>
+        <token>cES0SSuWIIPlfe5/dLtb0Qeg2jQuvYuuSEDOrz+w2EnAQiEeS86gzYf7ehiU3UaYit5FRb9z/3zq</token>
+        <sign>a6QSSZBgLf0TTcktSNteeSg3qXsMVjo/F5py/Gtw7xucTrUWbsrVCdIoGE8Cm1bixpuVPlr58k6n</sign>
+    </credentials>
+    </loginTicketResponse>
+    """
+    
+    def __init__(self):
+        # Header
+        self.source = None
+        self.destination = None
+        self.uniqueId = None
+        self.generation_time = None
+        self.expiration_time = None
+
+        # Credentials
+        self.token = None
+        self.sign = None
+        
+    def create_token_from_login(self, login_fault):
+        """
+        Asigna los atributos al token desde el login
+        :param login_fault: XML con el login autorizado 
+        """
+
+        if sys.version_info[0] >= 3:
+            login_fault_tree = etree.fromstring(login_fault.encode('utf-8'))
+        else:
+            login_fault_tree = etree.fromstring(str(login_fault))
+
+        try:
+            
+            self.source = login_fault_tree.find('header/source').text
+            self.destination = login_fault_tree.find('header/destination').text
+            self.generation_time = login_fault_tree.find('header/generationTime').text
+            self.expiration_time = login_fault_tree.find('header/expirationTime').text
+            
+            self.token = login_fault_tree.find('credentials/token').text
+            self.sign = login_fault_tree.find('credentials/sign').text
+        
+        except AttributeError:
+            raise AttributeError("Error al generar el token de acceso")

l10n_ar_api/afip_webservices/wsaa/wsaa.py

@@ -0,0 +1,32 @@
+from zeep import Client
+from requests import Session
+from zeep.transports import Transport
+
+from l10n_ar_api.afip_webservices import config
+
+
+class Wsaa(object):
+
+    def __init__(self, homologation=True, url=None):
+        
+        if not url:
+            self.url = config.authorization_urls.get('homologation') if homologation\
+                else config.authorization_urls.get('production')
+        else:
+            self.url = url
+
+    def login(self, tra):
+        """
+        :param tra: TRA que se usara para el logeo
+        :return: XML con el login autorizado
+        """
+        
+        try:
+            session = Session()
+            session.verify = False
+            transport = Transport(session=session)
+            login_fault = Client(self.url, transport=transport).service.loginCms(tra)
+        except Exception as e:
+            raise Exception("Error al autenticarse\n{}".format(e))
+        
+        return login_fault

l10n_ar_api/afip_webservices/wsbfe/__init__.py

@@ -0,0 +1,3 @@
+from . import wsbfe
+from . import error
+from . import invoice

l10n_ar_api/afip_webservices/wsbfe/error.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+class AfipError:
+
+    @classmethod
+    def parse_error(cls, error):
+        return Exception("Error {}: {}".format(
+            error.BFEErr.ErrCode,
+            error.BFEErr.ErrMsg),
+        )

l10n_ar_api/afip_webservices/wsbfe/invoice.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+from l10n_ar_api.documents import invoice
+from datetime import date, datetime
+
+
+class FiscalElectronicBondValidator:
+
+    @classmethod
+    def validate_invoice(cls, invoice):
+        '''
+        Valida que los campos de la factura cumplan con los requisitos de la AFIP
+        :param invoices: Factura a validar, objeto FiscalElectronicBond
+        '''
+
+        cls._validate_document_date(invoice)
+        cls._validate_amount(invoice)
+
+    @staticmethod
+    def _validate_document_date(invoice):
+        assert invoice.document_date, "El documento no tiene fecha"
+
+        invoice_date = datetime.strptime(invoice.document_date, '%Y%m%d').date()
+
+        if abs(date.today() - invoice_date).days > 5:
+            raise AttributeError("La fecha del documento debe ser\
+                    mayor o menor a 5 dias de la fecha de generacion")
+
+        date_today = date.today().replace(day=1)
+        new_invoice_date = invoice_date.replace(day=1)
+        if date_today != new_invoice_date:
+            raise AttributeError("La fecha del documento no debe exceder el mes de la fecha de\
+                                envío del pedido de autorización")
+
+    @staticmethod
+    def _validate_amount(invoice):
+        if invoice.get_total_items_amount() > invoice.get_total_amount():
+            raise AttributeError("La Suma de los items de la factura\
+                                 debe ser menor o igual al total de la misma")
+
+class FiscalElectronicBondItem(object):
+
+    def __init__(self, codigo_prod_ncm, description, quantity = None, measurement_unit = None, unit_price = None, bonification = None, iva_id = None):
+        self.codigo_prod_ncm = codigo_prod_ncm
+        self.description = description
+        self.quantity = quantity
+        self.measurement_unit = measurement_unit
+        self.unit_price = unit_price
+        self.bonification = bonification
+        self.iva_id = iva_id
+
+    @property
+    def total_price(self):
+        assert self.quantity, "No existe cantidad para el item"
+        assert self.unit_price, "No existe precio para el item"
+
+        return (self.quantity * self.unit_price) - self.bonification
+
+
+class FiscalElectronicBond(invoice.Invoice):
+
+    def __init__(self, document_code):
+        self.zone_id = 0
+        self.reception_amount = None
+        self.municipal_reception_amount = None
+        self.array_items = []
+
+        # Cliente
+        self.customer_name = None
+        self.customer_address = None
+        self.customer_document_type = None
+        self.customer_document_number = None
+
+        # Tributos
+        self.total_amount = None
+        self.pay_off_tax_amount = None
+        self.rni_pay_off_tax_amount = None
+        self.internal_tax_amount = None
+        self.iibb_amount = None
+
+        # Moneda
+        self.mon_id = None
+        self.mon_cotiz = None
+
+        # Opcionales
+        self.array_optionals = []
+
+        # Comprobantes asociados
+        self.associated_documents = []
+
+        self._payment_due_date = None
+
+        super(FiscalElectronicBond, self).__init__(document_code)
+
+    # Override
+    def get_total_amount(self):
+        return self.total_amount
+
+    def get_total_items_amount(self):
+        return sum(item.total_price for item in self.array_items)
+
+    def add_item(self, value):
+        self.array_items.append(value)
+
+    @property
+    def document_date(self):
+        return self._document_date
+
+    @document_date.setter
+    def document_date(self, value):
+        self._document_date = value.strftime('%Y%m%d')
+
+    @property
+    def payment_due_date(self):
+        return self._payment_due_date
+
+    @payment_due_date.setter
+    def payment_due_date(self, value):
+        self._payment_due_date = value.strftime('%Y%m%d')