def register(self, request: Request):
ip, port = request.connection
if isinstance(request.body, dict):
nickname = request.body.get("nickname")
if nickname != None:
player = Player(ip, port, nickname)
# Block if the gamming is running
if self.game_running or self.last_question != None:
return Response(code=codes.IS_RUNNING,
body="Gamming is running")
if len(self.players) == self.max_players:
return Response(code=codes.FULL, body="The room is full")
# Check if user is not already registred
elif player in self.players:
return Response(code=codes.ALREADY_EXISTS,
body="Already exists")
# Add new player
print("[*] Player Registred!", str(player))
self.players.append(player)
return Response(code=codes.REGISTRED, body="OK")
# Return invalid parameters
return Response(code=codes.INVALID_PARAMETERS, body="Invalid params")
async def execute_head(self, request):
file_data = self.get_file_info(request)
if file_data == 403: # forbidden error
return Response(status=ALLOWED_CODES.get(403), protocol=request.protocol, connection='')
elif file_data == 404: # not found error
return Response(status=ALLOWED_CODES.get(404), protocol=request.protocol, connection='')
else:
return Response(status=ALLOWED_CODES.get(200), protocol=request.protocol, connection='closed',
content_length=file_data.get('content_length'), content_type=file_data.get('content_type'))
def update(user, card, response):
"""
Update the card's parameters (and its parents')
when given a response.
"""
# TODO-3 split up into smaller methods
if not card.has_assessment():
return {
'response': Response({}),
'feedback': '',
}
errors = card.validate_response(response)
if errors:
return {'errors': errors}
score, feedback = card.score_response(response)
response = Response({
'user_id': user['id'],
'card_id': card['entity_id'],
'unit_id': card['unit_id'],
'response': response,
'score': score,
})
card_parameters = CardParameters.get(entity_id=card['entity_id'])
previous_response = Response.get_latest(user_id=user['id'],
unit_id=card['unit_id'])
now = time()
time_delta = now - (int(previous_response['created'].strftime("%s"))
if previous_response else now)
learned = (previous_response['learned']
if previous_response else init_learned)
guess_distribution = card_parameters.get_distribution('guess')
slip_distribution = card_parameters.get_distribution('slip')
updates = formula_update(score, time_delta,
learned, guess_distribution, slip_distribution)
response['learned'] = updates['learned']
response, errors = response.save()
if errors:
return {'errors': errors, 'feedback': feedback}
card_parameters.set_distribution('guess', updates['guess_distribution'])
card_parameters.set_distribution('slip', updates['slip_distribution'])
card_parameters, errors = card_parameters.save()
if errors:
return {'errors': errors, 'feedback': feedback}
return {'response': response, 'feedback': feedback}
def create_prospect(self, prospect):
try:
message = self.xstream_service.create_message(
FunctionTypes.CREATE_PROSPECT.value, prospect=prospect)
service_response = self.xstream_service.process_message(message)
api_response_body = self.xstream_service.process_response(
service_response, ResponseType.PROSPECT)
api_response = Response(api_response_body, status_code=200)
except Exception as e:
print('Error: create_prospect failed - {}'.format(e))
api_response = Response(ErrorResponses.INTERNAL_SERVER_ERROR.value,
status_code=500)
return api_response
async def _execute_head_request(self, request: Request) -> Response:
try:
resource = self._build_resource(request)
except ForbiddenError:
return Response(status_code=StatusCodes.FORBIDDEN,
protocol=request.protocol)
except NotFoundError:
return Response(status_code=StatusCodes.NOT_FOUND,
protocol=request.protocol)
return Response(status_code=StatusCodes.OK,
protocol=request.protocol,
content_length=resource.size,
content_type=resource.content_type.value,
body=b'')
def execute_head(self, request):
try:
file = self.get_file_info(request)
content_length = self.get_file_content_length(file.file_path)
return Response(status_code=Response.OK,
protocol=request.protocol,
connection=request.connection,
content_type=file.content_type.value,
content_length=content_length)
except (BadFilePathException, FileNotFoundError):
return Response(status_code=Response.NOT_FOUND,
protocol=request.protocol,
connection=request.connection)
def status(self, request: Request):
return Response(code=codes.SUCCESS,
body={
"total": self.max_players,
"actual": len(self.players),
'running': self.running
})
async def execute_head(self, request):
try:
file = self.get_file_info(request)
except ForbidenError:
return Response(status=Response.FORBIDDEN,
protocol=request.protocol,
connection='')
except NotFoundError:
return Response(status=Response.NOT_FOUND,
protocol=request.protocol,
connection='')
return Response(status=Response.OK,
protocol=request.protocol,
connection='closed',
content_length=file.content_length,
content_type=file.content_type)
def register(self, request: Request):
ip, port = request.connection
p = Player(ip, port)
if len(self.room.players) == self.room.max_players:
return Response(code=codes.SUCCESS,
body="the game is full, await some minutes")
elif (p in self.room.players):
return Response(code=codes.SUCCESS,
body="you're already registred")
# Add into a virtual database
self.room.players.append(p)
print("[*] Player Registred!", str(p))
return Response(code=codes.SUCCESS, body="ok")
async def execute(self, request):
if request.get_method() not in [b'GET', b'HEAD']:
return Response(Response.METHOD_NOT_ALLOWED,
request.get_protocol(), request.get_connection())
elif request.get_method() == b'HEAD':
return await self.execute_head(request)
else:
return await self.execute_get(request)
async def _execute_get_request(self, request: Request) -> Response:
try:
resource = self._build_resource(request)
except ForbiddenError:
return Response(status_code=StatusCodes.FORBIDDEN,
protocol=request.protocol)
except NotFoundError:
if request.url[-1:] == '/':
return Response(status_code=StatusCodes.FORBIDDEN,
protocol=request.protocol)
else:
return Response(status_code=StatusCodes.NOT_FOUND,
protocol=request.protocol)
try:
body = await self._reader.read(resource.filename)
except FileNotFoundError:
if request.url[-1:] == '/':
return Response(status_code=StatusCodes.FORBIDDEN,
protocol=request.protocol)
else:
return Response(status_code=StatusCodes.NOT_FOUND,
protocol=request.protocol)
except NotADirectoryError:
return Response(status_code=StatusCodes.NOT_FOUND,
protocol=request.protocol)
return Response(status_code=StatusCodes.OK,
protocol=request.protocol,
content_type=resource.content_type.value,
content_length=resource.size,
body=body)
async def execute_get(self, request):
try:
file = self.get_file_info(request)
body = await self.read_file(file.filename)
return Response(status=Response.OK,
protocol=request.protocol,
connection='closed',
content_type=file.content_type,
content_length=file.content_length,
body=body)
except ForbiddenError:
return Response(status=Response.FORBIDDEN,
protocol=request.protocol,
connection='')
except NotFoundError:
return Response(status=Response.NOT_FOUND,
protocol=request.protocol,
connection='')
async def execute_get(self, request):
try:
file = self.get_file_info(request)
body = await self.read_file(file.file_path, request.url)
return Response(status_code=Response.OK,
protocol=request.protocol,
connection=request.connection,
content_type=file.content_type.value,
content_length=len(body),
body=body)
except (BadFilePathException, FileNotFoundError):
return Response(status_code=Response.NOT_FOUND,
protocol=request.protocol,
connection=request.connection)
except ForbiddenException:
return Response(status_code=Response.FORBIDDEN,
protocol=request.protocol,
connection=request.connection)
async def execute(self, request):
if request.method not in [b'GET', b'HEAD']:
return Response(Response.METHOD_NOT_ALLOWED,
request.protocol,
connection=request.connection)
elif request.method == b'HEAD':
return await self.execute_head(request)
else:
return await self.execute_get(request)
async def execute(self, request: Request) -> Optional[Response]:
if request.method not in ('GET', 'HEAD'):
return Response(status_code=StatusCodes.NOT_ALLOWED,
protocol=request.protocol)
if request.method == 'HEAD':
return await self._execute_head_request(request=request)
elif request.method == 'GET':
return await self._execute_get_request(request=request)
async def execute(self, request):
if request.get_method == ALLOWED_METHODS.get('HEAD'):
# print('Request: HEAD')
return await self.execute_head(request)
elif request.get_method == ALLOWED_METHODS.get('GET'):
# print('Request: GET')
return await self.execute_get(request)
else:
# print('Request: Unknown')
return Response(ALLOWED_CODES.get(405), request.get_protocol, request.get_connection)
def main():
url = 'https://www.westerncalendar.uwo.ca/Courses.cfm?Subject=COMPSCI&SelectedCalendar=Live'
scraper = Scraper(url)
course_headers = scraper.get_course_headers_list()
course_details = scraper.get_course_details_list()
response = Response(
transformer.generate_course_summary_list(course_headers,
course_details))
json_response = json.dumps(vars(response),
default=lambda x: x.__dict__,
indent=4)
print(json_response)
def open_connection(socket, client_conn, data, router):
request = None
try:
payload = json.loads(data)
request = Request(**payload)
request.connection = client_conn
try:
response = router.resolve(request)
if response != None:
socket.sendto(response.encode(), client_conn)
except Exception as e:
print(e)
socket.sendto(
Response(code=codes.INTERNAL_ERROR,
body="Internal error").encode(), client_conn)
except Exception as e:
print(e)
socket.sendto(
Response(code=codes.BAD_REQUEST,
body="Invalid request").encode(), client_conn)
def new_session(user, message, response):
sms_session = Session(user_id=user.id, interval_id=user.interval.id)
models.storage.new(sms_session)
models.storage.save()
if message.strip().lower() == user.predictor.name:
sms_response = Response(session_id=sms_session.id,
predictor_id=user.predictor.id,
user_id=user.id,
message=message,
twilio_json="{}")
models.storage.new(sms_response)
models.storage.save()
else:
response.message('This should be the predictor.')
def test_created(db_conn, responses_table):
"""
Expect to have a created date.
"""
response = Response({
'user_id': 'A',
'card_id': 'BC',
'unit_id': 'RM',
'response': 42,
'score': 0.9,
'learned': 0.9,
})
del response['created'] # should be set to default anywho
response, errors = response.save()
assert len(errors) == 0
def handler(event, context):
prospect = json.loads(event['body'])
print(event)
# todo move jwt functionality into a service class to keep things dry
try:
# todo make jwt secret an env var
jwt.decode(event['headers']['Authorization'], 'paigeleah1')
except Exception as e:
print('Error: jwt did not decode correctly - {}'.format(e))
# todo refactor Response, it ain't pretty atm
return Response(ErrorResponses.NOT_AUTHORIZED.value,
status_code=401).to_json()
prospect_service = ProspectService()
api_response = prospect_service.create_prospect(prospect)
return api_response.to_json()
def answer(self, request: Request):
ip, port = request.connection
p = Player(ip, port, "")
result = [player for player in self.players if p == player]
if len(result) == 0:
return Response(code=codes.NOT_ALLOWED,
body="You aren't in this room")
elif not self.running and self.last_question == None:
return Response(code=codes.NOT_RUNNING,
body="Game ins't started yet")
elif self.round_hit:
return Response(code=codes.ALREADY_EXISTS,
body="Someone alrady won")
player = result[0]
for ans in self.last_question.answers:
if ans.player == player:
return Response(code=codes.ALREADY_EXISTS,
body="You already answered")
if isinstance(request.body, dict):
answer_obj = request.body.get("answer")
if answer_obj:
# Add new answer in actual question
self.last_question.answers.append(
Answer(player, answer_obj,
answer_obj == self.last_question.correct_code))
if answer_obj == self.last_question.correct_code:
self.round_hit = True
return Response(code=codes.SUCCESS, body="OK")
# Return invalid parameters
return Response(code=codes.INVALID_PARAMETERS, body="Invalid params")
def run(self):
while not self.stop_request.isSet():
try:
data = self.conn.recv(2048)
if not data:
break
res = data.decode().split('#')
header = int(res[0])
mess = res[1]
print("Server received data:", data.decode())
if header == Command.Response.close:
break
self.join()
elif header == Command.Response.echo:
if mess is None:
self.response_queue.put(
Response(host, Command.Type.echo, True))
else:
self.response_queue.put(
Response(host, Command.Type.echo, False, mess))
elif header == Command.Response.wifi_checking:
if mess is None:
self.response_queue.put(
Response(host, Command.Type.wifi_checking, True))
else:
self.response_queue.put(
Response(host, Command.Type.wifi_checking, False,
mess))
elif header == Command.Response.sensor_checking:
if mess is None:
self.response_queue.put(
Response(host, Command.Type.sensor_checking, True))
else:
self.response_queue.put(
Response(host, Command.Type.sensor_checking, False,
mess))
elif header == Command.Response.info:
temp = mess.split(',')
host = Client(int(temp[0]), int(temp[1]), temp[2],
int(temp[3]), temp[4], temp[5])
if clientControl.is_exist(host):
self.response_queue.put(
Response(host, Command.Type.info, True))
else:
self.response_queue.put(
Response(host, Command.Type.info, False,
'client not found!'))
elif header == Command.Response.identify:
temp = mess.split(',')
host = Client(int(temp[0]), int(temp[1]), temp[2],
int(temp[3]), temp[4], temp[5])
if not clientControl.is_exist(host):
new_host = clientControl.add(host)
self.response_queue.put(
Response(host, Command.Type.identify, True))
self.response_thread = ResponseTheard(
new_host, self.response_queue)
self.response_thread.response_signal.connect(
self.callback_response_signal)
self.response_thread.start()
else:
self.response_queue.put(
Response(host, Command.Type.identify, False,
'client is exist!'))
else:
print(res)
command = self.command_queue.get(True, 0.05)
self.conn.send(command.encode())
except Exception:
break
def resolve(self, request) -> Response:
for route in self.routes:
if route.route == request.route and request.method in route.methods:
return route.callback(request)
return Response(code=codes.NOT_FOUND, body=f"Not found {request.route}")
def sms():
session, counter, consent, name_req = get_session()
response = MessagingResponse()
phone_number = request.form['From']
message = request.form['Body']
user = find_user_by_phone(phone_number)
if user:
if not user.predictor and not user.outcome:
response.message(
"Hi {}. You need to set up your variables first: {}".format(
user.username, SITE_URL))
elif message.strip().lower() != user.predictor.name and message.strip(
).lower() != user.outcome.name:
response.message('That does not match your variables. Try again.')
else:
user.sessions.sort(key=lambda sess: sess.updated_at, reverse=True)
if message.strip().lower() == user.predictor.name:
if len(user.sessions
) == 0 or user.sessions[0].complete is True:
new_session(user, message, response)
elif user.sessions[0].complete is False:
if session_expired(user.sessions[0].created_at,
user.sessions[0].interval.duration):
user.sessions[0].complete = True
new_session(user, message, response)
else:
response.message(
'We were expecting outcome: {}'.format(
user.outcome.name))
elif message.strip().lower() == user.outcome.name:
if len(user.sessions
) == 0 or user.sessions[0].complete is True:
response.message('We were expecting predictor: {}'.format(
user.predictor.name))
elif user.sessions[0].complete is False:
if session_expired(user.sessions[0].created_at,
user.sessions[0].interval.duration):
user.sessions[0].complete = True
response.message(
'We were expecting predictor: {}'.format(
user.predictor.name))
else:
sms_response = Response(session_id=user.sessions[0].id,
outcome_id=user.outcome.id,
user_id=user.id,
message=message,
twilio_json="{}")
models.storage.new(sms_response)
user.sessions[0].complete = True
models.storage.save()
elif consent is True and name_req is True:
access_code = binascii.hexlify(os.urandom(8)).decode()
session['access-code'] = access_code
user = User()
user.username = message.strip()
user.phone_number = phone_number
user.access_code = access_code
models.storage.new(user)
models.storage.save()
session['user-id'] = user.id
response.message(
"Welcome {}! Please go to: {}/register/?access-code={}".format(
user.username, SITE_URL, access_code))
elif consent is True and name_req is False:
session['name_req'] = True
if message.strip().lower() == 'yes':
session['consent'] = True
response.message("What's your name?")
elif message.strip().lower() == 'no':
response.message("Sorry to hear that. Bye.")
else:
response.message("Would you like to enroll in rel8? [Yes, No]")
session['consent'] = True
return str(response)
def index():
response = Response()
response.message = "I'm the home controller "
return make_response(jsonify(response.__dict__), 200)
def play(self):
for q in self.questions:
q.answers = []
try:
while len(self.players) != self.max_players and self.running:
print(".")
time.sleep(1)
if not self.running:
return
self.game_running = True
for i_round, question in enumerate(
random_sort(self.questions)[:5]):
self.round_hit = False
if not self.running:
return
self.last_question = question
start_time = time.time()
for p in self.players:
result = {
"question": question.text,
"alternatives":
[a.__dict__ for a in question.alternatives]
}
self.socket.sendto(
Response(codes.QUESTION, result).encode(), (
p.ip,
p.port,
))
while not self.round_hit and (
time.time() - start_time) <= self.round_time and len(
self.last_question.answers) != len(
self.players) and self.running:
pass
if not self.running:
return
for i in range(len(self.players)):
_exists = False
_won = False
for ans in self.last_question.answers:
if ans.player == self.players[i]:
_exists = True
_won = ans.correct
break
if _won:
self.players[i].points += 25
elif _exists:
self.players[i].points -= 5
else:
self.players[i].points -= 1
if _won:
self.socket.sendto(
Response(
codes.FINISH_ROUND,
"\nYou won this round!\nWait 5 seconds!\nGet ready!"
).encode(), (
self.players[i].ip,
self.players[i].port,
))
else:
self.socket.sendto(
Response(codes.FINISH_ROUND,
"\nWait 5 seconds!\nGet ready!").encode(),
(
self.players[i].ip,
self.players[i].port,
))
if i_round < len(self.questions) - 1:
time.sleep(5)
ranking = {p.name: p.points for p in self.players}
for p in self.players:
self.socket.sendto(
Response(codes.RESULT_RANK, ranking).encode(), (
p.ip,
p.port,
))
self.game_running = False
except ValueError as e:
print(e)
