# NOTE: VALIDAR PEDIDOS import re, json from time import sleep from generic.gn_api import gn_api # from generic.gn_request import Request # from datetime import datetime import base64 class mobilesales(gn_api): def __init__(self, argv:list): self.db = False setup = self.setup(argv) token = self.get_token_data('x-api-key') self.rote_handler() self.mobilesales_request = Request( base_url = "{}api/int/".format(self.environment_config.get('url')) , headers={ 'x-api-key' : f'{token}' }) super(mobilesales, self, ).__init__() print('Fim') def afterGet_historicoPedido_pendentes(self, data): timestamp = datetime.now().strftime("%Y%m%d%H%M%S") with open(f"/var/tmp/mobilesales_pedidos_{timestamp}.json", 'w') as f: json.dump(data['data'], f, indent=4, ensure_ascii=False) filtered_orders = [] for order in data['data']: if int(order['empresa']) != int(self.cdempresa) or int(order['filial']) != int(self.cdfilial): json_order = json.dumps(order, indent=4, ensure_ascii=False) self.createLog("400", "Pedido: {} - {}: Empresa/Filial do pedido não corresponde a empresa/filial configurada no integração. JSON {}".format(order['id'], order['sequence'], json_order)) continue filtered_orders.append(order) return filtered_orders def get_order_items(self, order): items = [ self.extractValues(item, "itenscarrinho_fields") for item in order['itens']] for indice, item in enumerate(items): items[indice]['IDTBPEDIDO'] = self.current_order['sequence'] return items def get_order_data(self, order) : req = self.mobilesales_request.doRequest( rote="historicoPedido/{id}".format(id=order['id']) ) if req.status_code == 200 : self.current_order = self.tryJson(req) return [ self.extractValues(self.current_order, 'pedido_fields') ] return False def customer_data(self, data) : # 139257 try: cliente = self.mobilesales_request.doRequest( rote="cliente/{id}".format(id=self.current_order['clienteId']) ) cliente = cliente.json() endereco = cliente.get('enderecos', []) contatos = cliente.get('contatos', []) data[ 'TIPO_PESSOA'] = cliente.get('tipo', '') data[ 'CNPJ_CPF'] = cliente.get('documento', '') data[ 'NOME_FANTASIA'] = cliente.get('nome', '') data[ 'RAZAO_SOCIAL'] = cliente.get('razaoSocial', '') if len(endereco): endereco = endereco[0] data[ 'ENDERECO'] = endereco.get('endLogradouro', '') data[ 'ENDERECO_NRO'] = endereco.get('endNumero', '') data[ 'COMPLEMENTO'] = endereco.get('endComplemento', '') data[ 'CEP'] = endereco.get('endCep', '') data[ 'BAIRRO'] = endereco.get('endBairro', '') data[ 'CIDADE'] = endereco.get('endCidade', '') data[ 'ESTADO'] = endereco.get('endEstado', '') else: self.createLog("400", "Erro ao coletar o endereço do cliente para cadastro em nosso sistema") if len(contatos): contatos = contatos[0] data[ 'TELEFONE'] = contatos.get('conTelefone')[2:] data[ 'DDD'] = contatos.get('conTelefone')[:2] data[ 'EMAIL'] = contatos.get('conEmail') else: self.createLog("400", "Erro ao coletar o telefone do cliente para cadastro em nosso sistema") except Exception as e: self.createLog("400", "Erro ao coletar os dados para cadastro o cliente em nosso sistema") #print(response) return data #--------------------------------------------------------# #--------------- TRATAMENTO FILTROS DE ROTA -------------# #--------------------------------------------------------# def rote_filter_historicoPedido_pendentes_sequence(self): return self.mountRouteParams( { "empresa" : int(self.cdempresa), "filial" : int(self.cdfilial) #,"sequence" : 58 } ) def rote_filter_historicoPedido_pendentes(self): return self.mountRouteParams( { "empresa" : int(self.cdempresa), "filial" : int(self.cdfilial) #,"sequence" : 58 } ) # #### ###### ## ###### ## ## #### ##### ###### #### ###### #### #### # ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## # #### ## ## ## ## ## ## #### ## ## ##### ## ## ## ## ## ## ## # ## ## ## ## ## ## ## ## ##### ## ## ## ## ## ## ## ## # ## ## ###### ## ## ## ## ## ## ## ## ## ## ## ## ## # #### ## ## ## ## ###### #### ## ###### #### ###### #### #### def beforeSend_historicoPedido_sequence(self, data): #SITUACAO_DIGITACAO { # INICIADA = "0", # IMPORTADO = "1", # PENDENTE_APROVACAO = "2", # APROVADO = "3", # REJEITADO = "4", # CANCELADO = "9" # } self.current_method = "PATCH" self.current_rote = f"historicoPedido/sequence/{data['sequence']}" if data['situacaoDigitacao'] == "9": data['codigo'] = "DEL-" + data['codigo'] del data['sequence'] return data def afterSend_historicoPedido_sequence(self, data) : self.getDb().delete( "TBPEDIDOSSTATUS" , ["IDTBPEDIDOSSTATUS={}".format(self.current_data['softdib_id'] )] ) pass # ##### ## ######## ####### ##### ##### ###### ###### ## ##### # ## ## #### # ## # ## ## ## ## ## ## ## ## ## #### ## ## # ## ## ## ## ## ## ## ## ## ## ## ## ## ## # ## ###### ## #### ## ## ## ##### ## ###### ##### # ## ## ## ## ## ## ### ## ## #### ## ## ## ## # ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## # ##### ## ## #### ####### ##### ##### ### ## ###### ## ## ##### def beforeSend_categoria(self, data): self.configDefaultRequest() if self.current_data['subgrupo'] != 0: data['codigo'] = "{}.{}".format(self.current_data['codigo'], self.current_data['subgrupo']) data['pai'] = "{}".format(self.current_data['codigo']) return data # ##### ###### ##### ##### ###### #### ###### ## ## ###### ## ## ## ###### ###### # ## ## ## ## ## ## ## ## ## ## ### ## ## #### ### ## ## ## # ## ## ##### ## ## ## ## ##### #### ##### ###### ## ## ## ###### ## ##### # ##### ## ##### ##### ## ## ## ###### ## ## ## ###### ## ## # ## ## ## ## ## ## ## ## ## ## ### ## ###### ## ### ## ## # ## ## ###### ## ## ## ###### #### ###### ## ## ## ## ## ## ## ## ###### def beforeSend_representante(self, data): self.configDefaultRequest() return self.remove_empty_fields(data) # #### ## ###### ###### ## ## ###### ###### # ## ## ## ## ## ### ## ## ## # ## ## ## ##### ###### ## ##### # ## ## ## ## ###### ## ## # ## ## ## ## ## ## ### ## ## # #### ###### ###### ###### ## ## ## ###### def beforeSend_cliente(self, data): self.configDefaultRequest() data['definicoes'][0]['usoConsumo'] = data['definicoes'][0]['usoConsumo'] == "S" data['definicoes'][0]['revenda'] = data['definicoes'][0]['revenda'] != "S" data['definicoes'][0]['tributaSt'] = False if data['definicoes'][0]['tributaSt'] == "ISENTO" else True data['definicoes'][0]['tributaIpi'] = data['definicoes'][0]['tributaIpi'] != "S" data['definicoes'][0]['tributaPis'] = data['definicoes'][0]['tributaPis'] != "S" data['definicoes'][0]['tributaCofins'] = data['definicoes'][0]['tributaCofins'] != "S" data = self.remove_empty_fields(data) return data # ###### ##### ## ## ## #### ##### #### ##### ###### ## #### #### ##### ## # ## ## ## #### ### ## ## ## ## ## ## ## ## ## #### ## ## ## ## ## ## #### # ## ## ## ## ## ###### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## # ## ##### ## ## ###### ## ##### ## ## ##### ## ## ## ## ## ## ## ##### ## ## # ## ## ## ###### ## ### ## ## ## ## ## ## ## ###### ## ## ## ## ## ## ###### # ## ## ## ## ## ## ## #### ## #### ## ## ## ## ## #### #### ## ## ## ## def beforeSend_transportadora(self, data): self.configDefaultRequest() data = self.remove_empty_fields(data) return data # ###### ###### ##### ###### ## ## ######## ##### ##### # ## ## ## ## ## ## ## ## ## ## # ## # ## ## ## ## # ## ## ## ## ## ## ## ## ## ## ## ## ## ## # ## ## ##### ## ## ## ## ## ## ## ## ## ##### # ##### #### ## ## ## ## ## ## ## ## ## ## # ## ## ## ## ## ## ## ## ## ## ## ## ## ## # ### ### ## ##### ###### #### #### ##### ##### def beforeSend_produto(self, data): self.configDefaultRequest() if data['codigoBarras'] == "": del data['codigoBarras'] data['tributaIpi'] = data['tributaIpi'] == 'S' return data # #### #### ## ## #### ##### ## ##### # ## ## ## ## ### ## ## ## ## ## #### ## # ## ## ## ###### ## ## ## ## ## ## ## # ## ## ## ###### ## ## ##### ## ## ## ### # ## ## ## ## ## ### ## ## ## ###### ## ## # #### #### ## ## #### ## ## ## ##### def beforeSend_condicao_pagamento(self, data): self.configDefaultRequest() return data # ###### ## ## ##### #### #### ###### #### #### # ## ### ### ## ## ## ## ## ## ## ## ## # ## ####### ## ## ## ## #### ## ## ## #### # ## ## # ## ##### ## ## ## ## ## ## ## # ## ## ## ## ## ## ## ## ## ## ## # ###### ## ## ## #### #### ## #### #### def beforeSend_icmsStParametros(self, data): self.configDefaultRequest() return data # ## ## ###### ###### ## #### # ## ## ## ## ## ## # ## ## ## ## ## #### # ## ## ## ## ## ## # ## ## ## ## ## ## # ###### ## ###### ###### #### def remove_empty_fields(self, data): if isinstance(data, dict): return {k: self.remove_empty_fields(v) for k, v in data.items() if v not in [None, "", [], {}]} elif isinstance(data, list): return [self.remove_empty_fields(item) for item in data if item not in [None, "", [], {}]] return data def configDefaultRequest(self): if self.current_data['request_method'] == 'PUT': self.current_method = "PATCH" if self.current_data['request_method'] == "POST": self.current_rote = self.current_rote.strip('/') ##### ###### ## ## ##### ###### ##### ## ## ###### ####### ## ###### ## ## ## ### ## ## ## ## ## ## ## ### ## ## ## ## #### ## ## ## ## #### ## ## ## ## ## ## #### ## ## ## ## ## ## ## ##### ## ## #### ## ##### ## ## ## #### ## ## ###### ##### ## ## ## ### ## #### ## ## ## ### ## ## ## ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##### ###### ## ## ##### ### ## ##### ## ## ###### ####### ## ## ### ## def format_rote_sincronizar_clientes(self, rote): self.rote = "cliente?size=1000" return "cliente?size=1000" def afterGet_sincronizar_clientes(self, data): return data['data'] def sincronizar_clientes_handler(self, clientes): for cliente in clientes: id_cliente = cliente.get('id') codigo = cliente.get('codigo', '') if codigo == '': self.createLog("435", "Cliente: {} - {}: Sem código para fazer relaciona ID".format(id_cliente, codigo)) continue cliente_db = self.select(f""" SELECT CDCLIENTE FROM TBCLIENTE WHERE 1 = 1 AND CDEMPRESA IN ({int(self.cdempresa)}, 0) AND CDFILIAL IN ({int(self.cdfilial)}, 0) AND CDCLIENTE = '{codigo}' """) if not cliente_db: self.createLog("436", "Cliente: {} - {}: Cliente não encontrado na base de dados".format(id_cliente, codigo)) continue exist_relacionaId = self.select(f""" SELECT COUNT(*) AS count FROM TBRELACIONAID WHERE NMNOMEAPI = 'mobilesales' AND NMTABELA = 'TBCLIENTE' AND IDAPI = '{id_cliente}' """) if cliente_db and exist_relacionaId[0]['count'] == 0: self.relatement({ "NMNOMEAPI" : "mobilesales", "NMTABELA" : "TBCLIENTE", "IDAPI" : id_cliente, "IDSOFTDIB" : "0.0.{}".format(cliente_db[0]['CDCLIENTE']), "DTULTIMAALTERACAO" : datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "HASHMD5" : "INTEGRADO" }) # Buscar o nosso ID baseado no SKU # print(produtos) # #### ###### ## ###### ###### ###### # ## ## ## ## ## ## ## # ## ## ##### ## ##### ## ##### # ## ## ## ## ## ## ## # ## ## ## ## ## ## ## # #### ###### ###### ###### ## ###### def deleteFromApi(self, **data): rote = self.atualWs.get('rote') mobilesales_id = data.get('mobilesales_id') softdib_id = data.get('softdib_id') if not mobilesales_id: return delete_params = { "rote" : f"{rote}/{mobilesales_id}" , "method" : "PATCH" , "headers": { "Content-Type": "application/json" } , "data" : json.dumps({ "situacao": "I" }) } delete_reponse = self.throttling(**delete_params) delete_is_ok = delete_reponse.ok if not delete_is_ok: self.response_log(delete_reponse) if delete_is_ok: rote = self.atualWs.get('rote') if rote == 'products/id/images': upload_id = self.translate(id = f"{softdib_id}" , table = "TBPRODUTOIMAGEMUPLOAD") self.getDb().delete("TBRELACIONAID" , [ f"IDAPI='{upload_id}'" , f"NMTABELA='TBPRODUTOIMAGEMUPLOAD'" , f"NMNOMEAPI='sellent'" ] ) return delete_is_ok # #### #### ## ## ###### ###### ## ## ###### ###### ##### ## ## ## # ## ## ## ## ### ## ## ## ### ## ## ## ## ## ### ## #### # ## ## ## ###### ##### ## ###### ## ##### ## ## ###### ## ## # ## ## ## ###### ## ## ###### ## ## ##### ###### ## ## # ## ## ## ## ## ### ## ## ## ### ## ## ## ## ## ### ###### # #### #### ## ## ## ###### ## ## ## ###### ## ## ## ## ## ## def define_sd_request(self,rota='/integracao/pedido/authentication'): """ Monta a estrutura base de headers e paramentros para consumir ou enivar dados para api softdib """ prot = "http://" base = "192.168.1.3" if self.debug else self.softdib_ip port = f':{self.softdib_port or 3000}'#.format() base_url = f"{prot}{base}{port}" #""" .format( # prot=prot # , base=base # , port=port #) """ auth = Request( base_url = base_url ) auth_res = auth.doRequest( rote = rota, method = "post", json = { "user" : "SAC" , "lkgp" : self.nmlkgrupo , "banco" : self.nmbanco , "apiname" : self.apiName , "empresa" : self.cdempresa , "filial" : self.cdfilial } ) if auth_res.status_code != 200 : print(f"Falhou: {auth_res.status_code} - {auth_res.reason}")#.format(auth_res.status_code)) exit() self.softdib_request = Request( base_url = base_url, headers = { "Content-Type": "application/json" ,"Accept": "application/json" ,"x-access-token": auth_res.text.replace('"','') } ) print(self.softdib_request) # #### #### ## ## ###### ##### #### ## ###### #### # ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## # ## ## ## ###### ## ## ## ## ## ## ## ## ## # ## ## ## ###### ## ##### ## ## ## ## ## ## # ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## # #### #### ## ## ## ## ## #### ###### ###### #### def custom_control_id(self, response): data = json.loads(response.text) return data['id'] def pagination_rules(self, response, data): if response.ok: import math data = self.tryJson(response) total_pages = math.ceil((data['total']/data['size'])) page = data['page'] if page < total_pages: page += 1 if len(data['data']) == 0: return None if data['total'] > data['size']: query = { 'page': page, } params = self.mountRouteParams(query) if '?' in self.rote: return f"{self.rote}&{params}" return f"{self.rote}?{params}" return None return None def removerAcentos(self, txt): from unidecode import unidecode txt.replace("\t","") return unidecode(txt) # #### ###### ## ## #### ## ###### ##### # ## ## ### ## ## ## ## ## ## ## # #### ##### ###### ## ## ## ##### ## ## # ## ## ###### ## ## ## ## ##### # ## ## ## ### ## ## ## ## ## ## # #### ###### ## ## #### ###### ###### ## ## def send_handler(self, data) : """ Metodo para manipular o envio """ # o data pode ser alterado aqui dentro self.prepare_send(data) # Faz um tratamento no dados antes de enviar func_rote = self.fixed_rote() func = f"beforeSend_{func_rote}"#.format(func_rote) # Tratamento de dados antes de enviar data = self.call(func, data, is_required= self.atualWs.get('need_beforeSend',False)) if hasattr(self, 'ignore_request') and self.ignore_request == True: self.ignore_request = False return sended = self.send( data ) if sended == None: return # Executa apoas enviar - cada rota tem a sua especifica - deve-se criar dentro da arquivo da api if not self.atualWs['send'] or self.send_response.status_code in range(200,300) : func = f"afterSend_{func_rote}"#format(func_rote) # Tratamento de dados depois de enviar #if self.hasAttr(func, self) : # getattr(self, func)( data ) self.call(func, data ) self.current_data = {} # ##### ###### #### ##### #### #### ###### ## #### # ## ## ## ## ## ## ## ## ## ## #### ## # ## ## ##### #### ## ## ## ## #### ## ## ## #### # ##### ## ## ##### ## ## ## ## ## ## ## # ## ## ## ## ## ## ## ## ## ###### ## # ## ## ###### #### ## #### #### ## ## ## #### def response_code_504(self, req) : self.createLog("504", "Erro: Servidor em atualização!") return True def response_code_409(self, req) : self.createLog("409", "Erro: Item já existente! Enviado: {}".format(req.request.body)) return True def response_code_400(self, req) : self.createLog("400", "Erro: {} | Enviado: {}".format(json.loads(req.text)['error'], req.request.body)) return True def response_code_404(self, req) : self.createLog("404", "Erro: {} | Enviado: {}".format(json.loads(req.text)['error'], req.request.body)) return True def response_code_502(self, req) : self.createLog("502", "Erro: {} | Enviado: {}".format(req.text, req.request.body)) return True def response_code_200(self, response) : data = json.loads(response.text) if data['httpStatusCode'] == 400: return super().response_code_400(response) elif data['httpStatusCode'] == 200: return super().response_code_201(response) # ###### ## ## ##### #### ###### ###### ## ###### ## ## ##### # ## ## ## ## ## ## ## ## ## ## ## ### ## ## # ## ###### ## ## ## ## ## ## ## ## ###### ## # ## ## ## ##### ## ## ## ## ## ## ###### ## ### # ## ## ## ## ## ## ## ## ## ## ## ## ### ## ## # ## ## ## ## ## #### ## ## ###### ###### ## ## ##### def throttling(self, **params) : """ Metodo que controla throttling - para ativar o throttling é preciso definir no map em config - Por padrao se nao existir o throttling definido ele nao é aplicado """ while True: req = self.api_request.doRequest(**params) try: if int(req.headers['x-ratelimit-remaining']) == 0: sleep(int(req.headers['x-ratelimit-reset'])) break; else: break except: pass return req def throttling_rules(self, req) : try: if int(req.headers['x-ratelimit-remaining']) > 0: return 0 else: self.createLog("400", "|> Throttling ativo tempo restante para nova requisição: {}".format(int(req.headers['x-ratelimit-reset']))) return int(req.headers['x-ratelimit-reset']) except Exception as e: return 0 #### ## ## #### ###### #### ## ## ## ## ## ## ## ## ## ## ### ### ## ## ## #### ## ## ## ####### ## ## ## ## ## ## ## ## # ## ## ## ## ## ## ## ## ## ## ## #### ###### #### ## #### ## ## def tipo_frete(self, data): if data == '': return 9 valor = "1" if data == "C" else "2" return valor def send(self ,data) : """ Envia dados para uma api - via POST ou PUT """ if 'send' in self.atualWs and self.atualWs['send'] == False: return """ Função especifica para somente fazer o send se a empresa filial ser diferente da setada""" if 'sendOnlyCompany' in self.atualWs: empresa_permitida = int(self.atualWs['sendOnlyCompany']['empresa']) filial_permitida = int(self.atualWs['sendOnlyCompany']['filial']) if int(self.cdempresa) != empresa_permitida or int(self.cdfilial) != filial_permitida: return raw_type_rote = self.atualWs.get('raw_type') raw_type_default = self.config.get('raw_type') #raw_type_rote or "json" # Por padrao o envio de dados é via json raw_type = raw_type_rote or raw_type_default or "json" # mudar em configuracoes o raw_type se for diferente - ver na documentacao de cada api if raw_type == "text" : data = json.dumps(data) raw_type = "data" if raw_type == 'urlencoded': raw_type = 'data' params = { "rote" : self.current_rote , "method" : self.current_method , raw_type : data } print(f":params |> {params}\n:data |> {self.current_data}") # ! SENDREQUEST self.send_response = self.throttling( **params ) # retrn status_code = self.send_response.status_code or 0 response_func = f"response_code_{status_code}"#.format(status_code) # Chama uma funcao especifica para cada resposta # pode ser generica ou cricada em cada arquivo da api call = self.call(response_func, self.send_response) if call == None: #self.response_log(self.send_response) print(f":fail |> Funcao status code {status_code} nao criado ainda \n data:{data}")#.format(status_code)) return True def salvar_cliente_softdib(self, data): """ Cadastro de cliente quando nao existe no sistema softdib """ response = self.softdib_request.doRequest( rote = "/integracao/pedido/cliente" , params = data , method = "POST" ) if response.status_code == 200: retorno_cobol = response.json() codigo_cliente = retorno_cobol['cliente'][0]['Codigo'] data_relaciona_id = { "NMNOMEAPI" : self.apiName , "NMTABELA" : "TBCLIENTE" , "IDSOFTDIB" : f"{int(self.cdempresa)}.{int(self.cdfilial)}.{codigo_cliente}" # Exclusividade da Multilit. , "DTULTIMAALTERACAO" : data.get('DTULTIMAALTERACAO', "now()") , "IDAPI" : data.get('IDCLIENTEEXTERNO', '') , "HASHMD5" : "NextUpdateWillGenerateNewHash" } self.relatement(data_relaciona_id) self.createLog(response.status_code,f"cliente cadastrado com sucesso : {codigo_cliente}:{data.get('IDCLIENTEEXTERNO', '')}") return codigo_cliente def __del__(self): self.createLog("999","Final da exportacao")