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 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 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 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 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 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) + "\"" )
