def test_subscription_search(): subscription = Subscription.search('google').first() assert subscription is not None assert subscription.name == 'Google Developers Blog' subscription = Subscription.search('youtube').first() assert subscription is not None assert subscription.name == 'YouTube'
def test_user_subscriptions(): seed_user = User.get() subscription = Subscription.get() # Query checking if the subscription is in the user. count_query = (UserSubscription.select() .where(UserSubscription.user == seed_user, UserSubscription.subscription == subscription)) # Unsubscribe first (regardless of subscription). seed_user.unsubscribe(subscription) assert count_query.count() == 0 assert subscription.num_subscribers() == 0 # Resubscribe. seed_user.subscribe(subscription) assert count_query.count() == 1 assert subscription.num_subscribers() == 1 # Resubscribe again. seed_user.subscribe(subscription) assert count_query.count() == 1 assert subscription.num_subscribers() == 1 # Unsubscribe again. seed_user.unsubscribe(subscription) assert count_query.count() == 0 assert subscription.num_subscribers() == 0
def get(self, event_key=None): self._require_login() self._require_registration() if event_key is None: events = EventHelper.getEventsWithinADay() EventHelper.sort_events(events) self.template_values['events'] = events self.response.out.write(jinja2_engine.render('mytba_add_hot_matches_base.html', self.template_values)) return event = Event.get_by_id(event_key) if not event: self.abort(404) subscriptions_future = Subscription.query( Subscription.model_type==ModelType.MATCH, Subscription.notification_types==NotificationType.UPCOMING_MATCH, ancestor=self.user_bundle.account.key).fetch_async(projection=[Subscription.model_key]) matches = [] if event.matchstats and 'match_predictions' in event.matchstats: match_predictions = event.matchstats['match_predictions'] max_hotness = 0 min_hotness = float('inf') for match in event.matches: if not match.has_been_played and match.key.id() in match_predictions: prediction = match_predictions[match.key.id()] red_score = prediction['red']['score'] blue_score = prediction['blue']['score'] if red_score > blue_score: winner_score = red_score loser_score = blue_score else: winner_score = blue_score loser_score = red_score hotness = winner_score + 2.0*loser_score # Favor close high scoring matches max_hotness = max(max_hotness, hotness) min_hotness = min(min_hotness, hotness) match.hotness = hotness matches.append(match) existing_subscriptions = set() for sub in subscriptions_future.get_result(): existing_subscriptions.add(sub.model_key) hot_matches = [] for match in matches: match.hotness = 100 * (match.hotness - min_hotness) / (max_hotness - min_hotness) match.already_subscribed = match.key.id() in existing_subscriptions hot_matches.append(match) hot_matches = sorted(hot_matches, key=lambda match: -match.hotness) matches_dict = {'qm': hot_matches[:25]} self.template_values['event'] = event self.template_values['matches'] = matches_dict self.response.out.write(jinja2_engine.render('mytba_add_hot_matches.html', self.template_values))
def get(self, match_key): self._require_login() self._require_registration() match = Match.get_by_id(match_key) if not match: self.abort(404) user = self.user_bundle.account.key favorite = Favorite.query(Favorite.model_key==match_key, Favorite.model_type==ModelType.MATCH, ancestor=user).get() subscription = Subscription.query(Favorite.model_key==match_key, Favorite.model_type==ModelType.MATCH, ancestor=user).get() if not favorite and not subscription: # New entry; default to being a favorite is_favorite = True else: is_favorite = favorite is not None enabled_notifications = [(en, NotificationType.render_names[en]) for en in NotificationType.enabled_match_notifications] self.template_values['match'] = match self.template_values['is_favorite'] = is_favorite self.template_values['subscription'] = subscription self.template_values['enabled_notifications'] = enabled_notifications self.response.out.write(jinja2_engine.render('mytba_match.html', self.template_values))
def get(self, team_number): self._require_login() self._require_registration() team_key = 'frc{}'.format(team_number) team = Team.get_by_id(team_key) if not team: self.abort(404) user = self.user_bundle.account.key favorite = Favorite.query(Favorite.model_key==team_key, Favorite.model_type==ModelType.TEAM, ancestor=user).get() subscription = Subscription.query(Favorite.model_key==team_key, Favorite.model_type==ModelType.TEAM, ancestor=user).get() if not favorite and not subscription: # New entry; default to being a favorite is_favorite = True else: is_favorite = favorite is not None enabled_notifications = [(en, NotificationType.render_names[en]) for en in NotificationType.enabled_team_notifications] self.template_values['team'] = team self.template_values['is_favorite'] = is_favorite self.template_values['subscription'] = subscription self.template_values['enabled_notifications'] = enabled_notifications self.response.out.write(jinja2_engine.render('mytba_team.html', self.template_values))
def add_subscription(self, request): current_user = endpoints.get_current_user() if current_user is None: return BaseResponse(code=401, message="Unauthorized to add subscription") userId = PushHelper.user_email_to_id(current_user.email()) modelKey = request.model_key sub = Subscription.query( Subscription.user_id == userId, Subscription.model_key == modelKey).get() if sub is None: # Subscription doesn't exist, add it Subscription( user_id = userId, model_key = modelKey, notification_types = PushHelper.notification_enums_from_string(request.notifications)).put() if request.device_key: # Send updates to user's other devices GCMMessageHelper.send_subscription_update(userId, request.device_key) return BaseResponse(code=200, message="Subscription added") else: if sub.notification_types == PushHelper.notification_enums_from_string(request.notifications): # Subscription already exists. Don't add it again return BaseResponse(code=304, message="Subscription already exists") else: # We're updating the settings sub.notification_types = PushHelper.notification_enums_from_string(request.notifications) sub.put() if request.device_key: # Send updates to user's other devices GCMMessageHelper.send_subscription_update(userId, request.device_key) return BaseResponse(code=200, message="Subscription updated")
def get_users_subscribed_to_event(cls, event, notification): keys = [] keys.append(event.key_name) keys.append("{}*".format(event.year)) users = Subscription.query(Subscription.model_key.IN(keys), Subscription.notification_types == notification).fetch() output = [] for user in users: output.append(user.user_id) return output
def get_users_subscribed_for_alliances(cls, event, notification): keys = [] for team in event.alliance_teams: keys.append(team) keys.append("{}_{}".format(event.key_name, team)) # team@event key keys.append("{}*".format(event.year)) # key for all events in year keys.append(event.key_name) users = Subscription.query(Subscription.model_key.IN(keys), Subscription.notification_types == notification).fetch() output = [user.user_id for user in users] return output
def remove_subscription(cls, userId, modelKey, device_key=""): to_delete = Subscription.query(Subscription.model_key == modelKey, ancestor=ndb.Key(Account, userId)).fetch(keys_only=True) if len(to_delete) > 0: ndb.delete_multi(to_delete) # Send updates to user's other devices NotificationHelper.send_subscription_update(userId, device_key) return 200 else: # Subscription doesn't exist. Can't delete it return 404
def list_subscriptions(self, request): current_user = endpoints.get_current_user() if current_user is None: return SubscriptionCollection(subscriptions = []) userId = PushHelper.user_email_to_id(current_user.email()) subscriptions = Subscription.query( Subscription.user_id == userId ).fetch() output = [] for subscription in subscriptions: output.append(SubscriptionMessage(model_key = subscription.model_key, notifications = PushHelper.notification_string_from_enums(subscription.notification_types))) return SubscriptionCollection(subscriptions = output)
def list_subscriptions(self, request): user_id = get_current_user_id(self.headers) if user_id is None: return SubscriptionCollection(subscriptions=[]) subscriptions = Subscription.query(ancestor=ndb.Key(Account, user_id)).fetch() output = [] for subscription in subscriptions: output.append(SubscriptionMessage( model_key=subscription.model_key, notifications=PushHelper.notification_string_from_enums(subscription.notification_types), model_type=subscription.model_type)) return SubscriptionCollection(subscriptions=output)
def get_users_subscribed_to_match(cls, match, notification): keys = [] for team in match.team_key_names: keys.append(team) keys.append("{}_{}".format(match.event.id(), team)) keys.append(match.key_name) keys.append(match.event.id()) logging.info("Getting subscriptions for keys: "+str(keys)) users = Subscription.query(Subscription.model_key.IN(keys), Subscription.notification_types == notification).fetch() output = [] for user in users: output.append(user.user_id) return output
def get_users_subscribed_to_match(cls, match, notification): keys = [] for team in match.team_key_names: keys.append(team) keys.append("{}_{}".format(match.event_key_name, team)) keys.append("{}*".format(match.year)) # key for all events in year keys.append(match.key_name) keys.append(match.event_key_name) users = Subscription.query(Subscription.model_key.IN(keys), Subscription.notification_types == notification).fetch() output = [] for user in users: output.append(user.user_id) return output
def get(self): self._require_registration() push_sitevar = Sitevar.get_by_id('notifications.enable') if push_sitevar is None or not push_sitevar.values_json == "true": ping_enabled = "disabled" else: ping_enabled = "" # Compute myTBA statistics user = self.user_bundle.account.key num_favorites = Favorite.query(ancestor=user).count() num_subscriptions = Subscription.query(ancestor=user).count() # Compute suggestion statistics submissions_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING, Suggestion.author==user).count() submissions_accepted = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_ACCEPTED, Suggestion.author==user).count() # Suggestion review statistics review_permissions = False num_reviewed = 0 total_pending = 0 if self.user_bundle.account.permissions: review_permissions = True num_reviewed = Suggestion.query(Suggestion.reviewer==user).count() total_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING).count() # Fetch trusted API keys api_keys = ApiAuthAccess.query(ApiAuthAccess.owner == user).fetch() write_keys = filter(lambda key: key.is_write_key, api_keys) read_keys = filter(lambda key: key.is_read_key, api_keys) self.template_values['status'] = self.request.get('status') self.template_values['webhook_verification_success'] = self.request.get('webhook_verification_success') self.template_values['ping_sent'] = self.request.get('ping_sent') self.template_values['ping_enabled'] = ping_enabled self.template_values['num_favorites'] = num_favorites self.template_values['num_subscriptions'] = num_subscriptions self.template_values['submissions_pending'] = submissions_pending self.template_values['submissions_accepted'] = submissions_accepted self.template_values['review_permissions'] = review_permissions self.template_values['num_reviewed'] = num_reviewed self.template_values['total_pending'] = total_pending self.template_values['read_keys'] = read_keys self.template_values['write_keys'] = write_keys self.template_values['auth_write_type_names'] = AuthType.write_type_names self.response.out.write(jinja2_engine.render('account_overview.html', self.template_values))
def get(self): self._require_registration() push_sitevar = Sitevar.get_by_id("notifications.enable") if push_sitevar is None or not push_sitevar.values_json == "true": ping_enabled = "disabled" else: ping_enabled = "" # Compute myTBA statistics user = self.user_bundle.account.key num_favorites = Favorite.query(ancestor=user).count() num_subscriptions = Subscription.query(ancestor=user).count() # Compute suggestion statistics submissions_pending = Suggestion.query( Suggestion.review_state == Suggestion.REVIEW_PENDING, Suggestion.author == user ).count() submissions_accepted = Suggestion.query( Suggestion.review_state == Suggestion.REVIEW_ACCEPTED, Suggestion.author == user ).count() # Suggestion review statistics review_permissions = False num_reviewed = 0 total_pending = 0 if self.user_bundle.account.permissions: review_permissions = True num_reviewed = Suggestion.query(Suggestion.reviewer == user).count() total_pending = Suggestion.query(Suggestion.review_state == Suggestion.REVIEW_PENDING).count() # Fetch trusted API keys trusted_keys = ApiAuthAccess.query(ApiAuthAccess.owner == user).fetch() self.template_values["status"] = self.request.get("status") self.template_values["webhook_verification_success"] = self.request.get("webhook_verification_success") self.template_values["ping_enabled"] = ping_enabled self.template_values["num_favorites"] = num_favorites self.template_values["num_subscriptions"] = num_subscriptions self.template_values["submissions_pending"] = submissions_pending self.template_values["submissions_accepted"] = submissions_accepted self.template_values["review_permissions"] = review_permissions self.template_values["num_reviewed"] = num_reviewed self.template_values["total_pending"] = total_pending self.template_values["trusted_keys"] = trusted_keys self.template_values["auth_type_names"] = AuthType.type_names self.response.out.write(jinja2_engine.render("account_overview.html", self.template_values))
def remove_subscription(self, request): current_user = endpoints.get_current_user() if current_user is None: return BaseResponse(code=401, message="Unauthorized to remove subscription") userId = PushHelper.user_email_to_id(current_user.email()) modelKey = request.model_key to_delete = Subscription.query( Subscription.user_id == userId, Subscription.model_key == modelKey).fetch(keys_only=True) if len(to_delete) > 0: ndb.delete_multi(to_delete) if request.device_key: # Send updates to user's other devices GCMMessageHelper.send_subscription_update(userId, request.device_key) return BaseResponse(code=200, message="Subscriptions deleted") else: # Subscription doesn't exist. Can't delete it return BaseResponse(code=404, message="Subscription not found")
def get(self): redirect = self.request.get('redirect') if redirect: self._require_login(redirect) else: self._require_login('/account') # Redirects to registration page if account not registered self._require_registration('/account/register') push_sitevar = Sitevar.get_by_id('notifications.enable') if push_sitevar is None or not push_sitevar.values_json == "true": ping_enabled = "disabled" else: ping_enabled = "" # Compute myTBA statistics user = self.user_bundle.account.key num_favorites = Favorite.query(ancestor=user).count() num_subscriptions = Subscription.query(ancestor=user).count() # Compute suggestion statistics submissions_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING, Suggestion.author==user).count() submissions_accepted = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_ACCEPTED, Suggestion.author==user).count() # Suggestion review statistics review_permissions = False num_reviewed = 0 total_pending = 0 if AccountPermissions.MUTATE_DATA in self.user_bundle.account.permissions: review_permissions = True num_reviewed = Suggestion.query(Suggestion.reviewer==user).count() total_pending = Suggestion.query(Suggestion.review_state==Suggestion.REVIEW_PENDING).count() self.template_values['status'] = self.request.get('status') self.template_values['webhook_verification_success'] = self.request.get('webhook_verification_success') self.template_values['ping_enabled'] = ping_enabled self.template_values['num_favorites'] = num_favorites self.template_values['num_subscriptions'] = num_subscriptions self.template_values['submissions_pending'] = submissions_pending self.template_values['submissions_accepted'] = submissions_accepted self.template_values['review_permissions'] = review_permissions self.template_values['num_reviewed'] = num_reviewed self.template_values['total_pending'] = total_pending self.response.out.write(jinja2_engine.render('account_overview.html', self.template_values))
def get(self, event_key): self._require_registration() # Handle wildcard for all events in a year event = None is_wildcard = False if event_key.endswith("*"): try: year = int(event_key[:-1]) except: year = None if year and year >= 1992 and year <= tba_config.MAX_YEAR: event = Event(name="ALL {} EVENTS".format(year), year=year) # fake event for rendering is_wildcard = True else: event = Event.get_by_id(event_key) if not event: self.abort(404) user = self.user_bundle.account.key favorite = Favorite.query( Favorite.model_key == event_key, Favorite.model_type == ModelType.EVENT, ancestor=user ).get() subscription = Subscription.query( Favorite.model_key == event_key, Favorite.model_type == ModelType.EVENT, ancestor=user ).get() if not favorite and not subscription: # New entry; default to being a favorite is_favorite = True else: is_favorite = favorite is not None enabled_notifications = [ (en, NotificationType.render_names[en]) for en in NotificationType.enabled_event_notifications ] self.template_values["event"] = event self.template_values["is_wildcard"] = is_wildcard self.template_values["is_favorite"] = is_favorite self.template_values["subscription"] = subscription self.template_values["enabled_notifications"] = enabled_notifications self.response.out.write(jinja2_engine.render("mytba_event.html", self.template_values))
def add_subscription(cls, sub, device_key=""): current = Subscription.query(Subscription.model_key == sub.model_key, ancestor=ndb.Key(Account, sub.user_id)).get() if current is None: # Subscription doesn't exist, add it sub.put() # Send updates to user's other devices NotificationHelper.send_subscription_update(sub.user_id, device_key) return 200 else: if current.notification_types == sub.notification_types: # Subscription already exists. Don't add it again return 304 else: # We're updating the settings current.notification_types = sub.notification_types current.put() # Send updates to user's other devices NotificationHelper.send_subscription_update(sub.user_id, device_key) return 200
def get(self): self._require_login('/account/register') self._require_registration('/account/register') user = self.user_bundle.account.key favorites = Favorite.query(ancestor=user).fetch() subscriptions = Subscription.query(ancestor=user).fetch() favorites_by_type = defaultdict(list) for fav in favorites: favorites_by_type[ModelType.type_names[fav.model_type]].append(fav) subscriptions_by_type = defaultdict(list) for sub in subscriptions: subscriptions_by_type[ModelType.type_names[sub.model_type]].append(sub) now = datetime.datetime.now() self.template_values['favorites_by_type'] = dict(favorites_by_type) self.template_values['subscriptions_by_type'] = dict(subscriptions_by_type) self.template_values['enabled_notifications'] = NotificationType.enabled_notifications self.template_values['this_year'] = now.year error = self.request.get('error') if error: if error == 'invalid_model': error_message = "Invalid model key" elif error == "no_sub_types": error_message = "No notification types selected" elif error == "invalid_account": error_message = "Invalid account" elif error == "invalid_year": error_message = "You can only subscribe to the current year" elif error == "sub_not_found": error_message = "Subscription not found" elif error == "fav_not_found": error_message = "Favorite not found" else: error_message = "An unknown error occurred" self.template_values['error_message'] = error_message path = os.path.join(os.path.dirname(__file__), '../templates/mytba.html') self.response.out.write(template.render(path, self.template_values))
def get(self): year = date.today().year - 1 # Compile key regex # Matches event (2014ctgro), team@event (frc2014_2014ctgro), firehose (2014*) ps = "^{}[a-z]+|_{}[a-z]+|{}\*$".format(year, year, year) logging.info("Pattern: {}".format(ps)) p = re.compile(ps) subs = Subscription.query().fetch() to_delete = [] for sub in subs: if p.match(sub.model_key): to_delete.append(sub.key) count = len(to_delete) if to_delete: ndb.delete_multi(to_delete) logging.info("Removed {} old subscriptions".format(count)) template_values = {'count': count} path = os.path.join(os.path.dirname(__file__), '../../templates/admin/subs_clear_do.html') self.response.out.write(template.render(path, template_values))
def get(self, event_key): self._require_registration() # Handle wildcard for all events in a year event = None is_wildcard = False if event_key.endswith('*'): try: year = int(event_key[:-1]) except: year = None if year and year >= 1992 and year <= tba_config.MAX_YEAR: event = Event( # fake event for rendering name="ALL {} EVENTS".format(year), year=year, ) is_wildcard = True else: event = Event.get_by_id(event_key) if not event: self.abort(404) user = self.user_bundle.account.key favorite = Favorite.query(Favorite.model_key==event_key, Favorite.model_type==ModelType.EVENT, ancestor=user).get() subscription = Subscription.query(Favorite.model_key==event_key, Favorite.model_type==ModelType.EVENT, ancestor=user).get() if not favorite and not subscription: # New entry; default to being a favorite is_favorite = True else: is_favorite = favorite is not None enabled_notifications = [(en, NotificationType.render_names[en]) for en in NotificationType.enabled_event_notifications] self.template_values['event'] = event self.template_values['is_wildcard'] = is_wildcard self.template_values['is_favorite'] = is_favorite self.template_values['subscription'] = subscription self.template_values['enabled_notifications'] = enabled_notifications self.response.out.write(jinja2_engine.render('mytba_event.html', self.template_values))
def add_subscription(cls, sub, device_key=""): current = Subscription.query(Subscription.model_key == sub.model_key, ancestor=ndb.Key(Account, sub.user_id)).get() if current is None: # Subscription doesn't exist, add it sub.put() if device_key: # Send updates to user's other devices NotificationHelper.send_subscription_update(sub.user_id, device_key) return 200 else: if current.notification_types == sub.notification_types: # Subscription already exists. Don't add it again return 304 else: # We're updating the settings current.notification_types = sub.notification_types current.put() if device_key: # Send updates to user's other devices NotificationHelper.send_subscription_update(sub.user_id, device_key) return 200
def send_match_video(cls, match): """ Sends match_video and event_match_video notifications If the match is current, MatchVideoNotification is sent. Otherwise, EventMatchVideoNotification is sent """ match_users = set( PushHelper.get_users_subscribed_to_match( match, NotificationType.MATCH_VIDEO)) event_users = set( Subscription.users_subscribed_to_event( match.event.get(), NotificationType.MATCH_VIDEO)) users = match_users.union(event_users) if match.within_seconds(60 * 10): user_keys = PushHelper.get_client_ids_for_users( users, os_types=[ClientType.OS_ANDROID]) MatchVideoNotification(match).send(user_keys) else: user_keys = PushHelper.get_client_ids_for_users( users, os_types=[ClientType.OS_ANDROID]) EventMatchVideoNotification(match).send(user_keys)
def update(plan_id): subscription_plan = Subscription.get_by_id(plan_id) user = User.get_by_id(current_user.id) result = gateway.subscription.update(str(current_user.id), { "price" : subscription_plan.price, "plan_id" : subscription_plan.id, }) if result.is_success : user.subscription = subscription_plan if user.save(): flash("Plan changed successfully", "success") return redirect(url_for('home')) else : flash("Failed to change plan", "danger") return redirect(url_for('subscriptions.show')) else : flash("Failed to change plan", "danger") return redirect(url_for('subscriptions.show'))
def new_2(): client_token = generate_client_token() price = request.form.get('price') if price == 93: subscriptiontype = 'standard' elif price == 109: subscriptiontype = 'premium' else: subscriptiontype = 'exclusive' subscription = Subscription.get_or_none( Subscription.user == current_user.id) if subscription: flash( "You already have a subscription. Contact us in case you would like to change." ) return redirect(url_for('home')) else: return render_template('subscriptions/new.html', client_token=client_token, price=price, subscriptiontype=subscriptiontype)
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 get(self): self._require_login('/account/register') self._require_registration('/account/register') user = self.user_bundle.account.key favorites = Favorite.query(ancestor=user).fetch() subscriptions = Subscription.query(ancestor=user).fetch() favorites_by_type = defaultdict(list) for fav in favorites: favorites_by_type[ModelType.type_names[fav.model_type]].append(fav) subscriptions_by_type = defaultdict(list) for sub in subscriptions: subscriptions_by_type[ModelType.type_names[sub.model_type]].append( sub) self.template_values['favorites_by_type'] = dict(favorites_by_type) self.template_values['subscriptions_by_type'] = dict( subscriptions_by_type) self.template_values[ 'enabled_notifications'] = NotificationType.enabled_notifications error = self.request.get('error') if error: if error == 'invalid_model': error_message = "Invalid model key" elif error == "no_sub_types": error_message = "No notification types selected" elif error == "invalid_account": error_message = "Invalid account" else: error_message = "An unknown error occurred" self.template_values['error_message'] = error_message path = os.path.join(os.path.dirname(__file__), '../templates/mytba.html') self.response.out.write(template.render(path, self.template_values))
def get(self): """ list of topics that were updated in last 24 hours """ # get the topics from datastore time_24_hours_old = datetime.datetime.now() - datetime.timedelta(hours=24) newest_topics = Topic.query(Topic.updated_at < time_24_hours_old, Topic.deleted == False).fetch() # list of topic idents for links topics_idents = [topic.key.id() for topic in newest_topics] # get all subscribers from datastore subscribers = Subscription.query(Subscription.subscribed == True).fetch() # list of emails emails = [subscriber.email for subscriber in subscribers] urls = "" # building topics links and sending mails if newest_topics: for topic_id in topics_idents: urls += "<li>http://emerald-eon-159115.appspot.com/topic/{}\n</li>".format(topic_id) for email in emails: newest_topics_email(email, urls)
def post(self): author_email = self.request.get("author_email") topic_title = self.request.get("topic_title") topic_id = self.request.get("topic_id") topic = Topic.get_by_id(int(topic_id)) mail.send_mail(sender="*****@*****.**", to=author_email, subject="New comment", body="""Tvoja tema {0} ima nov komentar. <a href="http://ninjatechforum.appspot.com/topic/{1}">{0}</a>""".format( topic_title, topic_id)) subscriptions = Subscription.query( Subscription.topic_id == topic.key.id()).fetch() for subscription in subscriptions: mail.send_mail(sender="*****@*****.**", to=subscription.email, subject="New comment", body="""Tema {0} ima nov komentar. <a href="http://ninjatechforum.appspot.com/topic/{1}">{0}</a>""".format( topic_title, topic_id))
def get(self, team_number): self._require_login('/account/register') self._require_registration('/account/register') team_key = 'frc{}'.format(team_number) team = Team.get_by_id(team_key) if not team: self.abort(404) user = self.user_bundle.account.key favorite = Favorite.query(Favorite.model_key == team_key, Favorite.model_type == ModelType.TEAM, ancestor=user).get() subscription = Subscription.query( Favorite.model_key == team_key, Favorite.model_type == ModelType.TEAM, ancestor=user).get() if not favorite and not subscription: # New entry; default to being a favorite is_favorite = True else: is_favorite = favorite is not None enabled_notifications = [ (en, NotificationType.render_names[en]) for en in NotificationType.enabled_team_notifications ] self.template_values['team'] = team self.template_values['is_favorite'] = is_favorite self.template_values['subscription'] = subscription self.template_values['enabled_notifications'] = enabled_notifications self.response.out.write( jinja2_engine.render('mytba_team.html', self.template_values))
def insert(article, topic, source): db_subscription = Subscription.update_or_create(Subscription.url == source.url, url=source.url, name=source.name, image=source.image_url) db_article = Article.update_or_create(Article.url == article.url, source=db_subscription, publish_date=article.publish_date, url=article.url, author="", title=article.title, description=article.description, body=article.body, preview_image=article.preview_image_url) db_topic = Topic.update_or_create(Topic.source == db_subscription and Topic.name == topic.name and Topic.url == topic.url, source=db_subscription, name=topic.name, url=topic.url) try: ArticleTopic.get(article=db_article, topic=db_topic) except ArticleTopic.DoesNotExist: ArticleTopic.create(article=db_article, topic=db_topic)
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 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 get(self): self._require_login('/account/register') self._require_registration('/account/register') user = self.user_bundle.account.key favorites = Favorite.query(ancestor=user).fetch() subscriptions = Subscription.query(ancestor=user).fetch() team_keys = set() team_fav = {} team_subs = {} event_keys = set() event_fav = {} event_subs = {} events = [] for item in favorites + subscriptions: if item.model_type == ModelType.TEAM: team_keys.add(ndb.Key(Team, item.model_key)) if type(item) == Favorite: team_fav[item.model_key] = item elif type(item) == Subscription: team_subs[item.model_key] = item elif item.model_type == ModelType.EVENT: if item.model_key.endswith('*'): # All year events wildcard event_year = int(item.model_key[:-1]) events.append(Event( # add fake event for rendering id=item.model_key, short_name='ALL EVENTS', event_short=item.model_key, year=event_year, start_date=datetime.datetime(event_year, 1, 1) )) else: event_keys.add(ndb.Key(Event, item.model_key)) if type(item) == Favorite: event_fav[item.model_key] = item elif type(item) == Subscription: event_subs[item.model_key] = item team_futures = ndb.get_multi_async(team_keys) event_futures = ndb.get_multi_async(event_keys) teams = sorted([team_future.get_result() for team_future in team_futures], key=lambda x: x.team_number) team_fav_subs = [] for team in teams: fav = team_fav.get(team.key.id(), None) subs = team_subs.get(team.key.id(), None) team_fav_subs.append((team, fav, subs)) events += [event_future.get_result() for event_future in event_futures] events = sorted(events, key=lambda x: x.start_date) event_fav_subs = [] for event in events: fav = event_fav.get(event.key.id(), None) subs = event_subs.get(event.key.id(), None) event_fav_subs.append((event, fav, subs)) self.template_values['team_fav_subs'] = team_fav_subs self.template_values['event_fav_subs'] = event_fav_subs self.template_values['status'] = self.request.get('status') self.template_values['year'] = datetime.datetime.now().year self.response.out.write(jinja2_engine.render('mytba.html', self.template_values))
def _subscriptions(self): return Subscription.all_active_for_event(self.event).fetch()
'parent_event': TripEvent.select().first().id + 4, 'url': 'photoplace.com/files/some_photo.jpg' }, { 'parent_event': TripEvent.select().first().id + 4, 'url': 'photoplace.com/files/last_photo.jpg' }] for pa in photo_list: if PhotoAttachment.get_or_none(PhotoAttachment.url == pa['url']) == None: PhotoAttachment.create(parent_event=pa['parent_event'], url=pa['url']) # Payments from models.payment import Payment import decimal payment_list = [{'amount': 50, 'payment_nonce': 'abcde'}] for py in payment_list: Payment.create(amount=py['amount'], payment_nonce=py['payment_nonce']) # Subscriptions from models.subscription import Subscription subscription_list = [{ 'for_user': User.select().first().id + 1, 'payment': Payment.select().first().id }] for sb in subscription_list: Subscription.create(for_user=sb['for_user'], payment=sb['payment'])
def show(): admin = False authentic = False if current_user.is_authenticated: authentic = True user = User.get_or_none(User.id == current_user.id) if user.Admin == True: admin = True outfits = Outfit.select() size = Size.select() out = Outfit.select() outfits_cart = Outfit.select().order_by(Outfit.outfit_price.asc()) subscription = None amount = 0 # outfits = [] discount = 0 # user = None surplus = [] sub = [] sess = [] price = 0 if 'cart' in session: sess = session['cart'] if current_user.is_authenticated: # user= User.select().where(User.id == current_user.id) subscription = Subscription.get_or_none( Subscription.user == current_user.id) if subscription: sub_length = int(subscription.subscription_type) if len(sess) > sub_length: sess2 = len(sess) - sub_length count = 0 for item in outfits_cart: if count < sess2: if item.id in sess: amount = amount + item.outfit_price if item.id not in surplus: surplus.append(item.id) count += 1 else: break discount = int(amount) / count * 0.33 * (count - 1) # if len(sess) > (sub_length+1): # sess2 = len(sess) - (sub_length+1) # count = 0 # for item in outfits_cart: # if count < sess2: # if item.id in sess: # price = float(item.outfit_price) # discount = discount + price*0.35 # count = count-1 # count = count+1 # else: # break if len(surplus) > 0: for s in sess: if s not in surplus: sub.append(s) else: for s in sess: sub.append(s) else: count = 0 for s in sess: item = Outfit.get(Outfit.id == s).outfit_price amount = amount + item item = float(item) # outfits.append(outfit) if count > 0: discount = discount + item * 0.33 count = count + 1 else: count = 0 for s in sess: item = Outfit.get(Outfit.id == s).outfit_price amount = amount + item item = float(item) # outfits.append(outfit) if count > 0: discount = discount + item * 0.33 count = count + 1 if amount > 0: amount = float(amount) price = amount - discount if subscription: subscriptiontype = subscription.subscription_type subtype = int(subscriptiontype) else: subtype = 0 return object_list('outfits/show.html', outfits, admin=admin, authentic=authentic, size=size, price=price, subtype=subtype, out=out, sub=sub, subscription=subscription, surplus=surplus, discount=discount, amount=amount, sess=sess, paginate_by=9)
def get_users_subscribed(cls, model_key): user_list = Subscription.query(Subscription.model_key == model_key).fetch() output = [] for user in user_list: output.append(user.user_id) return output
def detail(id): pictures = Outfit_Picture.select().where(Outfit_Picture.outfit == id) outfit = Outfit.select().where(Outfit.id == id) size = Size.select().where(Size.outfit == id) admin = False authentic = False if current_user.is_authenticated: authentic = True user = User.get_or_none(User.id == current_user.id) if user.Admin == True: admin = True out = Outfit.select() outfits_cart = Outfit.select().order_by(Outfit.outfit_price.desc()) subscription = None amount = 0 # outfits = [] discount = 0 # user = None surplus = [] sub = [] sess = [] price = 0 if 'cart' in session: sess = session['cart'] if current_user.is_authenticated: # user= User.select().where(User.id == current_user.id) subscription = Subscription.get_or_none( Subscription.user == current_user.id) if subscription: sub_length = int(subscription.subscription_type) if len(sess) > sub_length: sess2 = len(sess) - sub_length count = 0 for item in outfits_cart: if count < sess2: if item.id in sess: amount = amount + item.outfit_price if item.id not in surplus: surplus.append(item.id) count += 1 else: break if len(sess) > (sub_length + 1): sess2 = len(sess) - (sub_length + 1) count = 0 for item in outfits_cart: if count < sess2: if item.id in sess: price = float(item.outfit_price) discount = discount + price * 0.35 count = count + 1 else: break if len(surplus) > 0: for s in sess: if s not in surplus: sub.append(s) else: for s in sess: sub.append(s) else: count = 0 for s in sess: item = Outfit.get(Outfit.id == s).outfit_price amount = amount + item item = float(item) # outfits.append(outfit) if count > 0: discount = discount + item * 0.33 count = count + 1 else: count = 0 for s in sess: item = Outfit.get(Outfit.id == s).outfit_price amount = amount + item item = float(item) # outfits.append(outfit) if count > 0: discount = discount + item * 0.33 count = count + 1 if amount > 0: amount = float(amount) price = amount - discount if subscription: subscriptiontype = subscription.subscription_type subtype = int(subscriptiontype) else: subtype = 0 return render_template('outfits/detail.html', size=size, pictures=pictures, outfit=outfit, admin=admin, authentic=authentic, price=price, subtype=subtype, out=out, sub=sub, subscription=subscription, surplus=surplus, discount=discount, amount=amount, sess=sess)
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 create(self, subscription: Subscription): try: subscription = subscription.save() return subscription, None except Exception as e: return None, e
def delete(self, subscription: Subscription): subscription.delete()
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')
def show_update(): subscription_plan = Subscription.select() return render_template('subscriptions/show_update.html', subscription_plan = subscription_plan)
def get(self, event_key=None): self._require_registration() if event_key is None: events = EventHelper.getEventsWithinADay() EventHelper.sort_events(events) self.template_values['events'] = events self.response.out.write( jinja2_engine.render('mytba_add_hot_matches_base.html', self.template_values)) return event = Event.get_by_id(event_key) if not event: self.abort(404) subscriptions_future = Subscription.query( Subscription.model_type == ModelType.MATCH, Subscription.notification_types == NotificationType.UPCOMING_MATCH, ancestor=self.user_bundle.account.key).fetch_async( projection=[Subscription.model_key]) matches = [] if event.matchstats and 'match_predictions' in event.matchstats: match_predictions = event.matchstats['match_predictions'] max_hotness = 0 min_hotness = float('inf') for match in event.matches: if not match.has_been_played and match.key.id( ) in match_predictions: prediction = match_predictions[match.key.id()] red_score = prediction['red']['score'] blue_score = prediction['blue']['score'] if red_score > blue_score: winner_score = red_score loser_score = blue_score else: winner_score = blue_score loser_score = red_score hotness = winner_score + 2.0 * loser_score # Favor close high scoring matches max_hotness = max(max_hotness, hotness) min_hotness = min(min_hotness, hotness) match.hotness = hotness matches.append(match) existing_subscriptions = set() for sub in subscriptions_future.get_result(): existing_subscriptions.add(sub.model_key) hot_matches = [] for match in matches: match.hotness = 100 * (match.hotness - min_hotness) / (max_hotness - min_hotness) match.already_subscribed = match.key.id() in existing_subscriptions hot_matches.append(match) hot_matches = sorted(hot_matches, key=lambda match: -match.hotness) matches_dict = {'qm': hot_matches[:25]} self.template_values['event'] = event self.template_values['matches'] = matches_dict self.response.out.write( jinja2_engine.render('mytba_add_hot_matches.html', self.template_values))
from models.user import User from models.trip import Trip from models.trip_event import TripEvent from models.file_attachment import FileAttachment from models.photo_attachment import PhotoAttachment from models.payment import Payment from models.subscription import Subscription FileAttachment.delete().execute() PhotoAttachment.delete().execute() Subscription.delete().execute() Payment.delete().execute() User.delete().execute() Trip.delete().execute() TripEvent.delete().execute()
def get(self): self._require_registration() user = self.user_bundle.account.key favorites = Favorite.query(ancestor=user).fetch() subscriptions = Subscription.query(ancestor=user).fetch() team_keys = set() team_fav = {} team_subs = {} event_keys = set() event_fav = {} event_subs = {} events = [] match_keys = set() match_event_keys = set() match_fav = {} match_subs = {} for item in favorites + subscriptions: if item.model_type == ModelType.TEAM: team_keys.add(ndb.Key(Team, item.model_key)) if type(item) == Favorite: team_fav[item.model_key] = item elif type(item) == Subscription: team_subs[item.model_key] = item elif item.model_type == ModelType.MATCH: match_keys.add(ndb.Key(Match, item.model_key)) match_event_keys.add( ndb.Key(Event, item.model_key.split('_')[0])) if type(item) == Favorite: match_fav[item.model_key] = item elif type(item) == Subscription: match_subs[item.model_key] = item elif item.model_type == ModelType.EVENT: if item.model_key.endswith('*'): # All year events wildcard event_year = int(item.model_key[:-1]) events.append( Event( # add fake event for rendering id=item.model_key, short_name='ALL EVENTS', event_short=item.model_key, year=event_year, start_date=datetime.datetime(event_year, 1, 1), end_date=datetime.datetime(event_year, 1, 1))) else: event_keys.add(ndb.Key(Event, item.model_key)) if type(item) == Favorite: event_fav[item.model_key] = item elif type(item) == Subscription: event_subs[item.model_key] = item team_futures = ndb.get_multi_async(team_keys) event_futures = ndb.get_multi_async(event_keys) match_futures = ndb.get_multi_async(match_keys) match_event_futures = ndb.get_multi_async(match_event_keys) teams = sorted( [team_future.get_result() for team_future in team_futures], key=lambda x: x.team_number) team_fav_subs = [] for team in teams: fav = team_fav.get(team.key.id(), None) subs = team_subs.get(team.key.id(), None) team_fav_subs.append((team, fav, subs)) events += [event_future.get_result() for event_future in event_futures] EventHelper.sort_events(events) event_fav_subs = [] for event in events: fav = event_fav.get(event.key.id(), None) subs = event_subs.get(event.key.id(), None) event_fav_subs.append((event, fav, subs)) matches = [match_future.get_result() for match_future in match_futures] match_events = [ match_event_future.get_result() for match_event_future in match_event_futures ] MatchHelper.natural_sort_matches(matches) match_fav_subs_by_event = {} for event in match_events: match_fav_subs_by_event[event.key.id()] = (event, []) for match in matches: event_key = match.key.id().split('_')[0] fav = match_fav.get(match.key.id(), None) subs = match_subs.get(match.key.id(), None) match_fav_subs_by_event[event_key][1].append((match, fav, subs)) event_match_fav_subs = sorted( match_fav_subs_by_event.values(), key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0])) event_match_fav_subs = sorted( event_match_fav_subs, key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0])) self.template_values['team_fav_subs'] = team_fav_subs self.template_values['event_fav_subs'] = event_fav_subs self.template_values['event_match_fav_subs'] = event_match_fav_subs self.template_values['status'] = self.request.get('status') self.template_values['year'] = datetime.datetime.now().year self.response.out.write( jinja2_engine.render('mytba.html', self.template_values))
def subscriptions(self, limit=50, offset=0): return (Subscription.select() .join(UserSubscription) .where(UserSubscription.user == self) .limit(limit) .offset(offset))
def get(self): self._require_login() self._require_registration() user = self.user_bundle.account.key favorites = Favorite.query(ancestor=user).fetch() subscriptions = Subscription.query(ancestor=user).fetch() team_keys = set() team_fav = {} team_subs = {} event_keys = set() event_fav = {} event_subs = {} events = [] match_keys = set() match_event_keys = set() match_fav = {} match_subs = {} for item in favorites + subscriptions: if item.model_type == ModelType.TEAM: team_keys.add(ndb.Key(Team, item.model_key)) if type(item) == Favorite: team_fav[item.model_key] = item elif type(item) == Subscription: team_subs[item.model_key] = item elif item.model_type == ModelType.MATCH: match_keys.add(ndb.Key(Match, item.model_key)) match_event_keys.add(ndb.Key(Event, item.model_key.split('_')[0])) if type(item) == Favorite: match_fav[item.model_key] = item elif type(item) == Subscription: match_subs[item.model_key] = item elif item.model_type == ModelType.EVENT: if item.model_key.endswith('*'): # All year events wildcard event_year = int(item.model_key[:-1]) events.append(Event( # add fake event for rendering id=item.model_key, short_name='ALL EVENTS', event_short=item.model_key, year=event_year, start_date=datetime.datetime(event_year, 1, 1), end_date=datetime.datetime(event_year, 1, 1) )) else: event_keys.add(ndb.Key(Event, item.model_key)) if type(item) == Favorite: event_fav[item.model_key] = item elif type(item) == Subscription: event_subs[item.model_key] = item team_futures = ndb.get_multi_async(team_keys) event_futures = ndb.get_multi_async(event_keys) match_futures = ndb.get_multi_async(match_keys) match_event_futures = ndb.get_multi_async(match_event_keys) teams = sorted([team_future.get_result() for team_future in team_futures], key=lambda x: x.team_number) team_fav_subs = [] for team in teams: fav = team_fav.get(team.key.id(), None) subs = team_subs.get(team.key.id(), None) team_fav_subs.append((team, fav, subs)) events += [event_future.get_result() for event_future in event_futures] EventHelper.sort_events(events) event_fav_subs = [] for event in events: fav = event_fav.get(event.key.id(), None) subs = event_subs.get(event.key.id(), None) event_fav_subs.append((event, fav, subs)) matches = [match_future.get_result() for match_future in match_futures] match_events = [match_event_future.get_result() for match_event_future in match_event_futures] MatchHelper.natural_sort_matches(matches) match_fav_subs_by_event = {} for event in match_events: match_fav_subs_by_event[event.key.id()] = (event, []) for match in matches: event_key = match.key.id().split('_')[0] fav = match_fav.get(match.key.id(), None) subs = match_subs.get(match.key.id(), None) match_fav_subs_by_event[event_key][1].append((match, fav, subs)) event_match_fav_subs = sorted(match_fav_subs_by_event.values(), key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0])) event_match_fav_subs = sorted(event_match_fav_subs, key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0])) self.template_values['team_fav_subs'] = team_fav_subs self.template_values['event_fav_subs'] = event_fav_subs self.template_values['event_match_fav_subs'] = event_match_fav_subs self.template_values['status'] = self.request.get('status') self.template_values['year'] = datetime.datetime.now().year self.response.out.write(jinja2_engine.render('mytba.html', self.template_values))
def delete_subscription(subscription_id): subscription = Subscription.get_by_id(subscription_id) subscription.key.delete()
def get(self): self._require_login('/account/register') self._require_registration('/account/register') user = self.user_bundle.account.key favorites = Favorite.query(ancestor=user).fetch() subscriptions = Subscription.query(ancestor=user).fetch() team_keys = set() team_fav = {} team_subs = {} event_keys = set() event_fav = {} event_subs = {} events = [] for item in favorites + subscriptions: if item.model_type == ModelType.TEAM: team_keys.add(ndb.Key(Team, item.model_key)) if type(item) == Favorite: team_fav[item.model_key] = item elif type(item) == Subscription: team_subs[item.model_key] = item elif item.model_type == ModelType.EVENT: if item.model_key.endswith('*'): # All year events wildcard event_year = int(item.model_key[:-1]) events.append( Event( # add fake event for rendering id=item.model_key, short_name='ALL EVENTS', event_short=item.model_key, year=event_year, start_date=datetime.datetime(event_year, 1, 1), end_date=datetime.datetime(event_year, 1, 1))) else: event_keys.add(ndb.Key(Event, item.model_key)) if type(item) == Favorite: event_fav[item.model_key] = item elif type(item) == Subscription: event_subs[item.model_key] = item team_futures = ndb.get_multi_async(team_keys) event_futures = ndb.get_multi_async(event_keys) teams = sorted( [team_future.get_result() for team_future in team_futures], key=lambda x: x.team_number) team_fav_subs = [] for team in teams: fav = team_fav.get(team.key.id(), None) subs = team_subs.get(team.key.id(), None) team_fav_subs.append((team, fav, subs)) events += [event_future.get_result() for event_future in event_futures] EventHelper.sort_events(events) event_fav_subs = [] for event in events: fav = event_fav.get(event.key.id(), None) subs = event_subs.get(event.key.id(), None) event_fav_subs.append((event, fav, subs)) self.template_values['team_fav_subs'] = team_fav_subs self.template_values['event_fav_subs'] = event_fav_subs self.template_values['status'] = self.request.get('status') self.template_values['year'] = datetime.datetime.now().year self.response.out.write( jinja2_engine.render('mytba.html', self.template_values))
def get_subscription(client): subscription = Subscription.query(Subscription.client == client.key, Subscription.status == STATUS_AVAILABLE).get() return subscription
def new_checkout(subscription_id): subscription = Subscription.get_or_none(Subscription.id == subscription_id) client_token = gateway.client_token.generate() return render_template('transactions/new.html',client_token = client_token, subscription = subscription)