def sendfcmtest():
j = request.get_json()
return jsonify(
send_fcm(user_id=j['user_id'],
title=j['title'],
body=j['body'],
data=j['data']))
def sendfcmtest(device_token):
return send_fcm(0,
0,
data={
"token": device_token,
"title": "A Tournament Went Live!",
"body":
"The Alamo Hold'em 2019 tournament is now live",
"data": {
"type": "tournament",
"id": "3",
"initialPath": "Tournaments",
"finalPath": "TourneyLobby"
}
})
def update_swap(user_id, id):
# Get sender user
sender = Profiles.query.get(user_id)
req = request.get_json()
utils.check_params(req)
# Get swaps
swap = Swaps.query.get(id)
if swap is None:
raise APIException('Swap not found', 404)
if sender.id != swap.sender_id:
raise APIException(
'Access denied: You are not the sender of this swap', 401)
current_percentage = swap.percentage
if sender.get_coins() < swap.cost:
raise APIException('Insufficient coins to see this swap', 402)
if swap.status._value_ in ['canceled', 'rejected', 'agreed']:
raise APIException('This swap can not be modified', 400)
counter_swap_body = {}
counter_swap = Swaps.query.get(swap.counter_swap_id)
if counter_swap is None:
raise APIException('Counter swap not found', 404)
# Get recipient user
recipient = Profiles.query.get(swap.recipient_id)
if recipient is None:
raise APIException('Recipient user not found', 404)
new_status = req.get('status')
current_status = swap.status._value_
if 'percentage' in req and new_status not in [
'agreed', 'rejected', 'canceled'
]:
# Handle percentage errors
percentage = req['percentage']
counter = req.get('counter_percentage', percentage)
if percentage < 1 or counter < 1:
raise APIException('Cannot swap less than %1', 400)
sender_availability = sender.available_percentage(
swap.tournament_id)
considering_this_swap = current_status == 'incoming'
actions = percentage if considering_this_swap else (
percentage - swap.percentage)
if actions > sender_availability:
raise APIException((
'Swap percentage too large. You can not exceed 50% per tournament. '
f'You have available: {sender_availability}%'), 400)
recipient_availability = \
recipient.available_percentage( swap.tournament_id )
if (counter - counter_swap.percentage) > recipient_availability:
raise APIException(
('Swap percentage too large for recipient. '
f'He has available to swap: {recipient_availability}%'),
400)
# Update percentages
swap.percentage = percentage
counter_swap.percentage = counter
# Handle status errors
if current_status == 'pending':
if new_status == 'agreed':
raise APIException('Cannot agree a swap on a pending status',
400)
if new_status == 'rejected':
raise APIException('Cannot reject this swap', 400)
if current_status in ['incoming', 'counter_incoming'
] and new_status == 'canceled':
raise APIException('Cannot cancel this swap', 400)
# Update status
if new_status in ['agreed', 'rejected', 'canceled']:
if new_status == 'agreed':
if recipient.get_coins() < swap.cost:
raise APIException(
'Recipient has insufficient coins to process this swap'
)
if current_status == 'incoming':
overdraft = current_percentage - sender.available_percentage(
swap.tournament_id)
if overdraft > 0:
raise APIException(
f'Cannot agree to this swap, you are overdrafting by {str(overdraft)}%',
400)
swap.status = new_status
counter_swap.status = new_status
# If current swap is pending, leave statuses as they are
elif current_status != 'pending':
swap.status = Swaps.counter_status(swap.status._value_)
counter_swap.status = Swaps.counter_status(
counter_swap.status._value_)
db.session.commit()
if new_status == 'agreed':
db.session.add(Transactions(user_id=user_id, coins=-swap.cost))
db.session.add(Transactions(user_id=recipient.id,
coins=-swap.cost))
db.session.commit()
user1_receipt = Buy_ins.get_latest(sender.id, swap.tournament_id)
user2_receipt = Buy_ins.get_latest(recipient.id,
swap.tournament_id)
send_email(template='swap_confirmation',
emails=[sender.user.email, recipient.user.email],
data={
'tournament_date':
swap.tournament.start_at,
'tournament_name':
swap.tournament.name,
'user1_name':
f'{sender.first_name} {sender.last_name}',
'user1_prof_pic':
sender.profile_pic_url,
'user1_percentage':
swap.percentage,
'user1_receipt_url':
user1_receipt and user1_receipt.receipt_img_url,
'user2_name':
f'{recipient.first_name} {recipient.last_name}',
'user2_prof_pic':
recipient.profile_pic_url,
'user2_percentage':
counter_swap.percentage,
'user2_receipt_url':
user2_receipt and user2_receipt.receipt_img_url
})
# Notifications
status_to_fcm = ['counter_incoming', 'canceled', 'rejected', 'agreed']
status = counter_swap.status._value_
if status in status_to_fcm:
buyin = Buy_ins.get_latest(user_id=sender.id,
tournament_id=swap.tournament_id)
data = {
'counter_incoming': ('Swap Countered', 'countered'),
'canceled': ('Swap Canceled', 'canceled'),
'rejected': ('Swap Rejected', 'rejected'),
'agreed': ('Swap Agreed', 'agreed to')
}
msg = f'{sender.get_name()} {data[status][1]} your swap'
send_fcm(user_id=recipient.id,
title=data[status][0],
body=msg,
data={
'id': counter_swap.id,
'buyin_id': buyin and buyin.id,
'alert': msg,
'type': 'swap',
'initialPath': 'SwapDashboard',
'finalPath': 'SwapOffer'
})
return jsonify([
swap.serialize(),
counter_swap.serialize(),
])
def create_swap(user_id):
# Get sender user
sender = Profiles.query.get(user_id)
# Get request json
req = request.get_json()
utils.check_params(req, 'tournament_id', 'recipient_id', 'percentage')
if user_id == req['recipient_id']:
raise APIException(
f'Cannot swap with yourself, user_id: {user_id}, '
f'recipient_id: {req["recipient_id"]}')
# Check for sufficient coins
swap_cost = req.get('cost', 1)
if swap_cost < 1:
raise APIException('No free swaps', 400)
if sender.get_coins() - sender.get_reserved_coins() < swap_cost:
raise APIException('Insufficient coins to make this swap', 402)
# Get recipient user
recipient = Profiles.query.get(req['recipient_id'])
if recipient is None:
raise APIException('Recipient user not found', 404)
# Check recipient swap availability
if recipient.swap_availability_status._value_ == 'unavailable':
raise APIException('This person is unavailable for swaps', 401)
# Can only send one swap offer at a time
existing_swaps = Swaps.query.filter_by(
sender_id=user_id,
recipient_id=recipient.id,
tournament_id=req['tournament_id'])
unacceptable_status = ['pending', 'incoming', 'counter_incoming']
for swap in existing_swaps:
if swap.status._value_ in unacceptable_status:
raise APIException(
f'Already have a swap with status "{swap.status._value_}"'
' with this player', 401)
percentage = req['percentage']
counter = req.get('counter_percentage', percentage)
if percentage < 1 or counter < 1:
raise APIException('Cannot swap less than %1', 400)
# Check tournament existance
trmnt = Tournaments.query.get(req['tournament_id'])
if trmnt is None:
raise APIException('Tournament not found', 404)
# Swap percentage availability
sender_availability = sender.available_percentage(req['tournament_id'])
if percentage > sender_availability:
raise APIException((
'Swap percentage too large. You can not exceed 50% per tournament. '
f'You have available: {sender_availability}%'), 400)
recipient_availability = recipient.available_percentage(
req['tournament_id'])
if counter > recipient_availability:
raise APIException(
('Swap percentage too large for recipient. '
f'He has available to swap: {recipient_availability}%'), 400)
# Create swap
swap = Swaps(sender_id=user_id,
tournament_id=req['tournament_id'],
recipient_id=recipient.id,
percentage=percentage,
cost=swap_cost,
status='pending')
counter_swap = Swaps(sender_id=recipient.id,
tournament_id=req['tournament_id'],
recipient_id=user_id,
percentage=counter,
cost=swap_cost,
status='incoming',
counter_swap=swap)
swap.counter_swap = counter_swap
db.session.add_all([swap, counter_swap])
db.session.commit()
# Notification
buyin = Buy_ins.get_latest(user_id=sender.id,
tournament_id=swap.tournament_id)
send_fcm(user_id=recipient.id,
title="New Swap",
body=sender.get_name() + ' wants to swap',
data={
'id': counter_swap.id,
'buyin_id': buyin and buyin.id,
'alert': sender.get_name() + ' wants to swap',
'type': 'swap',
'initialPath': 'SwapDashboard',
'finalPath': 'SwapOffer'
})
return jsonify({
'swap_id': swap.id,
'message': 'Swap created successfully.'
}), 200
# # Helper function to calculate the swap rating, used below
def calculate_swap_rating(user_id):
swaps = session.query(m.Swaps) \
.filter_by( sender_id=user_id ) \
.filter( m.Swaps.due_at != None )
total_swap_ratings = 0
for swap in swaps:
total_swap_ratings += swap.swap_rating
return total_swap_ratings / swaps.count()
for user in users_to_update_swaprating:
user.swap_rating = calculate_swap_rating(user.id)
# print(f'Updating swap rating for user {user.id} to {user.swap_rating}')
session.commit()
for a_user in users_to_notify:
print("User being notified", a_user['user_id'], " about ", a_user['body'])
if a_user['update'] == True:
send_fcm(user_id=a_user['user_id'],
title=a_user['title'],
body=a_user['body'],
data={
'id': a_user['trmnt_id'],
'alert': a_user['body'],
'type': 'result',
'initialPath': 'Event Results',
'finalPath': 'Swap Results'
})
def check_tournaments():
def get_all_players_from_trmnt(trmnte):
the_users = []
for flight in trmnte.flights:
for a_buyin in flight.buy_ins:
if a_buyin.user not in the_users: # no repeats
the_users.append(a_buyin.user)
return the_users
close_time = utils.designated_trmnt_close_time()
# any tournaments that are open and latest flight start at isnt later close_time
trmnts = db.session.query(m.Tournaments) \
.filter( m.Tournaments.status == 'open') \
.filter( m.Tournaments.flights.any(
m.Flights.start_at < close_time
))
if trmnts is not None:
for trmnt in trmnts:
latest_flight = trmnt.flights[-1]
print(latest_flight.start_at.strftime("%c"))
start_time = latest_flight.start_at + timedelta(hours=17)
# lastTime = start_time.strftime("%b. %d %I:%M %p")
if latest_flight.start_at < close_time:
# This tournament is over: change status and clean swaps
trmnt.status = 'waiting_results'
swaps = db.session.query(Swaps) \
.filter( Swaps.tournament_id == trmnt.id ) \
.filter( or_(
Swaps.status == 'pending',
Swaps.status == 'incoming',
Swaps.status == 'counter_incoming' ) )
if swaps is not None:
for swap in swaps:
print('Update swap status to "canceled", id:',
swap.id)
swap.status = 'canceled'
db.session.commit()
eww = db.session.query(m.Tournaments).get(trmnt.id)
users = get_all_players_from_trmnt(eww)
print('Update tournament status to "waiting_results", id:',
trmnt.id)
# buyin = m.Buy_ins.get_latest(user_id=user.id, tournament_id=trmnt.id )
###############################################################################
# Send fcm to all players when trmnt opens
_5mins_ago = datetime.utcnow() - timedelta(minutes=5)
_5mins_ahead = datetime.utcnow() + timedelta(minutes=5)
trmnts = db.session.query(m.Tournaments) \
.filter( m.Tournaments.start_at < _5mins_ahead) \
.filter( m.Tournaments.start_at > _5mins_ago )
if trmnts is not None:
for trmnt in trmnts:
users = get_all_players_from_trmnt(trmnt)
for user in users:
# buyin = m.Buy_ins.get_latest(user_id=user.id, tournament_id=trmnt.id )
time = datetime.utcnow()
domain = os.environ['MAILGUN_DOMAIN']
requests.post(
f'https://api.mailgun.net/v3/{domain}/messages',
auth=('api', os.environ.get('MAILGUN_API_KEY')),
data={
'from':
f'{domain} <*****@*****.**>',
'to':
user.user.email,
'subject':
'Event Started: ' + trmnt.name,
'text':
'Sending text email',
'html':
f'''
<div>trmnt.id {trmnt.id}</div><br />
<div>{trmnt.start_at} trmnt.start_at</div>
<div>{time} datetime.utcnow()</div>
<div>{_5mins_ago} _4mins_ago</div>
<div>{_5mins_ahead} _4mins_ahead</div>
'''
})
my_buyin = db.session.query(m.Buy_ins) \
.filter( Buy_ins.flight.has( tournament_id=trmnt.id )) \
.filter( m.Buy_ins.user_id==user.id ) \
.order_by( m.Buy_ins.id.desc() ).first()
print('check if this correct', user, user.id,
user.event_update)
if user.event_update is True:
# start_time = est.strftime("%b. %d, %a. %I:%M %p")
send_fcm(user_id=user.id,
title="Event Started",
body=trmnt.name + '\nopened just now',
data={
'id': trmnt.id,
'alert': trmnt.name + '\nopened just now',
'buyin_id': my_buyin.id,
'type': 'event',
'initialPath': 'Event Listings',
'finalPath': 'Event Lobby'
})
###############################################################################
# Delete buy-ins created before close time with status 'pending'
buyins = db.session.query(m.Buy_ins) \
.filter_by( status = 'pending' ) \
.filter( m.Buy_ins.flight.has( m.Flights.start_at < close_time ))
for buyin in buyins:
print('Deleting buy-in', buyin.id)
db.session.delete(buyin)
db.session.commit()
return 'Tournaments updated are on time'
def get_results():
'''
{
"api_token": "oidf8wy373apudk",
"tournament_id": 45,
"tournament_buyin": 150,
"users": {
"*****@*****.**": {
"place": 11,
"winnings": 200
}
}
}
'''
print("GETTING RESULGX")
r = request.get_json()
print('r', r)
print('Token here', r['api_token'])
print(os.environ['SP_API_TOKEN_LIVE'])
# Security token check
if r['api_token'] != os.environ['SP_API_TOKEN_LIVE']:
return jsonify({'error': r['api_token']})
print('b')
# print('Buyin ID', r['tournament_buyin'])
trmnt = Tournaments.query.get(r['tournament_id'])
if trmnt is None:
return jsonify({
'error':
'Tournament not found with id: ' + r['tournament_id']
})
print('c')
trmnt_buyin = r['tournament_buyin']
trmnt.results_link = (os.environ['POKERSOCIETY_HOST'] +
'/results/tournament/' + str(r['tournament_id']))
print('d')
# Add all players that haven't won but have swaps in this trmnt
all_swaps_in_trmnt = Swaps.query.filter_by( tournament_id=trmnt.id ) \
.filter_by( status='agreed' )
print('d')
for swap in all_swaps_in_trmnt:
email = swap.sender_user.user.email
if email not in r['users']:
r['users'][email] = {
'place': None,
'winnings': None,
}
print('e')
# Variable to set swap due date
due_date = datetime.utcnow() + timedelta(days=4)
# Process each player's data.. update roi and swap rating.. send email
for email, userdata in r['users'].items():
print('userdata', userdata)
user = Profiles.query.filter(
Profiles.user.has(email=email)).first()
if user is None:
return jsonify(
{'error': 'User not found with email: ' + email})
# Consolidate swaps if multiple with same user
all_agreed_swaps = user.get_agreed_swaps(r['tournament_id'])
swaps = {}
# If user has no swaps, don't send email
if len(all_agreed_swaps) == 0:
continue
print(all_agreed_swaps[0])
for swap in all_agreed_swaps:
print("SWAP IS", swap)
'''
{
"2": {
"count": 2,
"counter_percentage": 11,
"percentage": 11,
"recipient_email": "*****@*****.**"
},
"4": {
"count": 1,
"counter_percentage": 7,
"percentage": 5,
"recipient_email": "*****@*****.**"
}
}
'''
id = str(swap.recipient_id)
if id not in swaps:
swaps[id] = {
'count': 1,
'percentage': swap.percentage,
'counter_percentage': swap.counter_swap.percentage,
'recipient_email': swap.recipient_user.user.email
}
else:
swaps[id]['count'] += 1
swaps[id]['percentage'] += swap.percentage
swaps[id][
'counter_percentage'] += swap.counter_swap.percentage
# Set payment due date, swap_rating and result_winnings for each swap
swap.due_at = due_date
swap.swap_rating = 5
swap.result_winnings = True if userdata[
'winnings'] != None else False
db.session.commit()
total_swap_earnings = 0
total_amount_of_swaps = 0
render_swaps = []
# Go thru the consolidated swaps to create the email templates
for recipient_id, swapdata in swaps.items():
recipient = Profiles.query.get(recipient_id)
if recipient is None:
return jsonify(
{'error': 'User not found with id: ' + recipient_id})
# Tournament buyin could be "$200" "$0++" "Day 2"
regex = re.search(r'\$\s*(\d+)', str(trmnt_buyin))
entry_fee = int(regex.group(1)) if regex else 0
# Winnings are integers, but in case they are a string, ex "Satellite"
to_int = lambda x: x if isinstance(x, int) else 0
profit_sender = to_int(userdata['winnings']) - entry_fee
amount_owed_sender = profit_sender * swapdata[
'percentage'] / 100
# recipient_winnings can be None
recipient_winnings = r['users'][
swapdata['recipient_email']]['winnings'] or 0
profit_recipient = to_int(recipient_winnings) - entry_fee
amount_owed_recipient = profit_recipient * swapdata[
'counter_percentage'] / 100
render_swaps.append({
'amount_of_swaps':
swapdata['count'],
'entry_fee':
entry_fee,
'sender_first_name':
user.first_name,
'total_earnings_sender':
'{:,}'.format(userdata['winnings']),
'swap_percentage_sender':
swapdata['percentage'],
'swap_profit_sender':
'{:,}'.format(profit_sender),
'amount_owed_sender':
'{:,}'.format(round(amount_owed_sender)),
'recipient_first_name':
recipient.first_name,
'recipient_last_name':
recipient.last_name,
'recipient_profile_pic_url':
recipient.profile_pic_url,
'total_earnings_recipient':
'{:,}'.format(recipient_winnings),
'swap_percentage_recipient':
swapdata['counter_percentage'],
'swap_profit_recipient':
'{:,}'.format(profit_recipient),
'amount_owed_recipient':
'{:,}'.format(round(amount_owed_recipient))
})
total_swap_earnings -= amount_owed_sender
total_swap_earnings += amount_owed_recipient
total_amount_of_swaps += swapdata['count']
if total_swap_earnings >= 0:
for swap in all_agreed_swaps:
a_swap = Swaps.query.get(swap.id)
a_swap.paid = True
a_swap.paid_at = datetime.utcnow()
a_swap.confirmed = True
a_swap.confirmed_at = datetime.utcnow()
# Update user and buy ins
user.roi_rating = user.calculate_roi_rating()
buyin = Buy_ins.get_latest(user.id, trmnt.id)
buyin.place = userdata['place']
buyin.winnings = userdata['winnings']
db.session.commit()
sign = '-' if total_swap_earnings < 0 else '+'
s = 's' if total_amount_of_swaps > 1 else ''
# print('coming in')
a_user = Profiles.query.get(user.id)
# print('isr esult update true', a_user.result_update, user.id)
if a_user.result_update == True:
send_fcm(user_id=user.id,
title="Results Posted",
body=trmnt.name + " posted their results.",
data={
'id': trmnt.id,
'alert':
trmnt.name + " just posted their results.",
'type': 'result',
'initialPath': 'Event Results',
'finalPath': 'Swap Results'
})
send_email(
'swap_results',
[email], #'*****@*****.**','*****@*****.**'],
data={
'tournament_date':
trmnt.start_at.strftime('%A, %B %d, %Y - %I:%M %p'),
'tournament_name':
trmnt.name,
'results_link':
trmnt.results_link,
'total_swaps':
f"{total_amount_of_swaps} swap{s}",
'total_swappers':
f"{len(swaps)} {'person' if len(swaps) == 1 else 'people'}",
'total_swap_earnings':
f'{sign}${"{:,.2f}".format( abs(total_swap_earnings) )}',
'render_swaps':
render_swaps,
'roi_rating':
round(user.roi_rating),
'swap_rating':
round(user.swap_rating, 1)
})
trmnt.status = 'closed'
db.session.commit()
return jsonify({'message': 'Results processed successfully'}), 200
def check_swaps():
swapsToBePaid = db.session.query(m.Swaps) \
.filter( Swaps.due_at != None ) \
.filter( Swaps.paid == False )
swapsToBeConfirmed = db.session.query(m.Swaps) \
.filter( m.Swaps.due_at != None ) \
.filter( m.Swaps.paid == True ) \
.filter(m.Swaps.confirmed == False) \
.filter(m.Swaps.disputed == False)
now = datetime.utcnow()
users_to_update_swaprating = []
users_to_notify = []
# REMINDERS FOR SWAPS TO BE PAID (SEND ONE NOTIFICATION PER USER, PER TOURNAMENT ID)
for swap in swapsToBePaid:
user = db.session.query(m.Profiles).get(swap.sender_id)
first_due = swap.due_at
time_after_due_date = now - swap.due_at
trmt_id = swap.tournament_id
title = ''
body = ''
if now < swap.due_at:
title = "5 Star Reminder"
body = "Pay before Swap Due"
elif time_after_due_date < timedelta(days=2):
title = "4 Star Reminder"
body = "Pay before 2 Days after Due Date"
elif time_after_due_date < timedelta(days=4):
title = "3 Star Reminder"
body = "Pay before 4 Days after Due Date"
elif time_after_due_date < timedelta(days=6):
title = "2 Star Reminder"
body = "Pay before 6 Days after Due Date"
elif time_after_due_date < timedelta(days=8):
title = "1 Star Reminder"
body = "8 days after results"
elif time_after_due_date < timedelta(days=9):
title = "Warning: Account Suspension"
body = "9 days after results"
time = datetime.utcnow()
# domain = os.environ['MAILGUN_DOMAIN']
# requests.post(f'https://api.mailgun.net/v3/{domain}/messages',
# auth=(
# 'api',
# os.environ.get('MAILGUN_API_KEY')),
# data={
# 'from': f'{domain} <*****@*****.**>',
# 'to': user.user.email,
# 'subject': 'You are in Danger of being Suspended',
# 'text': 'Sending text email',
# 'html': f'''
# <div>trmnt.id {trmnt.id}</div><br />
# <div>{trmnt.start_at} trmnt.start_at</div>
# <div>{time} datetime.utcnow()</div>
# <div>{_5mins_ago} _4mins_ago</div>
# <div>{_5mins_ahead} _4mins_ahead</div>
# '''
# })
# Suspend account
else:
title = "Account Suspension"
body = "You're account has been suspended until you pay your swaps"
swap_rating = 0
# user_account = session.query(m.Users).get( user.id )
user.naughty = True
print('Put on naughty list', user, user.id, user.naughty)
db.session.commit()
send_email(
template='account_suspension',
emails=user.email,
# data={'validation_link': utils.jwt_link(user.id, role='email_change')}
)
proto = {
"user_id": user.id,
"trmnt_id": trmt_id,
"title": title,
"body": body,
"update": user.result_update
}
print('Proto:', proto)
if users_to_notify == []:
users_to_notify.append(proto)
else:
for obj in users_to_notify:
print('obj', obj)
if any(obj['user_id'] == user.id):
print("Success!")
index = -1
for i, obj in enumerate(users_to_notify):
if obj['user_id'] == user.id:
index = i
if users_to_notify[i]['trmnt_id'] != trmt_id:
print("Sending to User Id:",
proto['user_id'])
users_to_notify.append(proto)
else:
print("Same tournament")
# REMINDERS FOR SWAPS TO BE CONFIRMED (SEND ONE NOTIFICATION PER USER, PER TOURNAMENT ID)
for swap in swapsToBeConfirmed:
user = db.session.query(m.Profiles).get(swap.sender_id)
a_user = db.session.query(m.Profiles).get(swap.recipient_id)
time_after_due_date = swap.paid_at - swap.due_at
trmt_id = swap.tournament_id
title = None
body = None
swap_rating = None
#If User had failed to confirm paid swaps after 5 days
if now >= swap.paid_at + timedelta(days=5):
if time_after_due_date < timedelta(days=0):
swap_rating = 5
elif time_after_due_date < timedelta(days=2):
swap_rating = 4
elif time_after_due_date < timedelta(days=4):
swap_rating = 3
elif time_after_due_date < timedelta(days=6):
swap_rating = 2
elif time_after_due_date < timedelta(days=8):
swap_rating = 1
else:
swap_rating = 0
title = "Swap Confirmation Auto-Completed"
body = "You Swap Rating has been updated accordingly."
swap.confirmed = True
# ADD TO SWAP RATINGS TO UPDATE
if swap.swap_rating != swap_rating:
# print(f'Updating swap rating for swap {swap.id} from {swap.swap_rating} to {swap_rating}')
swap.swap_rating = swap_rating
db.session.commit()
users_to_update_swaprating.append(user)
# ADD TO USERS TO UPDATE ( ONE PER PERSON SWAPPED WITH, PER TOURNAMENT)
proto = {
"user_id": user.id,
"trmnt_id": trmt_id,
"title": title,
"body": body,
"update": user.result_update
}
if any(obj['user_id'] == user.id for obj in users_to_notify):
index = -1
for i, obj in enumerate(users_to_notify):
if obj['user_id'] == user.id:
index = i
if users_to_notify[i]['trmnt_id'] != trmt_id:
users_to_notify.append(proto)
else:
print("Same tournament")
else:
# if now < swap.paid_at + timedelta(days=2) and now > swap.paid_at + timedelta(days=1):
if now > swap.paid_at:
title = "Confirm Swap Payment"
body = "Confirm the swap payment made to you"
elif now > swap.paid_at + timedelta(
days=4) and now < swap.paid_at + timedelta(days=5):
title = "Your Confirmation will be Autocompleted"
body = "Confirm or Dispute before 5 days have pass after being paid"
# ADD TO USERS TO UPDATE ( ONE PER PERSON SWAPPED WITH, PER TOURNAMENT)
proto = {
"user_id": a_user.id,
"trmnt_id": trmt_id,
"title": title,
"body": body,
"update": user.result_update
}
print("Proto: ", proto)
if users_to_notify == []:
users_to_notify.append(proto)
else:
if any(obj['user_id'] == a_user.id
for obj in users_to_notify):
index = -1
for i, obj in enumerate(users_to_notify):
if obj['user_id'] == a_user.id:
index = i
if users_to_notify[i]['trmnt_id'] != trmt_id:
users_to_notify.append(proto)
else:
print("Same tournament")
# # Helper function to calculate the swap rating, used below
def calculate_swap_rating(user_id):
swaps = db.session.query(m.Swaps) \
.filter_by( sender_id=user_id ) \
.filter( m.Swaps.due_at != None )
total_swap_ratings = 0
for swap in swaps:
total_swap_ratings += swap.swap_rating
return total_swap_ratings / swaps.count()
for user in users_to_update_swaprating:
user.swap_rating = calculate_swap_rating(user.id)
# print(f'Updating swap rating for user {user.id} to {user.swap_rating}')
db.session.commit()
for a_user in users_to_notify:
print("User being notified", a_user['user_id'], " about ",
a_user['body'])
if a_user['update'] == True:
send_fcm(user_id=a_user['user_id'],
title=a_user['title'],
body=a_user['body'],
data={
'id': a_user['trmnt_id'],
'alert': a_user['body'],
'type': 'result',
'initialPath': 'Event Results',
'finalPath': 'Swap Results'
})
return "Swappers notified Successfully"
'''
})
my_buyin = session.query(m.Buy_ins) \
.filter( Buy_ins.flight.has( tournament_id=trmnt.id )) \
.filter( m.Buy_ins.user_id==user.id ) \
.order_by( m.Buy_ins.id.desc() ).first()
print("check if this goes through", user.id, user.event_update)
if user.event_update is True:
send_fcm(user_id=user.id,
title="Event Started",
body=trmnt.name + '\nopened just now',
data={
'id': trmnt.id,
'alert': trmnt.name + '\nopened just now',
'buyin_id': my_buyin.id,
'type': 'event',
'initialPath': 'Event Listings',
'finalPath': 'Event Lobby'
})
###############################################################################
# Delete buy-ins created before close time with status 'pending'
buyins = session.query(m.Buy_ins) \
.filter_by( status = 'pending' ) \
.filter( m.Buy_ins.flight.has( m.Flights.start_at < close_time ))
for buyin in buyins:
print('Deleting buy-in', buyin.id)