Exemplo n.º 1
0
Arquivo: manage.py Projeto: jxster/cbl
def populate_games():
    with app.open_resource('./testing/data/games.json') as gamedata:
        games = json.load(gamedata)['games']
        for g in games:
            Game.add_game(teams=g['teams'],
                          court=int(g['court']),
                          time=g['time'])
            scrs = g['score'].split(' ')
            Game.update_game(int(g['court']), g['time'],
                             g['winner'], scrs[0], scrs[1])
Exemplo n.º 2
0
class GameController:
    def __init__(self, game_point, dice_amount, first_point_limit):
        self.game_point = game_point
        self.dice_amount = dice_amount
        self.first_point_limit = first_point_limit
        self.players = []
        
        self.manager_ui = ManagerUI(self)
        self.player_ui = PlayerUI(self)
        self.game_ui = GameUI(self, game_point)

    def register_player(self, name):
        self.players.append(Player(name))

    def start_game(self):
        for player in self.players:
            player.score = 0            # プレイヤーの得点を初期化する
            player.is_winner = False    # プレイヤーの勝利者判定をoffにする
        
        self.game = Game(self.players, self.game_point, self.dice_amount, self.first_point_limit)
        self.game.set_current_player(self.players[0])     # 最初のプレイヤーを ゲームのcurrentPlayerに編集
        self.new_turn()

    def get_players_count(self):
        return len(self.players)
    
    def new_turn(self):
        self.game.new_turn()
        
    def do_turn(self):
        return self.game.turn.do_turn()
    
    def end_turn(self):
        self.game.end_turn()
    
    def get_current_player(self):
        return self.game.current_player
    
    def next_player(self):
        self.game.next_player()

    def is_turn_bust(self):
        return self.game.is_turn_bust

    def is_turn_none_of_dice(self):
        return self.game.is_turn_none_of_dice

    def is_game_end(self):
        return self.game.is_game_end()
    
    def winner_check(self):
        _score = 0
        for player in self.players:
            if(player.score > _score):
                _score = player.score
                
        if(_score >= self.game_point):
            for player in self.players:
                if(_score == player.score):
                    player.is_winner = True
Exemplo n.º 3
0
def start_new_game():
    new_game = Game()
    new_game_id = str(datetime.now())
    active_games[new_game_id] = new_game
    try:
        q = new_game.get_next_question()
    except IKnow as e:
        return jsonify(game_id=new_game_id,
                       question_type=QuestionTypes.FINAL.value,
                       movies=[m.serialize() for m in e.movie_list]), 200

    return jsonify(game_id=new_game_id,
                   question=q.text,
                   question_type=QuestionTypes.COMMON.value,
                   question_id=q.id), 200
Exemplo n.º 4
0
def end_game(request, game_id):
   
    t = datetime.now()

    game = Game.get_by_uid(game_id)
    last_round = game.get_current_round()
    
    if not game.is_over():
        logging.critical('game:%s game end task called but game is not over' % \
                         game.uid)
        raise FactionizeTaskException, 'game not yet in a completed state'

    if game.is_complete:
        logging.warning('game:%s game end task called on a game that is ' + \
                        'has already marked as complete. possibly a ' + \
                        'repeated message' % game.uid)
        raise FactionizeTaskException, 'game is already marked as complete'

    # do lots of processing here to assign various awards
    if game.is_innocent_victory():
        win = InnocentWin(thread=last_round.get_thread(role_vanillager))
    else:
        win = MafiaWin(thread=last_round.get_thread(role_vanillager))
    win.put()
    
    game.is_complete = True
    game.put()

    return HttpResponse('ok', status=200)
Exemplo n.º 5
0
def messages(request, game_id, round_id, thread_id):
    thread = Thread.get_by_uid(thread_id)
    if thread is None:
        raise Http404

    if not thread.profile_can_view(request.profile):
        return HttpResponse('Unauthorized', status=401)

    if request.method == 'GET':
        since = request.GET.get('since', None)
        return json(Message.get_activities(request.user,
                                           thread,
                                           since=since))

    if request.method == 'POST':

        if not thread.profile_can_create(request.profile):
            return HttpResponse('Unauthorized', status=401)

        content = request.POST.get('content', None)
        if not content:
            return HttpResponse('Method Not Allowed - A message is required', status=405)

        # create the new message
        game = Game.get_by_uid(game_id)
        actor = Role.get_by_profile(game, request.profile)
        message = Message(actor=actor,
                          content=content,
                          thread=thread)
        message.put()
        return json(message)

    return HttpResponse('Method Not Allowed', status=405)
Exemplo n.º 6
0
 def start_game(self):
     for player in self.players:
         player.score = 0            # プレイヤーの得点を初期化する
         player.is_winner = False    # プレイヤーの勝利者判定をoffにする
     
     self.game = Game(self.players, self.game_point, self.dice_amount, self.first_point_limit)
     self.game.set_current_player(self.players[0])     # 最初のプレイヤーを ゲームのcurrentPlayerに編集
     self.new_turn()
Exemplo n.º 7
0
def join(request, game_id):
    game = Game.get_by_uid(game_id)
    if game is None:
        raise Http404

    now = datetime.now()
    if (game.started and game.started < now) or game.signup_deadline < now:
        return HttpResponse(status=401)

    if request.profile.key() not in game.signups:
        game.add_to_waitlist(request.profile)
    return redirect('/games/%s' % game.uid)
Exemplo n.º 8
0
def start(request, game_id):
    game = Game.get_by_uid(game_id)
    if game.game_starter.uid != request.profile.uid:
        return HttpResponse(status=403)

    now = datetime.now()
    if (game.started and game.started < now) or game.signup_deadline < now:
        return HttpResponse(status=401)

    try:
        game.start_game()
    except FactionizeError, e:
        return HttpResponse('Cannot start game', status=401)
Exemplo n.º 9
0
def get_wishlist(message):
    """просто получить вишлист"""
    with session_scope() as session:
        wishlist = Wish.get_all(user_id=message.chat.id, session=session)
        games = [
            Game.get(id=wish.game_id, session=session) for wish in wishlist
        ]
        if games:
            response = '\n'.join([
                f'{i}) {game}'
                for i, game in enumerate(sorted(games, key=lambda x: x.name),
                                         start=1)
            ])
        else:
            response = 'Твой вишлист пуст :('
        bot.send_message(chat_id=message.chat.id,
                         text=response,
                         parse_mode='MARKDOWN')
Exemplo n.º 10
0
    def test_game_setup(self):
        # Setup user, player, game
        sneha = User(name='Sneha Yadgire', username='******')
        manisha = User(name='Manisha Auti', username='******')

        rohit = Player('Rohit Sharma')

        # Add them in db & refresh game status
        sneha.create()
        manisha.create()
        rohit.create()
        game = Game.init_game()

        # Read game and test
        self.assertEqual(game.player_count, 1)
        self.assertEqual(game.user_count, 2)
        self.assertEqual(game.avg_player_bid, User.INITIAL_BUDGET)
        self.assertEqual(rohit.status, Player.AVAILABLE)
Exemplo n.º 11
0
def view(request, game_id):
    game = Game.get_by_uid(game_id)
    if game is None:
        raise Http404

    current_round = game.get_current_round()
    rounds = game.get_rounds()
    threads = current_round.get_threads(request.profile)
    player_list = [r.player for r in game.get_active_roles()]

    context = dict(profile=request.profile,
                   player_list=player_list,
                   game=game,
                   current_round=current_round,
                   rounds=rounds,
                   threads=threads)
    context['serialized'] = json_encode(context)
    return render('game/view.html', context)
Exemplo n.º 12
0
def send_invite(opponent_username):
  opponent = User.query.filter_by(username=opponent_username).first_or_404()
  if not current_user.is_friends_with(opponent):
    flash('You cannot challenge users who are not your friends.')
    return redirect(url_for('games.list'))

  # form processing 
  form = AddGameForm()

  if form.validate_on_submit():
    game = Game(author=current_user,
                guest=opponent,
                max_points=form.max_points.data,)
    db.session.add(game)
    db.session.commit()
    flash('Game Invitation Sent')
    return redirect(url_for('games.game',game_id=game.id))
  
  return render_template('games/send_invite.html',form=form,opponent=opponent)
Exemplo n.º 13
0
def do_jaccard(query, max_results):
    tag_set = set(query.tags.keys())
    matching_app_ids = Tag.get_games_with_tags(tag_set)
    to_get = set()
    for games in matching_app_ids.values():
        to_get.update(games)
    to_get.remove(query.app_id)
    games = Game.get(to_get)
    scores = [(jaccard_sim(tag_set, set(g.tags.keys())), g.score_rank, g)
              for g in games.values()]
    # Magic trick: Python sorts tuples element-wise, so if the first value in a pair of tuples
    # is equal, it will sort by the next and so on. Since the score_rank is second element,
    # games with equal Jaccard will then be sorted by score_rank.
    scores.sort(reverse=True)
    scores = map(itemgetter(2), scores)
    if max_results is None:
        return scores
    else:
        return scores[:max_results]
Exemplo n.º 14
0
    def test_vote(self):
        user1 = User(username='******', email='*****@*****.**')
        team1 = Team(name='Yankees', city='New York', abbreviation='NYY')
        team2 = Team(name='Cubs', city='Chicago', abbreviation='CHC')
        game1 = Game(schedule_status='normal',
                     delayed_or_postponed_reason=None,
                     location='Yankee Stadium',
                     home_team=team1,
                     away_team=team2)
        db.session.add_all([user1, team1, team2, game1])
        db.session.commit()

        # User vote method
        user1.vote_for_team(game1, team2)
        self.assertEqual(team2.total_votes, 1)

        # Vote class method to create new vote
        Vote.place_vote(user1, game1, team2)
        self.assertEqual(team2.total_votes, 2)
Exemplo n.º 15
0
    def insert(self, data):
        session = self.__thread_safe_session_factory()
        i_game = 1
        i_genres = 1

        for title, infos in data.items():

            if len(title) > 128:
                continue

            # Adding game
            session.add(
                Game(id=i_game,
                     title=title,
                     publication_year=infos["publication_year"],
                     min_players=infos["min_players"],
                     max_players=infos["max_players"],
                     min_playtime=infos["min_playtime"],
                     image=infos["images"]["original"]))

            # Adding note
            session.add(
                Note(note=round(infos["average_rating"]),
                     message=self.__default_message,
                     user_id=1,
                     game_id=i_game))

            for genre in infos["type"]:
                # Adding genre
                if genre not in self.__genres_dict:
                    self.__genres_dict[genre] = i_genres
                    session.add(Genre(id=i_genres, name=genre))
                    i_genres += 1

                # Adding classification
                session.add(
                    Classification(game_id=i_game,
                                   genre_id=self.__genres_dict[genre]))

            i_game += 1

        session.commit()
        self.__thread_safe_session_factory.remove()
Exemplo n.º 16
0
def vote_summary(request, game_id, round_id, thread_id):
    thread = Thread.get_by_uid(thread_id)
    game = Game.get_by_uid(game_id)
    if thread is None:
        raise Http404

    if not thread.profile_can_view(request.profile):
        return HttpResponse('Unauthorized', status=401)

    # only deals with GET requests
    if not request.method == 'GET':
        raise Http404

    summaries = VoteSummary.all().filter('thread', thread)
    summaries = summaries.order('-total')
    data = []
    total_votes = 0
    for s in summaries:
        data.append(dict(profile=s.role.player,
                         total=s.total,
                         updated=s.updated))
        total_votes += s.total

    chart_data = dict(chxr="0,0,%s" % len(data),
                      chxt='y',
                      chbh='a',
                      chs='200x200',
                      cht='bhs',
                      chco='4D89F9',
                      chds="0,%s" % total_votes)

    player_labels = [s['profile'].name for s in data]
    player_labels.reverse()
    chart_data['chx1'] = "0:|%s" % "|".join(player_labels)
    chart_data['chd'] = "t:%s" % ",".join([str(s['total']) for s in data])

    chart_url = "http://chart.apis.google.com/chart?%s"
    chart_url = chart_url % urlencode(chart_data)

    return json(dict(thread=thread,
                     summaries=data,
                     chart_url=chart_url))
Exemplo n.º 17
0
def add_random_user(id):
    user = User(id=id, nickname=generate(), description="Team Devian", steam=generate(),
                discord=generate(), twitch=generate())

    s1 = Skill(title="Координатор", count=3, user=user)
    s2 = Skill(title="Лидер", count=2, user=user)

    g1 = Game(game_id=randint(0, 9), user=user)

    a1 = Award(title="Ez Game", imgSrc="https://www.ezride.be/wp-content/uploads/2017/11/cropped-Logo_EZRide_yellow_circle.png", user=user)

    db.session.add(user)
    db.session.add(s1)
    db.session.add(s2)
    db.session.add(g1)
    db.session.add(a1)

    db.session.commit()

    return user
 def post(self, _id):
     try:
         data = JoinGame.parser.parse_args()
         game = Game.find_by_id(_id)
         player = Player.find_by_id(data['player_id'])
         player_in_game = PlayerInstance.player_in_game(
             player_id=data['player_id'], game_id=_id)
         print('player in game yes or no come on', player_in_game)
         if player_in_game:
             return msg('Player {} has already joined game {}'.format(
                 data['player_id'], _id)), 200
         player_instance = PlayerInstance(player_id=data['player_id'],
                                          game_id=_id)
         player_instance.game = game
         player_instance.player = player
         player_instance.save_to_db()
         return msg('Player {} joined game {}'.format(
             data['player_id'], _id)), 201
     except:
         return msg('Player game join error'), 500
Exemplo n.º 19
0
def index(request):
    if request.method == 'GET':
        games = Game.all()
        return render('game/list.html',
                      dict(games=games))

    elif request.method == 'POST':
        if not hasattr(request, 'user') or not request.user:
            login_url = users.create_login_url(request.get_full_path())
            return redirect(login_url)
        values = request.POST
        game = Game(name=values.get('name', 'Unnamed game'),
                    game_starter=request.profile,
                    signup_deadline=datetime.now() + timedelta(7),
                    signups=[])
        game.put()

        game.start_pregame()
        game.add_to_waitlist(request.profile)

        # redirect to the game
        return redirect('/games/%s' % game.uid)
Exemplo n.º 20
0
def register():
    if current_user.is_authenticated:
        return redirect(url_for('auth.lobby'))

    # check if join token is in the next page to pass on to username validation
    game = None
    next_page = request.args.get('next')
    if next_page is not None:
        token_search = re.search('/join_game/(.+)', next_page)
        if token_search:
            game = Game.verify_join_token(token_search.groups()[0])
    form = UserRegistrationForm(game)
    if form.validate_on_submit():
        user = User(username=form.username.data)
        db.session.add(user)
        db.session.commit()
        flash(_('Welcome, %(username)s', username=user.username))
        login_user(user, remember=1)
        if not next_page or url_parse(next_page).netloc != '':
            next_page = url_for('auth.lobby')
        return redirect(next_page)
    return render_template('auth/register.html', title=_('Welcome'), form=form)
Exemplo n.º 21
0
def add_mates(id):
    player = db.session.query(Player).filter(Player.player_id == id).first()
    if not player:
        flash("Sorry there was an error, the player could not be found in our database")
        return redirect(url_for("games.create"))
    mates = find_mates(id)
    if "mateSelect" in request.form:
        joker = True if request.form.get("joker",None) else False
        game = Game(
            level=request.form["inlineDifficulty"], user_game=True, player_id=id, joker=joker
        )
        db.session.add(game)
        db.session.flush()
        for item in request.form.getlist("mateSelect"):
            player_id = item.split(" - ", 1)[0]
            player = find_player(int(player_id))
            add_player(player)
            link = LinkGamePlayer(game_id=game.id, player_id=int(player_id))
            db.session.add(link)
        flash("Congratulation, you created a new game")
        return redirect(url_for("game.share", game_id=game.id))
    return render_template("games/game_select_mates.html", player=player, mates=mates)
Exemplo n.º 22
0
def create_game():
    # 新增遊戲
    form = CreateGameForm()
    if form.validate_on_submit():
        game = Game(user_id=form.user_id.data,gamename=form.gamename.data,descript=form.descript.data, player_num=form.player_num.data,\
        category_id=form.category_id.data)
        db.session.add(game)
        db.session.commit()

        # '''obj_to_json'''
        g_query = Game.query.filter_by(gamename=form.gamename.data).first()
        result = ""
        if isinstance(g_query, list):
            result = obj_to_json(g_query)

        game_result = json.dumps(result, cls=ComplexEncoder)
        flash('Congratulations, the game is created!')
        return redirect(url_for('games.add_room', gameObj=game_result))

    return render_template('games/create_game.html',
                           title='Register',
                           form=form)
Exemplo n.º 23
0
def create(game_id=None):
    
    if game_id:
        abort(403)

    else:
        new_game = Game()
        print(request.json["general_data"])
        
        new_game.general_data = request.json["general_data"]
        new_game.character_data = request.json["character_data"]
        new_game.phases = request.json["phases"]

        
        new_game.save()
        
        return make_response(json.dumps(new_game), 201)
Exemplo n.º 24
0
def index():
    games = Game.query.order_by(Game.date.desc()).limit(
        5)  # Only Retrieve Latest 5 Games
    form = CreateGameForm()
    form.expansions.choices = [
        (e.id, e.name)
        for e in Expansion.query.filter(Expansion.id != "base").all()
    ]
    form.players.choices = [(str(x), str(x)) for x in range(1, 5)]
    if form.validate_on_submit():
        new_game = Game(player_count=int(form.data.get("players")),
                        expansions=form.expansions.data)
        db.session.add(new_game)
        db.session.commit()
        return redirect(url_for("edit_game", game_id=new_game.id))
    for error in form.errors:
        flash("{}: {}".format(error.capitalize(), form.errors[error][0]),
              "danger")

    return render_template("index.html",
                           title="Spirit Island",
                           games=games,
                           form=form)
Exemplo n.º 25
0
def del_game(message):
    """ удалить игру из вишлиста, пример:
`/del https://store.playstation.com/ru-ru/product/EP3862-CUSA10484_00-DEADCELLS0000000`
или
`/del EP3862-CUSA10484_00-DEADCELLS0000000`
удалить из вишлиста Dead Cells """
    game_id = message.text.split(' ', maxsplit=1)[1]
    try:
        with session_scope() as session:
            game, game_is_new = Game.get_or_create(game_id, session=session)
            was_deleted = Wish.delete(user_id=message.chat.id,
                                      game_id=game_id,
                                      session=session)
        if was_deleted:
            response = f'Игра была успешно удалена: {game}'
        elif game_is_new or game and not was_deleted:
            response = f'Игра отсутствует в вашем вишлисте: {game}'
        else:
            response = f'Игра с таким идентификатором не найдена: {game.name}'
    except ValueError as ve:
        response = str(ve)

    bot.send_message(message.chat.id, response, parse_mode='MARKDOWN')
Exemplo n.º 26
0
def quick_new_game(game_type):
    game_name = current_app.config['GAMES_TO_NAMES'][game_type]
    new_game_ = Game(player_id=current_user.id, game_type=game_type)
    db.session.add(new_game_)
    db.session.commit()
    flash(_('New game of {}'.format(game_name)))
    if 'grape' in game_type:
        grape_ids = Grape.query.with_entities(Grape.id).all()
        random_grape_id = random.choices(grape_ids)[0]
        print(random_grape_id)
        print('lol')
        return redirect(
            url_for('main.{}'.format(game_type),
                    grape_id=random_grape_id[0],
                    game_id=new_game_.id))
    elif 'aoc' in game_type:
        aoc_ids = AOC.query.with_entities(AOC.id).all()
        random_aoc_id = random.choices(aoc_ids)[0]
        return redirect(
            url_for('main.{}'.format(game_type),
                    aoc_id=random_aoc_id[0],
                    game_id=new_game_.id))
    return redirect('main.new_game')
Exemplo n.º 27
0
 def test_auto_bid(self):
     users = User.get_all()
     self.assertEqual(9, len(users))
     game = Game.read()
     self.assertIsNotNone(game)
     self.assertEqual(9, game.user_count)
     self.assertEqual(150, game.player_count)
     self.assertEqual(150, game.player_to_bid)
     self.assertFalse(game.bid_in_progress)
     invite_bid()
     game.refresh()
     while game.bid_in_progress:
         bid = Bid.query_first(player_name=game.player_in_bidding)
         for user in users:
             user.refresh()
             if user.balance > 0:
                 sbp = game.avg_player_bid
                 amount = randrange(sbp - 20, sbp + 20)
                 if user.balance < amount:
                     amount = user.balance
                 accept_bid(bid, user, amount)
         game.refresh()
     self.assertEqual(0, game.player_to_bid)
Exemplo n.º 28
0
def create_game():
    form = CreateGameForm()
    if form.validate_on_submit():
        game = Game(name=form.game_name.data,
                    owner=current_user,
                    blurb=form.blurb.data,
                    player_max=form.get_player_max())
        game.set_password(form.password.data)
        chapter = Chapter(name=form.chapter_name.data, game=game)
        scene = Scene(name=form.chapter_name.data, chapter=chapter)
        db.session.add_all([game, chapter, scene])
        game.ensure_has_current()
        db.session.commit()
        set_currents(int(game.id))
        flash('Congratulations, you created a game called "{}"!'.format(
            game.name))
        return redirect(url_for('game.game', gameid=game.id))
    return render_template('game/create_game.html', form=form)
Exemplo n.º 29
0
def addGame(genre_id=None):
    ''' Route function to add a game. If genre_id is supplied,
        the genre dropdown on the returned page is automatically
        populated with the genre. '''

    form = GameForm()
    form.genre.choices = [(g.id, g.name)
                          for g in db.session.query(Genre).all()]
    form.genre.choices.insert(0, ('', 'Select...'))
    # if genre_id in url set it as genre dropdown's default
    if genre_id is not None:
        # Throw 404 if genre in URL does not exist
        try:
            db.session.query(Genre).filter_by(id=genre_id).one()
        except:
            abort(404)
        form.genre.default = genre_id
        form.process()

    if form.validate_on_submit():
        user = login_session['user_id']
        title = form.title.data
        genre = form.genre.data
        description = form.description.data
        file = request.files['image']
        newGame = Game(user_id=user,
                       title=title,
                       genre_id=genre,
                       description=description)
        db.session.add(newGame)
        db.session.commit()
        uploadGameImage(file, newGame)
        flash('Game %s added successfully!' % newGame.title)
        return redirect(url_for('game', game_id=newGame.id))

    return render_template('addGame.html', genre_id=genre_id, form=form)
Exemplo n.º 30
0
def create_game():
    form = CreateGameForm()

    if form.validate_on_submit():
        new_game = Game(name=form.name.data,
                        words_per_player=form.words_per_player.data,
                        is_open=True,
                        owner_player_id=g.current_player.id,
                        created_at=datetime.utcnow())
        db.session.add(new_game)
        db.session.flush()

        for i in range(min(10, form.number_of_rounds.data)):
            db.session.add(
                Round(game_id=new_game.id,
                      round_number=i + 1,
                      seconds_per_turn=form.seconds_per_turn.data))
        db.session.commit()

        return redirect(url_for('.games'))

    return render_template('salad_bowl/actions/create_game.html',
                           form=form,
                           action_url=url_for('.create_game'))
Exemplo n.º 31
0
def create_game():
    form = CreateGameForm()
    if form.validate_on_submit():
        away_id = form.away_id.data
        home_id = form.home_id.data
        try:
            away_id = teams[away_id]
            home_id = teams[home_id]
        except KeyError:
            flash('Invalid team name')
            return redirect(url_for('main.create_game'))
        game = Game(week=form.week.data,
                    away_id=away_id,
                    away_value=form.away_value.data,
                    home_id=home_id,
                    home_value=form.home_value.data)
        db.session.add(game)
        db.session.commit()
        flash('A new game has been created')
        return redirect(url_for('main.create_game'))
    return render_template('create_game.html',
                           title='Create Game',
                           form=form,
                           user=current_user)
Exemplo n.º 32
0
    def post(self):
        '''Create a new game.'''
        players = api.payload["players"]
        columns = api.payload["columns"]
        rows = api.payload["rows"]
        if (len(players) <= 1 or len(players) > 2 or (columns != 4)
                or (rows != 4) or players[0] == players[1]):
            return {"message": "Malformed request"}, 400

        player_one = players[0]
        player_two = players[1]

        player_one = Player.query.get(player_one)
        if player_one == None:
            player_one = Player()
            player_one.id = players[0]
            player_one.symbol = "X"
            db.session.add(player_one)
            db.session.commit()

        player_two = Player.query.get(player_two)
        if player_two == None:
            player_two = Player()
            player_two.id = players[1]
            player_two.symbol = "O"
            db.session.add(player_two)
            db.session.commit()

        game = Game()
        game.playerOneId = player_one.id
        game.playerTwoId = player_two.id
        game.status = "IN_PROGRESS"  #TODO consider creating a const or an enum for the game status
        board = Board()
        game.board = board.layout
        db.session.add(game)
        db.session.commit()
        token = create_access_token(identity=game.id)

        return {"gameId": token}
Exemplo n.º 33
0
    def test_game(self):
        team1 = Team(name='Yankees', city='New York', abbreviation='NYY')
        team2 = Team(name='Cubs', city='Chicago', abbreviation='CHC')
        game1 = Game(schedule_status='normal',
                     delayed_or_postponed_reason=None,
                     location='Yankee Stadium',
                     home_team=team1,
                     away_team=team2)
        db.session.add_all([team1, team2, game1])
        db.session.commit()
        self.assertEqual(game1.schedule_status, 'normal')
        self.assertEqual(game1.location, 'Yankee Stadium')
        self.assertEqual(game1.delayed_or_postponed_reason, None)

        self.assertEqual(game1.home_team.name, 'Yankees')
        self.assertEqual(len(team1.home_games), 1)

        game2 = Game(schedule_status='normal',
                     delayed_or_postponed_reason=None,
                     location='Yankee Stadium',
                     home_team=team1,
                     away_team=team2)
        game3 = Game(schedule_status='normal',
                     delayed_or_postponed_reason=None,
                     location='Wrigley Field',
                     home_team=team2,
                     away_team=team1)
        db.session.add_all([game2, game3])
        db.session.commit()
        self.assertEqual(len(team1.home_games), 2)
        self.assertEqual(len(team1.away_games), 1)

        game2.schedule_status = 'postponed'
        game2.delayed_or_postponed_reason = 'rain'

        self.assertEqual(game2.schedule_status, 'postponed')
        self.assertEqual(game2.delayed_or_postponed_reason, 'rain')
Exemplo n.º 34
0
def new_game():
    form = NewGameForm()

    if form.validate_on_submit():
        # creating a new game
        new_game_ = Game(player_id=current_user.id)

        if form.game_type.data == 'quiz_grape_color':

            flash(_('New game of Grape Color Quiz'))

            grape_ids = Cepage.query.with_entities(Cepage.id).all()

            new_game_.game_type = 'Grape Color Quiz'
            db.session.add(new_game_)
            db.session.commit()

            return redirect(
                url_for('main.quiz_grape_color',
                        grape_id=random.choice(grape_ids)[0],
                        game_id=new_game_.id))
        elif form.game_type.data == 'quiz_grape_region':
            flash(_('New game of Grape Region Quiz'))
            grape_ids = Cepage.query.with_entities(Cepage.id).all()

            new_game_.game_type = 'Grape Region Quiz'
            db.session.add(new_game_)
            db.session.commit()

            return redirect(
                url_for('main.quiz_grape_region',
                        grape_id=random.choice(grape_ids)[0],
                        game_id=new_game_.id))
        elif form.game_type.data == 'quiz_aoc_region':
            flash(_('New game of AOC Region Quiz'))
            aoc_ids = AOC.query.with_entities(AOC.id).all()

            new_game_.game_type = 'AOC Region Quiz'
            db.session.add(new_game_)
            db.session.commit()

            return redirect(
                url_for('main.quiz_aoc_region',
                        aoc_id=random.choice(aoc_ids)[0],
                        game_id=new_game_.id))

        elif form.game_type.data == 'quiz_aoc_color':
            flash(_('New game of AOC Color Quiz'))
            aoc_ids = AOC.query.with_entities(AOC.id).all()

            new_game_.game_type = 'AOC Color Quiz'
            db.session.add(new_game_)
            db.session.commit()

            return redirect(
                url_for('main.quiz_aoc_color',
                        aoc_id=random.choice(aoc_ids)[0],
                        game_id=new_game_.id))

        else:
            flash(_('Not implemented yet...'))

    return render_template('new_game.html',
                           title=_('Launch a new game!'),
                           form=form)
Exemplo n.º 35
0
def login():

    # If the user is already logged in, move them to their game instead
    if current_user.is_authenticated:
        return redirect(url_for('main.game', group=current_user.group))

    # Instance all the forms
    joinForm = JoinForm()
    joinFormPOC = JoinFormPOC()
    createForm = CreateForm()

    # If they have joined
    if joinForm.submit1.data and joinForm.validate():
        user = User(group=joinForm.group.data, permission='1')
        db.session.add(user)
        db.session.commit()

        login_user(user)

        next_page = request.args.get('next')
        if not next_page or url_parse(next_page).netloc != '':
            next_page = url_for('main.game', group=current_user.group)
        return redirect(next_page)

    # If they have joined as host
    if joinFormPOC.submit10.data and joinFormPOC.validate():
        user = User(group=joinForm.group.data, permission='2')
        db.session.add(user)
        db.session.commit()

        login_user(user)

        next_page = request.args.get('next')
        if not next_page or url_parse(next_page).netloc != '':
            next_page = url_for('main.game', group=current_user.group)
        return redirect(next_page)

    # If they have created a game
    if createForm.submit2.data and createForm.validate():
        user = User(group=createForm.group.data, permission='2')
        db.session.add(user)
        db.session.commit()
        encounters = Encounter.query.all()
        game = Game(group=createForm.group.data,
                    compEnc='1',
                    mode='GAME',
                    curEnc='0')
        game.generateFrequency()
        game.applyCallsign(CALLSIGN_LIST[randint(0,
                                                 len(CALLSIGN_LIST) - 1)] +
                           ' ' + str(randint(1, 9)))
        game.location = LOCATION_LIST[randint(0, len(LOCATION_LIST) - 1)]
        game.setGoalEnc(20)
        game.setQRandUpper(len(encounters) - 1)
        game.setMRandUpper(19)
        game.selectMarch()
        game.updateTime()
        db.session.add(game)
        db.session.commit()

        login_user(user)

        next_page = request.args.get('next')
        if not next_page or url_parse(next_page).netloc != '':
            next_page = url_for('main.game', group=current_user.group)
        return redirect(next_page)

    prompt = Prompt.query.all()[0]

    return render_template(['joinCreate.html', 'base.html'],
                           prompt=prompt,
                           joinForm=joinForm,
                           createForm=createForm,
                           joinFormPOC=joinFormPOC)
Exemplo n.º 36
0
def create_test_data():
    role_user = user_datastore.create_role(**USER_ROLE._asdict())
    role_gs_admin = user_datastore.create_role(**SERVER_ADMIN_ROLE._asdict())
    role_aga_admin = user_datastore.create_role(**RATINGS_ADMIN_ROLE._asdict())

    u = user_datastore.create_user(email='*****@*****.**',
                                   password=encrypt_password('usgo'),
                                   id=1)
    user_datastore.add_role_to_user(u, role_aga_admin)

    kgs_admin = user_datastore.create_user(email='*****@*****.**',
                                           password=encrypt_password('kgs'),
                                           id=2)
    user_datastore.add_role_to_user(kgs_admin, role_gs_admin)

    u = user_datastore.create_user(email='*****@*****.**',
                                   aga_id=10,
                                   password=encrypt_password('foo'),
                                   id=3)
    db.session.add(
        Player(id=1,
               name="FooPlayerKGS",
               server_id=1,
               user_id=3,
               token="secret_foo_KGS"))
    db.session.add(
        Player(id=4,
               name="FooPlayerIGS",
               server_id=2,
               user_id=3,
               token="secret_foo_IGS"))
    user_datastore.add_role_to_user(u, role_user)

    u = user_datastore.create_user(email='*****@*****.**',
                                   aga_id=20,
                                   password=encrypt_password('bar'),
                                   id=4)
    db.session.add(
        Player(id=2,
               name="BarPlayerKGS",
               server_id=1,
               user_id=4,
               token="secret_bar_KGS"))
    db.session.add(
        Player(id=5,
               name="BarPlayerIGS",
               server_id=2,
               user_id=4,
               token="secret_bar_IGS"))
    user_datastore.add_role_to_user(u, role_user)

    u = user_datastore.create_user(email='*****@*****.**',
                                   aga_id=30,
                                   password=encrypt_password('baz'),
                                   id=5)
    db.session.add(
        Player(id=3,
               name="BazPlayerKGS",
               server_id=1,
               user_id=5,
               token="secret_baz_KGS"))
    db.session.add(
        Player(id=6,
               name="BazPlayerIGS",
               server_id=2,
               user_id=5,
               token="secret_baz_IGS"))
    user_datastore.add_role_to_user(u, role_user)

    gs = GoServer(id=1, name='KGS', url='http://gokgs.com', token='secret_kgs')
    gs.admins.append(kgs_admin)
    db.session.add(gs)
    db.session.add(
        GoServer(id=2,
                 name='IGS',
                 url='http://pandanet.com',
                 token='secret_igs'))

    basedir = os.path.abspath(os.path.dirname(__file__))
    with open(os.path.join(basedir, 'tests/testsgf.sgf')) as sgf_file:
        sgf_data = "\n".join(sgf_file.readlines()).encode()

    db.session.add(
        Game(server_id=1,
             white_id=1,
             black_id=2,
             rated=True,
             result="B+0.5",
             game_record=sgf_data,
             date_played=datetime.datetime.now() -
             datetime.timedelta(seconds=random.randint(0, 1000000))))
    db.session.add(
        Game(server_id=1,
             white_id=1,
             black_id=2,
             rated=True,
             result="W+39.5",
             game_record=sgf_data,
             date_played=datetime.datetime.now() -
             datetime.timedelta(seconds=random.randint(0, 1000000))))
    db.session.add(
        Game(server_id=2,
             white_id=5,
             black_id=4,
             rated=True,
             result="W+Resign",
             game_record=sgf_data,
             date_played=datetime.datetime.now() -
             datetime.timedelta(seconds=random.randint(0, 1000000))))
    db.session.add(
        Game(server_id=2,
             white_id=5,
             black_id=4,
             rated=True,
             result="W+Resign",
             game_record=sgf_data,
             date_played=datetime.datetime.now() -
             datetime.timedelta(seconds=random.randint(0, 1000000))))
    db.session.add(
        Game(server_id=2,
             white_id=6,
             black_id=5,
             rated=True,
             result="W+Resign",
             game_record=sgf_data,
             date_played=datetime.datetime.now() -
             datetime.timedelta(seconds=random.randint(0, 1000000))))
    db.session.add(
        Game(server_id=1,
             white_id=1,
             black_id=2,
             rated=True,
             result="B+0.5",
             game_record=sgf_data,
             date_played=datetime.datetime.now() -
             datetime.timedelta(seconds=random.randint(0, 1000000))))
    db.session.add(
        Game(server_id=1,
             white_id=3,
             black_id=2,
             rated=True,
             result="W+39.5",
             game_record=sgf_data,
             date_played=datetime.datetime.now() -
             datetime.timedelta(seconds=random.randint(0, 1000000))))
    db.session.add(
        Game(server_id=2,
             white_id=5,
             black_id=6,
             rated=True,
             result="W+Resign",
             game_record=sgf_data,
             date_played=datetime.datetime.now() -
             datetime.timedelta(seconds=random.randint(0, 1000000))))

    db.session.commit()

    try:
        # needed to reset the postgresql autoincrement counter
        db.engine.execute(
            "SELECT setval('myuser_id_seq', (SELECT MAX(id) FROM myuser))")
        db.engine.execute(
            "SELECT setval('player_id_seq', (SELECT MAX(id) FROM player))")
    except:
        pass
Exemplo n.º 37
0
 def create_mock_game2(session_add=True):
     game = Game(name='test_game2')
     if session_add:
         db.session.add(game)
     return game
Exemplo n.º 38
0
def enter_score(id):
    match = Match.query.filter_by(id=id).first()
    form = EnterScoresForm(obj=match)
    all_matches = Match.query.order_by(Match.date).all()
    hl_form = HLScoreForm()

    if form.submit_details.data and form.validate() and match is not None:
        match.win = form.win.data
        match.overtime = form.overtime.data
        match.team_score = form.team_score.data
        match.opponent_score = form.opponent_score.data
        match.food = form.food.data
        match.match_summary = form.match_summary.data
        db.session.add(match)
        db.session.commit()
        for p in match.get_roster():
            p.update_player_stats()
        flash('Match {} {} {} details edited!'.format(
            match.date.strftime('%Y-%m-%d'), match.opponent.name,
            match.home_away))
        return redirect(url_for('main.enter_score', id=match.id))

    if form.submit_scores.data and form.validate() and match is not None:

        match.win = form.win.data
        match.overtime = form.overtime.data
        match.team_score = form.team_score.data
        match.opponent_score = form.opponent_score.data
        match.food = form.food.data
        match.match_summary = form.match_summary.data
        db.session.add(match)
        db.session.commit()

        match.delete_all_games()

        count = 1
        for j, f in enumerate(form.d701):
            i = count + j
            game = Game(match=match,
                        win=f.win.data,
                        game_num=i,
                        game_type='doubles 701')
            p1 = Player.query.filter_by(nickname=f.p1.data).first()
            p2 = Player.query.filter_by(nickname=f.p2.data).first()
            pg1 = PlayerGame(player=p1, game=game, stars=int(f.p1_stars.data))
            pg2 = PlayerGame(player=p2, game=game, stars=int(f.p2_stars.data))
            db.session.add_all([game, pg1, pg2])
            db.session.commit()

        count = count + len(form.d701)
        for j, f in enumerate(form.d501):
            i = count + j
            game = Game(match=match,
                        win=f.win.data,
                        game_num=i,
                        game_type='doubles 501')
            p1 = Player.query.filter_by(nickname=f.p1.data).first()
            p2 = Player.query.filter_by(nickname=f.p2.data).first()
            pg1 = PlayerGame(player=p1, game=game, stars=int(f.p1_stars.data))
            pg2 = PlayerGame(player=p2, game=game, stars=int(f.p2_stars.data))
            db.session.add_all([game, pg1, pg2])
            db.session.commit()

        count = count + len(form.d501)
        for j, f in enumerate(form.s501):
            i = count + j
            game = Game(match=match,
                        win=f.win.data,
                        game_num=i,
                        game_type='singles 501')
            p1 = Player.query.filter_by(nickname=f.p1.data).first()
            pg1 = PlayerGame(player=p1, game=game, stars=int(f.p1_stars.data))
            db.session.add_all([game, pg1])
            db.session.commit()

        for p in match.get_roster():
            p.update_player_stats(match.season.season_name)
            p.update_activity()

        update_all_team_stats()
        match.update_match_stats()
        flash(
            'Match {} {} {} scores entered successfully!'.format(
                match.date.strftime('%Y-%m-%d'), match.opponent.name,
                match.home_away), 'success')
        return redirect(url_for('main.enter_score', id=match.id))

    if hl_form.add_btn.data:
        new_row = hl_form.hl_scores.append_entry()
        new_row.player.choices = [(p.nickname, p.nickname)
                                  for p in Player.query.all()]

        return render_template('enter_score.html',
                               title='Enter Scores',
                               form=form,
                               hl_form=hl_form,
                               match=match,
                               all_matches=all_matches)

    if hl_form.rem_btn.data:
        hl_form.hl_scores.pop_entry()
        return render_template('enter_score.html',
                               title='Enter Scores',
                               form=form,
                               hl_form=hl_form,
                               match=match,
                               all_matches=all_matches)

    if hl_form.submit_hl_scores.data and match is not None:
        match.delete_all_books()
        hl_form.save_scores(match)
        for p in match.get_roster():
            p.update_player_stats(match.season.season_name)
            p.update_activity()
        update_all_team_stats()
        flash(
            'Match {} {} {} high/low scores entered successfully!'.format(
                match.date.strftime('%Y-%m-%d'), match.opponent.name,
                match.home_away), 'success')
        return redirect(url_for('main.enter_score', id=match.id))

    if request.method == 'GET' and match is not None:
        form.load_games(match)
        hl_form.load_scores(match)

    if request.method == 'POST' and match is not None:
        form.load_games(match)
        hl_form.load_scores(match)

    return render_template('enter_score.html',
                           title='Enter Scores',
                           form=form,
                           hl_form=hl_form,
                           match=match,
                           all_matches=all_matches)
Exemplo n.º 39
0
def votes(request, game_id, round_id, thread_id):
    thread = Thread.get_by_uid(thread_id)
    game = Game.get_by_uid(game_id)
    if thread is None:
        raise Http404

    if not thread.profile_can_view(request.profile):
        return HttpResponse('Unauthorized', status=401)

    if request.method == 'GET':
        since = request.GET.get('since', None)
        return json(Vote.get_activities(request.user, thread, since=since))

    if request.method == 'POST':
        if not thread.profile_can_create(request.profile):
            return HttpResponse('Unauthorized', status=401)

        # find the target
        target_id = request.POST.get('target_id', None)
        if target_id is None:
            raise Exception('No target')

        target_profile = Profile.get_by_uid(target_id)
        target = Role.all().filter('player', target_profile)
        target = target.filter('game', game)
        target = target.fetch(1)[0]

        # find the last vote this user made (if any)
        game = Game.get_by_uid(game_id)
        actor = Role.get_by_profile(game, request.profile)

        last_vote = Vote.all().filter("thread", thread)
        last_vote = last_vote.filter("actor", actor)
        last_vote = last_vote.order("-created")
        try:
            last_vote = last_vote.fetch(1)[0]
        except IndexError, e:
            last_vote = None

        # if we found a vote, decrement that vote's counter
        if last_vote is not None:
            last_vote.decrement()

        # create the new vote
        vote = Vote(actor=actor,
                    target=target,
                    thread=thread)
        vote.put()

        # increment the counter
        vote.increment()

        if thread.name == role_vanillager:
            vote_count = Vote.all().filter('thread', thread).count()
            if not vote_count:
                # First vote in round
                c = Client(settings.BDM_SECRET, settings.BDM_KEY)
                eul = "profile:%s" % request.profile.uid
                c.post("named_transaction_group/613301/execute/%s" % eul)
                if thread.round.number == 1:
                    # First vote in game
                    c.post("named_transaction_group/613302/execute/%s" % eul)

        return json(vote)
Exemplo n.º 40
0
def receive():
    if not kik.verify_signature(request.headers.get('X-Kik-Signature'),
                                request.get_data()):
        return Response(status=403)

    messages = messages_from_json(request.json['messages'])

    for message in messages:
        to = message.from_user
        chat_id = message.chat_id
        mention = message.mention

        if not db.session.query(Game).filter(Game.id == chat_id).count():
            print(
                "No game found in db, creating a new game instance and adding to db"
            )
            game = Game(chatId=chat_id, state=StateType.INITIAL)
            db.session.add(game)
            db.session.commit()

        game = db.session.query(Game).filter(Game.id == chat_id).first()
        print("Restoring existing instance with state ", game.state)

        if isinstance(message, StartChattingMessage):
            Handler.handle_intro(to, game, None)
        elif isinstance(message, TextMessage):
            body = message.body.lower()
            if not body and mention and game.state == StateType.INITIAL:
                Handler.handle_song(to,
                                    game,
                                    None,
                                    song=music.get_song_from_playlist())
                return Response(status=200)

            if game.state == StateType.ANSWER_TIME:
                Handler.handle_answer(to, game, body)
                return Response(status=200)

            fn = srs.srs.get(body)
            if not fn:
                if body in music.Genre.GENRES and (
                        game.state == StateType.GENRE_SELECT
                        or game.state == StateType.INITIAL):
                    Handler.handle_song(to,
                                        game,
                                        body,
                                        song=music.get_song_from_genre(
                                            body, game.difficulty))
                elif game.state == StateType.ARTIST_SELECT or game.state == StateType.INITIAL:
                    print 'MATCHING ARTIST: {}'.format(body)
                    try:
                        song = music.get_song_from_artist(
                            body, game.difficulty)
                    except Exception as e:
                        print 'Exception: %r' % e
                        Handler.handle_error(to, game)
                        return Response(status=200)

                    Handler.handle_song(to, game, body, song=song)
                else:
                    Handler.handle_fallback(to, game, body)
                return Response(status=200)
            getattr(Handler, fn)(to, game, body)
        else:
            Handler.handle_fallback(to, game, None)
        return Response(status=200)
def seed_2021_tournament_round3():
    tournament = Tournament.query.filter(Tournament.year == 2021).one()
    tournament.last_round_completed = 3

    # West
    Gonzaga = College.query.filter(College.name == 'Gonzaga').one()
    gonzaga = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Gonzaga.id).one()

    Creighton = College.query.filter(College.name == 'Creighton').one()
    creighton = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Creighton.id).one()

    USC = College.query.filter(College.name == 'USC').one()
    uSC = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == USC.id).one()

    Oregon = College.query.filter(College.name == 'Oregon').one()
    oregon = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Oregon.id).one()

    # South
    Baylor = College.query.filter(College.name == 'Baylor').one()
    baylor = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Baylor.id).one()

    Villanova = College.query.filter(College.name == 'Villanova').one()
    villanova = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Villanova.id).one()

    Arkansas = College.query.filter(College.name == 'Arkansas').one()
    arkansas = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Arkansas.id).one()

    Oral_Roberts = College.query.filter(College.name == 'Oral Roberts').one()
    oral_Roberts = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Oral_Roberts.id).one()

    # Midwest
    Loyola_Chicago = College.query.filter(
        College.name == 'Loyola Chicago').one()
    loyola_Chicago = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Loyola_Chicago.id).one()

    Oregon_State = College.query.filter(College.name == 'Oregon State').one()
    oregon_State = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Oregon_State.id).one()

    Syracuse = College.query.filter(College.name == 'Syracuse').one()
    syracuse = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Syracuse.id).one()

    Houston = College.query.filter(College.name == 'Houston').one()
    houston = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Houston.id).one()

    # East
    Michigan = College.query.filter(College.name == 'Michigan').one()
    michigan = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Michigan.id).one()

    Florida_State = College.query.filter(College.name == 'Florida State').one()
    florida_State = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Florida_State.id).one()

    UCLA = College.query.filter(College.name == 'UCLA').one()
    uCLA = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == UCLA.id).one()

    Alabama = College.query.filter(College.name == 'Alabama').one()
    alabama = March_Madness_Team.query.filter(
        March_Madness_Team.tournament_id == tournament.id).filter(
            March_Madness_Team.college_id == Alabama.id).one()

    game_49 = Game.query.filter(Game.game_num == 49).filter(
        Game.tournament_id == tournament.id).one()
    game_49.winning_team_id = gonzaga.id

    game_50 = Game.query.filter(Game.game_num == 50).filter(
        Game.tournament_id == tournament.id).one()
    game_50.winning_team_id = uSC.id

    game_51 = Game.query.filter(Game.game_num == 51).filter(
        Game.tournament_id == tournament.id).one()
    game_51.winning_team_id = michigan.id

    game_52 = Game.query.filter(Game.game_num == 52).filter(
        Game.tournament_id == tournament.id).one()
    game_52.winning_team_id = uCLA.id

    game_53 = Game.query.filter(Game.game_num == 53).filter(
        Game.tournament_id == tournament.id).one()
    game_53.winning_team_id = baylor.id

    game_54 = Game.query.filter(Game.game_num == 54).filter(
        Game.tournament_id == tournament.id).one()
    game_54.winning_team_id = arkansas.id

    game_55 = Game.query.filter(Game.game_num == 55).filter(
        Game.tournament_id == tournament.id).one()
    game_55.winning_team_id = oregon_State.id

    game_56 = Game.query.filter(Game.game_num == 56).filter(
        Game.tournament_id == tournament.id).one()
    game_56.winning_team_id = houston.id

    db.session.commit()

    game_49_win_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_49.id).filter(
            Game_Team_Score.team_id == gonzaga.id).one()
    game_49_win_score.score = 83
    game_49_lose_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_49.id).filter(
            Game_Team_Score.team_id == creighton.id).one()
    game_49_lose_score.score = 65

    game_50_win_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_50.id).filter(
            Game_Team_Score.team_id == uSC.id).one()
    game_50_win_score.score = 82
    game_50_lose_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_50.id).filter(
            Game_Team_Score.team_id == oregon.id).one()
    game_50_lose_score.score = 68

    game_51_win_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_51.id).filter(
            Game_Team_Score.team_id == michigan.id).one()
    game_51_win_score.score = 76
    game_51_lose_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_51.id).filter(
            Game_Team_Score.team_id == florida_State.id).one()
    game_51_lose_score.score = 58

    game_52_win_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_52.id).filter(
            Game_Team_Score.team_id == uCLA.id).one()
    game_52_win_score.score = 88
    game_52_lose_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_52.id).filter(
            Game_Team_Score.team_id == alabama.id).one()
    game_52_lose_score.score = 78

    game_53_win_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_53.id).filter(
            Game_Team_Score.team_id == baylor.id).one()
    game_53_win_score.score = 62
    game_53_lose_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_53.id).filter(
            Game_Team_Score.team_id == villanova.id).one()
    game_53_lose_score.score = 51

    game_54_win_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_54.id).filter(
            Game_Team_Score.team_id == arkansas.id).one()
    game_54_win_score.score = 72
    game_54_lose_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_54.id).filter(
            Game_Team_Score.team_id == oral_Roberts.id).one()
    game_54_lose_score.score = 70

    game_55_win_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_55.id).filter(
            Game_Team_Score.team_id == oregon_State.id).one()
    game_55_win_score.score = 65
    game_55_lose_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_55.id).filter(
            Game_Team_Score.team_id == loyola_Chicago.id).one()
    game_55_lose_score.score = 58

    game_56_win_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_56.id).filter(
            Game_Team_Score.team_id == houston.id).one()
    game_56_win_score.score = 62
    game_56_lose_score = Game_Team_Score.query.filter(
        Game_Team_Score.game_id == game_56.id).filter(
            Game_Team_Score.team_id == syracuse.id).one()
    game_56_lose_score.score = 46

    db.session.commit()

    game_57 = Game(game_num=57,
                   round_num=4,
                   winning_team_id=None,
                   tournament_id=tournament.id)
    db.session.add(game_57)
    game_58 = Game(game_num=58,
                   round_num=4,
                   winning_team_id=None,
                   tournament_id=tournament.id)
    db.session.add(game_58)
    game_59 = Game(game_num=59,
                   round_num=4,
                   winning_team_id=None,
                   tournament_id=tournament.id)
    db.session.add(game_59)
    game_60 = Game(game_num=60,
                   round_num=4,
                   winning_team_id=None,
                   tournament_id=tournament.id)
    db.session.add(game_60)

    db.session.commit()

    game_49.child_game_id = game_57.id
    game_50.child_game_id = game_57.id

    game_51.child_game_id = game_58.id
    game_52.child_game_id = game_58.id

    game_53.child_game_id = game_59.id
    game_54.child_game_id = game_59.id

    game_55.child_game_id = game_60.id
    game_56.child_game_id = game_60.id

    db.session.commit()

    game_57_win_score = Game_Team_Score(game_id=game_57.id,
                                        team_id=gonzaga.id,
                                        score=None)
    game_57_lose_score = Game_Team_Score(game_id=game_57.id,
                                         team_id=uSC.id,
                                         score=None)
    game_57.game_team_scores = [game_57_win_score, game_57_lose_score]

    game_58_win_score = Game_Team_Score(game_id=game_58.id,
                                        team_id=michigan.id,
                                        score=None)
    game_58_lose_score = Game_Team_Score(game_id=game_58.id,
                                         team_id=uCLA.id,
                                         score=None)
    game_58.game_team_scores = [game_58_win_score, game_58_lose_score]

    game_59_win_score = Game_Team_Score(game_id=game_59.id,
                                        team_id=baylor.id,
                                        score=None)
    game_59_lose_score = Game_Team_Score(game_id=game_59.id,
                                         team_id=arkansas.id,
                                         score=None)
    game_59.game_team_scores = [game_59_win_score, game_59_lose_score]

    game_60_win_score = Game_Team_Score(game_id=game_60.id,
                                        team_id=oregon_State.id,
                                        score=None)
    game_60_lose_score = Game_Team_Score(game_id=game_60.id,
                                         team_id=houston.id,
                                         score=None)
    game_60.game_team_scores = [game_60_win_score, game_60_lose_score]

    db.session.commit()

    print('done')
Exemplo n.º 42
0
 def game_handler():
     if request.method == "POST":
         img_id = str(request.data.get('img_id', ''))
         diff = int(request.data.get('diff', ''))
         if img_id and diff:
             obj = randomiser(diff)
             rel = []
             for num in range(0, diff):
                 num = num + 1
                 rel.append(obj[num - 1])
             win_img = obj['url']
             game = Game(img_id, rel, win_img)
             game.save()
             relation = {}
             if game.t1:
                 relation['1'] = game.t1
             if game.t2:
                 relation['2'] = game.t2
             if game.t3:
                 relation['3'] = game.t3
             if game.t4:
                 relation['4'] = game.t4
             if game.t5:
                 relation['5'] = game.t5
             if game.t6:
                 relation['6'] = game.t6
             if game.t7:
                 relation['7'] = game.t7
             if game.t8:
                 relation['8'] = game.t8
             if game.t9:
                 relation['9'] = game.t9
             if game.t10:
                 relation['10'] = game.t10
             if game.t11:
                 relation['11'] = game.t11
             if game.t12:
                 relation['12'] = game.t12
             if game.t13:
                 relation['13'] = game.t13
             if game.t14:
                 relation['14'] = game.t14
             if game.t15:
                 relation['15'] = game.t15
             if game.t16:
                 relation['16'] = game.t16
             score = 'null'
             response = jsonify({
                 'id': game.id,
                 'img_id': game.img_id,
                 'date_created': game.date_created,
                 'date_completed': game.date_completed,
                 'score': 'null',
                 'relation': relation,
                 'win_img': game.win_img
             })
             response.status_code = 201
             return response
     else:
         # GET
         games = Game.get_all()
         results = []
         for game in games:
             if game.score:
                 score = game.score.strftime("%H:%M:%S")
             else:
                 score = 'null'
             relation = {}
             if game.t1:
                 relation['1'] = game.t1
             if game.t2:
                 relation['2'] = game.t2
             if game.t3:
                 relation['3'] = game.t3
             if game.t4:
                 relation['4'] = game.t4
             if game.t5:
                 relation['5'] = game.t5
             if game.t6:
                 relation['6'] = game.t6
             if game.t7:
                 relation['7'] = game.t7
             if game.t8:
                 relation['8'] = game.t8
             if game.t9:
                 relation['9'] = game.t9
             if game.t10:
                 relation['10'] = game.t10
             if game.t11:
                 relation['11'] = game.t11
             if game.t12:
                 relation['12'] = game.t12
             if game.t13:
                 relation['13'] = game.t13
             if game.t14:
                 relation['14'] = game.t14
             if game.t15:
                 relation['15'] = game.t15
             if game.t16:
                 relation['16'] = game.t16
             obj = {
                 'id': game.id,
                 'img_id': game.img_id,
                 'date_created': game.date_created,
                 'date_completed': game.date_completed,
                 'score': score,
                 'relation': relation,
                 'win_img': game.win_img
             }
             results.append(obj)
         response = jsonify(results)
         response.status_code = 200
         return response
Exemplo n.º 43
0
from app.models import Player, Game

from app.logconfig import logger

users = []
users.append(Player('robin', 'nobby'))
users.append(Player('nobby', 'robin'))

games = [Game(), Game()]
logger.info('ceated default users and 2 games')


def get_game_from_id(game_id):
    game_out = None

    if game_id in [g.id for g in games]:
        game_out = [g for g in games if g.id == game_id][0]

    return game_out


def get_user_from_id(user_id):
    user = None

    if user_id in [u.id for u in users]:
        user = [u for u in users if u.id == user_id][0]

    return user


def get_user_from_name(name):