def _call_federation(settings: CzNiaAppSettings, transport: Transport,
assertion: Element) -> Element:
"""Call FPSTS (Federation provider) service and return the assertion."""
plugins = []
history = None
if settings.DEBUG:
history = HistoryPlugin()
plugins.append(history)
client = Client(settings.FEDERATION_WSDL,
wsse=SAMLTokenSignature(assertion),
settings=SETTINGS,
transport=transport,
plugins=plugins)
# prepare request
request_type = client.get_element(
QName(NiaNamespaces.WS_TRUST.value, 'RequestType'))
request = AnyObject(request_type,
request_type(NiaNamespaces.WS_TRUST.value + '/Issue'))
# Prepare WSA header
applies = _get_wsa_header(client, settings.PUBLIC_ADDRESS)
# Call the service
service = client.bind('SecurityTokenService',
'WS2007FederationHttpBinding_IWSTrust13Sync')
try:
response = service.Trust13Issue(_value_1=[applies, request])
except (Error, XmlsecError, RequestException) as err:
_log_history(history, settings, 'FPSTS', success=False)
raise NiaException(err)
_log_history(history, settings, 'FPSTS')
return response.RequestSecurityTokenResponse[0]['_value_1'][3]['_value_1']
def _call_submission(settings: CzNiaAppSettings, transport: Transport,
assertion, message: NiaMessage) -> bytes:
"""Call Submission service and return the body."""
plugins = []
history = None
if settings.DEBUG:
history = HistoryPlugin()
plugins.append(history)
client = Client(settings.PUBLIC_WSDL,
wsse=SAMLTokenSignature(assertion),
settings=SETTINGS,
transport=transport,
plugins=plugins)
# Prepare the Body
bodies_type = client.get_type(
QName(NiaNamespaces.SUBMISSION.value, 'ArrayOfBodyPart'))
body_part_type = client.get_type(
QName(NiaNamespaces.SUBMISSION.value, 'BodyPart'))
# Call the service
service = client.bind('Public', 'Token')
try:
response = service.Submit(
message.action,
bodies_type(body_part_type(Body={'_value_1': message.pack()})), '')
except (Error, XmlsecError, RequestException) as err:
_log_history(history, settings, 'Submission', success=False)
raise NiaException(err)
_log_history(history, settings, 'Submission')
return b64decode(response.BodyBase64XML)
class SAWSessionService():
def __init__(self, wsdl):
session = Session()
transport = Transport(session=session)
settings = Settings(xml_huge_tree=True)
self.client = Client(wsdl=wsdl, transport=transport, settings=settings)
self.service = self.client.service
def logon(self, username, password):
session_id = self.service.logon(name=username, password=password)
return session_id
def logoff(self, session_id):
self.service.logoff(session_id)
def get_current_user(self, session_id):
return self.service.getCurUser(session_id)
def get_session_environment(self, session_id):
return self.service.getSessionEnvironment(session_id)
def get_session_variable(self, names, session_id):
return self.service.getSessionVariable(names, session_id)
def impersonate(self, name, password, impersonate_id):
session_id = self.service.getSessionVariable(name, password,
impersonate_id)
return session_id
def keep_alive(self, session_id):
self.service.keepAlive(session_id)
def bind(self, service_name, port_name=None):
return self.client.bind(service_name, port_name)
def seur_soap_send(self, service, method, data):
def trace(title, data):
_logger.debug('%s %s: %s' %
(method, title, etree.tostring(data['envelope'])))
def create_rewrite_plugin(data):
key = [k for k, v in data.items() if isinstance(v, dict)]
if not key:
return RewritePlugin('//no-dict', '')
key = key[0]
if 'total_bultos' not in data[key]:
return RewritePlugin('//missing-key', '')
xml_root = etree.Element('root')
xml_exp = etree.SubElement(xml_root, 'exp')
for _index in range(int(data[key].get('total_bultos') or 1)):
package = etree.SubElement(xml_exp, 'bulto')
for k, v in data[key].items():
etree.SubElement(package, k).text = str(v or '')
xml = etree.tostring(xml_root, encoding='utf8', method='xml')
data[key] = '-RewritePlugin-'
return RewritePlugin('//*[text()="-RewritePlugin-"]', xml)
history = HistoryPlugin()
client = Client(
wsdl=self.seur_wsdl_get(service),
transport=Transport(),
plugins=[history, create_rewrite_plugin(data)],
)
cli = client.bind(service)
response = cli[method](**data)
trace('Request', history.last_sent)
trace('Response', history.last_received)
return helpers.serialize_object(response, dict)
def main(api_key, mastr_number, limit, step, start, filter_type, units_file):
wsdl = 'https://www.marktstammdatenregister.de/MaStRAPI/wsdl/mastr.wsdl'
transport = Transport(cache=SqliteCache())
settings = Settings(strict=False, xml_huge_tree=True)
client = Client(wsdl=wsdl, transport=transport, settings=settings)
client_bind = client.bind('Marktstammdatenregister','Anlage')
writer = csv.DictWriter(units_file, field_names)
writer.writeheader()
total = total_filtered = 0
logging.getLogger('zeep').setLevel(logging.CRITICAL)
for current_step in range(start, math.ceil(limit/step)):
try:
try:
c = client_bind.GetListeAlleEinheiten(apiKey=api_key, marktakteurMastrNummer=mastr_number,
startAb=step*current_step, limit=step)
respond = serialize_object(c)
except Fault as e:
print('Probably reached the end, saving file: ' + e.message)
break
filtered = [dict(x) for x in respond['Einheiten'] if x['Einheittyp'] == filter_type]
print(f'[{current_step}] Fetched {len(respond["Einheiten"])} entries out of which {len(filtered)} was used')
writer.writerows(filtered)
total += len(respond["Einheiten"])
total_filtered += len(filtered)
except KeyboardInterrupt:
print('Aborting fetching!')
break
print(f'Fetched in total {total} entries which {total_filtered} was used.')
def __get_client(self):
# Create a new client and bind to service
# and port if doesn't exist
if self.__client is None:
client = Client(wsdl=self.wsdl)
self.__client = client.bind('VisionMobile', 'VisionMobileSoap')
return self.__client
def handle(self, *args, **options):
history = HistoryPlugin()
session = Session()
session.auth = HTTPBasicAuth('MedML', '12345')
apis = ParserAPI.objects.filter(is_active=True)
for api in apis:
client = Client(api.link, transport=Transport(session=session))
service2 = client.bind('WebPortal', 'WebPortalSoap12')
file = client.service.Sync()
self.get_handle(file, api.id)
def status(request):
"""
Checks that all the services (external or internal) used by the Self-Service Gateway are working,
returning a HTTP 500 if any of them do not work, or a 200 otherwise. It contains individual services checklist
in the view.
"""
status_results = {}
try:
User.objects.first()
status_results['Database'] = True
except:
status_results['Database'] = False
overall_result = status_results['Database']
if hasattr(settings, 'SERVICE_CHECKS'):
for name, service in settings.SERVICE_CHECKS.items():
try:
if isinstance(service, str):
# treat as REST endpoint
response = requests.get(service)
status_results[name] = response.status_code == 200
else:
# assume soap descriptor
client = Client(service['url'])
proxy = client.bind(service_name=service['name'],
port_name=service['name'] + 'Soap12')
proxy[service['operation']]()
status_results[name] = True
except Exception as e:
status_results[name] = False
overall_result = overall_result and status_results[name]
if not overall_result:
LOGGER.error("Status Webpage returning 500: %s" % status_results)
# Retrieve some context information from the environment if provided.
# Deployments can use this to indicate which commit is deployed, etc.
context_info = os.environ.get('AUTOMATION_WEBAPP_CONTEXT', '')
return render(request,
'status.html', {
'context_info': context_info,
'status_results': status_results
},
status=200 if overall_result else 500)
def _call_identity(settings: CzNiaAppSettings,
transport: Transport) -> Element:
"""Call IPSTS (Identity provider) service and return the assertion."""
plugins = []
history = None
if settings.DEBUG:
history = HistoryPlugin()
plugins.append(history)
client = Client(settings.IDENTITY_WSDL,
wsse=BinarySignature(settings.KEY, settings.CERTIFICATE,
settings.PASSWORD),
settings=SETTINGS,
transport=transport,
plugins=plugins)
# Prepare token
token_type = client.get_element(
QName(NiaNamespaces.WS_TRUST.value, 'TokenType'))
token = AnyObject(token_type, token_type(ASSERTION))
# Prepare request
request_type = client.get_element(
QName(NiaNamespaces.WS_TRUST.value, 'RequestType'))
request = AnyObject(request_type,
request_type(NiaNamespaces.WS_TRUST.value + '/Issue'))
# Prepare key
key_type = client.get_element(
QName(NiaNamespaces.WS_TRUST.value, 'KeyType'))
key = AnyObject(key_type,
key_type(NiaNamespaces.WS_TRUST.value + '/SymmetricKey'))
# Prepare WSA header
applies = _get_wsa_header(client, settings.FEDERATION_ADDRESS)
# Call the service
service = client.bind('SecurityTokenService',
'WS2007HttpBinding_IWSTrust13Sync2')
try:
response = service.Trust13Issue(
_value_1=[token, request, key, applies])
except (Error, XmlsecError, RequestException) as err:
_log_history(history, settings, 'IPSTS', success=False)
raise NiaException(err)
_log_history(history, settings, 'IPSTS')
return response.RequestSecurityTokenResponse[0]['_value_1'][3]['_value_1']
def mastr_session():
"""MaStR SOAP session using Zeep Client.
Returns
-------
client : SOAP client
API connection.
client_bind : SOAP client bind
bind API connection.
token : str
API key.
user : str
marktakteurMastrNummer.
"""
if on_rtd:
user, token = (None, None)
else:
user, token = mastr_config()
wsdl = 'https://www.marktstammdatenregister.de/MaStRAPI/wsdl/mastr.wsdl'
session = requests.Session()
session.max_redirects = 30
a = requests.adapters.HTTPAdapter(max_retries=3,
pool_connections=2000,
pool_maxsize=2000)
session.mount('https://', a)
session.mount('http://', a)
transport = Transport(cache=SqliteCache(), timeout=600, session=session)
settings = Settings(strict=True, xml_huge_tree=True)
client = Client(wsdl=wsdl, transport=transport, settings=settings)
client_bind = client.bind('Marktstammdatenregister', 'Anlage')
mastr_suppress_parsing_errors(['parse-time-second'])
# print(f'MaStR API connection established for user {user}')
return client, client_bind, token, user
def mastr_session():
"""MaStR SOAP session using Zeep Client.
Returns
-------
client : SOAP client
API connection.
client_bind : SOAP client bind
bind API connection.
token : str
API key.
user : str
marktakteurMastrNummer.
"""
user, token = mastr_config()
wsdl = 'https://www.marktstammdatenregister.de/MaStRAPI/wsdl/mastr.wsdl'
transport = Transport(cache=SqliteCache())
settings = Settings(strict=False, xml_huge_tree=True)
client = Client(wsdl=wsdl, transport=transport, settings=settings)
client_bind = client.bind('Marktstammdatenregister', 'Anlage')
print('MaStR API connection established.')
return client, client_bind, token, user
def enviaFacturaVenta(serieFactura, numeroFactura):
reload(sys)
sys.setdefaultencoding('utf8')
rutaLog = '.\\Log\\'
rutaCertificados = '.\\certificados\\'
rutaDatos = '.\\datos\\'
# Configuracion de las series de Facturas y series de Facturas rectificativas
serieFacturas = '18'
serieFacturasRectificativas = 'R18'
exentaIVA = 0
# SQL DETALLE FACTURA
sqlRecuperaFactura = """SELECT
'EMPRESA' NOMBRERAZON, 'BXXXXX' NIF, 'A0' TIPOCOMUNICACION,
YEAR(FC.FechaFactura) EJERCICIO, MONTH(fc.FechaFactura) PERIODO, 'BXXXXX' IDEMISORFACTURA,
( FS.SERIE + ' / ' + STR(FC.NUMFACTURA) ) NUMSERIEFACTURAEMISOR,
CONVERT(NVARCHAR(10),FC.FechaFactura, 103) FECHAEXPEDICIONFACTURAEMISOR,
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN 'F1' --SERIE FACTURAS NORMALES
WHEN FS.SERIE = '{SERIERECTIFICADAS}' THEN 'R1' --SERIE FACTURAS RECTIFICATIVAS
END ) TIPOFACTURA ,
--FACTURAS AGRUPADAS
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN ( STR(FC.NUMFACTURA) + ' - ' + FS.SERIE)
WHEN FS.Serie = '{SERIERECTIFICADAS}' THEN NULL
END ) NUMSERIEFACTURAEMISOR,
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN ( CONVERT(NVARCHAR(10),FC.FechaFactura, 103) )
WHEN FS.Serie = '{SERIERECTIFICADAS}' THEN NULL
END ) FECHAEXPEDICIONFACTURAEMISOR,
--FACTURAS RECTIFICADAS
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN NULL
WHEN FS.Serie = '{SERIERECTIFICADAS}' THEN ( FS.SERIE + ' - ' + STR(FC.NUMFACTURA) )
END ) NUMSERIEFACTURAEMISOR,
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN NULL
WHEN FS.Serie = '{SERIERECTIFICADAS}' THEN ( CONVERT(NVARCHAR(10),FC.FechaFactura, 103) )
END ) FECHAEXPEDICIONFACTURAEMISOR,
--BASE RECTIFICADA
(SELECT CASE
WHEN FS.SERIE = '{SERIERECTIFICADAS}' THEN SUM( FL.Cantidad * FL.Precio*(1-FL.Dto1/100) )
ELSE 0
END ) BASERECTIFICADA,
--CUOTA RECTIFICADA
(SELECT CASE
WHEN FS.SERIE = '{SERIERECTIFICADAS}' THEN SUM(FL.Cantidad * FL.Precio * (1-FL.Dto1/100)* FL.iva / 100)
ELSE 0
END ) CUOTARECTIFICADA,
(SELECT CASE
WHEN ( P.CODIGO IN ( 35, 38, 51, 52 ) ) THEN '09' -- IGIC/IPSI
WHEN ( FC.retencion <> 0 AND SUM(FL.CANTIDAD*FL.Precio*(1-Fl.Dto1/100)*Fl.iva/100) <> 0 ) THEN '13' -- NAVES?? 17/507
--WHEN ( FC.retencion <> 0 AND SUM(FL.CANTIDAD*FL.Precio*(1-Fl.Dto1/100)*Fl.iva/100) = 0 ) THEN 'XX'
WHEN ( FL.CODARTICULO IN ( 8790 ) ) THEN '14' --ALQUILERES, AQUI HAY QUE IDENTIFICAR POR EL CODIGO DEL ARTICULO
ELSE '01'
END ) CLAVEREGIMENESPECIALOTRASCENDENCIA,
'FACTURA DE VENTA ' + FS.SERIE + ' / ' + STR(FC.NumFactura) DESCRIPCIONOPERACION,
1 SITUACIONINMUEBLE, CONVERT(NVARCHAR(40), C.NOMBRE) NOMBRERAZONCLIENTE, C.CIF NIFCLIENTE,
'02' TIPOIDENTIFICACIONPAISRESIDENCIA, C.CIF NUMEROIDENTIFICACION,
FC.OBSERVACIONES OBSERVACIONES
FROM FACTURACAB FC FULL OUTER JOIN articulosdetalles FL ON FC.CodFactura = FL.CodFactura
FULL OUTER JOIN CLIENTES C ON C.CodCliente = FC.CodCliente
FULL OUTER JOIN PROVINCIAS P ON P.codigo = C.CodProvincia
INNER JOIN FACTURASERIE FS ON FS.CODSERIE = FC.SERIE
WHERE FS.SERIE = '{SERIEFACTURA}' AND FC.NumFactura = {NUMEROFACTURA}
GROUP BY FC.CodFactura, FS.SERIE, FC.NumFactura, C.Nombre, C.Direccion, FL.CodArticulo,
C.Poblacion, C.CP, P.Nombre, C.CIF, FC.FechaFactura, FC.retencion, FC.CodCliente, p.codigo, FC.OBSERVACIONES
ORDER BY FS.Serie, FC.NumFactura"""
##Cadenas ...
sqlRecuperaImpuesto = """SELECT FC.CODFACTURA, FS.SERIE, FC.NumFactura, FL.IVA,
SUM(FL.CANTIDAD*FL.Precio*(1-Fl.Dto1/100)*(1-Fl.Dto2/100)) BASEIMPONIBLE,
SUM(FL.CANTIDAD*FL.PRECIO*(1-FL.DTO1/100)*(1-Fl.Dto2/100)*FL.IVA/100) CUOTAIVA
FROM FACTURACAB FC FULL OUTER JOIN articulosdetalles FL ON FC.CODFACTURA = FL.CODFACTURA
INNER JOIN FACTURASERIE FS ON FS.CODSERIE = FC.SERIE
WHERE FS.Serie = '{SERIEFACTURA}' AND FC.NumFactura = {NUMEROFACTURA} AND FL.IVA = {IVA}
GROUP BY FC.CODFACTURA, FS.SERIE, FC.NumFactura, FL.IVA"""
sqlDistintosImpuestos = """SELECT SUBCONSULTA.iva
FROM (SELECT CodFactura, IVA, Cantidad FROM articulosdetalles
WHERE CodFactura = (SELECT CODFACTURA FROM FacturaCab
WHERE SERIE = ( SELECT CODSERIE FROM FacturaSerie WHERE SERIE = '{SERIEFACTURA}' )
AND NumFactura = {NUMEROFACTURA} )
GROUP BY Codfactura, iva, CANTIDAD) SUBCONSULTA
WHERE SUBCONSULTA.iva * SUBCONSULTA.Cantidad <> 0
GROUP BY iva"""
sqlIvaAlCero = """SELECT SUBCONSULTA.iva, SUBCONSULTA.BASEIMP
FROM (SELECT CodFactura, IVA, Cantidad, SUM(CANTIDAD*PRECIO*(1-DTO1/100)) AS BASEIMP
FROM articulosdetalles
WHERE CodFactura = (SELECT CODFACTURA FROM FacturaCab WHERE SERIE =
(SELECT CODSERIE FROM FACTURASERIE WHERE SERIE = '{serie}' ) AND NumFactura = {numDocPropio} )
GROUP BY Codfactura, iva, CANTIDAD, PRECIO, DTO1) SUBCONSULTA
WHERE SUBCONSULTA.IVA = 0
GROUP BY SUBCONSULTA.iva, SUBCONSULTA.BASEIMP
"""
sqlExencion = """SELECT TOP(1) SUBSTRING(IDDEARTICULO,1,2) EXENCION
FROM ARTICULOS WHERE CODARTICULO IN(
SELECT CODARTICULO FROM ARTICULOSDETALLES
WHERE CodFactura = (SELECT CODFACTURA FROM FacturaCab WHERE ( SERIE = ( SELECT CODSERIE FROM FACTURASERIE WHERE SERIE ='{SERIEFACTURA}') )
AND NumFactura = {NUMEROFACTURA} )
AND IDDeArticulo LIKE 'E%' AND CodFamilia = 34 AND BloqueoVentas = 0) """
sqlBaseImponible = """SELECT FC.CODFACTURA, FS.SERIE, FC.NumFactura, FL.IVA,
SUM(FL.CANTIDAD*FL.Precio*(1-Fl.Dto1/100)) BASEIMPONIBLE,
SUM(FL.CANTIDAD*FL.PRECIO*(1-FL.DTO1/100)*FL.IVA/100) CUOTAIVA
FROM FACTURACAB FC FULL OUTER JOIN articulosdetalles FL ON FC.CODFACTURA = FL.CODFACTURA
INNER JOIN FACTURASERIE FS ON FS.CODSERIE = FC.SERIE
WHERE FS.Serie = '{SERIEFACTURA}' AND FC.NumFactura = {NUMEROFACTURA} AND FL.IVA = 0
GROUP BY FC.CODFACTURA, FS.SERIE, FC.NumFactura, FL.IVA"""
sqlBaseRectificativas = """SELECT FC.CODFACTURA, FS.SERIE, FC.NumFactura,
SUM(FL.CANTIDAD*FL.Precio*(1-Fl.Dto1/100)) BASEIMPONIBLE,
SUM(FL.CANTIDAD*FL.PRECIO*(1-FL.DTO1/100)*FL.IVA/100) CUOTAIVA
FROM FACTURACAB FC FULL OUTER JOIN articulosdetalles FL ON FC.CODFACTURA = FL.CODFACTURA
INNER JOIN FACTURASERIE FS ON FS.CODSERIE = FC.SERIE
WHERE FS.Serie = '{SERIEFACTURA}' AND FC.NumFactura = {NUMEROFACTURA}
GROUP BY FC.CODFACTURA, FS.SERIE, FC.NumFactura"""
sqlFacturaARectificar = """SELECT FCC.OBSERVACIONES
FROM FacturaCab FCC INNER JOIN FacturaSerie FS ON FCC.SERIE= FS.CodSerie
WHERE FS.SERIE = '{SERIE}' AND FCC.NumFactura = {NUMERO}
AND UPPER(Observaciones) LIKE '%RECTIFICA: %'"""
sqlGuardaRespuesta = """INSERT INTO [dbo].[GV_SII]
([CSV]
,[TIPOFAC]
,[SERIE]
,[NUMERO]
,[ESTADOENVIO]
,[NUMSERIEFACTEMISOR]
,[ESTADOREGISTRO]
,[FECHAPRESENTACION]
,[CODERRORREGISTRO]
,[DESCRIPERRORREGISTRO]
,[CSV2])
VALUES
('{CSV}', '{TIPOFAC}', '{SERIE}', {NUMERO}, '{ESTADOENVIO}',
'{NUMSERIEFACTEMISOR}', '{ESTADOREGISTRO}', '{FECHAPRESENTACION}',
'{CODERRORREGISTRO}', '{DESCRIPERRORREGISTRO}', '{CSV2}')"""
sqlContabilizada = """SELECT Contabilizado FROM FACTURACAB FC INNER JOIN FacturaSerie FS ON FS.CodSerie = FC.SERIE
WHERE FS.SERIE = '{SERIEFACTURA}' AND FC.NumFactura = {NUMEROFACTURA} ORDER BY NumFactura DESC"""
# cadena para facturas rectificativas por sustitucion
cadRectificadas = """
"TipoRectificativa":"{TIPORECT}",
"FacturasRectificadas":{
"IDFacturaRectificada":{
"NumSerieFacturaEmisor":"{numSerieFactEmisor}",
"FechaExpedicionFacturaEmisor":"{fechaExpFactEm}"
}
},
"ImporteRectificacion":{
"BaseRectificada":"{BASERECTIFICADA}",
"CuotaRectificada":"{CUOTARECTIFICADA}",
"CuotaRecargoRectificado": 0
},"""
# cadena para facturas rectificativas por diferencias
cadRectificadasDif = """ "TipoRectificativa":"{TIPORECT}",
"FacturasRectificadas":{
"IDFacturaRectificada":{
"NumSerieFacturaEmisor":"{numSerieFactEmisor}",
"FechaExpedicionFacturaEmisor":"{fechaExpFactEm}"
}
},"""
cadDesgloseFactura = """
"DesgloseIVA":{
"DetalleIVA": [
{DESGLOSESIVAS}
]
}"""
cadDesgloseIVA = """ {
"TipoImpositivo":{porcenIVA},
"BaseImponible":{baseImp},
"CuotaRepercutida":{cuotaIVA}
}""" # concatenar con una coma para distintos IVAS
cadInvSujPasivo = """ "DesgloseFactura":{
"InversionSujetoPasivo":{
"DetalleIVA":{
"TipoImpositivo":{porcenIVA},
"BaseImponible":{baseImp},
"CuotaSoportada":{cuotaIVA}
}
}
}""" # concatenar con una coma para distintos IVAS
cadImpuestos = """ "DesgloseFactura":{
"Sujeta":{
"NoExenta":{
"TipoNoExenta":"S1",
{DESGLOSEIVA}
}
}
},
"DesgloseTipoOperacion":{
"PrestacionServicios":{
"Sujeta":{
"NoExenta":{
"TipoNoExenta":"S1",
{DESGLOSEIVA}
}
}
}
}"""
cadExentaImpuestos = """ "DesgloseFactura":{
"Sujeta":{
"Exenta":{
"CausaExencion":"{EXENCION}",
"BaseImponible": "{BASEIMPONIBLE}"
}
}
},
"DesgloseTipoOperacion":{
"PrestacionServicios":{
"Sujeta":{
"Exenta":{
"CausaExencion":"{EXENCION}",
"BaseImponible": "{BASEIMPONIBLE}"
}
}
}
}"""
cadFacturaManual = """{
"PeriodoImpositivo":{
"Ejercicio":"2017",
"Periodo":"07"
},
"IDFactura":{
"IDEmisorFactura":{
"NIF":"BXXXXX",
},
"NumSerieFacturaEmisor":"17 / 1079",
"FechaExpedicionFacturaEmisor":"31/07/2017"
},
"FacturaExpedida":{
"TipoFactura":"F1",
"ClaveRegimenEspecialOTrascendencia":"01",
"DescripcionOperacion":"ESTRUCTURA METALICA",
"Contraparte":{
"NombreRazon":"PROSOLIA FRANCE SARL",
"IDOtro":{
'CodigoPais': 'FR',
"IDType":"04",
"ID":"FR90502188717"
}
},
"TipoDesglose":{
"DesgloseTipoOperacion":{
"PrestacionServicios":"",
"Entrega":{
"Sujeta":{
"Exenta":{
"CausaExencion":"E5",
"BaseImponible":" 4634.19"
}
}
}
}
}
}
}"""
cadFacturaManual = """{
"PeriodoImpositivo":{
"Ejercicio":"2017",
"Periodo":"08"
},
"IDFactura":{
"IDEmisorFactura":{
"NIF":"BXXXXX",
},
"NumSerieFacturaEmisor":"17 / 1261",
"FechaExpedicionFacturaEmisor":"25/08/2017"
},
"FacturaExpedida":{
"TipoFactura":"F1",
"ClaveRegimenEspecialOTrascendencia":"01",
"DescripcionOperacion":"FACTURA DE VENTA 17 / 1261",
"Contraparte":{
"NombreRazon":"SARL HOTEL CLUB LAROSE BLEVE",
"IDOtro":{
"CodigoPais":"DZ",
"IDType":"04",
"ID":"000816098137052"
}
},
"TipoDesglose":{
"DesgloseFactura":{
"Sujeta":{
"NoExenta":{
"TipoNoExenta":"S1",
"DesgloseIVA":{
"DetalleIVA": [
{
"TipoImpositivo":21.00,
"BaseImponible": 83.33,
"CuotaRepercutida": 17.50
}
]
}
}
}
},
"DesgloseTipoOperacion":{
"PrestacionServicios":{
"Sujeta":{
"NoExenta":{
"TipoNoExenta":"S1",
"DesgloseIVA":{
"DetalleIVA": [
{
"TipoImpositivo":21.00,
"BaseImponible": 83.33,
"CuotaRepercutida": 17.50
}
]
}
}
}
}
}
}
}
}"""
#Preparamos la cadena del diccionario
cadCabecera = """{
"IDVersionSii":1.0,
"Titular":{
"NombreRazon":"EMPRESA",
"NIF":"BXXXXX"
},
"TipoComunicacion":"A0"}"""
#FACTURAS
cadFactura = """{
"PeriodoImpositivo":{
"Ejercicio":"{anio}",
"Periodo":"{mes}"
},
"IDFactura":{
"IDEmisorFactura":{
"NIF":"BXXXXX",
},
"NumSerieFacturaEmisor":"{numSerieFactEmisor}",
"FechaExpedicionFacturaEmisor":"{fechaExpFactEm}"
},
"FacturaExpedida":{
"TipoFactura":"{tipoFactura}",
{CADRECTIFICADAS}
"ClaveRegimenEspecialOTrascendencia":"{REGESPECIAL}",
"DescripcionOperacion":"{descripOperacion}",
"Contraparte":{
"NombreRazon":"{nombreCliente}",
"NIF":"{nifCliente}",
"IDOtro":{
"IDType":"02",
"ID":"ES"
}
},
"TipoDesglose":{
{CADDESGLOSEFACTURA}
}
}
}"""
cadTiempo = time.strftime("%Y") + time.strftime("%m") + time.strftime(
"%d") + time.strftime("%H") + time.strftime("%M") + time.strftime(
"%S") + "_" + str(serieFactura) + "_" + str(numeroFactura) + "_"
logger = logging.getLogger('zeep')
logger.setLevel(logging.DEBUG)
fh = logging.FileHandler(rutaLog + cadTiempo + '_vta_logSii.log')
fh.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.info('Iniciando el envio de la factura: ' + str(serieFactura) +
' / ' + str(numeroFactura))
#Primero comprobamos que la factura este contabilizada
consContabilizada = sqlContabilizada.replace("{SERIEFACTURA}",
str(serieFacturas))
consContabilizada = consContabilizada.replace("{NUMEROFACTURA}",
str(numeroFactura))
conta = consultaMSSQL(consContabilizada)
#print conta[0][0]
if conta[0][0] == True:
logger.info("Factura Contabilizada ...: " + str(serieFacturas) +
" / " + str(numeroFactura))
else:
logger.info(
"Error, factura sin contabilizar. No se enviará la factura: " +
str(serieFacturas) + " / " + str(numeroFactura))
sys.exit(1)
consDistintosImpuestos = sqlDistintosImpuestos.replace(
"{SERIEFACTURA}", str(serieFactura))
consDistintosImpuestos = consDistintosImpuestos.replace(
"{NUMEROFACTURA}", str(numeroFactura))
logger.info("Consulta Impuestos: " + consDistintosImpuestos)
impuestosFactura = consultaMSSQL(consDistintosImpuestos)
consRecFact = sqlRecuperaFactura.replace("{SERIEFACTURAS}",
str(serieFacturas))
consRecFact = consRecFact.replace("{SERIERECTIFICADAS}",
str(serieFacturasRectificativas))
consRecFact = consRecFact.replace("{SERIEFACTURA}", str(serieFactura))
consRecFact = consRecFact.replace("{NUMEROFACTURA}", str(numeroFactura))
logger.info("Impuestos --> " + str(impuestosFactura))
logger.info(consRecFact)
#Recuperamos la factura
detalleFactura = consultaMSSQL(consRecFact)
logger.info(detalleFactura)
#logger.info(detalleImpuestos)
#Cargamos las variables con la informacion
ejercicio = detalleFactura[0][3]
logger.info("Ejercicio: " + str(ejercicio))
mes = detalleFactura[0][4]
numSerieFactEmisor = detalleFactura[0][6]
fechaExpFactEmisor = detalleFactura[0][7]
tipoFactura = detalleFactura[0][8]
regEspecial = detalleFactura[0][15]
descripOperacion = detalleFactura[0][16]
nombreCliente = str(detalleFactura[0][18])
nifCliente = detalleFactura[0][19]
anulacion = detalleFactura[0][22]
#En caso de que sea rectificativa construimos la cadena.
if tipoFactura[0] == 'R':
logger.info("Factura Rectificativa ......................")
consBaseRectif = sqlBaseRectificativas.replace("{SERIEFACTURA}",
str(serieFactura))
consBaseRectif = consBaseRectif.replace("{NUMEROFACTURA}",
str(numeroFactura))
respRectif = consultaMSSQL(consBaseRectif)
baseRectif = respRectif[0][3]
cuotaRectif = respRectif[0][4]
consFactARect = sqlFacturaARectificar.replace("{SERIE}",
str(serieFactura))
consFactARect = consFactARect.replace("{NUMERO}", str(numeroFactura))
logger.info("Base Rectificada: " + str(baseRectif) +
" Cuota Rectificada: " + str(cuotaRectif) +
" FechaFactEmisor: " + str(fechaExpFactEmisor))
facturaARectificar = consultaMSSQL(consFactARect)
print "Observaciones: " + str(facturaARectificar) + "\r\n"
#aqui obtenemos el numero de la factura entre corchetes.
if facturaARectificar:
cadFact = facturaARectificar[0][0]
print str(cadFact)
pFacIni = cadFact.index("#")
pFacFin = cadFact.index("#", pFacIni + 1)
pFechaIni = cadFact.index("#", pFacFin + 1)
pFechaFin = cadFact.index("#", pFechaIni + 1)
print("Pos Ini: " + str(pFacIni) + " | Pos Fin: " + str(pFacFin))
numFactARectificar = cadFact[pFacIni + 1:pFacFin]
fechaFact = cadFact[pFechaIni + 1:pFechaFin]
#numFactARectificar = cadFact[cadFact.index("#")+1:cadFact.index("#",2)]
print "Factura: " + str(
numFactARectificar) + " | Fecha: " + fechaFact
else:
logger.info(
"Por favor debe introducir la informacion relativa a la factura que se modifica. Campo Observaciones."
)
logger.info("Base Rectificada: " + str(baseRectif) +
" Cuota Rectificada: " + str(cuotaRectif) +
" FechaFactEmisor: " + str(fechaExpFactEmisor))
logger.info("Anulacion: " + anulacion.upper())
#Caso de sustitucion de factura
if anulacion.upper().find("ANULACION") >= 0:
cadFinRectificadas = cadRectificadas.replace("{TIPORECT}", "S")
cadFinRectificadas = cadFinRectificadas.replace(
"{numSerieFactEmisor}", str(numFactARectificar))
cadFinRectificadas = cadFinRectificadas.replace(
"{fechaExpFactEm}", str(fechaFact))
cadFinRectificadas = cadFinRectificadas.replace(
"{BASERECTIFICADA}", '{:12.2f}'.format(baseRectif))
cadFinRectificadas = cadFinRectificadas.replace(
"{CUOTARECTIFICADA}", '{:12.2f}'.format(cuotaRectif))
else: #caso de diferencias
cadFinRectificadas = cadRectificadasDif.replace("{TIPORECT}", "I")
cadFinRectificadas = cadFinRectificadas.replace(
"{numSerieFactEmisor}", str(numFactARectificar))
cadFinRectificadas = cadFinRectificadas.replace(
"{fechaExpFactEm}", str(fechaFact))
logger.info("Cadena Rectificadas: " + str(cadFinRectificadas))
cadFactura = cadFactura.replace("{CADRECTIFICADAS}",
str(cadFinRectificadas))
else:
cadFactura = cadFactura.replace("{CADRECTIFICADAS}", "")
logger.info("Tipo de Factura:" + str(tipoFactura))
cadDesgloseImpuestos = ''
cuotaIVATotal = 0
cadDesglosesIVAs = ""
cadFinExenta = ""
logger.info("Comenzamos a tratar los ivas ... " +
str(len(impuestosFactura)) + " | ")
#Primero debemos cargar los Desgloses de IVA en caso de que exista
if len(impuestosFactura) > 0:
for i, imp in enumerate(impuestosFactura):
sqlDetImpuesto = sqlRecuperaImpuesto.replace(
"{SERIEFACTURA}", str(serieFactura))
sqlDetImpuesto = sqlDetImpuesto.replace("{NUMEROFACTURA}",
str(numeroFactura))
#print imp[0]
sqlDetImpuesto = sqlDetImpuesto.replace("{IVA}", str(imp[0]))
logger.info("Consulta Detalle impuesto: " + sqlDetImpuesto)
respDetalle = consultaMSSQL(sqlDetImpuesto)
iva = respDetalle[0][3]
base = respDetalle[0][4]
cuota = respDetalle[0][5]
cadParDesglose = cadDesgloseIVA.replace("{porcenIVA}",
"{:3.2f}".format(iva))
cadParDesglose = cadParDesglose.replace("{baseImp}",
"{:12.2f}".format(base))
cadParDesglose = cadParDesglose.replace("{cuotaIVA}",
"{:12.2f}".format(cuota))
logger.info("cadParDesglose: " + cadParDesglose)
if i == 0:
cadDesgloseImpuestos = cadParDesglose
#print "Primer Impuesto: " + cadDesgloseImpuestos
else:
cadDesgloseImpuestos = cadDesgloseImpuestos + "," + cadParDesglose
#print "Cadena final Impuestos" + cadDesgloseImpuestos
cuotaIVATotal = cuotaIVATotal + cuota
#aqui debemos comprobar si existe el iva al 0%
consIvaAlCero = sqlIvaAlCero.replace("{serie}", str(serieFactura))
consIvaAlCero = consIvaAlCero.replace("{numDocPropio}",
str(numeroFactura))
respIvaCero = consultaMSSQL(consIvaAlCero)
if respIvaCero:
base = respIvaCero[0][1]
cadParDesglose = cadDesgloseIVA.replace("{porcenIVA}",
"{:3.2f}".format(0))
cadParDesglose = cadParDesglose.replace("{baseImp}",
"{:12.2f}".format(base))
cadParDesglose = cadParDesglose.replace("{cuotaIVA}",
"{:12.2f}".format(0))
cadDesgloseImpuestos = cadDesgloseImpuestos + "," + cadParDesglose
#Caso de que sea una factura sin IVA
else:
logger.info("EXENTA IVA ...")
exentaIVA = 1
consExencion = sqlExencion.replace("{SERIEFACTURA}", str(serieFactura))
consExencion = consExencion.replace("{NUMEROFACTURA}",
str(numeroFactura))
# primero deberemos recuperar el tipo de exencion
logger.info("Consulta Exencion: " + consExencion)
exencion = consultaMSSQL(consExencion)
consBaseImponible = sqlBaseImponible.replace("{SERIEFACTURA}",
str(serieFactura))
consBaseImponible = consBaseImponible.replace("{NUMEROFACTURA}",
str(numeroFactura))
base = consultaMSSQL(consBaseImponible)
logger.info("Exencion: " + str(exencion) + " | " + "Base: " +
str(base[0][4]))
print "Exencion: " + str(exencion)
if exencion: #Ha encontrado una E, Inversion de sujeto Pasivo -> Sujeta/Exenta
print "Inversion de Sujeto Pasivo"
cadFinExenta = cadExentaImpuestos.replace("{EXENCION}",
str(exencion[0][0]))
cadFinExenta = cadFinExenta.replace("{BASEIMPONIBLE}",
"{:12.2f}".format(base[0][4]))
else: #Es una factura Normal --> Desglose IVA
print "DesgloseIVA"
cadFinExenta = cadDesgloseIVA.replace("{porcenIVA}", "0.00")
cadFinExenta = cadFinExenta.replace("{baseImp}",
"{:12.2f}".format(base[0][4]))
cadFinExenta = cadFinExenta.replace("{cuotaIVA}", "0.00")
# cadFinExenta = cadExentaImpuestos.replace( "{EXENCION}", str(exencion[0][0]) )
# cadFinExenta = cadFinExenta.replace("{BASEIMPONIBLE}", "{:12.2f}".format(base[0][4]) )
if len(impuestosFactura) >= 1:
cadFinImpuestos = cadDesgloseImpuestos
else:
cadFinImpuestos = cadFinExenta
logger.info("cadFinExenta: --> :" + str(cadFinExenta))
logger.info("Cad Fin Impuestos: --> : " + str(cadFinImpuestos))
#logger.info( "Cad Fin Exenta: --> " + str(cadFinExenta) )
#Ahora reemplazamos el desglose en los impuestos
# cadFinImpuestos = cadImpuestos.replace("{DESGLOSEIVA}", str(cadDesgloseImpuestos) )
logger.info("FechaExpedicion: " + str(fechaExpFactEmisor))
fact = cadFactura.replace("{anio}", str(ejercicio))
fact = fact.replace("{mes}", str(mes).zfill(2))
fact = fact.replace("{numSerieFactEmisor}", str(numSerieFactEmisor))
fact = fact.replace("{fechaExpFactEm}", str(fechaExpFactEmisor))
fact = fact.replace("{tipoFactura}", str(tipoFactura))
fact = fact.replace("{descripOperacion}", str(descripOperacion))
fact = fact.replace("{nombreCliente}", str(nombreCliente))
fact = fact.replace("{nifCliente}", str(nifCliente))
fact = fact.replace("{REGESPECIAL}", str(regEspecial))
logger.info("CadFinImpuestos: " + cadFinImpuestos)
cadDesFact = cadDesgloseFactura.replace("{DESGLOSESIVAS}",
str(cadFinImpuestos))
logger.info("CadDesFact: --> " + str(cadDesFact))
#concatenamos la cadena de impuestos
if exentaIVA == 0: #No tiene exencion Factura Normal
logger.info("Factura Normal - cadDesFact: " + str(cadDesFact))
logger.info("cadFinExenta: " + str(cadFinExenta))
logger.info("cadFinImpuestos: " + str(cadFinImpuestos))
cadDesgloseFactura = cadImpuestos.replace("{DESGLOSEIVA}",
str(cadDesFact))
fact = fact.replace("{CADDESGLOSEFACTURA}",
str(cadDesgloseFactura)) #antes cadDesFact
else:
#caso de sujeta bien
logger.info("Sujeta o sin IVA")
logger.info("Exenta IVA: " + str(exentaIVA))
logger.info("Exencion : " + str(exencion))
if exencion:
logger.info("cadFinExenta: " + str(cadFinExenta))
logger.info("cadFinImpuestos: " + str(cadFinImpuestos))
fact = fact.replace("{CADDESGLOSEFACTURA}",
str(cadFinExenta)) #antes cadFinExenta
else:
logger.info("CadDesFact: (2) --> " + str(cadDesFact))
cadDesgloseFactura = cadImpuestos.replace("{DESGLOSEIVA}",
str(cadDesFact))
logger.info("CadDesgloseFactura: " + cadDesgloseFactura)
fact = fact.replace(
"{CADDESGLOSEFACTURA}",
str(cadDesgloseFactura)) #antesw cadDesgloseFactura
logger.info(cadCabecera)
logger.info(fact)
#Convertimos cadenas a Diccionarios
dicCabecera = ast.literal_eval(cadCabecera)
dicFactura = ast.literal_eval(fact)
print dicCabecera
print '\r\n'
print dicFactura
#WEBSERVICE AEAT
#wsdl = 'http://www.agenciatributaria.es/static_files/AEAT/Contenidos_Comunes/La_Agencia_Tributaria/Modelos_y_formularios/Suministro_inmediato_informacion/FicherosSuministros/V_07/SuministroFactEmitidas.wsdl'
#wsdl = '/wlpl/SSII-FACT/ws/fe/SiiFactFEV1SOAP/SuministroFactEmitidasPrueba.wsdl'
# Descargar los wsdl de la aeat y modificar la url del servicio por la del servicio de pruebas ya que si no te manda a XXXX
wsdl = rutaDatos + 'SuministroFactEmitidas.wsdl'
#wsdl = "./WSDLPruebas/SuministroFactEmitidasPrueba.wsdl"
#SSL CONECTION
session = Session()
#session.cert='cert.pem'
session.cert = (rutaCertificados + "clavePublica.pem",
rutaCertificados + "clavePrivada.pem")
session.verify = True
transport = Transport(session=session)
#logger.debug()
#FIRMA XML ENVIO
#signature = Signature("./certificados/cert.pem","./certificados/clavePrivada.crt")
client = Client(wsdl=wsdl,
port_name="SuministroFactEmitidas",
transport=transport,
service_name='siiService')
logger.info('Establecida conexion con cliente')
#SELECCION SERVICIO DE PRUEBAS SuministroLRFacturasEmitidas
service2 = client.bind('siiService', 'SuministroFactEmitidas')
logger.info('Bind al servicio')
#INSERCION DE LA FACTURA Y RESPUESTA EN EL SERVICO DE PRUEBAS.
#print (service2.SuministroLRFacturasEmitidas(cabecera,facturas))
logger.info('Enviando factura ...')
try:
salida = (service2.SuministroLRFacturasEmitidas(
dicCabecera, dicFactura))
except:
e = sys.exc_info()[0]
logger.info("Error al enviar factura: " + str(e))
salida = None
datosPres = None
logger.info('Factura envidada')
logger.info('Salida: ' + str(salida))
#Procesamos la salida
if salida:
csv = salida['CSV']
datosPres = salida['DatosPresentacion']
logger.info('Datos Presentacion: ' + str(datosPres))
if datosPres is not None:
logger.info("Datos Presentacion: Datos ")
fechaPresentacion = datosPres['TimestampPresentacion']
else:
fa = datetime.datetime.now()
fechaPresentacion = "%s/%s/%s %s:%s:%s" % (
fa.day, fa.month, fa.year, fa.hour, fa.minute, fa.second)
estadoEnvio = salida['EstadoEnvio']
respLinea = salida['RespuestaLinea'][0]
logger.info("Respuesta Linea: " + str(respLinea))
idFactura = respLinea['IDFactura']
if idFactura is not None:
logger.info("ID Factura: Datos ")
nSerFacEm = idFactura['NumSerieFacturaEmisor']
if respLinea is not None:
logger.info("Respuesta Linea: Datos ")
estadoRegistro = respLinea['EstadoRegistro']
codErrorRegistro = respLinea['CodigoErrorRegistro']
descripErrorReg = respLinea['DescripcionErrorRegistro']
csv2 = respLinea['CSV']
#Preparamos la cadena para insertar
consInsResp = sqlGuardaRespuesta.replace('{CSV}', str(csv))
consInsResp = consInsResp.replace('{TIPOFAC}', 'VENTA')
consInsResp = consInsResp.replace('{SERIE}', str(serieFactura))
consInsResp = consInsResp.replace('{NUMERO}', str(numeroFactura))
consInsResp = consInsResp.replace('{ESTADOENVIO}', str(estadoEnvio))
consInsResp = consInsResp.replace('{NUMSERIEFACTEMISOR}', str(nSerFacEm))
consInsResp = consInsResp.replace('{ESTADOREGISTRO}', str(estadoRegistro))
consInsResp = consInsResp.replace('{FECHAPRESENTACION}',
str(fechaPresentacion))
consInsResp = consInsResp.replace('{CODERRORREGISTRO}',
str(codErrorRegistro))
consInsResp = consInsResp.replace('{DESCRIPERRORREGISTRO}',
str(descripErrorReg))
consInsResp = consInsResp.replace('{CSV2}', str(csv2))
logger.info("CSV: " + str(csv) + " | SERIE: " + str(serieFactura) +
" | Numero: " + str(numeroFactura) + " | Estado Envio: " +
str(estadoEnvio) + " | Num. Ser. Fac. Em.: " + str(nSerFacEm) +
" | Estado Registro: " + str(estadoRegistro) +
" | Fecha Presentacion: " + str(fechaPresentacion) +
" | Cod. Error Registro: " + str(codErrorRegistro) +
" | Descrip. Error: " + str(descripErrorReg) + " | CSV2: " +
str(csv2))
logger.info("Consulta: " + str(consInsResp))
insercionBD = consultaMSSQL(consInsResp)
logger.info('Respuesta de la insercion: ' + str(insercionBD))
print "Terminado..."
logger.removeHandler(fh)
def enviaFacturaCompra(serieFactura, numeroFactura):
reload(sys)
sys.setdefaultencoding('utf8')
rutaLog = '.\\Log\\'
rutaCertificados = '.\\certificados\\'
rutaDatos = '.\\datos\\'
cuotaDeducible = 0
# Configuracion de las series de Facturas y series de Facturas rectificativas
serieFacturas = '18'
serieFacturasRectificativas = 'R18'
exentaIVA = 0
##Cadenas ...
# SQL DETALLE FACTURA
sqlRecuperaFactura = """SELECT
'EMPRESA' NOMBRERAZON, 'BXXXXXX' NIF, 'A0' TIPOCOMUNICACION,
YEAR(FC.FECHAFACTURA) EJERCICIO, MONTH(fc.FECHAFACTURA) PERIODO, PROV.cif IDEMISORFACTURA,
( FC.NumDocumento ) NUMSERIEFACTURAEMISOR,
CONVERT(NVARCHAR(10),FC.FECHAFACTURA,103) FECHAEXPEDICIONFACTURAEMISOR,
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN 'F1' --SERIE FACTURAS NORMALES
WHEN FS.SERIE = '{SERIERECTIFICADAS}' THEN 'R1' --SERIE FACTURAS RECTIFICATIVAS
END ) TIPOFACTURA ,
--FACTURAS AGRUPADAS
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN ( FS.SERIE + ' - ' + STR(FC.NumDocPropio) + ' | ' + FC.NumDocumento )
WHEN FS.Serie = '{SERIERECTIFICADAS}' THEN NULL
END ) NUMSERIEFACTURAEMISOR,
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN ( CONVERT(NVARCHAR(10),FC.FechaDocProv, 103) )
WHEN FS.Serie = '{SERIERECTIFICADAS}' THEN NULL
END ) FECHAEXPEDICIONFACTURAEMISOR,
--FACTURAS RECTIFICADAS
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN NULL
WHEN FS.Serie = '{SERIERECTIFICADAS}' THEN ( FS.SERIE + ' - ' + STR(FC.NumDocPropio) + ' | ' + FC.NumDocumento )
END ) NUMSERIEFACTURAEMISOR,
(SELECT CASE
WHEN FS.Serie = '{SERIEFACTURAS}' THEN NULL
WHEN FS.Serie = '{SERIERECTIFICADAS}' THEN ( CONVERT(NVARCHAR(10),FC.FechaDocProv, 103) )
END ) FECHAEXPEDICIONFACTURAEMISOR,
--BASE RECTIFICADA
(SELECT CASE
WHEN FS.SERIE = '{SERIERECTIFICADAS}' THEN SUM( FL.Cantidad * FL.Precio*(1-FL.Dto1/100) )
ELSE 0
END ) BASERECTIFICADA,
--CUOTA RECTIFICADA
(SELECT CASE
WHEN FS.SERIE = '{SERIERECTIFICADAS}' THEN SUM(FL.Cantidad * FL.Precio * (1-FL.Dto1/100)* FL.iva / 100)
ELSE 0
END ) CUOTARECTIFICADA,
(SELECT CASE
WHEN ( FC.CodProveedor IN ( 581 ) ) THEN '14' -- SEGUROS
WHEN ( PROV.CODPROVINCIA IN ( 35, 38, 51, 52 ) ) THEN '09' -- IGIC/IPSI
ELSE '01' -- OPERACIONES REGIMEN COMUN
END ) CLAVEREGIMENESPECIALOTRASCENDENCIA,
('FACTURA DE COMPRA ' + FS.SERIE + ' / ' + FC.NumDocumento) DESCRIPCIONOPERACION,
1 SITUACIONINMUEBLE, CONVERT(NVARCHAR(40), PROV.NOMBRE) NOMBRERAZONCLIENTE, PROV.CIF NIFCLIENTE,
'02' TIPOIDENTIFICACIONPAISRESIDENCIA, PROV.CIF NUMEROIDENTIFICACION,
CONVERT(NVARCHAR(10),FC.FECHAFACTURA,103) FECHACONTABLE,
FC.OBSERVACIONES OBSERVACIONES
FROM FACTURACABCOMPRA FC FULL OUTER JOIN ArticulosDetallesCompra FL ON FC.CodFacturaCompra = FL.CodFacturaCompra
INNER JOIN PROVEEDORES PROV ON PROV.CODPROVEEDOR = FC.CODPROVEEDOR
FULL OUTER JOIN PROVINCIAS P ON P.codigo = PROV.CodProvincia
INNER JOIN FACTURASERIE FS ON FS.CODSERIE = FC.SERIE
WHERE FS.SERIE = '{SERIEFACTURA}' AND FC.NumDocPropio = {NUMEROFACTURA}
GROUP BY FC.CodFacturaCompra, FS.SERIE, FC.NumDocumento, FC.NumDocPropio, FC.CodProveedor, PROV.CIF, FC.FechaDocProv, PROV.CodProvincia, FC.retencion,
PROV.Nombre, FC.FechaFactura, FC.OBSERVACIONES, fc.FechaContable
ORDER BY FS.Serie, FC.NumDocPropio"""
# CLAVEREGIMENESPECIAL O TRASCENDENCIA
# SEGUROS -- VALOR: 15 -- LOCALIZAR POR EL CODIGO DEL PROVEEDOR
# OPERACIONES SUJETAS AL IPSI/IGIC -- VALOR: 09 -- LOCALIZAR POR EL CODIGO DE LA PROVINCIA ()
# RESTO -- VALOR: 01 -- RESTO
# SQL DETALLE DE IMPUESTOS (esta en principio no la voy a usar)
sqlRecuperaImpuestos = """SELECT
FC.CODFACTURA, FC.SERIE, FC.NumFactura, FL.IVA,
SUM(FL.CANTIDAD*FL.Precio*(1-Fl.Dto1/100)) BASEIMPONIBLE,
SUM(FL.CANTIDAD*FL.PRECIO*(1-FL.DTO1/100)*FL.IVA/100) CUOTAIVA
FROM FACTURACAB FC FULL OUTER JOIN articulosdetalles FL ON FC.CODFACTURA = FL.CODFACTURA
WHERE FC.Serie = {SERIEFACTURA} AND FC.NumFactura = {NUMEROFACTURA}
GROUP BY FC.CODFACTURA, FC.SERIE, FC.NumFactura, FL.IVA"""
sqlRecuperaImpuesto = """SELECT
REG_FAC.codfacturagestion CODFACTURACOMPRA, FAC_COM.Serie , FAC_COM.NumDocPropio,
REG_FAC.IVA, SUM(REG_FAC.BASE) BASE_CONTA,
SUM(REG_FAC.CUOTA) CUOTA_CONTA
FROM ( SELECT RF.codfacturagestion, RF.Baseimponible1 BASE, RF.iva1 IVA, RF.cuotaiva1 CUOTA
FROM cVillaescusa.DBO.RegistroEntradaFacturas RF
UNION
SELECT RF.codfacturagestion, RF.Baseimponible2 BASE, RF.iva2 IVA, RF.cuotaiva2 CUOTA
FROM cVillaescusa.DBO.RegistroEntradaFacturas RF
UNION
SELECT RF.codfacturagestion, RF.Baseimponible3 BASE, RF.iva3 IVA, RF.cuotaiva3 CUOTA
FROM cVillaescusa.DBO.RegistroEntradaFacturas RF
UNION
SELECT RF.codfacturagestion, RF.Baseimponible4 BASE, RF.iva4 IVA, RF.cuotaiva4 CUOTA
FROM cVillaescusa.DBO.RegistroEntradaFacturas RF
UNION
SELECT RF.codfacturagestion, RF.Baseimponible5 BASE, RF.iva5 IVA, RF.cuotaiva5 CUOTA
FROM cVillaescusa.DBO.RegistroEntradaFacturas RF
UNION
SELECT RF.codfacturagestion, RF.Baseimponible6 BASE, RF.iva6 IVA, RF.cuotaiva6 CUOTA
FROM cVillaescusa.DBO.RegistroEntradaFacturas RF ) REG_FAC INNER JOIN (SELECT
FS.SERIE, FC.CodFacturaCompra, FC.NumDocPropio, SUM(FL.CANTIDAD*FL.Precio*(1-Fl.Dto1/100)*(1-Fl.Dto2/100)) BASE, FC.FechaFactura,
SUM(FL.CANTIDAD*FL.PRECIO*(1-FL.DTO1/100)*(1-Fl.Dto2/100)*FL.IVA/100) CUOTAIVA, FL.iva
FROM gvilla.dbo.FACTURACABCOMPRA FC INNER JOIN gvilla.dbo.articulosdetallesCompra FL ON FC.CODFACTURACOMPRA = FL.CODFACTURACOMPRA
INNER JOIN gvilla.dbo.FACTURASERIE FS ON FS.CODSERIE = FC.SERIE
GROUP BY FS.Serie, FC.CodFacturaCompra, FC.NUMDOCPROPIO, FL.IVA, FC.FechaFactura ) FAC_COM ON FAC_COM.CodFacturaCompra = REG_FAC.codfacturagestion AND FAC_COM.iva = REG_FAC.IVA
WHERE FAC_COM.Serie = '{SERIEFACTURA}' AND FAC_COM.NumDocPropio = {NUMEROFACTURA} AND FAC_COM.iva = {IVA}
GROUP BY FAC_COM.SERIE, FAC_COM.CODFACTURACOMPRA, FAC_COM.NumDocPropio, REG_FAC.codfacturagestion, REG_FAC.IVA, FAC_COM.BASE, FAC_COM.CUOTAIVA
ORDER BY FAC_COM.Serie, FAC_COM.NumDocPropio, FAC_COM.BASE"""
sqlDistintosImpuestos = """SELECT SUBCONSULTA.iva
FROM (SELECT CodFacturaCompra, IVA, Cantidad FROM articulosdetallescompra
WHERE CodFacturacompra = (SELECT CODFACTURACOMPRA FROM FacturaCabCompra WHERE SERIE =
(SELECT CODSERIE FROM FACTURASERIE WHERE SERIE = '{SERIEFACTURA}' ) AND NumDocPropio = {NUMEROFACTURA} )
GROUP BY CodfacturaCompra, iva, CANTIDAD) SUBCONSULTA
WHERE SUBCONSULTA.iva * SUBCONSULTA.Cantidad <> 0
GROUP BY iva"""
sqlIvaAlCero = """SELECT SUBCONSULTA.iva, SUBCONSULTA.BASEIMP
FROM (SELECT CodFacturaCompra, IVA, Cantidad, SUM(CANTIDAD*PRECIO*(1-DTO1/100)) AS BASEIMP
FROM articulosdetallescompra
WHERE CodFacturacompra = (SELECT CODFACTURACOMPRA FROM FacturaCabCompra WHERE SERIE =
(SELECT CODSERIE FROM FACTURASERIE WHERE SERIE = '{serie}' ) AND NumDocPropio = {numDocPropio} )
GROUP BY CodfacturaCompra, iva, CANTIDAD, PRECIO, DTO1) SUBCONSULTA
WHERE SUBCONSULTA.IVA = 0
GROUP BY SUBCONSULTA.iva, SUBCONSULTA.BASEIMP"""
sqlExencion = """SELECT TOP(1) SUBSTRING(IDDEARTICULO,1,2) EXENCION
FROM ARTICULOS WHERE CODARTICULO IN(
SELECT CODARTICULO FROM ARTICULOSDETALLESCOMPRA
WHERE CodFacturaCompra = (SELECT CODFACTURACompra FROM FacturaCabCompra WHERE SERIE =
(SELECT CODSERIE FROM FACTURASERIE WHERE SERIE ='{SERIEFACTURA}') AND NumDocPropio = {NUMEROFACTURA})
) AND IDDeArticulo LIKE 'E%' AND CodFamilia = 34 AND BloqueoVentas = 0"""
sqlBaseImponible = """SELECT FC.CODFACTURACOMPRA, FS.SERIE, FC.NumDocPropio, FL.IVA,
SUM(FL.CANTIDAD*FL.Precio*(1-Fl.Dto1/100)) BASEIMPONIBLE,
SUM(FL.CANTIDAD*FL.PRECIO*(1-FL.DTO1/100)*FL.IVA/100) CUOTAIVA
FROM FACTURACABCOMPRA FC FULL OUTER JOIN articulosdetallesCompra FL ON FC.CODFACTURACOMPRA = FL.CODFACTURACOMPRA
INNER JOIN FACTURASERIE FS ON FS.CODSERIE = FC.SERIE
WHERE FS.Serie = '{SERIEFACTURA}' AND FC.NumDocPropio = {NUMEROFACTURA} AND FL.IVA = 0
GROUP BY FC.CODFACTURACOMPRA, FS.SERIE, FC.NumDocPropio, FL.IVA"""
sqlBaseRectificativas = """SELECT FC.CODFACTURACOMPRA, FS.SERIE, FC.NumDocPropio,
SUM(FL.CANTIDAD*FL.Precio*(1-Fl.Dto1/100)) BASEIMPONIBLE,
SUM(FL.CANTIDAD*FL.PRECIO*(1-FL.DTO1/100)*FL.IVA/100) CUOTAIVA
FROM FACTURACABCOMPRA FC FULL OUTER JOIN articulosdetallesCompra FL ON FC.CODFACTURACOMPRA = FL.CODFACTURACOMPRA
INNER JOIN FACTURASERIE FS ON FS.CODSERIE = FC.SERIE
WHERE FS.Serie = '{SERIEFACTURA}' AND FC.NumDocPropio = {NUMEROFACTURA}
GROUP BY FC.CODFACTURACOMPRA, FS.SERIE, FC.NumDocPropio"""
sqlFacturaARectificar = """SELECT FCC.OBSERVACIONES
FROM FacturaCabCompra FCC INNER JOIN FacturaSerie FS ON FCC.SERIE= FS.CodSerie
WHERE FS.SERIE = '{SERIE}' AND FCC.NumDocPropio = {NUMERO}
AND UPPER(Observaciones) LIKE '%RECTIFICA:%'"""
sqlGuardaRespuesta = """INSERT INTO [dbo].[GV_SII]
([CSV]
,[TIPOFAC]
,[SERIE]
,[NUMERO]
,[ESTADOENVIO]
,[NUMSERIEFACTEMISOR]
,[ESTADOREGISTRO]
,[FECHAPRESENTACION]
,[CODERRORREGISTRO]
,[DESCRIPERRORREGISTRO]
,[CSV2])
VALUES
('{CSV}', '{TIPOFAC}', '{SERIE}', {NUMERO}, '{ESTADOENVIO}',
'{NUMSERIEFACTEMISOR}', '{ESTADOREGISTRO}', '{FECHAPRESENTACION}',
'{CODERRORREGISTRO}', '{DESCRIPERRORREGISTRO}', '{CSV2}')"""
# Primero comprobamos que la factura este contabilizada
sqlContabilizada = """SELECT Contabilizado FROM FACTURACABCOMPRA FC INNER JOIN FacturaSerie FS ON FS.CodSerie = FC.SERIE
WHERE FS.SERIE = '{SERIEFACTURA}' AND FC.NumDocPropio = {NUMEROFACTURA}"""
# Preparamos la cadena del diccionario
cadCabecera = """{
"IDVersionSii":1.0,
"Titular":{
"NombreRazon":"EMPRESA",
"NIF":"BXXXXX"
},
"TipoComunicacion":"A0"}""" #A0 - NUEVAS || A1 - MODIFICACION
# FACTURAS
cadFactura = """{
"PeriodoImpositivo":{
"Ejercicio":"{anio}",
"Periodo":"{mes}"
},
"IDFactura":{
"IDEmisorFactura":{
"NIF":"{IDEMISORFACTURA}",
"IDOtro":{
"IDType":"02",
"ID":"ES"
}
},
"NumSerieFacturaEmisor":"{numSerieFactEmisor}",
"FechaExpedicionFacturaEmisor":"{fechaExpFactEm}"
},
"FacturaRecibida":{
"TipoFactura":"{tipoFactura}",
{CADRECTIFICADAS}
"ClaveRegimenEspecialOTrascendencia":"{REGESPECIAL}",
"DescripcionOperacion":"{descripOperacion}",
{CADDESGLOSEFACTURA},
"Contraparte":{
"NombreRazon":"{nombreCliente}",
"NIF":"{nifCliente}",
"IDOtro":{
"IDType":"02",
"ID":"ES"
}
},
"FechaRegContable":"{fechaRegContable}",
"CuotaDeducible":"{cuotaDeducible}"
}
}"""
# cadena para facturas rectificativas por sustitucion
cadRectificadas = """
"TipoRectificativa":"{TIPORECT}",
"FacturasRectificadas":{
"IDFacturaRectificada":{
"NumSerieFacturaEmisor":"{numSerieFactEmisor}",
"FechaExpedicionFacturaEmisor":"{fechaExpFactEm}"
}
},
"ImporteRectificacion":{
"BaseRectificada":"{BASERECTIFICADA}",
"CuotaRectificada":"{CUOTARECTIFICADA}",
"CuotaRecargoRectificado": 0
},"""
# cadena para facturas rectificativas por diferencias
cadRectificadasDif = """ "TipoRectificativa":"{TIPORECT}",
"FacturasRectificadas":{
"IDFacturaRectificada":{
"NumSerieFacturaEmisor":"{numSerieFactEmisor}",
"FechaExpedicionFacturaEmisor":"{fechaExpFactEm}"
}
},"""
cadDesgloseFactura = """ "DesgloseFactura":{
"DesgloseIVA":{
"DetalleIVA": [
{DESGLOSESIVAS}
]
}
}"""
cadDesgloseIVA = """ {
"TipoImpositivo":{porcenIVA},
"BaseImponible":{baseImp},
"CuotaSoportada":{cuotaIVA}
}""" # concatenar con una coma para distintos IVAS
cadInvSujPasivo = """ "DesgloseFactura":{
"InversionSujetoPasivo":{
"DetalleIVA":{
"TipoImpositivo":{porcenIVA},
"BaseImponible":{baseImp},
"CuotaSoportada":{cuotaIVA}
}
}
}""" # concatenar con una coma para distintos IVAS
cadTiempo = time.strftime("%Y") + time.strftime("%m") + time.strftime(
"%d") + time.strftime("%H") + time.strftime("%M") + time.strftime(
"%S") + "_" + str(serieFactura) + "_" + str(numeroFactura) + "_"
logger = logging.getLogger('zeep')
logger.setLevel(logging.DEBUG)
fh = logging.FileHandler(rutaLog + cadTiempo + '_compra_logSii.log')
fh.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.info('Iniciando el envio de la factura: ' + str(serieFactura) +
' / ' + str(numeroFactura))
consContabilizada = sqlContabilizada.replace("{SERIEFACTURA}",
str(serieFacturas))
consContabilizada = consContabilizada.replace("{NUMEROFACTURA}",
str(numeroFactura))
conta = consultaMSSQL(consContabilizada)
print str(conta)
#print conta[0][0]
if conta[0][0] == True:
logger.info("Factura Contabilizada ...: " + str(serieFacturas) +
" / " + str(numeroFactura))
else:
logger.info(
"Error, factura sin contabilizar. No se enviará la factura: " +
str(serieFacturas) + " / " + str(numeroFactura))
sys.exit(1)
consDistintosImpuestos = sqlDistintosImpuestos.replace(
"{SERIEFACTURA}", str(serieFactura))
consDistintosImpuestos = consDistintosImpuestos.replace(
"{NUMEROFACTURA}", str(numeroFactura))
impuestosFactura = consultaMSSQL(consDistintosImpuestos)
logger.info("Consulta distintos Impuestos: " + consDistintosImpuestos)
consRecFact = sqlRecuperaFactura.replace("{SERIEFACTURAS}",
str(serieFacturas))
consRecFact = consRecFact.replace("{SERIERECTIFICADAS}",
str(serieFacturasRectificativas))
consRecFact = consRecFact.replace("{SERIEFACTURA}", str(serieFactura))
consRecFact = consRecFact.replace("{NUMEROFACTURA}", str(numeroFactura))
logger.info("Impuestos --> " + str(impuestosFactura))
logger.info(consRecFact)
#logger.info( consRecImp )
#Recuperamos la factura
detalleFactura = consultaMSSQL(consRecFact)
# detalleImpuestos = consultaMSSQL(consRecImp)
logger.info("Detalle de la factura: " + str(detalleFactura))
#Cargamos las variables con la informacion
ejercicio = detalleFactura[0][3]
logger.info("Ejercicio: " + str(ejercicio))
mes = detalleFactura[0][4]
numSerieFactEmisor = detalleFactura[0][6]
fechaExpFactEmisor = detalleFactura[0][7]
tipoFactura = detalleFactura[0][8]
regEspecial = detalleFactura[0][15]
descripOperacion = detalleFactura[0][16]
nombreCliente = str(detalleFactura[0][18])
nifCliente = detalleFactura[0][19]
fechaContable = detalleFactura[0][22]
anulacion = detalleFactura[0][23]
logger.info("Regimen Especial o Trascendencia: " + str(regEspecial) +
" | Tipo Factura: " + str(tipoFactura))
#En caso de que sea rectificativa construimos la cadena.
if tipoFactura[0] == 'R':
logger.info("Factura Rectificativa ......................")
consBaseRectif = sqlBaseRectificativas.replace("{SERIEFACTURA}",
str(serieFactura))
consBaseRectif = consBaseRectif.replace("{NUMEROFACTURA}",
str(numeroFactura))
respRectif = consultaMSSQL(consBaseRectif)
baseRectif = respRectif[0][3]
cuotaRectif = respRectif[0][4]
consFactARect = sqlFacturaARectificar.replace("{SERIE}",
str(serieFactura))
consFactARect = consFactARect.replace("{NUMERO}", str(numeroFactura))
facturaARectificar = consultaMSSQL(consFactARect)
print "Observaciones: " + str(facturaARectificar) + "\r\n"
#aqui obtenemos el numero de la factura entre corchetes.
if facturaARectificar:
cadFact = facturaARectificar[0][0]
print str(cadFact)
pFacIni = cadFact.index("#")
pFacFin = cadFact.index("#", pFacIni + 1)
pFechaIni = cadFact.index("#", pFacFin + 1)
pFechaFin = cadFact.index("#", pFechaIni + 1)
print("Pos Ini: " + str(pFacIni) + " | Pos Fin: " + str(pFacFin))
numFactARectificar = cadFact[pFacIni + 1:pFacFin]
fechaFact = cadFact[pFechaIni + 1:pFechaFin]
#numFactARectificar = cadFact[cadFact.index("#")+1:cadFact.index("#",2)]
print "Factura: " + str(
numFactARectificar) + " | Fecha: " + fechaFact
else:
logger.info(
"Por favor debe introducir la informacion relativa a la factura que se modifica. Campo Observaciones."
)
logger.info("Base Rectificada: " + str(baseRectif) +
" Cuota Rectificada: " + str(cuotaRectif) +
" FechaFactEmisor: " + str(fechaExpFactEmisor))
logger.info("Anulacion: " + anulacion.upper())
#Caso de sustitucion de factura
if anulacion.upper().find("ANULACION") >= 0:
cadFinRectificadas = cadRectificadas.replace("{TIPORECT}", "S")
cadFinRectificadas = cadFinRectificadas.replace(
"{numSerieFactEmisor}", str(numFactARectificar))
cadFinRectificadas = cadFinRectificadas.replace(
"{fechaExpFactEm}", str(fechaFact))
cadFinRectificadas = cadFinRectificadas.replace(
"{BASERECTIFICADA}", '{:12.2f}'.format(baseRectif))
cadFinRectificadas = cadFinRectificadas.replace(
"{CUOTARECTIFICADA}", '{:12.2f}'.format(cuotaRectif))
else: #caso de diferencias
cadFinRectificadas = cadRectificadasDif.replace("{TIPORECT}", "I")
cadFinRectificadas = cadFinRectificadas.replace(
"{numSerieFactEmisor}", str(numFactARectificar))
cadFinRectificadas = cadFinRectificadas.replace(
"{fechaExpFactEm}", str(fechaFact))
logger.info("Cadena Rectificadas: " + str(cadFinRectificadas))
cadFactura = cadFactura.replace("{CADRECTIFICADAS}",
str(cadFinRectificadas))
else:
cadFactura = cadFactura.replace("{CADRECTIFICADAS}", "")
logger.info("Tipo de Factura:" + str(tipoFactura))
cadDesgloseImpuestos = ''
cuotaIVATotal = 0
cadDesglosesIVAs = ""
logger.info("Comenzamos a tratar los ivas ... " +
str(len(impuestosFactura)) + " | ")
#Primero debemos cargar los Desgloses de IVA en caso de que exista
if len(impuestosFactura) > 0: #aqui puede ser que lleve iva al 0
for i, imp in enumerate(impuestosFactura):
sqlDetImpuesto = sqlRecuperaImpuesto.replace(
"{SERIEFACTURA}", str(serieFactura))
sqlDetImpuesto = sqlDetImpuesto.replace("{NUMEROFACTURA}",
str(numeroFactura))
#print imp[0]
sqlDetImpuesto = sqlDetImpuesto.replace("{IVA}", str(imp[0]))
logger.info("Consulta Detalle impuesto: " + sqlDetImpuesto)
respDetalle = consultaMSSQL(sqlDetImpuesto)
iva = respDetalle[0][3]
base = respDetalle[0][4]
cuota = respDetalle[0][5]
cadParDesglose = cadDesgloseIVA.replace("{porcenIVA}",
'{:3.2f}'.format(iva))
cadParDesglose = cadParDesglose.replace("{baseImp}",
'{:12.2f}'.format(base))
cadParDesglose = cadParDesglose.replace("{cuotaIVA}",
'{:12.2f}'.format(cuota))
print cuota
if i == 0:
cadDesgloseImpuestos = cadParDesglose
#print "Primer Impuesto: " + cadDesgloseImpuestos
else:
cadDesgloseImpuestos = cadDesgloseImpuestos + "," + cadParDesglose
#print "Cadena final Impuestos" + cadDesgloseImpuestos
cuotaIVATotal = cuotaIVATotal + cuota
#aqui debemos comprobar si lleva también iva al 0%
consIvaAlCero = sqlIvaAlCero.replace("{serie}", str(serieFactura))
consIvaAlCero = consIvaAlCero.replace("{numDocPropio}",
str(numeroFactura))
respIvaCero = consultaMSSQL(consIvaAlCero)
if respIvaCero:
base = respIvaCero[0][1]
cadParDesglose = cadDesgloseIVA.replace("{porcenIVA}",
'{:3.2f}'.format(0))
cadParDesglose = cadParDesglose.replace("{baseImp}",
'{:3.2f}'.format(base))
cadParDesglose = cadParDesglose.replace("{cuotaIVA}",
'{:3.2f}'.format(0))
cadDesgloseImpuestos = cadDesgloseImpuestos + "," + cadParDesglose
#Caso de que sea una factura sin IVA
else:
logger.info("EXENTA IVA ...")
exentaIVA = 1
consExencion = sqlExencion.replace("{SERIEFACTURA}", str(serieFactura))
consExencion = consExencion.replace("{NUMEROFACTURA}",
str(numeroFactura))
# primero deberemos recuperar el tipo de exencion
logger.info("Consulta Exencion: " + consExencion)
exencion = consultaMSSQL(consExencion)
consBaseImponible = sqlBaseImponible.replace("{SERIEFACTURA}",
str(serieFactura))
consBaseImponible = consBaseImponible.replace("{NUMEROFACTURA}",
str(numeroFactura))
base = consultaMSSQL(consBaseImponible)
logger.info("Exencion: " + str(exencion) + " | " + "Base: " +
str(base[0][4]))
#NO USAR cadExentaImpuestos --> usar cadInversionSujetoPasivo
print "Exencion: " + str(exencion)
if exencion: #Ha encontrado una E, Inversion de sujeto Pasivo
print "Inversion de Sujeto Pasivo"
baseImponible = base[0][4]
cuotaIva = baseImponible * 0.21
cuotaDeducible = cuotaDeducible + cuotaIva
cadFinExenta = cadInvSujPasivo.replace("{porcenIVA}", "21.00")
cadFinExenta = cadFinExenta.replace("{baseImp}",
'{:12.2f}'.format(base[0][4]))
cadFinExenta = cadFinExenta.replace("{cuotaIVA}",
'{:12.2f}'.format(cuotaIva))
else: #Es una factura Normal --> Desglose IVA
print "DesgloseIVA"
cadFinExenta = cadDesgloseIVA.replace("{porcenIVA}", "0.00")
cadFinExenta = cadFinExenta.replace("{baseImp}",
'{:12.2f}'.format(base[0][4]))
cadFinExenta = cadFinExenta.replace("{cuotaIVA}", "0.00")
if len(impuestosFactura) >= 1:
cadFinImpuestos = cadDesgloseImpuestos
else:
cadFinImpuestos = cadFinExenta
#Ahora reemplazamos el desglose en los impuestos
#cadFinImpuestos = cadFactura.replace("{CADDESGLOSEFACTURA}", cadDesgloseImpuestos )
logger.info("FechaExpedicion: " + str(fechaExpFactEmisor))
logger.info("FechaContable: " + str(fechaContable))
fact = cadFactura.replace("{anio}", str(ejercicio))
fact = fact.replace("{mes}", str(mes).zfill(2))
fact = fact.replace("{numSerieFactEmisor}", str(numSerieFactEmisor))
fact = fact.replace("{fechaExpFactEm}", str(fechaExpFactEmisor))
fact = fact.replace("{tipoFactura}", str(tipoFactura))
fact = fact.replace("{descripOperacion}", str(descripOperacion))
fact = fact.replace("{nombreCliente}", str(nombreCliente))
fact = fact.replace("{nifCliente}", str(nifCliente))
fact = fact.replace("{IDEMISORFACTURA}", str(nifCliente))
fact = fact.replace("{REGESPECIAL}", str(regEspecial))
fact = fact.replace("{fechaRegContable}", str(fechaContable))
fact = fact.replace("{cuotaDeducible}", '{:12.2f}'.format(cuotaDeducible))
cadDesFact = cadDesgloseFactura.replace(
"{DESGLOSESIVAS}", str(cadFinImpuestos)) #antes cadFinImpuestos
logger.info("cadDesFact: " + str(cadDesFact))
logger.info("Factura Compra --> " + fact)
#concatenamos la cadena de impuestos
if exentaIVA == 0: #No Tiene exencion
fact = fact.replace("{CADDESGLOSEFACTURA}", str(cadDesFact))
else:
#comprobamos primero si es exenta.
if exencion:
fact = fact.replace("{CADDESGLOSEFACTURA}", str(cadFinExenta))
else:
fact = fact.replace("{CADDESGLOSEFACTURA}", str(cadDesFact))
# fact = fact.replace("{porcenIVA}", '{:3.2f}'.format(porcenIVA) )
# fact = fact.replace("{baseImp}", '{:12.2f}'.format(baseImp) )
# fact = fact.replace("{cuotaIVA}", '{:12.2f}'.format(cuotaIVA) )
logger.info(cadCabecera)
logger.info(fact)
#Convertimos cadenas a Diccionarios
dicCabecera = ast.literal_eval(cadCabecera)
dicFactura = ast.literal_eval(fact)
print dicCabecera
print '\r\n'
print dicFactura
#WEBSERVICE AEAT
#wsdl = 'http://www.agenciatributaria.es/static_files/AEAT/Contenidos_Comunes/La_Agencia_Tributaria/Modelos_y_formularios/Suministro_inmediato_informacion/FicherosSuministros/V_07/SuministroFactEmitidas.wsdl'
#wsdl = '/wlpl/SSII-FACT/ws/fe/SiiFactFEV1SOAP/SuministroFactEmitidasPrueba.wsdl'
# Descargar los wsdl de la aeat y modificar la url del servicio por la del servicio de pruebas ya que si no te manda a XXXX
## ------------------------- OJO CREO QUE NO ESTAMOS UTILIZANDO EL SERVICIO DE PRUEBAS --------
wsdl = rutaDatos + 'SuministroFactRecibidas.wsdl'
#wsdl = "./WSDLPruebas/SuministroFactEmitidasPrueba.wsdl"
#SSL CONECTION
session = Session()
#session.cert='cert.pem'
session.cert = (rutaCertificados + "clavePublica.pem",
rutaCertificados + "clavePrivada.pem")
session.verify = True
transport = Transport(session=session)
#logger.debug()
#FIRMA XML ENVIO
#signature = Signature("./certificados/cert.pem","./certificados/clavePrivada.crt")
client = Client(wsdl=wsdl,
port_name="SuministroFactRecibidas",
transport=transport,
service_name='siiService')
logger.info('Establecida conexion con cliente')
#SELECCION SERVICIO DE PRUEBAS SuministroLRFacturasEmitidas, SuministroFactRecibidas
service2 = client.bind('siiService', 'SuministroFactRecibidas')
logger.info('Bind al servicio')
#INSERCION DE LA FACTURA Y RESPUESTA EN EL SERVICO DE PRUEBAS.
#print (service2.SuministroLRFacturasEmitidas(cabecera,facturas))
salida = (service2.SuministroLRFacturasRecibidas(dicCabecera, dicFactura))
logger.info('Factura envidada')
#print salida
#INSERCION DE LA FACTURA Y RESPUESTA EN EL SERVICO.
#print (client.service.SuministroLRFacturasEmitidas(cabecera,facturas))
#Procesamos la salida
csv = salida['CSV']
datosPres = salida['DatosPresentacion']
logger.info('Datos Presentacion: ' + str(datosPres))
if datosPres is not None:
logger.info("Datos Presentacion: Datos ")
fechaPresentacion = datosPres['TimestampPresentacion']
else:
fa = datetime.datetime.now()
fechaPresentacion = "%s/%s/%s %s:%s:%s" % (
fa.day, fa.month, fa.year, fa.hour, fa.minute, fa.second)
estadoEnvio = salida['EstadoEnvio']
respLinea = salida['RespuestaLinea'][0]
logger.info("Respuesta Linea: " + str(respLinea))
idFactura = respLinea['IDFactura']
if idFactura is not None:
logger.info("ID Factura: Datos ")
nSerFacEm = idFactura['NumSerieFacturaEmisor']
if respLinea is not None:
logger.info("Respuesta Linea: Datos ")
estadoRegistro = respLinea['EstadoRegistro']
codErrorRegistro = respLinea['CodigoErrorRegistro']
descripErrorReg = respLinea['DescripcionErrorRegistro']
csv2 = respLinea['CSV']
#Preparamos la cadena para insertar
consInsResp = sqlGuardaRespuesta.replace('{CSV}', str(csv))
consInsResp = consInsResp.replace('{TIPOFAC}', 'COMPRA')
consInsResp = consInsResp.replace('{SERIE}', str(serieFactura))
consInsResp = consInsResp.replace('{NUMERO}', str(numeroFactura))
consInsResp = consInsResp.replace('{ESTADOENVIO}', str(estadoEnvio))
consInsResp = consInsResp.replace('{NUMSERIEFACTEMISOR}', str(nSerFacEm))
consInsResp = consInsResp.replace('{ESTADOREGISTRO}', str(estadoRegistro))
consInsResp = consInsResp.replace('{FECHAPRESENTACION}',
str(fechaPresentacion))
consInsResp = consInsResp.replace('{CODERRORREGISTRO}',
str(codErrorRegistro))
consInsResp = consInsResp.replace('{DESCRIPERRORREGISTRO}',
str(descripErrorReg))
consInsResp = consInsResp.replace('{CSV2}', str(csv2))
logger.info("CSV: " + str(csv) + " | SERIE: " + str(serieFactura) +
" | Numero: " + str(numeroFactura) + " | Estado Envio: " +
str(estadoEnvio) + " | Num. Ser. Fac. Em.: " + str(nSerFacEm) +
" | Estado Registro: " + str(estadoRegistro) +
" | Fecha Presentacion: " + str(fechaPresentacion) +
" | Cod. Error Registro: " + str(codErrorRegistro) +
" | Descrip. Error: " + str(descripErrorReg) + " | CSV2: " +
str(csv2))
logger.info("Consulta: " + str(consInsResp))
insercionBD = consultaMSSQL(consInsResp)
logger.info('Respuesta de la insercion: ' + str(insercionBD))
logger.removeHandler(fh)
# service = client.create_service(
# '{http://rg.kg/mis/portal}WebPortalSoap12Binding', 'http://rg.kg/mis/portal')
#
# print (a)
history = HistoryPlugin()
session = Session()
session.auth = HTTPBasicAuth('MedML', '12345')
client = Client('http://178.216.210.23/portal/ws/wsWebPortal.1cws?wsdl',
transport=Transport(session=session))
service2 = client.bind('WebPortal', 'WebPortalSoap12')
#
# a = client.service.Sync()
# d = datetime.datetime.strptime("2013-1-25", '%Y-%m-%d')
# print (datetime.date.strftime(d, "%m-%d-%Y"))
# print(a['Hospital']['Schedules'])
# print(a['Hospital'])
# print(a['Hospital']['Id'])
# print(a['Hospital']['Name'])
# for i in (a['Hospital']['Department']):
# print(i['Id'], i['Name'])
# for schedule in a['Schedules']['Schedule']:
# d = datetime.datetime.strptime(str(schedule['Date']), '%Y-%m-%d')
# print(schedule['CabinetId'], datetime.date.strftime(d, "%m-%d-%Y"))
def downloadReport(wsdl, username, password, reportpath, executionOptions):
"""
The function connects to the OBIEE and download report's data, returnes Pandas DataFrame
"""
# Initializing SOAP client, start a session, and make a connection to XmlViewService binding
session = Session()
session.verify = True
transport = Transport(session=session)
client = Client(wsdl=wsdl,
wsse=UsernameToken(username, password),
transport=transport)
sessionid = client.service.logon(username, password)
xmlservice = client.bind('XmlViewService')
# Retrieveing data schema and column headings
max_retries = 30
while max_retries > 0:
schema = xmlservice.executeXMLQuery(report=reportpath,
outputFormat="SAWRowsetSchema",
executionOptions=executionOptions,
sessionID=sessionid)
if schema.rowset == None:
max_retries -= 1
continue
else:
time.sleep(10)
break
if schema.rowset == None:
client.service.logoff(sessionID=sessionid)
raise SAWRowsetSchemaError
columnHeading = re.findall(r'columnHeading="(.*?)"', schema.rowset)
dataset_dict = {}
for head in columnHeading:
dataset_dict[head] = []
# Making a query and parsing first datarows
queryresult = xmlservice.executeXMLQuery(report=reportpath,
outputFormat="SAWRowsetData",
executionOptions=executionOptions,
sessionID=sessionid)
queryid = queryresult.queryID
if queryresult.rowset == None:
client.service.logoff(sessionID=sessionid)
raise SAWRowsetDataError
ETobject = ET.fromstring(queryresult.rowset)
namespacerows = ETobject.findall(
'{urn:schemas-microsoft-com:xml-analysis:rowset}Row')
for row in namespacerows:
for key in dataset_dict.keys():
dataset_dict[key].append(
row.find(
"{urn:schemas-microsoft-com:xml-analysis:rowset}Column" +
str(list(dataset_dict.keys()).index(key))).text)
# Determine if additional fetching is needed and if yes - parsing additional rows
queryfetch = queryresult.finished
while (not queryfetch):
queryfetch = xmlservice.fetchNext(queryID=queryid, sessionID=sessionid)
ETobject = ET.fromstring(queryfetch.rowset)
namespacerows = ETobject.findall(
'{urn:schemas-microsoft-com:xml-analysis:rowset}Row')
for row in namespacerows:
for key in dataset_dict.keys():
dataset_dict[key].append(
row.find(
'{urn:schemas-microsoft-com:xml-analysis:rowset}Column'
+ str(list(dataset_dict.keys()).index(key))).text)
queryfetch = queryfetch.finished
# By some reason OBIEE doesn't make the last fetching, it will fix it
queryfetch = False
while (not queryfetch):
queryfetch = xmlservice.fetchNext(queryID=queryid, sessionID=sessionid)
ETobject = ET.fromstring(queryfetch.rowset)
namespacerows = ETobject.findall(
'{urn:schemas-microsoft-com:xml-analysis:rowset}Row')
for row in namespacerows:
for key in dataset_dict.keys():
dataset_dict[key].append(
row.find(
'{urn:schemas-microsoft-com:xml-analysis:rowset}Column'
+ str(list(dataset_dict.keys()).index(key))).text)
queryfetch = True
return pd.DataFrame(dataset_dict)
rutaCertificados + "clavePrivada.pem")
session.verify = True
transport = Transport(session=session)
#logger.debug()
#FIRMA XML ENVIO
#SuministroFactRecibidas
client = Client(wsdl=wsdl,
port_name="SuministroFactRecibidas",
transport=transport,
service_name='siiService')
logger.info('Establecida conexion con cliente')
#SELECCION SERVICIO DE PRUEBAS SuministroLRFacturasEmitidas
#SuministroLRFacturasRecibidas
#SuministroLRFacturasRecibidas
service2 = client.bind('siiService', 'SuministroFactRecibidas')
logger.info('Bind al servicio')
#INSERCION DE LA FACTURA Y RESPUESTA EN EL SERVICO DE PRUEBAS.
#print (service2.SuministroLRFacturasEmitidas(cabecera,facturas))
salida = (service2.ConsultaLRFacturasRecibidas(dicCabecera, dicFactura))
logger.info("--> Salida: --> '" + str(salida))
logger.info('Consulta finalizada.')
#print salida
nFila = 2
nCol = 0
#Comprobamos si hay salida
if salida['RegistroRespuestaConsultaLRFacturasRecibidas']:
dPeriodo = salida['PeriodoImpositivo']
sinSalida = 0 #hay salida
def process_units(queue: multiprocessing.Queue, process_no, api_key,
mastr_number, output):
logging.getLogger('zeep').setLevel(logging.CRITICAL)
logging.basicConfig(stream=sys.stderr, level=logging.INFO)
output_exists = output.exists()
force_termination = False
def terminate(*args):
nonlocal force_termination
if force_termination:
logger.warning(f'Process {process_no}: Force termination')
raise KeyboardInterrupt('Force exit')
else:
logger.info(f'Process {process_no}: Set to gracefully terminate')
force_termination = True
signal.signal(signal.SIGINT, terminate)
wsdl = 'https://www.marktstammdatenregister.de/MaStRAPI/wsdl/mastr.wsdl'
transport = Transport(cache=InMemoryCache(), operation_timeout=60)
settings = Settings(strict=False, xml_huge_tree=True)
client = Client(wsdl=wsdl, transport=transport, settings=settings)
client_bind = client.bind('Marktstammdatenregister', 'Anlage')
with output.open('a') as f:
writer = csv.DictWriter(f, field_names)
if not output_exists:
writer.writeheader()
while True:
unit_mastr_numbers = queue.get(block=True)
logger.info(f'Process {process_no}: Processing next batch')
if unit_mastr_numbers is None:
logger.info(
f'Process {process_no}: Received termination sentinel -> no more data to process.'
)
return
errors_count = 0
for unit_number in unit_mastr_numbers:
if force_termination:
logger.info(
f'Process {process_no}: Gracefully terminating')
return
if errors_count > ERRORS_LIMIT:
logger.warning(
f'Process {process_no}: Reached errors limit, discarding this batch'
)
break
try:
c = fetch_unit(client_bind, api_key, mastr_number,
unit_number)
respond = serialize_object(c)
writer.writerow({
k: (v.get('Wert', '<<unknown structure>>') if hasattr(
v, 'get') else v)
for k, v in respond.items()
})
# We got successful reply, the previous errors might not be related ==> continue
errors_count = 0
except Fault as e:
logger.warning(
f'Process {process_no}: Got error, but continuing: {e.message}'
)
errors_count += 1
def executeSQLmulti(wsdl, username, password, queries, executionOptions):
# Initializing SOAP client, start a session, and make a connection to XmlViewService binding
session = Session()
session.verify = True
transport = Transport(session=session)
client = Client(wsdl=wsdl,
wsse=UsernameToken(username, password),
transport=transport)
sessionid = client.service.logon(username, password)
xmlservice = client.bind('XmlViewService')
data = {}
for queryname in queries.keys():
# Number of attemts to retrieve SAWRowsetSchema
max_retries = 30
while max_retries > 0:
schema = xmlservice.executeSQLQuery(
sql=queries[queryname],
outputFormat="SAWRowsetSchema",
executionOptions=executionOptions,
sessionID=sessionid)
if schema.rowset == None:
max_retries -= 1
continue
else:
break
if schema.rowset == None:
client.service.logoff(sessionID=sessionid)
raise SAWRowsetSchemaError
columnHeading = re.findall(r'columnHeading="(.*?)"', schema.rowset)
dataset_dict = {}
for head in columnHeading:
dataset_dict[head] = []
# Making a query and parsing first datarows
queryresult = xmlservice.executeSQLQuery(
sql=queries[queryname],
outputFormat="SAWRowsetData",
executionOptions=executionOptions,
sessionID=sessionid)
queryid = queryresult.queryID
if queryresult.rowset == None:
client.service.logoff(sessionID=sessionid)
raise SAWRowsetDataError
ETobject = ET.fromstring(queryresult.rowset)
namespacerows = ETobject.findall(
'{urn:schemas-microsoft-com:xml-analysis:rowset}Row')
for row in namespacerows:
for key in dataset_dict.keys():
rowdata = row.find(
"{urn:schemas-microsoft-com:xml-analysis:rowset}Column" +
str(list(dataset_dict.keys()).index(key)))
if rowdata != None:
dataset_dict[key].append(rowdata.text)
else:
dataset_dict[key].append("")
# Determine if additional fetching is needed and if yes - parsing additional rows
queryfetch = queryresult.finished
while (not queryfetch):
queryfetch = xmlservice.fetchNext(queryID=queryid,
sessionID=sessionid)
ETobject = ET.fromstring(queryfetch.rowset)
namespacerows = ETobject.findall(
'{urn:schemas-microsoft-com:xml-analysis:rowset}Row')
for row in namespacerows:
for key in dataset_dict.keys():
rowdata = row.find(
"{urn:schemas-microsoft-com:xml-analysis:rowset}Column"
+ str(list(dataset_dict.keys()).index(key)))
if rowdata != None:
dataset_dict[key].append(rowdata.text)
else:
dataset_dict[key].append("")
queryfetch = queryfetch.finished
data[queryname] = dataset_dict
client.service.logoff(sessionID=sessionid)
return data
#SSL CONECTION
session = Session()
session.cert = (rutaCertificados + "clavePublica.pem",
rutaCertificados + "clavePrivada.pem")
session.verify = True
transport = Transport(session=session)
#logger.debug()
#FIRMA XML ENVIO
client = Client(wsdl=wsdl,
port_name="SuministroFactEmitidas",
transport=transport,
service_name='siiService')
logger.info('Establecida conexion con cliente')
#SELECCION SERVICIO DE PRUEBAS SuministroLRFacturasEmitidas
service2 = client.bind('siiService', 'SuministroFactEmitidas')
logger.info('Bind al servicio')
#INSERCION DE LA FACTURA Y RESPUESTA EN EL SERVICO DE PRUEBAS.
#print (service2.SuministroLRFacturasEmitidas(cabecera,facturas))
logger.info("Cabecera : " + str(dicCabecera) + "Consulta: " + str(dicFactura))
salida = (service2.ConsultaLRFacturasEmitidas(dicCabecera, dicFactura))
logger.info("--> Salida: --> '" + str(salida))
logger.info('Consulta finalizada.')
nFila = 2
nCol = 0
#logger.info("Salida en Bruto: " + str(salida))
#Comprobamos si hay salida
if salida['RegistroRespuestaConsultaLRFacturasEmitidas']:
import requests
from requests.auth import HTTPBasicAuth
from zeep import Client
from zeep.transports import Transport
REPO_ID = 'b1f744ae-34c2-4ad3-b73d-c1f8ab5a8e2a'
ROOT_FOLDER_ID = 'workspace://SpacesStore/90e3ee82-c8dd-4eb6-8894-9802c24690e9'
session = requests.Session()
session.auth = HTTPBasicAuth('admin', 'admin')
client = Client('http://alfresco.example.org/alfresco/cmisws/cmis?wsdl',
transport=Transport(session=session))
factory = client.type_factory('ns2')
nav = client.bind('NavigationService', 'NavigationServicePort')
repo = client.bind('RepositoryService', 'RepositoryServicePort')
r = nav.getChildren(REPO_ID, ROOT_FOLDER_ID)
# - https://adriennedomingus.com/blog/using-zeep-to-make-soap-requests-in-python
# - https://webkul.com/blog/python-soap-clients-with-zeep/
# - https://hub.docker.com/r/jsorah/python-zeep-docker
# - https://github.com/mvantellingen/python-zeep
# - http://webservices.oorsprong.org/websamples.countryinfo/CountryInfoService.wso?WSDL
#
client = Client(
'http://webservices.oorsprong.org/websamples.countryinfo/CountryInfoService.wso?WSDL'
)
#
# @see https://docs.python-zeep.org/en/master/client.html#using-non-default-bindings
# usage:
# client = Client("https://www.my.wsdl") # this will use default binding
# client_s12 = client.bind('CountryInfoService', 'CountryInfoServiceSoap12')
#
#<service name="CountryInfoService">
# <documentation>This DataFlex Web Service opens up country information. 2 letter ISO codes are used for Country code. There are functions to retrieve the used Currency, Language, Capital City, Continent and Telephone code.</documentation>
# <port name="CountryInfoServiceSoap" binding="tns:CountryInfoServiceSoapBinding">
# <soap:address location="http://webservices.oorsprong.org/websamples.countryinfo/CountryInfoService.wso"/>
# </port>
# <port name="CountryInfoServiceSoap12" binding="tns:CountryInfoServiceSoapBinding12">
# <soap12:address location="http://webservices.oorsprong.org/websamples.countryinfo/CountryInfoService.wso"/>
# </port>
#</service>
#
client_s12 = client.bind('CountryInfoService', 'CountryInfoServiceSoap12')
result = client_s12.ListOfContinentsByName()
print("==========================================")
print(result)
print("==========================================")
class WSTitulusClient(object):
"""
"""
def __init__(self,
wsdl_url,
username,
password,
template_xml_flusso=open(
settings.DOCUMENTO_ENTRATA_PATH).read(),
**kwargs):
self.username = username
self.password = password
self.wsdl_url = wsdl_url
self.template_xml_flusso = template_xml_flusso
self.doc = self.template_xml_flusso.format(**kwargs)
# RPA username and code
# (per impersonificare RPA in fascicolazione!)
self.rpa_username = kwargs.get('destinatario_username')
self.rpa_code = kwargs.get('destinatario_code', None)
# send email
self.send_email = kwargs.get('send_email', False)
# zeep
self.client = None
self.service = None
# numero viene popolato a seguito di una protocollazione
if kwargs.get('numero') and kwargs.get('anno'):
self.numero = kwargs.get('numero')
self.anno = kwargs.get('anno')
else:
self.numero = None
self.anno = None
# attachments
self.allegati = []
def connect(self):
"""
"""
session = Session()
settings = Settings(strict=False, xml_huge_tree=True)
session.auth = HTTPBasicAuth(self.username, self.password)
transport = Transport(session=session)
self.client = Client(self.wsdl_url,
transport=transport,
settings=settings)
self.service = self.client.bind('Titulus4Service', 'Titulus4')
return self.client
def is_connected(self):
return True if self.client else False
def assure_connection(self):
if not self.is_connected():
self.connect()
def protocolla(self, test=False, force=False):
self.assure_connection()
namespaces = settings.PROTOCOL_NAMESPACES if not test else settings.PROTOCOL_NAMESPACES_DEBUG
if not force:
if self.numero or self.anno:
raise Exception(
('Stai tentando di protocollare '
'una istanza che ha già un '
'numero e un anno: {}/{}').format(self.numero, self.anno))
ns0 = namespaces["ns0"]
ns2 = namespaces["ns2"]
attachmentBean_type = self.client.get_type(f'{ns0}AttachmentBean')
attachmentBeans_type = self.client.get_type(
f'{ns2}ArrayOf_tns1_AttachmentBean')
saveParams = self.client.get_type(f'{ns0}SaveParams')()
attachmentBeans = attachmentBeans_type(self.allegati)
saveParams.pdfConversion = True
saveParams.sendEMail = self.send_email
saveDocumentResponse = None
saveDocumentResponse = self.service.saveDocument(
self.doc, attachmentBeans, saveParams)
if saveDocumentResponse:
root = ET.fromstring(saveDocumentResponse._value_1)
self.numero = root[1][0].attrib['num_prot']
return True
def _get_allegato_dict(self):
return {'content': None, 'description': None, 'filename': None}
# force PDF
# 'mimeType': "application/pdf"}
def aggiungi_allegato(self,
fopen,
nome,
descrizione,
is_doc_princ=False,
test=False):
namespaces = settings.PROTOCOL_NAMESPACES if not test else settings.PROTOCOL_NAMESPACES_DEBUG
ns1 = namespaces["ns1"]
ext = os.path.splitext(nome)[1]
if not ext:
raise Exception(("'nome' deve essere con l'estensione "
"esempio: .pdf altrimenti errore xml -201!"))
self.assure_connection()
content_type = self.client.get_type(f'{ns1}base64Binary')
content = content_type(fopen.read())
allegato_dict = self._get_allegato_dict()
allegato_dict['content'] = content
allegato_dict['description'] = descrizione
allegato_dict['filename'] = nome
# if it's principal document insert in first position
if is_doc_princ:
self.allegati.insert(0, allegato_dict)
else:
self.allegati.append(allegato_dict)
return allegato_dict
def aggiungi_docPrinc(self, fopen, nome_doc, tipo_doc):
return self.aggiungi_allegato(fopen=fopen,
nome=nome_doc,
descrizione=tipo_doc,
is_doc_princ=True)
def fascicolaDocumento(self, fascicolo):
self.assure_connection()
if self.rpa_username:
self.service.setWSUser(self.rpa_username, self.rpa_code)
response = self.service.addInFolder(fascicolo)
if response:
return True
# root = ET.fromstring(response._value_1)
def cercaDocumento(self, key, value):
self.assure_connection()
query = f'[{key}]={value}'
return self.service.search(query, xsd.SkipValue, xsd.SkipValue)
def connect_apriso(self):
try:
client = Client(constants.APRISO_URL % (self.host))
self.service = client.bind('JobExecutor', 'JobExecutorSoap12')
except Exception as e:
raise
operation.soapaction] if operation.soapaction is not None else []))
Soap12Binding._set_http_headers = _set_http_headers
def _set_http_headers(self, serialized, operation):
serialized.headers['Content-Type'] = '; '.join(
['application/soap+xml', 'charset=utf-8'] +
(['action="%s"' %
operation.soapaction] if operation.soapaction is not None else []))
soap = Client('config/drv.wsdl')
query = soap.bind('GetPSService', 'PSPort')
keys = [
'PS_Area', 'PS_CommissionAdr', 'PS_CommissionLocation', 'PS_Desc',
'PS_GeoDVK', 'PS_GeoData', 'PS_GeoPG', 'PS_Num', 'PS_PlaceVotingAdr',
'PS_PlaceVotingLocation', 'PS_Size', 'PS_Type', 'Region_Id'
]
geokeys = {'PS_GeoDVK', 'PS_GeoData', 'PS_GeoPG'}
def mapper(entry, key, geokeys):
"""
Extract the necessary output from a data record from the server response
:param entry: data record (one polling station)
:param key: field to be process
:param geokeys: set of keys with GeoJSON data
import os
from zeep.plugins import HistoryPlugin
from zeep import Client
from lxml import etree
from datetime import datetime
wsdl_url = 'https://podbwebservice.ports.je/AIDXQueryFlights/Services/RequestFlightService.svc?wsdl'
service = 'RequestFlightService'
port = 'BasicHttpsBinding_IRequestFlightService'
userID = 'POJWebInternal456'
history = HistoryPlugin()
client = Client(wsdl_url, plugins=[history])
service2 = client.bind(service, port)
service2.flightRequest(userID = userID, fullRefresh = True)
flight_xml = etree.tostring(history.last_received["envelope"], encoding="unicode", pretty_print=True)
if "Warning:" in flight_xml:
print("[",datetime.now(),"] - WARNING! Unable to access AIDX")
else:
f = open("flightinfo.xml", "w")
f.write(flight_xml)
f.close()
print("[",datetime.now(),"] -",os.path.getsize('flightinfo.xml'),"Bytes pulled from AIDX")
from zeep import Client
from zeep import xsd
client = Client(
'https://ws.conf.ebs.health.gov.on.ca:1443/EDTService/EDTService?wsdl')
service2 = client.bind('SecondService', 'Port12')
service2.someOperation(myArg=1)
#SSL CONECTION
session = Session()
session.cert = (rutaCertificados + "clavePublica.pem", rutaCertificados + "clavePrivada.pem")
session.verify = True
transport = Transport(session=session)
#logger.debug()
#FIRMA XML ENVIO
#SuministroFactRecibidas
client = Client(wsdl=wsdl,port_name="SuministroOpIntracomunitarias",transport=transport, service_name = 'siiService')
logger.info('Establecida conexion con cliente')
#SELECCION SERVICIO DE PRUEBAS SuministroLRFacturasEmitidas
#SuministroLRFacturasRecibidas
#SuministroLRFacturasRecibidas
service2 = client.bind('siiService', 'SuministroOpIntracomunitarias')
logger.info('Bind al servicio')
#INSERCION DE LA FACTURA Y RESPUESTA EN EL SERVICO DE PRUEBAS.
salida = (service2.ConsultaLRDetOperacionIntracomunitaria(dicCabecera, dicFactura ))
logger.info("--> Salida: --> '" + str(salida) )
logger.info('Consulta finalizada.')
#print salida
nFila = 2
nCol = 0
#Comprobamos si hay salida
