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')