def get_game_history(self, request):
        """ Query game history kind for games matching id """
        game = get_by_game_id(game_id=request.game_id)
        if not game:
            return OthelloGameHistoryForm(
                    message='No history found for game ' + request.game_id)
        # query Othello game history entity with game id request.game_id
        game_history = OthelloGameHistory.query(ancestor=game.key).get()
        if not game_history:
            raise endpoints.BadRequestException(
                    'Could not find history linked to this game')

        return OthelloGameHistoryForm(
                game_status=game_history.key.parent().get().status,
                game_id=int(request.game_id),
                moves=game_history.moves)
    def _make_move(self, request):
        """ Controller for movements. If game is SINGLE_PLAYER,
        CPU will take turn after player submits valid move.
        Otherwise, CPU waits for valid move or yield from player"""
        game = get_by_game_id(request.game_id)
        if not game:
            return False, "Game not found"
        print "Game status", game.status, type(game.status)
        if not game.status == "ACTIVE":
            return False, "This game is not active"

        if ndb.Key(OthelloPlayer, request.user_name,
                   parent=ndb.Key(User, request.user_name))\
                not in game.userKeys:
            return False, "Player {0} is not registered for this game".\
                    format(request.user_name)
        parent_keys = [p.parent() for p in game.userKeys]
        players = ndb.get_multi(parent_keys)
        print "Players in this game", players

        # load game logic object
        game_logic = load_game_logic(game.gamelogic)

        player_turn = 1 if players[0].name == request.user_name else 2
        isvalid, message = game_logic._make_move(player_turn, request.move)
        print message

        # load an update game history in memory
        game_history = OthelloGameHistory.query(ancestor=game.key).get()
        if not game_history.moves:
            moves = []
        else:
            moves = json.loads(game_history.moves)
        # append moves from user if move is valid
        if isvalid:
            moves.append([request.user_name, request.move])
            if game_logic.game_mode == TWO_PLAYER_MODE:
                # PUSH TASK QUEUE to notify opponent that move has been made
                taskqueue.add(params={'email': players[0].email if
                              player_turn == 2 else players[1].email,
                              'score': game_logic._getScore()},
                              url='/tasks/send_gameturn_notification_email')

        print "Whose turn is it?", game_logic.CP
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        # CPU MOVE

        if isvalid and game_logic.game_mode == SINGLE_PLAYER_MODE:
            print "Calling CPU for move..."
            isvalid, cpu_move = game_logic._cpu_move()
            moves.append(['cpu', cpu_move])
            print message
            message = "Your move was valid. {0}".format(cpu_move)

        # updates game logic with values from OthelloLogic instance
        update_game_logic(game_logic, game.gamelogic)

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        # GAME OVER CONDITIONS

        if game_logic._isBoardFull():
            game.status = "ENDED_COMPLETE"
            message = "Game has ended. The board is full!"
        if request.move == '0':
            game.status = "ENDED_INCOMPLETE"
            # record last move 
            moves.append([players[0].name if player_turn == 1 else 
                players[1].name, request.move])
            message = "The user abandoned the game. "
            "Score will be accounted for"

        if not game.status == "ACTIVE":
            # get score
            score_player1, score_player2 = game_logic._getScore()
            score_diff = abs(score_player1-score_player2)
            player1_entry = OthelloScoreBoardEntry.query(
                    ancestor=game.userKeys[0]).get()
            # CHECK END OF TWO PLAYER GAME
            if game_logic.game_mode == TWO_PLAYER_MODE:
                player2_entry = OthelloScoreBoardEntry.query(
                        ancestor=game.userKeys[1]).get()
                if score_player1 > score_player2:
                    # PLAYER 1 WINS
                    message = "Player {0} wins!".format(
                            game.userKeys[0].parent().get().name)
                    player1_entry.points += score_player1
                    player1_entry.wins += 1
                    player1_entry.winning_streak += 1
                    # update score difference average - player 1
                    update_score_difference_ave(
                            player1_entry.score_difference_average,
                            score_diff)
                    player2_entry.winning_streak = 0
                elif score_player1 < score_player2:
                    # PLAYER 2 WINS
                    message = "Player {0} wins!".format(
                            game.userKeys[1].parent().get().name)
                    player2_entry.points += score_player2
                    player2_entry.wins += 1
                    player2_entry.winning_streak += 1
                    # update score difference average - player 2
                    update_score_difference_ave(
                            player2_entry.score_difference_average,
                            score_diff)
                    player1_entry.winning_streak = 0
                else:
                    # tie game
                    message = "This game is tied! No changes in scoreboard"
                # update players scoreboard entries in datastore
                ndb.put_multi([player1_entry, player2_entry])
            # CHECK END FOR SINGLE PLAYER GAME
            if game_logic.game_mode == SINGLE_PLAYER_MODE:
                if score_player1 > score_player2:
                    # PLAYER 1 WINS
                    message = "Player {0} wins!".format(
                            game.userKeys[0].parent().get().name)
                    player1_entry.points += score_player1
                    player1_entry.wins += 1
                    update_score_difference_ave(
                            player1_entry.score_difference_average,
                            score_diff)
                    player1_entry.winning_streak += 1
                elif score_player1 < score_player2:
                    message = "CPU wins."
                    player1_entry.winning_streak = 0
                player1_entry.put()

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        # UPDATE GAME AND HISTORY DATASTORE
        game.put()
        # UPDATE GAME HISTORY
        game_history.moves = json.dumps(moves)
        game_history.put()

        return True, message
    def _newOthelloGame(self, request):
        """ Logic for creating a new Othello game.
        Create ndb types that will store the game
        logic using the OthelloLogic class
        implementation """

        # set game mode
        if request.player_two:
            playerNames = [ request.player_one, request.player_two ]
        else:
            playerNames = [ request.player_one ]

        if len(playerNames) == 1:
            game_mode = SINGLE_PLAYER_MODE
        else:
            game_mode = TWO_PLAYER_MODE

        # get OthelloPlayer keys for this game
        # assert : all keys have been verified to exist
        othello_players_keys = [ndb.Key(
            OthelloPlayer, name, parent=ndb.Key(
                User, name)) for name in playerNames]

        # initialize logic
        new_game_logic = OthelloLogic(game_mode=game_mode)
        # initialize game object with
        # explicit array name containers
        json_board = json.dumps(new_game_logic.B)
        json_array_x = json.dumps(new_game_logic.X)
        json_array_y = json.dumps(new_game_logic.Y)
        json_array_n = json.dumps(new_game_logic.N)
        json_array_move = json.dumps(new_game_logic.D)
        json_check_move = json.dumps(new_game_logic.C)
        game_logic = OthelloDatastoreLogic(
                board=json_board,
                player_turn=new_game_logic.CP,
                check_move=json_check_move,
                array_move=json_array_move,
                array_x=json_array_x,
                array_y=json_array_y,
                array_n=json_array_n,
                game_mode=new_game_logic.game_mode)

        new_game = OthelloGame(
                status="ACTIVE",
                starttime=datetime.today(),
                gamelogic=game_logic,
                userKeys=othello_players_keys)

        # link new game to creator, in this case, first user in player list
        g_id = OthelloGame.allocate_ids(size=1,
                                        parent=othello_players_keys[0])[0]
        g_key = ndb.Key('OthelloGame', g_id, parent=othello_players_keys[0])
        new_game.key = g_key
        # add generated id as game id
        new_game.game_id = g_id

        # create game history entity
        # adding scoreboard entry
        new_game.put()
        print "Game created"
        gh_id = OthelloGameHistory.allocate_ids(size=1, parent=g_key)[0]
        gh_key = ndb.Key(OthelloGameHistory, gh_id, parent=g_key)
        game_history = OthelloGameHistory(key=gh_key)

        game_history.put()

        # load OtheloPlayer entities
        players = ndb.get_multi(othello_players_keys)
        for p in players:
            p.gameKeys.append(g_key)
        ndb.put_multi(players)
        print "Added game to player game keys"

        return new_game.game_id