def process_audit_payload(self, audit_logs: List[dict]) -> None: """Process audit list and trigger annotation posting for matching Monitored Entities Args: audit_logs (List[dict]): list of audit records returned from the API """ audit_v1_entry = AuditEntryV1Handler() audit_v2_entry = AuditEntryV2Handler() request_handler = RequestHandler(self.url, self. headers, self.verify_ssl) for audit_log_entry in audit_logs: if self.is_system_user(str(audit_log_entry['user'])): continue api_version = self.get_api_version(audit_log_entry) if api_version == 1: request_params=audit_v1_entry.extract_info(audit_log_entry, request_handler) elif api_version == 2: request_params=audit_v2_entry.extract_info(audit_log_entry, request_handler) else: log_id = str(audit_log_entry['logId']) # pylint: disable=unused-variable logger.info('[Main] %(log_id)s ENTRY NOT MATCHED') request_handler.post_annotations( request_params['entityId'], request_params['properties'] )
def testReservationDenied(self): data = reservationRequestWithConflicts() requestHandler = RequestHandler() response = requestHandler.postReservations(data) self.assertEqual(409, response.status) self.assertEqual('Conflict', response.reason)
def handle_connection(sock): while 1: try: print "data received from IP: %s" % (sock.getsockname()[0],) ip, port = sock.getsockname() allData = "" while 1: data = sock.recv(1) if not data: break allData += data if "\r\n\r\n" in allData: if "Content-Length" in allData: start = allData.find("Content-Length: ") end = allData.find("\r\n", start) length = int(allData[start:end].split(": ")[1]) allData += sock.recv(length) break reqHand = RequestHandler() sock.sendall(reqHand.process(allData, ip, port)) sock.close() break except socket.error: break
class DataHandler(tornado.websocket.WebSocketHandler): def open(self): print "Connection has been opened" self.request_handler = RequestHandler(self) self.send({"connection": "open"}) print "Request handler has been created" def on_close(self): print "Connection has been closed" ####################################################### # Message recieved, delegate to the request handler ####################################################### def on_message(self, message): print "Message received: ", message self.request_handler.receive(message) ####################################################### # Send a message, will always be serialized to JSON ####################################################### def send(self, message): try: self.write_message(json.dumps(message)) print "Message sent: ", message except Exception: self.close() ####################################################### # Do not check for cross origin ####################################################### def check_origin(self, origin): return True
def handle_connection(sock): while 1: try: print 'data received from IP: %s' % (sock.getsockname()[0], ) ip, port = sock.getsockname() allData = '' while 1: data = sock.recv(1) if not data: break allData += data if '\r\n\r\n' in allData: if 'Content-Length' in allData: start = allData.find('Content-Length: ') end = allData.find('\r\n', start) length = int(allData[start:end].split(': ')[1]) allData += sock.recv(length) break reqHand = RequestHandler() sock.sendall(reqHand.process(allData, ip, port)) sock.close() break except socket.error: break
def test_RFQ(self): get = [ { "name": "BTCUSD.SPOT" }, ] post = { "valid_until": "2020-02-28T11:41:30.023467Z", "rfq_id": "some_unique_ID", "client_rfq_id": "some_unique_client_id", "quantity": "1.0000000000", "side": "buy", "instrument": "BTCUSD.SPOT", "price": "1.00000000", "created": "2020-02-28T11:41:15.023467Z" } with patch('requests.get') as mGet: with patch('requests.post') as mPost: mGet.return_value.status_code = 200 mGet.return_value.json.return_value = get mPost.return_value.status_code = 200 mPost.return_value.json.return_value = post rH = RequestHandler() self.assertEqual(rH.RFQ("BTCUSD.SPOT", "buy", "1.0"), post) self.assertEqual(rH._price, "1.00000000")
def generate_model(c1, c2): rh = RequestHandler(c1, c2) pd = PrepareData(c2) mb = ModelBuilder(pd.prepare(rh.get_data())) mb.train_model() mb.save_model("model_{}_{}".format(c1, c2)) logging.info("Model trained and saved for {}/{}".format(c1, c2))
def test_trade_fail(self): get = [ { "name": "BTCUSD.CFD" }, ] post = { "valid_until": "2020-02-28T11:41:30.023467Z", "rfq_id": "d4e41399-e7a1-4576-9b46-349420040e1a", "client_rfq_id": "149dc3e7-4e30-4e1a-bb9c-9c30bd8f5ec7", "quantity": "1.0000000000", "side": "buy", "instrument": "BTCUSD.SPOT", "price": "700.00000000", "created": "2018-02-06T16:07:50.122206Z" } trade = { "order_id": "d4e41399-e7a1-4576-9b46-349420040e1a", "client_order_id": "d4e41399-e7a1-4576-9b46-349420040e1a", "quantity": "3.0000000000", "side": "buy", "instrument": "BTCUSD.SPOT", "price": "11000.00000000", "executed_price": "10457.651100000", "executing_unit": "risk-adding-strategy", "trades": [{ "instrument": "BTCUSD.SPOT", "trade_id": "b2c50b72-92d4-499f-b0a3-dee6b37378be", "origin": "rest", "rfq_id": 'null', "created": "2018-02-26T14:27:53.675962Z", "price": "10457.65110000", "quantity": "3.0000000000", "order": "d4e41399-e7a1-4576-9b46-349420040e1a", "side": "buy", "executing_unit": "risk-adding-strategy", }], "created": "2018-02-06T16:07:50.122206Z" } with patch('requests.get') as mGet: with patch('requests.post') as mPost: mGet.return_value.status_code = 200 mGet.return_value.json.return_value = get mPost.return_value.status_code = 200 mPost.return_value.json.side_effect = [post, trade] rH = RequestHandler() rH.RFQ("BTCUSD.SPOT", "buy", "1.0") self.assertEqual(rH._price, "700.00000000") self.assertIsNone(rH.trade())
def __init__(self, base, currency): self.base = base self.currency = currency self.request_handler = RequestHandler(self.base, self.currency) self.prepare_data = PrepareData(currency) self.single_prediction_data = ModelData.data_for_prediction( self.prepare_data.single_dict_prepare( self.request_handler.get_100daysback_data()))
def test_requestHandler_Post(self): with patch('requests.post') as mRequest: mRequest.return_value.status_code = 200 mRequest.return_value.json.return_value = {"USD": "0"} rH = RequestHandler() self.assertEqual( rH._requestHandler('/request_for_quote/', {"USD": "0"}), {"USD": "0"})
class UVMPMServer: def __init__(self, host="0.0.0.0", port=1145): self.host = host self.port = port self.client_manager = ClientManager() self.request_handler = RequestHandler(self.client_manager) self.listening_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.listening_socket.bind((self.host, self.port)) self.client_manager.poller.register(self.listening_socket, select.POLLIN) def run(self): self.listening_socket.listen() print("Listening on port", self.port) self.client_manager.sockets[self.listening_socket.fileno()] = self.listening_socket while True: for fd, event in self.client_manager.poller.poll(): sock = self.client_manager.sockets.get(fd, None) if not sock: continue if sock is self.listening_socket: sock, address = self.listening_socket.accept() sock.setblocking(False) self.client_manager.create_client(sock) elif event & select.POLLIN: try: incoming_data = sock.recv(config.BUFFER_SIZE) except Exception: # connection reset, connection refused, etc continue try: decoded_data = incoming_data.decode("ascii") except Exception: # unable to convert to ascii continue if len(incoming_data) == 0: self.client_manager.poller.modify(sock, select.POLLHUP) continue self.client_manager.add_data(sock.fileno(), decoded_data) requests = self.client_manager.pop_buffered_requests(sock.fileno()) for request in requests: self.request_handler.handle(request) elif event & (select.POLLHUP | select.POLLERR | select.POLLNVAL): client = self.client_manager.clients.get(sock.fileno()) self.client_manager.remove_client(client)
def testPostAntennaAvailability(self): from datetime import datetime as dt from TimeUtils import datetimeAsIso8601 data = antennaAvailability() data['generationDate'] = datetimeAsIso8601(dt.now()) requestHandler = RequestHandler() response = requestHandler.postAntennaAvailability(data) self.assertEqual(201, response.status)
def testPostReservations(self): data = reservationRequest() requestHandler = RequestHandler() response = requestHandler.postReservations(data) self.assertEqual(201, response.status) self.assertEqual('Created', response.reason) responseSchema = loadReservationResponseSchema() validateWithChecker(response.body, responseSchema)
def test_getBalances(self): out = { "USD": "0", } with patch('requests.get') as mRequest: mRequest.return_value.status_code = 200 mRequest.return_value.json.return_value = out rH = RequestHandler() self.assertEqual(rH.getBalances(), out) self.assertEqual(rH.getBalances("USD"), {"USD": "0"})
def main(): s_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s_server.bind((LISTENING_ADDR, LISTENING_PORT)) s_server.listen() while True: new_request = s_server.accept() REQUEST_QUEUE.append(new_request) th = RequestHandler(new_request, ROOT_DIRECTORY) print(th.name) th.start()
def test_getInstruments(self): out = [ { "name": "BTCUSD.CFD" }, ] with patch('requests.get') as mRequest: mRequest.return_value.status_code = 200 mRequest.return_value.json.return_value = out rH = RequestHandler() self.assertEqual(rH._getInstruments(), ['BTCUSD.CFD'])
def test_isValid_quantity(self): get = [ { "name": "BTCUSD.CFD" }, ] with patch('requests.get') as mGet: mGet.return_value.status_code = 200 mGet.return_value.json.return_value = get with self.assertRaises(ValueError): rH = RequestHandler() rH._isValid('XRPUSD.SPOT', 'buy', '3+6j')
def test_isValid_side(self): get = [ { "name": "BTCUSD.CFD" }, ] with patch('requests.get') as mGet: mGet.return_value.status_code = 200 mGet.return_value.json.return_value = get with self.assertRaises(ValueError): rH = RequestHandler() rH._isValid('BCHUSD.SPOT', 'funny_side', '1')
def test_getAccountInfo(self): out = { "risk_exposure": "10000.15", "max_risk_exposure": "50000", "btc_max_qty_per_trade": "100", "ust_max_qty_per_trade": "600000" } with patch('requests.get') as mRequest: mRequest.return_value.status_code = 200 mRequest.return_value.json.return_value = out rH = RequestHandler() self.assertEqual(rH.getAccountInfo(), out)
def __init__(self, host="0.0.0.0", port=1145): self.host = host self.port = port self.client_manager = ClientManager() self.request_handler = RequestHandler(self.client_manager) self.listening_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.listening_socket.bind((self.host, self.port)) self.client_manager.poller.register(self.listening_socket, select.POLLIN)
def get_audit_logs(self) -> dict: """Pull Audit Logs From API Returns: dict: Audit log entrys recorded from the audit API """ request_handler = RequestHandler(self.url, self. headers, self.verify_ssl) audit_log_endpoint = "/api/v2/auditlogs?" \ + "filter=category(\"CONFIG\")&sort=timestamp" \ + f"&from={self.start_time}&to={self.end_time}" changes = request_handler.get_dt_api_json(audit_log_endpoint) return changes['auditLogs']
def test_isValid_instrument(self): get = [ { "name": "BTCUSD.CFD" }, ] with patch('requests.get') as mGet: mGet.return_value.status_code = 200 mGet.return_value.json.return_value = get with self.assertRaises(ValueError): rH = RequestHandler() rH._isValid('BTCUSD', 'buy', '1')
def testGetAntennaAvailability(self): requestHandler = RequestHandler() startDate = '2015-10-16T10:00:00Z' endDate = '2015-10-17T10:00:00Z' response = requestHandler.getAntennaAvailability(startDate, endDate) self.assertEqual(200, response.status) self.assertEqual('OK', response.reason) responseSchema = loadAntennaAvailabilitySchema() validateWithChecker(response.body, responseSchema)
def listen(self, ip: str, port: int): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: clients = [] print(f"{ip} Listening on port {port}") s.bind((ip, port)) s.listen() handler = RequestHandler() self.isListening = True while self.isListening: clientSocket, clientEndpoint = s.accept() print(f"new client joined") clients.append((clientSocket, clientEndpoint)) handler.handle_client(clientSocket, clientEndpoint)
def processRequest(self): self.port = os.getenv('port') # set port number self.handler = RequestHandler(self.port) # get RequestHandler data, rtype, response_code = self.handler.handleRequest( self) # handle request and receive data, type and code #log((data, rtype, response_code), 'info') if rtype == 'file': self.handler.returnResponse( self, data, response_code, rtype) # send the response back to requester else: bytedata = self.handler.typeData(data, rtype) # convert data to bytes self.handler.returnResponse(self, bytedata, response_code, rtype)
def test_getCurrencies(self): out = { "BTC": { "stable_coin": 'false', "is_crypto": 'true', "currency_type": "crypto", "readable_name": "Bitcoin", "long_only": 'false', "minimum_trade_size": 0.001 } } with patch('requests.get') as mRequest: mRequest.return_value.status_code = 200 mRequest.return_value.json.return_value = out rH = RequestHandler() self.assertEqual(rH.getCurrencies(), out)
def __init__(self, username=None, password=None, phone=None, cookieJar="cookies.txt"): if username != None: if isinstance(username, str): self.username = username else: raise ValueError("MotifAuthorizationManager.__init__: Username must be a string.") else: self.username = "" if password != None: if isinstance(password, str): self.password = password else: raise ValueError("MotifAuthorizationManager.__init__: Password must be a string.") else: self.password = "" if phone != None: if isinstance(phone, str): self.phone = phone else: raise ValueError("MotifAuthorizationManager.__init__: Phone must be a string.") else: self.phone = "" if cookieJar != "cookies.txt": if isinstance(cookieJar, str): self.__ensurePathExists(cookieJar) self.cookieJar = cookieJar else: raise ValueError("MotifAuthorizationManager.__init__: cookieJar must be a string.") else: self.cookieJar = cookieJar self.rh = RequestHandler(self.cookieJar)
def __init__(self, subredditList): self.subredditList = subredditList self.requestHandler = RequestHandler() #Set up reddit self.reddit = praw.Reddit(client_id=Config.appid, client_secret=Config.appsecret, user_agent=Config.useragent, username=Config.username, password=Config.password) print("Connected to Reddit") self.submissionProcessor = SubmissionProcessor(self.reddit, subredditList, self.requestHandler) self.submissionsLastProcessed = 0 self.updateTime = time.time()
def __init__(self, ip, port): self.ip = ip self.port = port self.__name__ = "Server" self.RequestHandler = RequestHandler() self.app = Flask(__name__) self.app.debug = True CORS(self.app) self.startListening()
class IntegrationProcessor(object): """ This class manages other processors into one integration pipeline. """ def __init__(self, config_path, root_path, output_path): self.config_path = config_path self.root_path = root_path self.output_path = output_path self.request_handler = RequestHandler() def integrate(self): """ Main integrating function. Binds FileProcessor and ConfigProcessor together. First, an array of patients is being made based on what is inside the folder under the given path. Then, the ConfigProcessor parses the template from the given path and renders the output. """ print "\033[95mStarted Integration Engine on " + unicode( datetime.datetime.now()) + "\033[0m" # Creating the patient array print "Processing the root folder structure ..." patients = FileProcessor().make_patients(self.root_path) # Generating result based on the config file print "Reading the template file..." result = ConfigProcessor(self.config_path, patients).render_template() # Writing the result to the output file print "Saving the output file..." self.save_to_file(result) # Sending a request to FHIR backend (if applicable) if self.request_handler.should_send_requests == "true": print "Making a " + self.request_handler.method + " request to " + self.request_handler.url self.send_final_request() else: print "Making requests is turned off." print "\033[92mFinished.\033[0m" def save_to_file(self, string): """ Saves given string to a file. """ with open(self.output_path, "w") as text_file: text_file.write(string) print "Saved to file " + self.output_path def send_final_request(self): """ Sends a request to FHIR backend """ with open(self.output_path, "r") as text_file: data = json.load(text_file) print self.request_handler.send(data)
def main(): try: print('Welcome to Text Based Trading Tool for .') instrument = input("Which instrument do you want to trade?") side = input("Do you want to buy or sell them?") quantity = input("How many units to trade?") rH = RequestHandler() rfq = rH.RFQ(instrument, side, quantity) pprint.pprint(rfq) inTrade = input("Do you wish to trade? (y/n)") if inTrade.lower() in ['y', 'yes']: trade = rH.trade() pprint.pprint(trade) print("Trade was successful. New balance below.") pprint.pprint(rH.getBalances()) print("You are now rich. Goodbye!") else: print('Thank you for trading. Goodbye!') except RuntimeError as e: logger.critical("Trade failed: %s" % e)
class MyHandler(BaseHTTPRequestHandler): # All http methods apart from some maybe, using lambda to make it neat do_GET = lambda self: self.processRequest() do_POST = lambda self: self.processRequest() do_HEAD = lambda self: self.processRequest() do_PUT = lambda self: self.processRequest() do_PATCH = lambda self: self.processRequest() do_DELETE = lambda self: self.processRequest() do_OPTIONS = lambda self: self.processRequest() # violates PEP but looks cool def processRequest(self): self.port = os.getenv('port') # set port number self.handler = RequestHandler(self.port) # get RequestHandler data, rtype, response_code = self.handler.handleRequest( self) # handle request and receive data, type and code #log((data, rtype, response_code), 'info') if rtype == 'file': self.handler.returnResponse( self, data, response_code, rtype) # send the response back to requester else: bytedata = self.handler.typeData(data, rtype) # convert data to bytes self.handler.returnResponse(self, bytedata, response_code, rtype)
def test_getAllTrades(self): out = [ { "created": "2016-09-27T11:27:46.599039Z", "price": "700.0000000000", "instrument": "BTCUSD.CFD", "trade_id": "5c7e90cc-a8d6-4db5-8348-44053b2dcbdf", "origin": "rest", "rfq_id": "f7492962-783e-45c7-ae81-6eb61f4d7251", "order": 'null', "cfd_contract": "945bac72-4d88-401b-9a7f-27bc328a125f", "side": "buy", "quantity": "0.5000000000", "user": "******", "executing_unit": "risk-adding-strategy" }, ] with patch('requests.get') as mRequest: mRequest.return_value.status_code = 200 mRequest.return_value.json.return_value = out rH = RequestHandler() self.assertEqual(rH.getAllTrades(), out)
def __init__(self, subredditList): self.subredditList = subredditList self.requestHandler = RequestHandler() #Set up reddit self.reddit = praw.Reddit(Config.useragent) self.reddit.set_oauth_app_info(client_id=Config.appid, client_secret=Config.appsecret, redirect_uri=Config.redirecturi) self.reddit.refresh_access_information(Config.refreshtoken) print("Connected to Reddit") self.submissionProcessor = SubmissionProcessor(self.reddit, subredditList, self.requestHandler) self.submissionsLastProcessed = 0 self.updateTime = time.time()
def testReservationWorkflow(self): # - Set Antenna Availabilty: this is testing step only from datetime import datetime as dt from TimeUtils import datetimeAsIso8601 data = antennaAvailability() data['generationDate'] = datetimeAsIso8601(dt.now()) requestHandler = RequestHandler() response = requestHandler.postAntennaAvailability(data) self.assertEqual(201, response.status) startDate = '2015-10-16T10:00:00Z' endDate = '2015-10-17T10:00:00Z' response = requestHandler.getAntennaAvailability(startDate, endDate) self.assertEqual(200, response.status) self.assertEqual('OK', response.reason) # - Get Antenna Availabilty: this begins every reservation cycle startDate = '2015-10-16T10:00:00Z' endDate = '2015-10-17T10:00:00Z' response = requestHandler.getAntennaAvailability(startDate, endDate) # TODO capture generation date from availability report self.assertEqual(200, response.status) self.assertEqual('OK', response.reason) responseSchema = loadAntennaAvailabilitySchema() validateWithChecker(response.body, responseSchema) # - Update (POST) reservations. data = reservationRequest() # TODO consider: do we inject the date form our antenna avail report at this point? Or let service do that # TODO update generation date in reservation request before posting requestHandler = RequestHandler() response = requestHandler.postReservations(data) self.assertEqual(201, response.status) self.assertEqual('Created', response.reason) # TODO assert expected generation date in response responseSchema = loadReservationResponseSchema() validateWithChecker(response.body, responseSchema)
#Enable beaker sessions #RequestHandler= SessionMiddleware(RequestHandler, Config.session_opts) #RequestHandler.__init__ = SessionMiddleware(RequestHandler.__init__, Config.session_opts) RequestHandler.handleNewRequest = SessionMiddleware(RequestHandler.handleNewRequest, Config.session_opts) #Make a file to show we're running with PidLock() as lockFile: #Make server httpd = make_server('',8000,RequestHandler.handleNewRequest) print "Serving on port 8000" #Create and set the shutdown thread for the wsgi server RequestHandler.initializeStatics( httpd, threading.Thread(target=RequestHandler.shutdown) ) #SERVE!!! print "Serving forever!" httpd.serve_forever(5) #poll_interval as arg print "Bye!" except Exception, e: print "An exception occured while trying to launch wsgi:",e finally: f=open("wsgi_pid.lock", "w") f.write("0") f.close()
class YugiohLinkBot(object): def __init__(self, subredditList): self.subredditList = subredditList self.requestHandler = RequestHandler() #Set up reddit self.reddit = praw.Reddit(Config.useragent) self.reddit.set_oauth_app_info(client_id=Config.appid, client_secret=Config.appsecret, redirect_uri=Config.redirecturi) self.reddit.refresh_access_information(Config.refreshtoken) print("Connected to Reddit") self.submissionProcessor = SubmissionProcessor(self.reddit, subredditList, self.requestHandler) self.submissionsLastProcessed = 0 self.updateTime = time.time() def run(self): try: print("Starting stream") commentStream = praw.helpers.comment_stream(self.reddit, self.subredditList, limit=1000, verbosity=0) for comment in commentStream: if ((time.time() - self.updateTime) > Config.tcgUpdateInterval * 60 * 60): DatabaseHandler.updateTCGCardlist() self.updateTime = time.time() if ((time.time() - self.submissionsLastProcessed) > Config.submissionProcessingInterval * 60 * 60): self.submissionProcessor.processSubmissions(100) self.submissionsLastProcessed = time.time() #print("Found comment") #If we've already seen this comment, ignore it if DatabaseHandler.commentExists(comment.id): continue #If the post has been deleted, getting the author will return an error try: author = comment.author.name except Exception as e: continue #If this is one of our own comments, ignore it if (author == 'YugiohLinkBot'): continue reply = self.requestHandler.buildResponse(comment.body) try: if reply: cards = re.findall('\[\*\*(.+?)\*\*\]\(', reply) for card in cards: DatabaseHandler.addRequest(card, author, comment.subreddit) if("VENT THREAD" in comment.link_title): reply = self.submissionProcessor.convertCase(True, reply) elif("happiness thread" in comment.link_title): reply = self.submissionProcessor.convertCase(False, reply) DatabaseHandler.addComment(comment.id, author, comment.subreddit, True) comment.reply(reply) print("Comment made.\n") else: if ('{' in comment.body and '}' in comment.body): print('') DatabaseHandler.addComment(comment.id, author, comment.subreddit, False) except Exception as e: print("Reddit probably broke when replying:" + str(e) + '\n') except Exception as e: print("Error with comment stream: " + str(e)) traceback.print_exc()
class Server: # #DONE #Initialisation du serveur #Args : ip du serveur, port du serveur #Return : Aucun # def __init__(self, ip, port): self.ip = ip self.port = port self.__name__ = "Server" self.RequestHandler = RequestHandler() self.app = Flask(__name__) self.app.debug = True CORS(self.app) self.startListening() # # DONE # Démarre vraiment le serveur (API REST) # Args : Aucun # Return Aucun # def startListening(self): Logger.log('Listening') # # TODO # Gère les requètes sur / # Args : Aucun # Return : Code html de la page d'index (pas fini) # @self.app.route("/", methods=['GET']) def index(): Logger.printCurrentState( self.RequestHandler.SessionStorage.sessions) return "index" # # DONE # Gère les requètes sur /move/url/id # Args : Une url unique de partie, l'id de la personne qui joue, une réprésentation JSON du mouvement par POST # Return : JSON # @self.app.route("/move/<uniqueurl>/<int:uniqueid>", methods=['POST']) def move(uniqueurl, uniqueid): Logger.printCurrentState( self.RequestHandler.SessionStorage.sessions) Logger.log('Received request on /move') res = self.RequestHandler.dispatchRequest( Request( uniqueurl=uniqueurl, uniqueid=uniqueid, requestKind=RequestKind.MoveRequest)) return str(res) # # DONE # Gère les requètes sur /createnewgame # Args : Aucun # Return : ID de la game créée. # @self.app.route("/createnewgame", methods=['GET']) def create(): Logger.printCurrentState( self.RequestHandler.SessionStorage.sessions) Logger.log('Received request on /createnewgame') res = self.RequestHandler.dispatchRequest( Request(requestKind=RequestKind.CreateNewGameRequest)) Logger.log(res) return str(res) # # DONE # Gère les requètes sur /joingame/uniqueurl # Args : Url unique # Return : Id de joueur si la game peut être créée, False sinon # @self.app.route("/joingame/<int:uniqueurl>", methods=['GET']) def join(uniqueurl): Logger.printCurrentState( self.RequestHandler.SessionStorage.sessions) Logger.log('Received request on /joingame') res = self.RequestHandler.dispatchRequest( Request(requestKind=RequestKind.JoinGameRequest, uniqueurl=uniqueurl)) return str(res) # # DONE # Gère les requètes sur /gameupdate/uniqueurl # Args : Url unique # Return : JSON représentant la partie # @self.app.route("/gameupdate/<int:uniqueurl>", methods=['GET']) def update(uniqueurl): Logger.printCurrentState(self.RequestHandler.SessionStorage.sessions) Logger.log('Received a request on /gameupdate') res = self.RequestHandler.dispatchRequest( Request(requestKind=RequestKind.GameUpdateRequest, uniqueurl=uniqueurl)) return str(res) # # DONE # Url de debug # Args : Aucun # Return : Renvoie les sessions stockées, à supprimer en prod. # @self.app.route("/debug", methods=['GET']) def debug(): return str(self.RequestHandler.SessionStorage.sessions) self.app.run(host=self.ip, port=self.port)
class MotifAuthorizationManager(object): URL_AUTH_STEP1 = "https://auth.motifinvesting.com/authenticate" URL_AUTH_STEP2 = "https://trader.motifinvesting.com/two-factor-auth" URL_AUTH_STEP3 = "https://trader.motifinvesting.com/two-factor-auth/send" URL_AUTH_STEP4 = "https://trader.motifinvesting.com/two-factor-auth/confirm" URL_SETTINGS = "https://trader.motifinvesting.com/account/settings" def __init__(self, username=None, password=None, phone=None, cookieJar="cookies.txt"): if username != None: if isinstance(username, str): self.username = username else: raise ValueError("MotifAuthorizationManager.__init__: Username must be a string.") else: self.username = "" if password != None: if isinstance(password, str): self.password = password else: raise ValueError("MotifAuthorizationManager.__init__: Password must be a string.") else: self.password = "" if phone != None: if isinstance(phone, str): self.phone = phone else: raise ValueError("MotifAuthorizationManager.__init__: Phone must be a string.") else: self.phone = "" if cookieJar != "cookies.txt": if isinstance(cookieJar, str): self.__ensurePathExists(cookieJar) self.cookieJar = cookieJar else: raise ValueError("MotifAuthorizationManager.__init__: cookieJar must be a string.") else: self.cookieJar = cookieJar self.rh = RequestHandler(self.cookieJar) def setUsername(self, username=None): if username != None: if isinstance(username, str): self.username = username else: raise ValueError("MotifAuthorizationManager.setUsername: Username must be a string.") else: raise ValueError("MotifAuthorizationManager.setUsername: Username not optional.") def getUsername(self): return self.username def setPassword(self, password=None): if password != None: if isinstance(password, str): self.password = password else: raise ValueError("MotifAuthorizationManager.setPassword: Password must be a string.") else: raise ValueError("MotifAuthorizationManager.setPassword: Password not optional.") def setPhone(self, phone=None): if phone != None: if isinstance(phone, str): self.phone = phone else: raise ValueError("MotifAuthorizationManager.setPhone: Phone must be a string.") else: raise ValueError("MotifAuthorizationManager.setPhone: Phone not optional.") def getPhone(self): return self.phone def setCookieJar(self, cookieJar=None): if cookieJar != None: if isinstance(cookieJar, str): self.__ensurePathExists(cookieJar) self.cookieJar = cookieJar self.rh.setCookieJar(self.cookieJar) return True else: raise ValueError("MotifAuthorizationManager.setCookieJar: cookieJar must be a string.") else: raise ValueError("MotifAuthorizationManager.setCookieJar: cookieJar not optional.") def getCookieJar(self): return self.cookieJar def __ensurePathExists(self, path): truePath = os.path.dirname(path) if not os.path.exists(truePath): os.makedirs(truePath) def __getNonceFromSoup(self, soup): scriptResults = soup('script',{'type' : 'text/javascript'}) for line in scriptResults: for result in line.stripped_strings: result = result.split('\n') for tag in result: if "nonce" in tag: return tag.split("\"")[1].strip() def authorizeUser(self): ########### STEP 1 ############ try: curlOut = subprocess.check_output(["curl", "-c", self.cookieJar, "-d", "email=" + self.username + "&password="******"MotifAuthorizationManager.authorizeUser: Step 1 Failed With \"" + str(e) + "\"" ) ########### STEP 2 ########### nonce = None try: curlOut = subprocess.check_output(["curl", "-b", self.cookieJar, self.URL_AUTH_STEP2]) soup = BeautifulSoup(curlOut, "html.parser") nonce = self.__getNonceFromSoup(soup) except Exception, e: raise ValueError("MotifAuthorizationManager.authorizeUser: Step 2 Failed With \"" + str(e) + "\"" )