Exemple #1
0
  def __init__( self ):
    webapp.RequestHandler.__init__( self )

    self.log = getLogger()

    self.dao = DAO()
    
    self.xml_gen = XMLGenerator()
Exemple #2
0
  def __init__( self ):
    webapp.RequestHandler.__init__( self )

    self.log = getLogger()
    self.dao = DAO()  
    self.config = ConfigObj("Config/skajserver.cfg")
Exemple #3
0
class GameHandler( webapp.RequestHandler ):
    
  def __init__( self ):
    webapp.RequestHandler.__init__( self )

    self.log = getLogger()
    self.dao = DAO()  
    self.config = ConfigObj("Config/skajserver.cfg")


  def handleCreateGame(self, url):
    """
    Create a game... ..   DUH
    NO SECURITY YET.....
    """
    response = "sorry... operation failed"
    data = "<game>FAILED</game>"

    try:
      self.log.debug("GameHandler:handleCreateGame start")

      name = self.request.get("name")    
      password = self.request.get("password")
      num_players = int( self.request.get("num_players") )
      map_name = self.request.get("map_name", "default")
     
      (stat, game) =  self.dao.createGame( name, password, num_players, map_name )
          
      if stat == StatusCodes.SUCCESSFUL:
        self.log.debug("SUCCESSFULLY CREATED GAME " + name )
        data = "<game name=%s></game>"%( name )

    except:
      self.log.error("GameHandler:handleCreateGame  ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data )

  def handleModifyGameState(self, url):
    """
    Create a game... ..   DUH
    NO SECURITY YET.....
    """
    response = "sorry... operation failed"
    data = "<game>FAILED</game>"

    try:
      self.log.debug("GameHandler:handleModifyGameState start")

      name = self.request.get("name")    
      state = self.request.get("state")
  
      
      (stat, game) =  self.dao.modifyGameState( name, state )
          
      if stat == StatusCodes.SUCCESSFUL:
        self.log.debug("SUCCESSFULLY MODIFIED STATE GAME " + name )
        data = "<game name=%s></game>"%( name )

    except:
      self.log.error("GameHandler:handleModifyGameState  ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data )

  # will eventually go into a proper object for this.
  def populateGame( self, game ):
    """
    Assigns countries to players and does initial populating of armies.
    """

    # get list of countries for map name
    game_name = game.game_name
    (game_status, countries_list) = self.dao.getMasterCountries( game.map_name )

    # randomize list.
    random.shuffle( countries_list )

    # get players.
    (players_status, players_list) = self.dao.getAllPlayersForGame( game.game_name )

    # assign equals num of countries to players
    starting_armies = int( self.config["starting_armies"] )
    starting_countries = int( self.config["starting_countries"] )

    # need to check if enough countries.
    if len( players_list) * starting_countries > countries_list:
      self.log.error("NOT ENOUGH COUNTRIES FOR NUMBER OF PLAYERS")

    else:
      for player in players_list:

        for i in xrange( starting_countries ):
          country_name = countries_list.pop()
          self.dao.createCountryForPlayer( game_name, player.user_name, country_name, starting_armies )
      
  def handleStartGame(self, url):
    """
    Create a game... ..   DUH
    NO SECURITY YET.....
    """
    response = "sorry... operation failed"
    data = "<game>FAILED</game>"

    try:
      self.log.debug("GameHandler:handleStartGame start")

      name = self.request.get("name")    
 
      (stat, game) =  self.dao.modifyGameState( name, "STARTED" )
          
      if stat == StatusCodes.SUCCESSFUL:
        self.log.debug("SUCCESSFULLY MODIFIED STATE GAME " + name )

        # populate game with countries.
        self.populateGame( game )
        
        data = "<game name=%s>%s</game>"%( name, "STARTED" )

    except:
      self.log.error("GameHandler:handleStartGame  ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data )

  def handleJoinGame(self, url):
    """
    Join a game... ..   DUH
    NO SECURITY YET.....

    1) Get username
    2) get token
    3) authenticate
    4) get game
    5) create player for game
    """
    response = "sorry... operation failed"
    data = "<game>FAILED</game>"

    try:
      self.log.debug("GameHandler:handleJoinGame start")

      user_name = self.request.get("username")
      token = self.request.get("token")
      state = self.request.get("state")
      game_name = self.request.get("gamename")
      
      ( stat, user ) =  self.dao.authenticateUser( user_name, token )

      if stat == StatusCodes.SUCCESSFUL:
        (game_status, game) = self.dao.getGame( game_name )

        if game_status == StatusCodes.SUCCESSFUL and game != None:

          # check if user has already joined the game.
          ( stat, player ) = self.dao.getPlayerForGame( user_name, game )
          
          if stat != StatusCodes.PLAYER_NOT_IN_GAME:

            # create the player.
            ( player_status, player) = self.dao.createPlayer( user, game )
            if player_status == StatusCodes.SUCCESSFUL:
              data = "<game>JOINED</game>"

    except:
      self.log.error("GameHandler:handleJoinGame  ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data )

  def get(self, url):
    """
    handle various User based gets
    """

    self.log.debug("URL is " + url)
    
    path = self.request.path
    self.log.debug("path is " + path)

    # dict string --> method.
    # FIXME
    if path == "/1/creategame":
      self.handleCreateGame( url )
    else:
      if path == "/1/modifygamestate":
        self.handleModifyGameState( url )
      else:
        if path == "/1/joingame":
          self.handleJoinGame( url )
        else:
          if path == "/1/startgame":
            self.handleStartGame( url )
          else:
            if path == "/foo":
              self.dao.generateCountryMaster()
Exemple #4
0
class UserHandler( webapp.RequestHandler ):
    
  def __init__( self ):
    webapp.RequestHandler.__init__( self )

    self.log = getLogger()
    self.dao = DAO()  
    self.config = ConfigObj("Config/skajserver.cfg")

  def handleLogin(self, url):
    """
    Create a user... ..   DUH
    NO SECURITY YET.....
    MARKS the user as logged in (on the server?)
    """
    response = "sorry... operation failed"
    data = "<user>FAILED</user>"

    try:
      
      self.log.debug("UserHandler:handleLogin")

      user_name = self.request.get("user_name")    
      password = self.request.get("password")    

      self.log.debug("user URL is " + user_name )

      (stat, user ) = self.dao.getUserWithPassword( user_name, password )

      print "stat is "+str(stat)

      #print "fooooooooooooo"

      if stat == StatusCodes.SUCCESSFUL:
        self.log.debug("SUCCESSFULLY RETRIEVED USER " + user_name )

        # get token.
        new_token = str( random.randrange(0,1000000000) )
        user.token = new_token
        
        # store it 
        self.dao.storeUser( user)

        data = "<user id=%s token=%s></user>"%( user_name, new_token )

    except:
      self.log.error("UserHandler:handleLogin ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data )

  def handleGetUser(self, url):
    """
    Retrieve User.
    NO SECURITY YET.....
    MARKS the user as logged in (on the server?)
    """
    response = "sorry... operation failed"
    data = "<user>FAILED</user>"

    try:
      
      self.log.debug("UserHandler:handleGetUser")

      user_name = self.request.get("user_name")    
      password = self.request.get("password")    

      self.log.debug("user URL is " + user_name )

      (stat, user ) = self.dao.getUserWithPassword( user_name, password )

      print "stat is "+str(stat)

      #print "fooooooooooooo"

      if stat == StatusCodes.SUCCESSFUL:
        self.log.debug("SUCCESSFULLY RETRIEVED USER " + user_name )


        data = "<user id=%s token=%s></user>"%( user_name, user.token )

    except:
      self.log.error("UserHandler:handleGetUser ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data ) 
            
  def handleCreateUser(self, url):
    """
    Create a user... ..   DUH
    NO SECURITY YET.....
    """
    response = "sorry... operation failed"
    data = "<user>FAILED</user>"

    try:
      
      d = str(dir(self.request ))
      self.log.debug("D " + d )
      self.log.debug("path "+self.request.path)
      self.log.debug("path_url " + self.request.path_url)
      self.log.debug("UserHandler:handleCreateUser")
      data = "success2"
      user_name = self.request.get("user_name")    
      password = self.request.get("password")    
      data = "success3"
      self.log.debug("user URL is " + user_name )

      (status, user ) = self.dao.createUser( user_name, password )
      data = "success4"
      
      #print "fooooooooooooo"

      if status == StatusCodes.SUCCESSFUL:
        self.log.debug("SUCCESSFULLY CREATED USER " + user_name )
        data = "<user name=%s></user>"%(user_name)

    except:
      self.log.error("UserHandler:handleCreateUser ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data )

  def get(self, url):
    """
    handle various User based gets
    """

    self.log.debug("URL is " + url)
    
    path = self.request.path
    self.log.debug("path is " + path)

    # dict string --> method.
    # FIXME
    if path == "/1/createuser":
      self.handleCreateUser( url )
    else:
      if path == "/1/login":
        self.handleLogin( url )
      else:
        if path == "/1/getuser":
          self.handleGetUser( url )
class PlayerHandler( webapp.RequestHandler ):
    
  def __init__( self ):
    webapp.RequestHandler.__init__( self )

    self.log = getLogger()
    self.dao = DAO()  
    self.config = ConfigObj("Config/skajserver.cfg")

  def createPlayerHandler(self, url):
    """
    create player based on user that is logged in. 
    """
    response = "sorry... operation failed"
    data = "<player>FAILED</player>"

    try:
      
      self.log.debug("PlayerHandler:createPlayerHandler")

      user_name = self.request.get("user_name")    
      token = self.request.get("token")    
      
      # need to know which game we're joining.
      game_name = self.request.get("game_name")

      if self.dao.authenticateUser( user_name, token ):

        # check if user has already joined the game.
        ( stat, player ) = self.dao.getPlayerForGame( user_name, game_name )
        
        if stat == StatusCodes.PLAYER_NOT_IN_GAME:

          self.log.debug("player does not exist in game")
          ( user_status, user) = self.dao.getUser( user_name )

          if user_status == StatusCodes.SUCCESSFUL:

            self.log.debug("have user successfully")

            # get the game.
            ( game_stat, game) = self.dao.getGame( game_name )

            self.log.debug("game name is " + game.game_name)
            
            # create the player.
            player = self.dao.createPlayer( user, game )


            data = "<player id=%s game_name=%s></user>"%( user_name, game_name )
        else:
          self.log.debug("player already in game")
          data = "<player id=%s game_name=%s></user>"%( user_name, game_name )
    except:
      self.log.error("PlayerHandler:createPlayerHandler ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data )


  def getPlayerHandlerForGame( self, url):
    """
    Retrieve User.
    NO SECURITY YET.....
    MARKS the user as logged in (on the server?)
    """
    response = "sorry... operation failed"
    data = "<player>FAILED</player>"

    try:
      
      self.log.debug("PlayerHandler:getPlayerHandlerForGame")

      user_name = self.request.get("user_name")    
      token = self.request.get("token")    
      game_name = self.request.get("game_name")

      (stat, player ) = self.dao.getPlayerForGame( user_name, game_name )


      if stat == StatusCodes.SUCCESSFUL:
        self.log.debug("SUCCESSFULLY RETRIEVED PLAYER " + user_name )
        data = "<player id=%s game_name=%s></user>"%( user_name, game_name )

    except:
      self.log.error("PlayerHandler:getPlayerHandlerForGame ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data ) 
            


  def get(self, url):
    """
    handle various User based gets
    """

    self.log.debug("URL is " + url)
    
    path = self.request.path
    self.log.debug("path is " + path)

    # dict string --> method.
    # FIXME
    if path == "/1/createplayer":
      self.createPlayerHandler( url )
    else:
      if path == "/1/getplayer":
        self.getPlayerHandlerForGame( url )
class ActionHandler( webapp.RequestHandler ):
    
  def __init__( self ):
    webapp.RequestHandler.__init__( self )

    self.log = getLogger()
    self.dao = DAO()  
    self.config = ConfigObj("Config/skajserver.cfg")


  def canAttack( self, attacking_country, attacked_country ):
    """
    Confirms if countries can attack eachother.
    """

    # FIXME
    return true
  
  def attack( self, attacking_country, attacked_country ):
    """
    Confirms if countries can attack eachother.
    """

    # FIXME
    return true


  def handleAttack(self, url):
    """
    Create a game... ..   DUH
    NO SECURITY YET.....
    """
    response = "sorry... operation failed"
    data = "<action>FAILED</action>"

    try:
      self.log.debug("ActionHandler:handleAttack start")

      name = self.request.get("name")    
      token = self.request.get("token")

      if self.dao.authenticateUser( name, token):
      
        # get country doing the attacking        
        attacking_country = self.request.get("attacking_name")
                
        # get country being attacked.
        attacked_country = self.request.get("attacked_name")

        # confirm they're near eachother.
        if self.canAttack( attacking_country, attacked_country ):

          # attack
          self.attack( attacking_country, attacked_country )

        
    except:
      self.log.error("GameHandler:handleCreateGame  ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data )

  def handlePopulate(self, url):
    """
    Create a game... ..   DUH
    NO SECURITY YET.....
    """
    response = "sorry... operation failed"
    data = "<action>FAILED</action>"

    try:
      self.log.debug("ActionHandler:handlePopulate start")

      name = self.request.get("name")    
      token = self.request.get("token")

      if self.dao.authenticateUser( name, token):
      
        # get country doing the attacking        
        country_name = self.request.get("country")
                
        # get country being attacked.
        attacked_country = self.request.get("attacked_name")

        # confirm they're near eachother.
        if self.canAttack( attacking_country, attacked_country ):

    except:
      self.log.error("GameHandler:handlePopulate  ex " + traceback.format_exc()  ) 
      
    self.response.out.write( data )

  def get(self, url):
    """
    handle various User based gets
    """

    self.log.debug("URL is " + url)
    
    path = self.request.path
    self.log.debug("path is " + path)

    # dict string --> method.
    # FIXME
    if path == "/1/attack":
      self.handleAttack( url )
    else:
      if path == "/1/populate":
        self.handleModifyGameState( url )
Exemple #7
0
class APIHandler(webapp.RequestHandler):
    

  def __init__( self ):
    webapp.RequestHandler.__init__( self )

    self.log = getLogger()

    self.dao = DAO()
    
    self.xml_gen = XMLGenerator()
        

        
  def decode_short_url(self, url ):
    """
    Decodes short url.
    This is really duplicated code, which is bad. 
    But its really only a 1 liner.   
    """

    full_url = None

    self.log.info("APIHandler::decode_short_url start")
    
    try:


        self.log.debug("short url " + str( url ) )
        
        if url != None and url != "":
          full_url = self.dao.get_long_url( short_url )
        
          self.log.debug("long url " + str( full_url ) )
          
        
    except:
      self.log.error("APIHandler::decode_short_url ex " + traceback.format_exc() )
    
    return full_url  
      
                      
  def get(self, command ):
    """
    Can issue 3 types of commands.
    1) Get a LONG_URL from a short url
    2) Assign a LONG_URL to a given short_url
    3) Assign a LONG_URL to a random url.   
    """

    try:

      self.log.debug("command is " + str( command ) )
      
      if command == "get":
        url = self.request.get("short_url")
        
        if url != None and url != "":
          full_url = self.dao.get_long_url( url )
        
          if full_url != None and full_url != "":
            res = self.xml_gen.generate_successful_get( full_url )
          else:
            res = self.xml_gen.generate_unsuccessful_get( url )
            
          self.response.out.write( res )
        
      else:
        if command == "set":
          short_url = self.request.get("short_url")
          full_url = self.request.get("full_url")
          creator = self.request.get("creator")
          tags = self.request.get("tags")
          
          if short_url != None and short_url != "" and full_url != None and full_url != "" and creator != None and creator != "" :
            
            result_url, status_code = self.dao.replace_entry( short_url, full_url, creator, tags )
               
            if status_code == StatusCodes.SUCCESSFUL:
              res = self.xml_gen.generate_successful_set(  )
            else:
              res = self.xml_gen.generate_unsuccessful_set( status_code )
              
            self.response.out.write( res )

        
        else:
          if command == "list":
            creator = self.request.get("creator")
            
            if creator != None and creator != "":
              entry_list = self.dao.get_all_entries_for_creator( creator )
            
              self.log.debug("entry list " + str( entry_list ) )
              
              if entry_list != None and entry_list != [] :
                res = self.xml_gen.generate_successful_list( entry_list)
              else:
                res = self.xml_gen.generate_unsuccessful_List( creator )
                
              self.response.out.write( res )
            
    except:
      self.log.error("APIHandler::get ex " + traceback.format_exc() )