def buscaListaMotivosDivergencia(self): banco = BANCO() try: c = banco.conexao.cursor() c.execute('''SELECT DESCRICAO FROM MOTIVOS_DIVERGENCIAS ORDER BY DESCRICAO ''') linhas = c.fetchall() for linha in linhas: self.listaMotivos.append(linha[0]) c.close() return self.listaMotivos except Exception as e: logger.logError( "Ocorreu um erro na busca dos motivos - Details: {}". format(str(e)))
def __init__(self): diretorio = os.path.dirname(os.path.abspath(__file__)) configFile = cfgprsr.ConfigParser() configFile.read(diretorio + '/config.ini') self.printer_type = configFile['PRINTER']['tipo'] self.printer_device = configFile['PRINTER']['dispositivo'] self.printer_vid = int(configFile['PRINTER']['vid'], 16) self.printer_pid = int(configFile['PRINTER']['pid'], 16) self.printer_baudrate = int(configFile['PRINTER']['baudrate']) self.printer_timeout = int(configFile['PRINTER']['timeout']) self.printer_parity = configFile['PRINTER']['parity'] try: if self.printer_type.lower() == 'serial': self.printer = Serial(devfile=self.printer_device, baudrate=int(self.printer_baudrate), timeout=int(self.printer_timeout), parity=self.printer_parity) self.printer.open() elif self.printer_type.lower() == 'usb': self.printer = Usb(idVendor=self.printer_vid, idProduct=self.printer_pid) self.printer.codepage = 'CP860' except Exception as e: logger.logError("Erro ao comunicar com a impressora. - Details: {}".format(str(e)))
def RegistraOrdenacaoNoBanco(self): try: self.DefinePrioridades() except Exception as e: logger.logError( "Erro ao definir as prioridades no algoritmo de Priorização de PDS. - Details: {}" .format(str(e))) self.lco.sort_values('PRIORIDADE').to_sql('tempTabelaOrdenada', self.connLocal, if_exists='replace', index=False) curLocal = self.connLocal.cursor() curLocal.execute(""" UPDATE PDS SET PRIORIDADE = (SELECT PRIORIDADE FROM tempTabelaOrdenada TEMP WHERE TEMP.PK_RCQ = PDS.PK_RCQ);""" ) curLocal.execute("DROP TABLE tempTabelaOrdenada;") self.connLocal.commit() curLocal.close() self.connLocal.close()
def buscaPD(self, ID): banco = BANCO() try: curDados = banco.conexao.cursor() curDados.execute('''SELECT PDS.*, COALESCE(CORES.DESCRICAO, 'SEM COR'), COALESCE(CORES.PRIMARIA, '#000000'), COALESCE(CORES.SECUNDARIA, '#000000'), COALESCE(CORES.COR_TEXTO, '#FFFFFF') FROM PDS LEFT JOIN CORES ON (CORES.PK_CRS = PDS.COR) WHERE PK_RCQ = "{}" '''.format(str(ID))) self.dadosPD = curDados.fetchone() return "Busca feita com sucesso!" except Exception as e: return "Ocorreu um erro na busca do PD" logger.logError( "Ocorreu um erro na busca do PD - Details: {}".format( str(e)))
def DefineRankeamento(self): try: self.ExtraiTerminais() except Exception as e: logger.logError( "Erro ao extrair os terminais da lista de PDs para priorização dos PDs. - Details: {}" .format(str(e))) self.ranking = pd.DataFrame() vol = pd.Series([]) for t in self.terminais: q = 0 for a in ('ACABAMENTO_1', 'ACABAMENTO_2'): q += self.lco[self.lco[a] == t].sum()['QTD'] vol[len(vol)] = q self.ranking['ACABAMENTO'] = self.terminais self.ranking['Volume'] = vol self.ranking = self.ranking.join(self.apl.set_index('ACABAMENTO'), on='ACABAMENTO') \ .fillna('Z') \ .sort_values(['APLICAVEL', 'Volume'], ascending=[False, False]) \ .reset_index(drop=True)
def tomaTempoEvento(self, FK_ID, FK_TTM, FK_USU, MAQ): try: banco = BANCO() agora = dt.now() cur = banco.conexao.cursor() cur.execute( """INSERT INTO TEMPOS ( DATA, FK_ID, FK_TTM, FK_USU, MAQUINA) VALUES (datetime(?), ?, ?, ?, ?) """, (agora, FK_ID, FK_TTM, FK_USU, MAQ)) banco.conexao.commit() except Exception as e: logger.logError( "Erro ao tomar tempo de Evento - Details: {}".format( str(e)))
def marketOrder(self, type, asset, currency): try: currentAmount = self.getAmountOfItem(asset + currency) print("current amount of %s%s: %f \n" % (asset, currency, currentAmount)) change = self.resetToEquilibrium_Market(currentAmount, asset, currency) # orderSize = self.bank.update(change) orderSize = self.getMaxAmountToUse(asset, currency) * 0.4 if type == self.buyText: result = self.marketBuy( orderSize, asset, currency, note='Going long.. Previous round trip profit') else: if type == self.sellText: result = self.marketSell(orderSize, asset, currency, note='Going short') self.attemptsLeft = self.attemptsTotal return True except: tb = traceback.format_exc() logger.logError(tb) if self.attemptsLeft == 0: self.attemptsLeft = self.attemptsTotal return None sleep(self.delayBetweenAttempts) self.connect() self.attemptsLeft = self.attemptsLeft - 1 self.marketOrder(type, asset, currency)
def verifyParam(name, value, inf_bound, sup_bound): if value < inf_bound or value > sup_bound: logError( '[PGCYCL]: Error, {} must be in the range [{},{}], given : {}'. format(name, inf_bound, sup_bound, value), True, True) exit(2) else: return value
def InsertDomainWrapper(domainArray, InScopeId): curInScope = models.InScope(InScopeId) newDomains = returnNewDomainsArrayInScopeObject(domainArray, curInScope) # Check Internet if dnsCheck.checkInternet(): for domain in newDomains: mysqlfunc.insertDomain(domain, InScopeId) else: print '[-] Internet Check failed' logger.logError('[-] Internet check failed: ' + ', '.join(newDomains))
def __init__(self): try: self.conexao = sqlite3.connect(diretorio + '/database/DADOS.db') except Exception as e: logger.logError( "Erro ao conectar ao banco de dados local. - Details: {}" .format(str(e))) # self.conexao.text_factory = lambda x: str(x, 'cp1252') self.createTable()
def OrdenaLista(self): try: self.RegistraOrdenacaoNoBanco() except Exception as e: logger.logError( "Erro ao registrar a lista já priorizada no banco de dados local. - Details: {}" .format(str(e))) # self.ExibeResultados() if not self.headless: self.master.destroy()
def ImportaAplicaveis(self): try: self.apl = pd.read_sql_query( """ SELECT * FROM APLICAVEL; """, self.connLocal) except Exception as e: logger.logError( "Erro ao ler a tabela APLICAVEL do banco de dados local. - Details: {}" .format(str(e)))
def registraAlteracoes(self): if self.virtualNumPadVisible: self.popUpVNumPad.destroy() self.virtualNumPadVisible = False self.mensagemMenu.set( "Por favor aguarde enquanto as configurações são salvas") self.master.update() self.configFile.set('DEFAULT', 'maquina', str(self.cboMaquina.get())) self.configFile.set('DEFAULT', 'filtralista', str(self.varLoadMode.get())) self.configFile.set('DEFAULT', 'maqautomatica', str(self.varMaqAuto.get())) if self.varLoadMode.get() == 'True': self.configFile.set('DEFAULT', 'ordens', '({})'.format(str(self.entryNrListas.get()))) else: self.configFile.set('DEFAULT', 'limite horizonte', str(self.scrLimiteHorizonte.get())) self.configFile.set('DEFAULT', 'limitediariocircuitos', str(self.scrLimiteCircuitos.get())) with open(self.diretorio + '/config.ini', 'w') as configfile: self.configFile.write(configfile) try: import atualiza_bdlocal atualiza_bdlocal.AtualizaBancoLocal() priori.AlgoritmoSeparacao(headless=True) self.parent.limpaTela() self.parent.montaTelaPrincipal() self.master.destroy() except Exception as e: self.configFile.set('DEFAULT', 'filtralista', 'False') with open(self.diretorio + '/config.ini', 'w') as configfile: self.configFile.write(configfile) self.mensagemMenu.set('Erro. Verifique as configurações') self.lblMsgMenu['fg'] = 'red' logger.logError( "Erro ao salver as configurações do Menu. - Details: {}". format(str(e)))
def buscaLista(self): banco = BANCO() if self.maquinaAutomatica == 'True': strOrdenacao = """ORDER BY PDS.PRIORIDADE, BITOLA, (SELECT SUM([QTD_PD_REQ]) FROM PDS P where P.CABO = PDS.CABO GROUP BY CABO) DESC, MEDIDA DESC""" else: strOrdenacao = """ORDER BY BITOLA, (SELECT SUM([QTD_PD_REQ]) FROM PDS P where P.CABO = PDS.CABO GROUP BY CABO) DESC, MEDIDA DESC""" try: c = banco.conexao.cursor() if self.filtaLista == 'True': c.execute('''SELECT * FROM PDS WHERE PDS."QTD_PD_REQ" > PDS.QTD_CORTADA ''' + strOrdenacao) else: c.execute('''SELECT * FROM PDS WHERE PDS.MAQUINA = "%s" AND PDS."QTD_PD_REQ" > PDS.QTD_CORTADA ''' % self.maquina + strOrdenacao) self.lista = c.fetchall() c.close() return "Busca feita com sucesso!" except Exception as e: return "Ocorreu um erro na busca do PD" logger.logError( "Ocorreu um erro na busca do PD - Details: {}".format( str(e)))
def limitBuy(self, price, asset, currency, orderQuantity, orderId=None, note=None): result = None openOrder = self.orderOpen(orderId) if openOrder and orderQuantity != 0: try: result = self.market.Order.Order_amend(orderID=orderId, price=price).result() logger.logOrder( self.marketName, 'Limit', price, asset, currency, orderQuantity, str(note) + ' amend for order: ' + str(orderId)) except Exception as e: if e.response.status_code == 400: logger.logError('LIMIT AMEND ERROR') orderQuantity = self.quantityLeftInOrder( orderId, orderQuantity) if orderQuantity != 0: openOrder = False else: logger.logError('UNKNOWN LIMIT ERROR: ' + str(e)) raise e if not openOrder and orderQuantity != 0: result = self.market.Order.Order_new( symbol=asset + currency, orderQty=orderQuantity, ordType="Limit", price=price, execInst='ParticipateDoNotInitiate').result() logger.logOrder(self.marketName, 'Limit', price, asset, currency, orderQuantity, note) if result is not None: tradeInfo = result[0] for key, value in tradeInfo.items(): if key == "orderID": newOrderId = (key + ": {0}".format(value)) return newOrderId[9:] else: return None
def upload_file(file_name, s3=s3, acl="public-read"): bucket_name = os.environ.get('TGM_BUCKET_NAME') #opens file, reads it, and uploads it to the S3 bucket. try: with open(file_name, 'rb') as data: s3.upload_fileobj(data, bucket_name, file_name, ExtraArgs={ "ACL": acl, "ContentType": file_name.split(".")[-1] }) except: logError('ERROR_S3_UPLOAD of ' + file_name) file_url = "https://s3.ap-south-1.amazonaws.com/" + bucket_name + "/" + file_name return file_url
def Definicoes(self): try: self.diretorio = os.path.dirname(os.path.abspath(__file__)) self.configFile = cfgprsr.ConfigParser() self.configFile.read(self.diretorio + '/config.ini') self.maquina = self.configFile['DEFAULT']['maquina'] except Exception as e: logger.logError( "Erro ao ler as variáveis de ambiente. - Details: {}". format(str(e))) try: self.connLocal = BANCO().conexao except Exception as e: logger.logError( "Erro ao conectar ao banco de dados Local para priorização dos PDs. - Details: {}" .format(str(e)))
def limitOrderStatus(self, orderID, triesLeft=None): if triesLeft == None: triesLeft = 1 if orderID == None: return False filter = '{"orderID": "' + orderID + '"}' res = self.market.Order.Order_getOrders(filter=filter).result() try: res = res[0][0] status = res['ordStatus'] except: if triesLeft != 0: sleep(1) return self.limitOrderStatus(orderID) triesLeft = triesLeft - 1 logger.logError('--- ORDER LIST ERROR ---') return res
def memTest(logNum, server, session, command): try: if command is None: return session.sendline(command) session.prompt() lines = session.before.decode() for line in lines.splitlines(): print('{:4d}\t{:15s}\t{:16.5f}\t{}'.format(logNum, server, time.time(), line)) if 'ERROR' in line: logMessage = 'MemTest Failed {} {}'.format(line, command) logger.logError(logNum, server, logMessage) except Exception as ex: template = "An exception of type {0} occurred. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message) logger.logError(logNum, server, message) print('Command Failed {:4d}\t{:15s}\t{:16.5f}\t{}'.format( logNum, server, time.time(), command))
def botaoLogin(self): global idUsuario, nomeUsuario banco = BANCO() cur = banco.conexao.cursor() usr = self.user.get() pwd = self.password.get() pwdbco = None try: cur.execute(""" SELECT PK_USU, NOME, SENHA FROM USUARIOS WHERE NOME = "%s" """ % usr) dadosUsuario = cur.fetchone() idUsuario = dadosUsuario[0] nomeUsuario = dadosUsuario[1] pwdbco = dadosUsuario[2] if pwdbco == pwd: self.lblMensagem["text"] = "Login OK" loginRoot.destroy() else: self.lblMensagem["text"] = "Senha incorreta" logger.logError( "Tentativa de Login inválida - Details: Senha incorreta para usuario '{}'" .format(str(usr))) except: self.lblMensagem["text"] = "Usuário não encontrado" logger.logError( "Tentativa de Login inválida - Details: Usuário '{}' não encontrado" .format(str(usr)))
def ImportaLista(self): try: self.lco = pd.read_sql_query( """ SELECT PK_RCQ, [QTD_PD_REQ] - [QTD_CORTADA] AS "QTD", [ACABAMENTO_1], [ACABAMENTO_2], PRIORIDADE FROM PDS WHERE [QTD_PD_REQ] - [QTD_CORTADA] > 0 AND MAQUINA = '%s'; """ % self.maquina, self.connLocal).fillna('Vazio') except Exception as e: logger.logError( "Erro ao importar a lista de PDs para priorização de PDs. - Details: {}" .format(str(e)))
def Subfinder(InScopeObject): # Remove the wildcard print '[+] Starting Subfinder on: ' + InScopeObject.ScopeText # Takes -d for domain && -o for name of the output file outputFileLoc = variables.tempFolder + 'subfinder.temp' # Remove the files between subprocess.call('rm ' + outputFileLoc, shell=True) subprocess.call(variables.goBin + 'subfinder -d %s -o %s > /dev/null' % (InScopeObject.ScopeText[2:], outputFileLoc), shell=True) try: domainsOutput = subprocess.check_output('cat ' + outputFileLoc, shell=True) newDomains = parsingSqlData.returnNewDomainsArrayInScopeObject( filter(None, domainsOutput.split('\n')), InScopeObject) # Check Internet if dnsCheck.checkInternet(): print '[*] Internet seems to be successs in responses' print '[*] \tStarting insert newDomains' # Need to wrap this so it's faster pool = ThreadPool(50) insertDomainInScopeId = partial( mysqlfunc.insertDomain, domainRangeId=InScopeObject.InScopeId) pool.map(insertDomainInScopeId, newDomains) #for domain in newDomains: #+ mysqlfunc.insertDomain(domain, InScopeObject.InScopeId) else: print '[-] Internet Check failed' logger.logError('[-] Internet check failed: ' + ', '.join(newDomains)) except OSError, e: if e[0] == 2: print '[-] Subfinder errored out: By the fact that the output file does not exist\n' pdb.set_trace() else: print '[-] Subfinder errored out: Weird error... debug in InScopeTextTasks >> subfinder function' pdb.set_trace()
def __init__(self): try: self.global_database_dsn = configFile['GLOBAL_DATABASE']['dsn'] self.global_database_user = configFile['GLOBAL_DATABASE']['user'] self.global_database_password = configFile['GLOBAL_DATABASE'][ 'password'] self.global_database_charset = configFile['GLOBAL_DATABASE'][ 'charset'] except Exception as e: logger.logError( "Erro ao ler as variáveis de ambiente. - Details: {}". format(str(e))) try: self.conexao = fdb.connect(dsn=self.global_database_dsn, user=self.global_database_user, password=self.global_database_password, charset=self.global_database_charset) except Exception as e: logger.logError( "Erro ao abrir a conexão com o banco global (Delphus). - Details: {}" .format(str(e)))
def pullTransactionData(): if not os.path.exists(path): logger.logError("Path (%s) doesnt exist. Creating new path'" % path) try: os.mkdir(path) if not os.path.exists(path): logger.logError("Path (%s) creation failed. Exiting" % path) sys.exit(1) else: logger.logthis("Path created") except FileExistsError: logger.logError("Folder (%s) already exists" % path) filename = path+"transactions_" + time.strftime("%d%m%Y") + ".csv" url = "https://shapeshift.io/recenttx/50" r = requests.get(url) if r.status_code is 200: transactions = json.loads(r.text) logger.logthis(str("Picked up " + str(len(transactions)) + " transactions.")) logger.logthis("parsing") if not os.path.isfile(filename): logger.logthis("File not found, creating new one") csvFile = open(filename, "w+") csvWriter = csv.writer(csvFile, delimiter=",") csvWriter.writerow(["timestamp", "curIn", "curOut", "amount", "txid"]) csvFile.close() else: logger.logthis("Appending to existing file") # to ensure we dont have duplicates inMemCSV = [] csvFile = open(filename, "r") for row in csv.reader(csvFile): inMemCSV.append(row) csvFile.close() dupcount = 0 with open(filename, "a") as csvFile: csvWriter = csv.writer(csvFile, delimiter=",") for tx in transactions: row =[str(tx['timestamp']), str(tx['curIn']), str(tx['curOut']), str(tx['amount']), str(tx['txid'])] if row in inMemCSV: # duplicate found dupcount += 1 continue csvWriter.writerow(row) csvFile.close() logger.logthis("Found "+str(dupcount)+" duplicates, Wrote " + str(len(transactions)-dupcount)+ " to file") logger.logthis("All transactions have been written to a file") logger.logthis("Complete, closing") else: logger.logthis("Error when pulling the data") logger.logthis(str("Status code" + str(r.status_code)))
def addNewTask(args): ##### # Var initialization ##### index = 0 # Index of the first optional arg arg = 0 # Current argument data = { 'command': '', 'minute': 0, 'hour': 0, 'frequency': '0', 'day': '0', 'month': '0' } args_length = len(args) if args_length < 3: printUsage() else: data.update({'command': args[index]}) file = open(FBATCH, 'a') try: index += 1 minute = verifyParam('minute', int(args[index]), 0, 59) data.update({'minute': minute}) index += 1 hour = verifyParam('hour', int(args[index]), 0, 23) data.update({'hour': hour}) index += 1 if index < args_length: arg = args[index] else: arg = '-d' index += 1 if arg == '-d' or arg == '--daily': data.update({'frequency': 'daily'}) elif arg == '-w' or arg == '--weekly': day = verifyParam('day of the week', args[index], 1, 7) data.update({'frequency': 'weekly', 'day': day}) elif arg == '-m' or arg == '--monthly': day = verifyParam('day', (args[index]), 1, 31) data.update({'frequency': 'monthly', 'day': day}) elif arg == '-y' or arg == '--yearly': month = verifyParam('month', int(args[index]), 1, 12) index += 1 day = verifyParam('day', int(args[index]), 1, 31) data.update({ 'frequency': 'yearly', 'day': day, 'month': month }) else: printUsage() content = writeToFBatch(**data) if os.stat(FBATCH).st_size != 0: content = '\n' + content file.write(content) file.flush() logInfo( '[PGCYCL]: Added command "{command}" will be executed at : {hour}:{minute} on a {frequency} basis' .format(**data), True) except IndexError: logError( '[PGCYCL]: Error : No value behind parameter : {}'.format(arg), True, True) exit(2) except ValueError: logError( '[PGCYCL]: Parameter {} needs integer value, given {}'.format( arg, args[index]), True, True) exit(2) finally: file.close()
def deleteTask(): tasks = listAllTasks(True) lines = listAllTasks(False) tasks_count = len(lines) if tasks_count == 0: logError( '[PGCYCL]: No tasks in fbatch file for the moment, add some first', True, False) exit(0) print(tasks) print('Give id of the tasks you which to delete (q to exit) ') index = getinput() if index == 'q' or index == '' or index == 'exit': logInfo('[PGCYCL]: User aborted deletion', True) exit(0) try: index = int(index) except ValueError: logError('[PGCYCL]: Id invalid, given "{}"'.format(index), True, True) exit(1) if index > tasks_count: logError( '[PGCYCL]: Id not found, "{}" given, only {} tasks'.format( index, tasks_count), True, True) exit(1) elif 0 < index <= tasks_count: line = lines[index - 1] output = 'Deleting tasks {} :\n'.format(index) output += 'Minute\tHour\tDay\tMonth\tFrequency\tCommand\n' output += line output += '\nAre you sure ? (y/N) ' try: print(output) answer = getinput() if not answer or answer == 'n': logInfo("User aborted deletion", True) exit(0) elif answer == 'y': lines.pop(index - 1) last = len(lines) - 1 lines[last] = lines[last].rstrip() # Resets file content open(FBATCH, 'w').close() fbatch_file = open(FBATCH, 'a') lines = ''.join(lines) fbatch_file.write(lines) fbatch_file.close() logInfo('[PGCYCL]: Recurrent task deleted successfully', True) except SyntaxError: logError('[PGCYCL]: Error : Answer invalid', True, True) exit(1) else: logError('[PGCYCL]: Id not valid', True, True) exit(1)
argv = sys.argv if len(argv) >= 2: param = argv[1] if param == 'help' or param == '-h' or param == '?': printUsage() if param == 'list': print(useSemaphore(listAllTasks, True, False)) elif param == 'add': useSemaphore(addNewTask, argv[2:], True) elif param == 'del': useSemaphore(deleteTask, None, True) else: logError('[PGCYCL]: Command not found', True, True) printUsage() ''' deleteTask() addNewTask(['command', 5, 39, '-d']) addNewTask(['echo test', 7, 42, '-w', 3]) addNewTask(['error', 12, 1, '-m', 21]) addNewTask(['exit(1)', 3, 34, '-y', 9, 5]) addNewTask(['drop database', 23, 6]) '''
def origem(self): try: conGlobal = banco.GLOBAL_DATABASE().conexao except Exception as e: logger.logError("Erro na conexao com o banco de dados de origem! - Details: {}".format(str(e))) if self.filtraLista == 'True': try: dadosOrigem = pd.read_sql_query("""SELECT * FROM PDS_PENDENTES_CORTE_COR WHERE "NR_ORDEM_CORTE" in {} ORDER BY "DATA_ENTREGA", "CABO"; """.format(self.ordensCorte), conGlobal) self.dadosLimitados = dadosOrigem self.aplicavelOrigem = pd.read_sql_query("""SELECT PRO.COD_FABRIC as "ACABAMENTO", PRO.APLICAVEL FROM PRODUTOS PRO WHERE PRO.FK_CAD != 13; """, conGlobal) except Exception as e: logger.logError("Erro na obtenção dos dados de origem! - Details: {}".format(str(e))) else: try: dadosOrigem = pd.read_sql_query("""SELECT * FROM PDS_PENDENTES_CORTE_COR WHERE "DATA_ENTREGA" <= CURRENT_DATE + %i AND "MAQUINA" = '%s' ORDER BY "DATA_ENTREGA", "CABO"; """ % (int(self.limiteHorizonte), self.maquina), conGlobal) dadosOrdenados = dadosOrigem.sort_values( by='DATA ENTREGA').reset_index(drop=True) qtdAcumulada = pd.Series(dadosOrdenados['QTD_PD_REQ'].cumsum()) self.dadosLimitados = dadosOrdenados[:qtdAcumulada.where(qtdAcumulada <= int(self.limiteCircuitos)).idxmax(skipna=True)] self.aplicavelOrigem = pd.read_sql_query("""SELECT PRO.COD_FABRIC as "ACABAMENTO", PRO.APLICAVEL FROM PRODUTOS PRO WHERE PRO.FK_CAD != 13; """, conGlobal) except Exception as e: logger.logError("Erro na obtenção dos dados de origem! - Details: {}".format(str(e))) self.origem2destino()
def registraCorteNoBanco(self, ID, qtdCortadaEmPecas, qtdCortadaEmMetros): try: try: conOrigem = GLOBAL_DATABASE().conexao curOrigem = conOrigem.cursor() except Exception as e: logger.logError( "Erro no metodo: pd.registraCorteNoBanco() -> Erro na conexão com o banco de dados de origem! - Details: {}" .format(str(e))) return False try: id_array = ID.split('|') requisicao = id_array[0] corte = id_array[1] quantidade = id_array[2] curOrigem.execute( "EXECUTE PROCEDURE ATUALIZA_IQC({}, {}, {}, {})".format( str(requisicao), str(corte), str(quantidade), str(qtdCortadaEmMetros))) except Exception as e: logger.logError( "Erro no metodo: pd.registraCorteNoBanco() -> Erro ao tentar transmissao para o Banco de dados Global! - Details: {}" .format(str(e))) return False try: bancoLocal = BANCO() curLocal = bancoLocal.conexao.cursor() except Exception as e: logger.logError( "Erro no metodo: pd.registraCorteNoBanco() -> Erro na conexão com o banco de dados local! - Details: {}" .format(str(e))) return False try: query = """ UPDATE PDS SET QTD_CORTADA = {} WHERE PK_RCQ = '{}'; """.format(str(qtdCortadaEmPecas), str(ID)) curLocal.execute(query) except Exception as e: logger.logError( "Erro no metodo: pd.registraCorteNoBanco() -> Erro ao tentar transmissao para o Banco de dados Local! - Details: {}" .format(str(e))) return False try: conOrigem.commit() bancoLocal.conexao.commit() conOrigem.close() bancoLocal.conexao.close() return True except Exception as e: logger.logError( "Erro ao commitar registro de corte nos bancos! - Details: {}" .format(str(e))) except Exception as e: logger.logError( "Erro ao registrar o corte nos bancos! - Details: {} ". format(str(e))) return False
def followingLimitOrder(self, type, asset, currency, orderQuantity, restricted=True, initial_price=None, orderID=None, note=None): try: asset = self.interpretType(asset) currency = self.interpretType(currency) type = self.interpretType(type) previousLimitPrice = None initialPrice = initial_price if initialPrice == None: initialPrice = self.getCurrentPrice(asset, currency) previousLimitPrice = initialPrice while self.isInRange(type, initialPrice, previousLimitPrice, self.maximumDeviationFromPrice, restricted) and orderQuantity != 0: orderQuantity = self.quantityLeftInOrder( orderID, orderQuantity) if orderQuantity != 0: res = self.sendLimitOrder( type, asset, currency, orderQuantity, orderID, note, previousLimitPrice=previousLimitPrice) if not hasattr(res, 'orderID'): orderQuantity = self.quantityLeftInOrder( orderID, orderQuantity) orderID = None previousLimitPrice = self.getCurrentPrice( asset, currency) else: orderID = res.orderID previousLimitPrice = res.limitPrice sleep(self.delayBetweenLimitOrder) if self.orderOpen(orderID): self.closeLimitOrder(orderID) return True except: tb = traceback.format_exc() logger.logError(tb) if self.attemptsLeft == 0: self.attemptsLeft = self.attemptsTotal return None sleep(self.delayBetweenAttempts) self.connect() currentPrice = self.getCurrentPrice(asset, currency) self.attemptsLeft = self.attemptsLeft - 1 self.followingLimitOrder(type, asset, currency, orderQuantity, restricted, initialPrice, orderID)