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):
        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))
Exemple #23
0
    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)
Exemple #26
0
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'))
Exemple #27
0
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)
Exemple #28
0
    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)
Exemple #29
0
    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))
Exemple #30
0
    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))
Exemple #33
0
 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)
Exemple #34
0
    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))
Exemple #37
0
 def _subscriptions(self):
     return Subscription.all_active_for_event(self.event).fetch()
Exemple #38
0
    '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'])
Exemple #39
0
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)
Exemple #40
0
 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
Exemple #41
0
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)
Exemple #42
0
    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))
Exemple #43
0
 def create(self, subscription: Subscription):
     try:
         subscription = subscription.save()
         return subscription, None
     except Exception as e:
         return None, e
Exemple #44
0
 def delete(self, subscription: Subscription):
     subscription.delete()
Exemple #45
0
    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')
Exemple #46
0
def show_update():
    subscription_plan = Subscription.select()
    return render_template('subscriptions/show_update.html', subscription_plan = subscription_plan)
Exemple #47
0
    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))
Exemple #48
0
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()
Exemple #49
0
    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))
Exemple #50
0
 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))
Exemple #52
0
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))
Exemple #54
0
def get_subscription(client):
    subscription = Subscription.query(Subscription.client == client.key, Subscription.status == STATUS_AVAILABLE).get()
    return subscription
 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
Exemple #56
0
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)