def post(self, match_key):
self._require_registration()
current_user_id = self.user_bundle.account.key.id()
match = Match.get_by_id(match_key)
if self.request.get('favorite'):
favorite = Favorite(parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.MATCH,
model_key=match_key)
MyTBAHelper.add_favorite(favorite)
else:
MyTBAHelper.remove_favorite(current_user_id, match_key,
ModelType.MATCH)
subs = self.request.get_all('notification_types')
if subs:
subscription = Subscription(
parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.MATCH,
model_key=match_key,
notification_types=[int(s) for s in subs])
MyTBAHelper.add_subscription(subscription)
else:
MyTBAHelper.remove_subscription(current_user_id, match_key,
ModelType.MATCH)
self.redirect('/account/mytba?status=match_updated#my-matches')
def create_checkout(subscriptiontype, price):
subscription = ""
subscriptiontype = subscriptiontype
subscriptionprice = price
result = transact({
'amount':
request.form.get('amount'),
'payment_method_nonce':
request.form.get('payment_method_nonce'),
'options': {
"submit_for_settlement": True
}
})
if result.is_success or result.transaction:
subscription = Subscription(user=current_user.id,
subscription_active=True,
subscription_type=subscriptiontype,
subscription_price=subscriptionprice)
if subscription.save():
flash("Grazie Mille!!")
return render_template('home.html')
else:
for x in result.errors.deep_errors:
flash('Error: %s: %s' % (x.code, x.message))
return redirect(url_for('subscriptions.pick'))
def create(subscription):
email = subscription.get('email', None)
discord_user_id = subscription.get('discord_user_id', None)
if discord_user_id:
existing = Subscription.query.filter_by(
discord_user_id=discord_user_id).first()
elif email:
existing = Subscription.query.filter_by(email=email).first()
else:
# data for subscription missing
abort(400, "data missing for subscription")
if existing:
abort(
406,
"Subscription with given email or discord user id already exists")
try:
sub = Subscription(email=email, discord_user_id=discord_user_id)
print("add sub")
db.session.add(sub)
db.session.commit()
except SQLAlchemyError as e:
# TODO: use abort() here as well
print("Failed to create subscription")
print(e)
abort(400, str(e.__dict__['orig']))
return subscription_schema.dump(sub)
def post(self, team_number):
self._require_registration()
current_user_id = self.user_bundle.account.key.id()
team_key = 'frc{}'.format(team_number)
if self.request.get('favorite'):
favorite = Favorite(parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.TEAM,
model_key=team_key)
MyTBAHelper.add_favorite(favorite)
else:
MyTBAHelper.remove_favorite(current_user_id, team_key,
ModelType.TEAM)
subs = self.request.get_all('notification_types')
if subs:
subscription = Subscription(
parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.TEAM,
model_key=team_key,
notification_types=[int(s) for s in subs])
MyTBAHelper.add_subscription(subscription)
else:
MyTBAHelper.remove_subscription(current_user_id, team_key,
ModelType.TEAM)
self.redirect('/account/mytba?status=team_updated#my-teams')
def post(self, event_key):
self._require_login('/account/register')
self._require_registration('/account/register')
current_user_id = self.user_bundle.account.key.id()
if self.request.get('favorite'):
favorite = Favorite(parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.EVENT,
model_key=event_key)
MyTBAHelper.add_favorite(favorite)
else:
MyTBAHelper.remove_favorite(current_user_id, event_key)
subs = self.request.get_all('notification_types')
if subs:
subscription = Subscription(
parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.EVENT,
model_key=event_key,
notification_types=[int(s) for s in subs])
MyTBAHelper.add_subscription(subscription)
else:
MyTBAHelper.remove_subscription(current_user_id, event_key)
self.redirect('/account/mytba?status=event_updated#my-events')
def post(self, event_key):
self._require_registration()
current_user_id = self.user_bundle.account.key.id()
event = Event.get_by_id(event_key)
subscribed_matches = set(self.request.get_all('subscribed_matches'))
for match in event.matches:
if not match.has_been_played:
match_key = match.key.id()
if match.key.id() in subscribed_matches:
sub = Subscription(
parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_type=ModelType.MATCH,
model_key=match_key,
notification_types=[NotificationType.UPCOMING_MATCH])
MyTBAHelper.add_subscription(sub)
else:
MyTBAHelper.remove_subscription(current_user_id, match_key,
ModelType.MATCH)
self.redirect(
'/account/mytba?status=match_updated#my-matches'.format(event_key))
def test_users_subscribed_to_event_year(self):
# Make sure we match year*
Subscription(parent=ndb.Key(Account, 'user_id_1'),
user_id='user_id_1',
model_key='2020*',
model_type=ModelType.EVENT,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
Subscription(parent=ndb.Key(Account, 'user_id_2'),
user_id='user_id_2',
model_key='2020*',
model_type=ModelType.EVENT,
notification_types=[NotificationType.MATCH_SCORE]).put()
users = Subscription.users_subscribed_to_event(
self.event, NotificationType.UPCOMING_MATCH)
self.assertEqual(users, ['user_id_1'])
def test_users_subscribed_to_event_year_key(self):
# Make sure we fetch both key and year together
Subscription(parent=ndb.Key(Account, 'user_id_1'),
user_id='user_id_1',
model_key='2020miket',
model_type=ModelType.EVENT,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
Subscription(parent=ndb.Key(Account, 'user_id_2'),
user_id='user_id_2',
model_key='2020*',
model_type=ModelType.EVENT,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
users = Subscription.users_subscribed_to_event(
self.event, NotificationType.UPCOMING_MATCH)
self.assertItemsEqual(users, ['user_id_1', 'user_id_2'])
def test_users_subscribed_to_event_model_type(self):
# Make sure we filter for model types
Subscription(parent=ndb.Key(Account, 'user_id_1'),
user_id='user_id_1',
model_key='2020miket',
model_type=ModelType.EVENT,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
Subscription(parent=ndb.Key(Account, 'user_id_2'),
user_id='user_id_2',
model_key='frc7332',
model_type=ModelType.TEAM,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
users = Subscription.users_subscribed_to_event(
self.event, NotificationType.UPCOMING_MATCH)
self.assertItemsEqual(users, ['user_id_1'])
def test_users_subscribed_to_match_key(self):
# Make sure we match a match key
Subscription(parent=ndb.Key(Account, 'user_id_1'),
user_id='user_id_1',
model_key='2020miket_qm1',
model_type=ModelType.MATCH,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
Subscription(parent=ndb.Key(Account, 'user_id_2'),
user_id='user_id_2',
model_key='2020miket_qm1',
model_type=ModelType.MATCH,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
users = Subscription.users_subscribed_to_match(
self.match, NotificationType.UPCOMING_MATCH)
self.assertItemsEqual(users, ['user_id_1', 'user_id_2'])
def test_users_subscribed_to_team_key(self):
# Make sure we match a team key
Subscription(parent=ndb.Key(Account, 'user_id_1'),
user_id='user_id_1',
model_key='frc7332',
model_type=ModelType.TEAM,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
Subscription(parent=ndb.Key(Account, 'user_id_2'),
user_id='user_id_2',
model_key='frc7332',
model_type=ModelType.TEAM,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
users = Subscription.users_subscribed_to_team(
self.team, NotificationType.UPCOMING_MATCH)
self.assertItemsEqual(users, ['user_id_1', 'user_id_2'])
def test_users_subscribed_to_event_key(self):
# Make sure we event key
Subscription(parent=ndb.Key(Account, 'user_id_1'),
user_id='user_id_1',
model_key='2020miket',
model_type=ModelType.EVENT,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
Subscription(parent=ndb.Key(Account, 'user_id_2'),
user_id='user_id_2',
model_key='2020mike2',
model_type=ModelType.EVENT,
notification_types=[NotificationType.MATCH_SCORE]).put()
users = Subscription.users_subscribed_to_event(
MockEvent(key_name="2020miket", year=2020),
NotificationType.UPCOMING_MATCH)
self.assertEqual(users, ['user_id_1'])
def test_users_subscribed_to_team_unique(self):
# Make sure we filter for duplicates
Subscription(parent=ndb.Key(Account, 'user_id_1'),
user_id='user_id_1',
model_key='frc7332',
model_type=ModelType.TEAM,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
Subscription(parent=ndb.Key(Account, 'user_id_1'),
user_id='user_id_1',
model_key='frc7332',
model_type=ModelType.TEAM,
notification_types=[NotificationType.UPCOMING_MATCH
]).put()
users = Subscription.users_subscribed_to_team(
self.team, NotificationType.UPCOMING_MATCH)
self.assertEqual(users, ['user_id_1'])
def post(self, topic_id):
user = users.get_current_user()
topic = Topic.get_by_id(int(topic_id))
new_subscription = Subscription(email=user.email(),
topic_id=topic.key.id())
# subscriptions = Subscription.query().fetch()
new_subscription.put()
return self.redirect_to("topic-details", topic_id=topic.key.id())
def test_add_subscription_200_sending_device_key(self):
subscription = Subscription(
parent=ndb.Key(Account, 'user_id'),
user_id='user_id',
model_key='frc7332',
model_type=ModelType.TEAM)
# Subscription does not already exist - return a 200 and put
with patch.object(NotificationHelper, 'send_subscription_update') as mock_send_subscription_update, \
patch.object(subscription, 'put') as mock_put:
self.assertEqual(MyTBAHelper.add_subscription(subscription, 'sending_device_key'), 200)
mock_put.assert_called_once()
mock_send_subscription_update.assert_called_once_with('user_id', 'sending_device_key')
def test_remove_subscription_200_sending_device_key(self):
subscription = Subscription(
parent=ndb.Key(Account, 'user_id'),
user_id='user_id',
model_key='frc7332',
model_type=ModelType.TEAM)
subscription_key = subscription.put()
# Subscription does not exist - 404
with patch.object(NotificationHelper, 'send_subscription_update') as mock_send_subscription_update, \
patch.object(ndb, 'delete_multi') as mock_delete:
self.assertEqual(MyTBAHelper.remove_subscription(subscription.user_id, subscription.model_key, subscription.model_type, 'sending_device_key'), 200)
mock_delete.assert_called_once_with([subscription_key])
mock_send_subscription_update.assert_called_once_with('user_id', 'sending_device_key')
def test_add_subscription_200_update_sending_device_key(self):
subscription = Subscription(
parent=ndb.Key(Account, 'user_id'),
user_id='user_id',
model_key='frc7332',
model_type=ModelType.TEAM)
subscription.put()
new_subscription = Subscription(
parent=ndb.Key(Account, 'user_id'),
user_id='user_id',
model_key='frc7332',
model_type=ModelType.TEAM,
notification_types=[NotificationType.UPCOMING_MATCH])
# Subscription exists but with different notification types - update and return 200
with patch.object(NotificationHelper, 'send_subscription_update') as mock_send_subscription_update, \
patch.object(subscription, 'put') as mock_put:
self.assertEqual(MyTBAHelper.add_subscription(new_subscription, 'sending_device_key'), 200)
self.assertEqual(new_subscription.notification_types, subscription.notification_types)
mock_put.assert_called_once()
mock_send_subscription_update.assert_called_once_with('user_id', 'sending_device_key')
def create(self, create_subscription_request: CreateSubscriptionRequest):
subscription = Subscription()
park, error = self.park_repo.get_by_id(
create_subscription_request.park_id)
if park is not None and error is None:
subscription.park = park
else:
return None, error
user, error = self.user_repo.get_by_id(
create_subscription_request.user_id)
if user is not None and error is None:
subscription.user = user
else:
return None, error
subscription = Subscription(created_at=time.time_ns(),
park=park,
user=user)
subscription, error = self.subscription_repo.create(subscription)
if subscription is not None and error is None:
return self.subscription_schema.dump(subscription).data, None
else:
return None, error
def post(self):
user = CustomUser.get_current_user(self)
if not user or not user.is_active:
return self.write(
"Please login before you're allowed to post a topic.")
title = cgi.escape(self.request.get("title").strip())
text = cgi.escape(self.request.get("text").strip())
if title == "" or text == "":
return self.write("Please fill out all the fields.")
if not CSRF.validate_token(self.request.get("csrf_token")):
return self.write("CSRF fail")
# Validate recaptcha
payload = {
'secret': os.environ.get("RECAPTCHA_KEY"),
'response': self.request.get("g-recaptcha-response"),
}
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
result = urlfetch.fetch(
url="https://www.google.com/recaptcha/api/siteverify",
headers=headers,
payload=urlencode(payload),
method=urlfetch.POST)
recaptcha_response = json.loads(result.content)
if not recaptcha_response['success']:
return self.write("Please verify you are not a robot")
new_topic = Topic(title=title, content=text, user_email=user.email())
new_topic.put()
topic_id = new_topic.key.id()
# Subscribe the author to the topic
new_subscription = Subscription(user_id=user.id,
user_email=user.email(),
topic_id=topic_id)
new_subscription.put()
return self.redirect("/topic/view/" + str(topic_id))
def get(self, topic_id):
user = CustomUser.get_current_user(self)
if not user:
return self.redircet("/")
if user.is_subscribed(topic_id):
user.delete_subscription(topic_id)
return self.write(
"You have successfuly unsubscribed from the topic")
else:
new_subscription = Subscription(user_id=user.id,
user_email=user.email(),
topic_id=int(topic_id))
new_subscription.put()
return self.write("You have successfuly subscribed to the topic")
def get(self):
user = CustomUser.get_current_user(self)
if not user:
return self.redirect("/")
existing_subscription = Subscription.query(
Subscription.user_id == user.id,
Subscription.topic_id == 1).fetch()
if existing_subscription:
existing_subscription[0].key.delete()
return self.write("You have been unsubscribed.")
new_subscription = Subscription(user_id=user.id,
topic_id=1,
user_email=user.email())
new_subscription.put()
return self.write("You have successfuly subscribed.")
def post(self):
"""
Create new subscription.
"""
# Checks
parsed_args = parser.parse_args()
client = session.query(Client).filter(
Client.user_id == auth.user.id).first()
if not client:
abort(404, message="Client doesn't exist")
car = session.query(Car).filter(
Car.id == parsed_args["car_id"]).first()
if not car or car.client_id != client.id:
abort(400, message="Not client's car.")
place = session.query(Place).filter(
Place.id == parsed_args["place_id"]).first()
if not place or place.occupied:
abort(400, message="Place not allowed.")
if parsed_args["end"] <= datetime.utcnow().replace(tzinfo=pytz.UTC):
abort(400, message="End date in past.")
subscription = Subscription(
end=parsed_args["end"],
type=parsed_args["type"],
place_id=place.id,
car_id=car.id,
)
session.add(subscription)
self.try_session_commit()
# make new payment for subscription
payment = Payment(
sale_date=datetime.utcnow().replace(tzinfo=pytz.UTC),
price=calc_price(subscription.start, subscription.end),
tax=calc_tax(),
subscription_id=subscription.id,
)
session.add(payment)
return self.finalize_post_req(subscription)
def add():
user_id = get_jwt_identity()
name = request.json.get('name')
amount = request.json.get('amount')
payment_date = request.json.get('payment_date')
payment_date = convert_date(payment_date)
subs_type = request.json.get('subs_type')
frequency = request.json.get('frequency')
description = request.json.get('description')
new_subs = Subscription(user_id=user_id,
name=name,
amount=amount,
payment_date=payment_date,
subs_type=subs_type,
frequency=int(frequency),
description=description)
if new_subs.save():
responseObj = {
'status': 'success',
'message': 'New subscription added!',
'subscription': {
'name': name,
'amount': amount,
'next_payment': new_subs.next_payment,
'description': description
}
}
return jsonify(responseObj), 200
else:
responseObj = {
'status': 'failed',
'message': 'Subscription has failed to be added'
}
return jsonify(responseObj), 200
def register():
uuid = request.form.get('uuid')
channel_key = request.form.get('channel_key')
if not uuid:
return to_error_json("uuid is required")
elif not channel_key:
return to_error_json("channel_key is required")
sub = Subscription.query.filter_by(uuid=uuid).filter_by(
channel_key=channel_key).first()
if sub is None:
channel_name = Channel.query.with_entities(
Channel.name).filter_by(listen_key=channel_key).first()
subscription = Subscription(uuid=uuid,
channel_key=channel_key,
channel_name=channel_name[0])
db.session.add(subscription)
db.session.commit()
return jsonify(subscription.dict())
else:
return to_error_json("Subscription already exists")
from database import db
from models.subscription import Subscription
from models.recipe import Recipe
vegetarian_meal_1 = Subscription(name='Vegetarian_2_meals',
amount_of_meals=2,
price=88.00)
vegetarian_meal_1.save()
vege_meal_2 = Subscription(name='Vegetarian_3_meals',
amount_of_meals=3,
price=131.88)
vege_meal_2.save()
vege_meal_3 = Subscription(name='Vegetarian_4_meals',
amount_of_meals=4,
price=175.84)
vege_meal_3.save()
meat_meal_1 = Subscription(name='Mix_2_meals', amount_of_meals=2, price=88.00)
meat_meal_1.save()
meat_meal_2 = Subscription(name='Mix_3_meals', amount_of_meals=3, price=131.88)
meat_meal_2.save()
meat_meal_3 = Subscription(name='Mix_4_meals', amount_of_meals=4, price=175.84)
meat_meal_3.save()
def update_model_preferences(self, request):
user_id = get_current_user_id(self.headers)
if user_id is None:
return BaseResponse(
code=401, message="Unauthorized to update model preferences")
model_key = request.model_key
model_type = request.model_type
output = {}
code = 0
if request.favorite:
fav = Favorite(parent=ndb.Key(Account, user_id),
user_id=user_id,
model_key=model_key,
model_type=model_type)
result = MyTBAHelper.add_favorite(fav, request.device_key)
if result == 200:
output['favorite'] = {"code": 200, "message": "Favorite added"}
code += 100
elif result == 304:
output['favorite'] = {
"code": 304,
"message": "Favorite already exists"
}
code += 304
else:
output['favorite'] = {
"code": 500,
"message": "Unknown error adding favorite"
}
code += 500
else:
result = MyTBAHelper.remove_favorite(user_id, model_key,
model_type,
request.device_key)
if result == 200:
output['favorite'] = {
"code": 200,
"message": "Favorite deleted"
}
code += 100
elif result == 404:
output['favorite'] = {
"code": 404,
"message": "Favorite not found"
}
code += 404
else:
output['favorite'] = {
"code": 500,
"message": "Unknown error removing favorite"
}
code += 500
if request.notifications:
sub = Subscription(
parent=ndb.Key(Account, user_id),
user_id=user_id,
model_key=model_key,
model_type=request.model_type,
notification_types=PushHelper.notification_enums_from_string(
request.notifications))
result = MyTBAHelper.add_subscription(sub, request.device_key)
if result == 200:
output['subscription'] = {
"code": 200,
"message": "Subscription updated"
}
code += 100
elif result == 304:
output['subscription'] = {
"code": 304,
"message": "Subscription already exists"
}
code += 304
else:
output['subscription'] = {
"code": 500,
"message": "Unknown error adding favorite"
}
code += 500
else:
result = MyTBAHelper.remove_subscription(user_id, model_key,
model_type,
request.device_key)
if result == 200:
output['subscription'] = {
"code": 200,
"message": "Subscription removed"
}
code += 100
elif result == 404:
output['subscription'] = {
"code": 404,
"message": "Subscription not found"
}
code += 404
else:
output['subscription'] = {
"code": 500,
"message": "Unknown error removing subscription"
}
code += 500
return BaseResponse(code=code, message=json.dumps(output))
def post(self):
self._require_login('/account/register')
self._require_registration('/account/register')
current_user_id = self.user_bundle.account.key.id()
target_account_id = self.request.get('account_id')
if current_user_id == target_account_id:
action = self.request.get('action')
# if action == "favorite_add":
# model = self.request.get('model_key')
# if not ValidationHelper.is_valid_model_key(model):
# self.redirect('/account/mytba?error=invalid_model')
# return
# favorite = Favorite(parent = ndb.Key(Account, current_user_id), model_key = model, user_id = current_user_id)
# MyTBAHelper.add_favorite(favorite)
# self.redirect('/account/mytba')
# return
if action == "favorite_delete":
model_key = self.request.get('model_key')
result = MyTBAHelper.remove_favorite(current_user_id,
model_key)
if result == 404:
self.redirect('/account/mytba?error=fav_not_found')
return
self.redirect('/account/mytba')
return
# elif action == "subscription_add":
# model = self.request.get('model_key')
# if not ValidationHelper.is_valid_model_key(model):
# self.redirect('/account/mytba?error=invalid_model')
# return
# subs = self.request.get_all('notification_types')
# if not subs:
# # No notification types specified. Don't add
# self.redirect('/account/mytba?error=no_sub_types')
# return
# subscription = Subscription(parent = ndb.Key(Account, current_user_id), user_id = current_user_id, model_key = model, notification_types = [int(s) for s in subs])
# MyTBAHelper.add_subscription(subscription)
# self.redirect('/account/mytba')
# return
elif action == "subscription_year_add":
now = datetime.datetime.now()
year = self.request.get('year')
if not "{}".format(now.year) == year:
# Can only subscribe to the current year's firehose
self.redirect('/account/mytba?error=invalid_year')
return
key = "{}*".format(year)
subs = self.request.get_all('notification_types')
if not subs:
# No notification types specified. Don't add
self.redirect('/account/mytba?error=no_sub_types')
return
subscription = Subscription(
parent=ndb.Key(Account, current_user_id),
user_id=current_user_id,
model_key=key,
model_type=ModelType.EVENT,
notification_types=[int(s) for s in subs])
logging.info("{}".format(self.request.get('webhooks_only')))
MyTBAHelper.add_subscription(subscription)
self.redirect('/account/mytba')
return
elif action == "subscription_delete":
model_key = self.request.get('model_key')
result = MyTBAHelper.remove_subscription(
current_user_id, model_key)
if result == 404:
self.redirect('/account/mytba?error=sub_not_found')
return
self.redirect('/account/mytba')
return
self.redirect('/account/mytba?error=invalid_account')
