def create_test_user(user_dict):
u = User(_id=user_dict['id'], name=user_dict['phone'], _is_test_user=True)
u.password = TEST_USER_PASSWORD
u.role = User.Role.tower.value
u.active = True
for k in user_dict.keys():
setattr(u, k, user_dict[k])
u.update_position(user_dict['last_lat_seen'], user_dict['last_long_seen'])
logger.debug("created test user: {}".format(User.query.get(u.id)))
return u
def get(self):
logger.info(request.args)
try:
lat = str(request.args['lat'])[:10].strip()
lon = str(request.args['lon'])[:10].strip()
logger.info("{}, {}".format(lat, lon))
# This is an ugly way to test availability but for some reason
# I have to create a user to run that Geo DB Query
user_id = ("internal_avail_checker{}").format(random.randint(
0, 10))
u = User.query.get(user_id)
if not u:
u = User(_id=user_id, name=user_id)
u.update_position(lat, lon)
db.session.merge(u)
requestees = u.get_possible_requestees()
except Exception as e:
logger.exception(e)
db.session.rollback()
return {'status': 'error'}
return {"num_found": "{}".format(len(requestees))}
def post(self):
"""
DEPRECATED: Use /login to create a new user
.. :quickref: User; Deprecated.
:resheader Content-Type: application/json
:<json string phone: 10 digit phone number
:<json string email: User's email
:<json string name: User's name
:<json string name: User's password
:<json float one_signal_player_id: user's one_signal_player_id
:>json string: status
:>json user_id: status
:status 200: success
:status 400: invalid params
:status 401: authorization failed
"""
# DEPRECATED
logger.warning("Makin a new tower")
args = request.get_json()
if not g.user.is_admin:
return {'status': 'Cant create a user - youre not an admin'}, 401
# You must provide these args
required_args = ['lat', 'lon', 'name', 'phone']
for arg in required_args:
if arg not in args:
logger.info("Missed required value '{}'".format(arg))
return bad_request("Missed required value '{}'".format(arg))
user = User(_id=args['name'], name=args['name'], _is_test_user=False)
user.is_android = True
user.active = True
user.phone = args['phone']
user.role = User.Role.tower.value
user.update_position(args['lat'], args['lon'])
db.session.merge(user)
db.session.commit()
return {'status': 'New user created', 'user_id': str(user.id)}, 201
def verify_auth_token(auth_token):
# Try to get the user from session cookies
try:
if User.query.get(session['user_id']):
g.user = User.query.get(session['user_id'])
return True
except Exception:
logger.debug("Couldn't log in via session cookie")
if not auth_token:
logger.warning("Showed up at token_auth with no token")
return False
logger.info("Authtoken: {}".format(auth_token))
# Verify token with FB
try:
response = requests.get('https://graph.facebook.com/me?access_token=' + auth_token)
data = response.json()
if data.get('error'):
logger.warning(data.get('error'))
logger.warning("FB token got bad response: {}".format(data))
elif int(data.get('id'), 0) > 0:
user_id = data.get('id')
logger.info("Got FB ID: {}".format(user_id))
g.user = User.query.get(user_id)
if not g.user:
logger.info("verify_auth_token found no user with from FB data: {}".format(data))
user_name = data.get('name')
try:
new_user = User(_id=user_id, name=user_name)
db.session.merge(new_user)
g.user = new_user
g.logging_in_new_user = True
except Exception as e:
logger.error("Exception in verify_token")
logger.exception(e)
session['user_id'] = g.user.id
return True
except Exception as e:
logger.error("Exception in verify_token")
logger.exception(e)
return False
def get(self):
logger.info(request.args)
body = request.args.get('Body', '').upper().strip()
phone = request.args.get('From', '')[2:]
# logger.info("Phone Number recieved is [{}]".format(phone))
this_user = User.get_most_recent_user_by_phone(phone)
logging.debug("{} {} {}".format(body, phone, this_user))
# Valid bodies:
# "adam, (352) 414-9721"
# "adam 123-456-7890"
try:
if ',' in body:
command_args = [x.strip() for x in body.strip().split(',')]
else:
command_args = [x.strip() for x in body.strip().split(' ')]
if len(command_args) != 2:
raise ValueError(
"Invalid marina command_args {}".format(command_args))
name = name_parser.parse_name(command_args[0])
phone = phone_parser.parse_phone(command_args[1])
except Exception as e:
logging.exception(e)
return twilio_response_templates.invalid_marina_flow()
twilio_message_sender.send_twilio_message_with_raw_phone((
"Captain {} from Freedom Boat Club is on their way to help you out. "
"If you require further assistance "
"please call Freedom Boat Club at (855) 373-3366").format(
this_user.name), phone)
twilio_message_sender.send_twilio_message_with_raw_phone(
"To see live updates of Captain {}'s progress, please click this link: {}. "
.format(this_user.name,
config.APPLICATION_ROOT + '/marina_user/live_map'), phone)
return twilio_response_templates.marina_flow_started(name, phone)
def post(self):
expected_args = [
"boat_make", "boat_type", "boat_length", "lat", "lon", "name",
"phone", "service_type"
]
try:
args = request.get_json()
logger.info("MWeb Drift Request: {}".format(args))
for arg in expected_args:
if arg not in args:
logger.error("Missing required arg: {}".format(arg))
return {"status": "missing_arg"}, 400
except Exception as e:
logger.exception(e)
# Make the new User object
u = User.query.get(args['phone'])
if u is not None:
logger.info("Found returning user: {}".format(u))
g.user = u
else:
u = User(_id=args['phone'],
name=args['name'],
role=User.Role.mweb_user.value)
u.update_position(args['lat'], args['lon'])
u.phone_number = args['phone']
u.name = args['name']
# Give em a boat
try:
b = Boat(u, args['boat_make'], args['boat_type'],
args['boat_length'])
except Exception as e:
logger.exception(e)
try:
trb = u.request_tow(args["service_type"])
except NoRequesteesFound as e:
return {"status": "no_captains_in_area"}
return {"status": "success"}
def get(self):
logger.info(request.args)
twilio_command = request.args.get('Body', '').upper().strip()
phone = request.args.get('From', '')[2:]
logger.warning("Phone Number recieved is [{}]".format(phone))
this_user = User.get_most_recent_user_by_phone(phone)
# ==== Argument Validation ==== #
# Validate phone number
if len(phone) != 10:
logger.error("Invalid phone number {}".format(phone))
return twilio_response_templates.invalid_phone(phone)
# Validate a user exists for this phone number
if this_user is None:
logger.exception("User not found for phone {}".format(phone))
return twilio_response_templates.user_not_found(phone)
# Validate body
if twilio_command not in constants.TWILIO_VALID_ARGS:
logger.warning(
"Received invalid twilio command: [{}]".format(twilio_command))
return twilio_response_templates.invalid_args()
logger.info(
"valid Twilio request from [{}]. User: [{}]. Body: [{}]".format(
phone, this_user.id, twilio_command))
# ==== Actual Logic ==== #
# TOW command
if twilio_command.upper() in constants.TWILIO_HELP_ARGS:
try:
tow_request_batch = this_user.request_tow()
except NoRequesteesFound:
return twilio_response_templates.no_requestees_found(phone)
except Exception as e:
logger.exception(e)
return twilio_response_templates.error500(e)
logger.info("User {} at ({},{}) requests a tow to {} users".format(
this_user.id, this_user.last_lat_seen,
this_user.last_long_seen, tow_request_batch.num_requests))
return twilio_response_templates.successful_trb_creation(
tow_request_batch)
# YES command
elif twilio_command.upper() == "YES":
try:
requestor, _, tow_request_batch, tow_event = this_user.accept_tow_request(
this_user.requestee_tow_request_id)
except TowRequestNotFoundError:
logger.info(
"User {} accepted, but doesn't have any outstanding tows".
format(this_user.id))
return twilio_response_templates.no_outstanding_requests()
except TowRequestAlreadyAcceptedError:
logger.info("Tow {} was already accepted".format(
this_user.requestee_tow_request_id))
return twilio_response_templates.already_accepted()
except TowRequestCancelledError:
logger.info("Tow {} was already cancelled".format(
this_user.requestee_tow_request_id))
return twilio_response_templates.already_cancelled()
except Exception as e:
logger.exception(e)
return twilio_response_templates.error500(e)
logger.info(
"User {} at ({},{}) accepted user {}'s ({},{}) tow request.".
format(this_user.id, this_user.last_lat_seen,
this_user.last_long_seen, requestor.id,
requestor.last_lat_seen, requestor.last_long_seen))
return twilio_response_templates.successful_accept_tr(
requestor, tow_event)
# NO command
elif twilio_command.upper() == "NO":
try:
this_user.reject_tow(this_user.requestee_tow_request_id)
except TowRequestNotFoundError:
logger.info(
"User {} rejected, but doesn't have any outstanding tows".
format(this_user.id))
return twilio_response_templates.no_outstanding_requests()
return twilio_response_templates.successful_reject_tr()
logger.error("This should never happen!\n{}\n{}\n{}".format(
twilio_command, phone, this_user.id()))
return twilio_response_templates.slipped_through_the_cracks(
twilio_command)
def render_towers(self):
logger.debug("rendering towers page")
towers = User.towers()
return render_template('towers.html', towers=towers)
def run():
print("Creating new users")
mark = User(_id='Mark', name='Mark')
mark.password = '******'
mark.phone = "8139577566"
mark.is_android = True
mark.update_position(38.997144, -77.12401) # DC
mark.role = User.Role.tower.value
adam = User(_id='Adam', name='Adam')
adam.password = '******'
adam.phone = "3475563921"
adam.is_android = True
adam.role = User.Role.tower.value
adam.update_position(40.727328, -73.9876522) # NYC
brent = User(_id='Brent', name='Brent')
brent.password = '******'
brent.phone = "5613061883"
brent.is_android = True
brent.role = User.Role.tower.value
brent.update_position(30.4670643, -84.3972845) # Tallahasse
# rayna = User(_id='rayna', name='rayna')
# rayna.password = '******'
# rayna.phone = "5613061883"
# rayna.is_android = True
# rayna.role = User.Role.tower.value
# rayna.update_position(28.359309, -82.66591) # Tampa
db.session.merge(adam)
db.session.merge(mark)
db.session.merge(brent)
# db.session.merge(rayna)
db.session.commit()
print("Successfully created users :)")