예제 #1
0
 def testChangePassword(self):
   oldTime = PlayerPassword.objects.get(player__id=3).time_set
   newPassword = "******"
   response = self.doPost('/udj/0_6/players/3/password', {'password': newPassword})
   self.assertEqual(response.status_code, 200, "Error: " + response.content)
   playerPassword = PlayerPassword.objects.get(player__id=3)
   self.assertEqual(playerPassword.password_hash, hashPlayerPassword(newPassword))
   self.assertTrue(oldTime < playerPassword.time_set)
예제 #2
0
 def testSetPassword(self):
     newPassword = '******'
     response = self.doPost('/udj/0_6/players/1/password',
                            {'password': newPassword})
     self.assertEqual(response.status_code, 200)
     playerPassword = PlayerPassword.objects.get(player__id=1)
     self.assertEqual(playerPassword.password_hash,
                      hashPlayerPassword(newPassword))
예제 #3
0
def createPlayer(request):
  user = getUserForTicket(request)
  try:
    newPlayerJSON = json.loads(request.raw_post_data)
  except ValueError:
    return HttpResponseBadRequest('Bad JSON')

  #Ensure the name attribute was provided with the JSON
  try:
    newPlayerName = newPlayerJSON['name']
  except KeyError:
    return HttpResponseBadRequest('No name given')

  #Determine which sorting algorithm to use
  if 'sorting_algorithm_id' in newPlayerJSON:
    try:
      sortingAlgo = SortingAlgorithm.objects.get(pk=newPlayerJSON['sorting_algorithm_id'])
    except ObjectDoesNotExist:
      toReturn = HttpResponseNotFound()
      toReturn[MISSING_RESOURCE_HEADER] = 'sorting-algorithm'
      return toReturn
  else:
    try:
      sortingAlgo = SortingAlgorithm.objects.get(function_name=default_sorting_algo)
    except ObjectDoesNotExist:
      raise ImproperlyConfigured('Default sorting algorithm is not in database')


  #Ensure that the suers doesn't already have a player with the given name
  conflictingPlayer = Player.objects.filter(owning_user=user, name=newPlayerName)
  if conflictingPlayer.exists():
    return HttpResponse('A player with that name already exists', status=409)

  #Create and save new player
  newPlayer = Player(
      owning_user=user,
      name=newPlayerName,
      sorting_algo=sortingAlgo)
  newPlayer.save()

  #If password provided, create and save password
  if 'password' in newPlayerJSON:
    PlayerPassword(player=newPlayer, password_hash=hashPlayerPassword(newPlayerJSON['password'])).save()

  #If locaiton provided, geocode it and save it
  if 'location' in newPlayerJSON:
    location = newPlayerJSON['location']
    if isValidLocation(location):
      try:
        setPlayerLocation(location, newPlayer)
      except LocationNotFoundError as e:
        return HttpResponseBadRequest('Location not found. Geocoder error: ' + str(e))
    else:
      return HttpResponseBadRequest('Bad location')

  return HttpJSONResponse(json.dumps(newPlayer, cls=UDJEncoder), status=201)
예제 #4
0
 def testChangePassword(self):
     oldTime = PlayerPassword.objects.get(player__id=3).time_set
     newPassword = "******"
     response = self.doPost('/udj/0_6/players/3/password',
                            {'password': newPassword})
     self.assertEqual(response.status_code, 200,
                      "Error: " + response.content)
     playerPassword = PlayerPassword.objects.get(player__id=3)
     self.assertEqual(playerPassword.password_hash,
                      hashPlayerPassword(newPassword))
     self.assertTrue(oldTime < playerPassword.time_set)
예제 #5
0
def participateWithPlayer(request, player_id, player):

  def onSuccessfulPlayerAuth(activePlayer, user):
    #very important to check if they're banned or player is full first.
    #otherwise we might might mark them as actually participating
    if Participant.objects.filter(user=user, player=activePlayer, ban_flag=True).exists():
      toReturn = HttpResponseForbidden()
      toReturn[FORBIDDEN_REASON_HEADER] = 'banned'
      return toReturn
    if activePlayer.isFull():
      toReturn = HttpResponseForbidden()
      toReturn[FORBIDDEN_REASON_HEADER] = 'player-full'
      return toReturn

    obj, created = Participant.objects.get_or_create(player=activePlayer, user=user)
    if not created:
      obj.time_last_interation = datetime.now()
      obj.kick_flag = False
      obj.logout_flag = False
      obj.save()

    return HttpResponse(status=201)


  user = getUserForTicket(request)
  playerPassword = PlayerPassword.objects.filter(player=player)
  if playerPassword.exists():
    hashedPassword = ""
    if not request.META.has_key('CONTENT_TYPE'):
      return HttpResponseBadRequest("must specify content type")
    elif request.META['CONTENT_TYPE'] != 'text/json':
      return HttpResponse("must send json", status=415)
    elif request.raw_post_data == '':
      return HttpResponseBadRequest("Bad JSON")
    try:
      password_json = json.loads(request.raw_post_data)
      password = password_json['password']
      hashedPassword = hashPlayerPassword(password)
    except ValueError:
      return HttpResponseBadRequest('Bad JSON')

    if hashedPassword == playerPassword[0].password_hash:
      return onSuccessfulPlayerAuth(player, user)


    toReturn = HttpResponse(status=401)
    toReturn['WWW-Authenticate'] = 'player-password'
    return toReturn
  else:
    return onSuccessfulPlayerAuth(player, user)
예제 #6
0
def setPlayerPassword(request, player_id, player):
    givenPassword = request.POST['password']
    if givenPassword == '':
        return HttpResponseBadRequest("Bad password")

    hashedPassword = hashPlayerPassword(givenPassword)

    playerPassword, created = PlayerPassword.objects.get_or_create(
        player=player, defaults={'password_hash': hashedPassword})
    if not created:
        playerPassword.password_hash = hashedPassword
        playerPassword.save()

    return HttpResponse()
def setPlayerPassword(request, player_id, player):
  givenPassword = request.POST['password']
  if givenPassword == '':
    return HttpResponseBadRequest("Bad password")

  hashedPassword = hashPlayerPassword(givenPassword)

  playerPassword , created = PlayerPassword.objects.get_or_create(
      player=player,
      defaults={'password_hash': hashedPassword})
  if not created:
    playerPassword.password_hash = hashedPassword
    playerPassword.save()

  return HttpResponse()
예제 #8
0
  def testCreatePasswordPlayer(self):
    playerName = "Yunyoung Player"
    password = '******'
    passwordHash = hashPlayerPassword(password)
    payload = {'name' : playerName, 'password' : password}
    response = self.doJSONPut('/udj/0_6/players/player', json.dumps(payload))
    self.assertEqual(response.status_code, 201, "Error: " + response.content)
    self.isJSONResponse(response)
    givenPlayerId = json.loads(response.content)['player_id']
    addedPlayer = Player.objects.get(pk=givenPlayerId)
    self.assertEqual(addedPlayer.name, playerName)
    self.assertEqual(addedPlayer.owning_user.id, 7)
    self.assertFalse(PlayerLocation.objects.filter(player=addedPlayer).exists())

    addedPassword = PlayerPassword.objects.get(player=addedPlayer)
    self.assertEqual(addedPassword.password_hash, passwordHash)
예제 #9
0
    def testCreatePasswordPlayer(self):
        playerName = "Yunyoung Player"
        password = "******"
        passwordHash = hashPlayerPassword(password)
        payload = {"name": playerName, "password": password}
        response = self.doJSONPut("/udj/0_6/players/player", json.dumps(payload))
        self.assertEqual(response.status_code, 201, "Error: " + response.content)
        self.isJSONResponse(response)
        givenPlayerId = json.loads(response.content)["id"]
        addedPlayer = Player.objects.get(pk=givenPlayerId)
        self.assertEqual(addedPlayer.name, playerName)
        self.assertEqual(addedPlayer.owning_user.id, 7)
        self.assertFalse(PlayerLocation.objects.filter(player=addedPlayer).exists())

        addedPassword = PlayerPassword.objects.get(player=addedPlayer)
        self.assertEqual(addedPassword.password_hash, passwordHash)
        self.verify_libs_created(addedPlayer)
        self.verify_permissions_set(addedPlayer)
예제 #10
0
    def testCreatePasswordPlayer(self):
        playerName = "Yunyoung Player"
        password = '******'
        passwordHash = hashPlayerPassword(password)
        payload = {'name': playerName, 'password': password}
        response = self.doJSONPut('/udj/0_6/players/player',
                                  json.dumps(payload))
        self.assertEqual(response.status_code, 201,
                         "Error: " + response.content)
        self.isJSONResponse(response)
        givenPlayerId = json.loads(response.content)['player_id']
        addedPlayer = Player.objects.get(pk=givenPlayerId)
        self.assertEqual(addedPlayer.name, playerName)
        self.assertEqual(addedPlayer.owning_user.id, 7)
        self.assertFalse(
            PlayerLocation.objects.filter(player=addedPlayer).exists())

        addedPassword = PlayerPassword.objects.get(player=addedPlayer)
        self.assertEqual(addedPassword.password_hash, passwordHash)
예제 #11
0
def participateWithPlayer(request, player_id, player):
    def onSuccessfulPlayerAuth(activePlayer, user):
        #very important to check if they're banned or player is full first.
        #otherwise we might might mark them as actually participating
        if Participant.objects.filter(user=user,
                                      player=activePlayer,
                                      ban_flag=True).exists():
            toReturn = HttpResponseForbidden()
            toReturn[FORBIDDEN_REASON_HEADER] = 'banned'
            return toReturn
        if activePlayer.isFull():
            toReturn = HttpResponseForbidden()
            toReturn[FORBIDDEN_REASON_HEADER] = 'player-full'
            return toReturn

        obj, created = Participant.objects.get_or_create(player=activePlayer,
                                                         user=user)
        if not created:
            obj.time_last_interation = datetime.now()
            obj.kick_flag = False
            obj.logout_flag = False
            obj.save()

        return HttpResponse(status=201)

    user = getUserForTicket(request)
    playerPassword = PlayerPassword.objects.filter(player=player)
    if playerPassword.exists():
        if DJANGO_PLAYER_PASSWORD_HEADER in request.META:
            hashedPassword = hashPlayerPassword(
                request.META[DJANGO_PLAYER_PASSWORD_HEADER])
            if hashedPassword == playerPassword[0].password_hash:
                return onSuccessfulPlayerAuth(player, user)

        toReturn = HttpResponse(status=401)
        toReturn['WWW-Authenticate'] = 'player-password'
        return toReturn
    else:
        return onSuccessfulPlayerAuth(player, user)
예제 #12
0
def participateWithPlayer(request, player_id, player):

  def onSuccessfulPlayerAuth(activePlayer, user):
    #very important to check if they're banned or player is full first.
    #otherwise we might might mark them as actually participating
    if Participant.objects.filter(user=user, player=activePlayer, ban_flag=True).exists():
      toReturn = HttpResponseForbidden()
      toReturn[FORBIDDEN_REASON_HEADER] = 'banned'
      return toReturn
    if activePlayer.isFull():
      toReturn = HttpResponseForbidden()
      toReturn[FORBIDDEN_REASON_HEADER] = 'player-full'
      return toReturn

    obj, created = Participant.objects.get_or_create(player=activePlayer, user=user)
    if not created:
      obj.time_last_interation = datetime.now()
      obj.kick_flag = False
      obj.logout_flag = False
      obj.save()

    return HttpResponse(status=201)


  user = getUserForTicket(request)
  playerPassword = PlayerPassword.objects.filter(player=player)
  if playerPassword.exists():
    if DJANGO_PLAYER_PASSWORD_HEADER in request.META:
      hashedPassword = hashPlayerPassword(request.META[DJANGO_PLAYER_PASSWORD_HEADER])
      if hashedPassword == playerPassword[0].password_hash:
        return onSuccessfulPlayerAuth(player, user)

    toReturn = HttpResponse(status=401)
    toReturn['WWW-Authenticate'] = 'player-password'
    return toReturn
  else:
    return onSuccessfulPlayerAuth(player, user)
예제 #13
0
 def testSetPassword(self):
   newPassword = '******'
   response = self.doPost('/udj/0_6/players/1/password', {'password': newPassword})
   self.assertEqual(response.status_code, 200)
   playerPassword = PlayerPassword.objects.get(player__id=1)
   self.assertEqual(playerPassword.password_hash, hashPlayerPassword(newPassword))
예제 #14
0
def createPlayer(request):
  user = getUserForTicket(request)
  try:
    newPlayerJSON = json.loads(request.raw_post_data)
  except ValueError:
    return HttpResponseBadRequest('Bad JSON')

  #Ensure the name attribute was provided with the JSON
  try:
    newPlayerName = newPlayerJSON['name']
  except KeyError:
    return HttpResponseBadRequest('No name given')

  #Determine which sorting algorithm to use
  if 'sorting_algorithm_id' in newPlayerJSON:
    try:
      sortingAlgo = SortingAlgorithm.objects.get(pk=newPlayerJSON['sorting_algorithm_id'])
    except ObjectDoesNotExist:
      toReturn = HttpResponseNotFound()
      toReturn[MISSING_RESOURCE_HEADER] = 'sorting-algorithm'
      return toReturn
  else:
    try:
      sortingAlgo = SortingAlgorithm.objects.get(function_name=DEFAULT_SORTING_ALGO)
    except ObjectDoesNotExist:
      raise ImproperlyConfigured('Default sorting algorithm is not in database')


  #Ensure that the suers doesn't already have a player with the given name
  conflictingPlayer = Player.objects.filter(owning_user=user, name=newPlayerName)
  if conflictingPlayer.exists():
    return HttpResponse('A player with that name already exists', status=409)

  #Create and save new player
  newPlayer = Player(
      owning_user=user,
      name=newPlayerName,
      sorting_algo=sortingAlgo)
  newPlayer.save()

  #If password provided, create and save password
  if 'password' in newPlayerJSON:
    PlayerPassword(player=newPlayer, password_hash=hashPlayerPassword(newPlayerJSON['password'])).save()

  #If locaiton provided, geocode it and save it
  if 'location' in newPlayerJSON:
    location = newPlayerJSON['location']
    if isValidLocation(location):
      try:
        setPlayerLocation(location, newPlayer)
      except LocationNotFoundError as e:
        return HttpResponseBadRequest('Location not found. Geocoder error: ' + str(e))
    else:
      return HttpResponseBadRequest('Bad location')

  #create default library for new player
  new_library = Library(name="Default library", description="default library", pub_key="")
  new_library.save()
  new_default = DefaultLibrary(library=new_library, player=newPlayer)
  new_default.save()
  new_owned = OwnedLibrary(library=new_library, owner=user)
  new_owned.save()
  new_associated = AssociatedLibrary(library=new_library, player=newPlayer)
  new_associated.save()

  #Create Owner Permissions Group
  owner_group = PlayerPermissionGroup(player=newPlayer, name="owner")
  owner_group.save()
  owner_group.add_member(user)

  #Create Admin Permissions Group
  admin_group = PlayerPermissionGroup(player=newPlayer, name="admin")
  admin_group.save()

  #Add owner_group and admin group to select permissions
  set_default_player_permissions(newPlayer, owner_group)
  set_default_player_permissions(newPlayer, admin_group)

  return HttpJSONResponse(json.dumps(newPlayer, cls=UDJEncoder), status=201)
예제 #15
0
def createPlayer(request):
    user = getUserForTicket(request)
    try:
        newPlayerJSON = json.loads(request.raw_post_data)
    except ValueError:
        return HttpResponseBadRequest('Bad JSON')

    #Ensure the name attribute was provided with the JSON
    try:
        newPlayerName = newPlayerJSON['name']
    except KeyError:
        return HttpResponseBadRequest('No name given')

    #Determine which sorting algorithm to use
    if 'sorting_algorithm_id' in newPlayerJSON:
        try:
            sortingAlgo = SortingAlgorithm.objects.get(
                pk=newPlayerJSON['sorting_algorithm_id'])
        except ObjectDoesNotExist:
            toReturn = HttpResponseNotFound()
            toReturn[MISSING_RESOURCE_HEADER] = 'sorting_algorithm'
            return toReturn
    else:
        try:
            sortingAlgo = SortingAlgorithm.objects.get(
                function_name=default_sorting_algo)
        except ObjectDoesNotExist:
            raise ImproperlyConfigured(
                'Default sorting algorithm is not in database')

    #Determine external library
    externalLib = None
    if 'external_library_id' in newPlayerJSON:
        try:
            externalLib = ExternalLibrary.objects.get(
                pk=newPlayerJSON['external_library_id'])
        except ObjectDoesNotExist:
            toReturn = HttpResponseNotFound()
            toReturn[MISSING_RESOURCE_HEADER] = 'external_library'
            return toReturn

    #Ensure that the suers doesn't already have a player with the given name
    conflictingPlayer = Player.objects.filter(owning_user=user,
                                              name=newPlayerName)
    if conflictingPlayer.exists():
        return HttpResponse('A player with that name already exists',
                            status=409)

    #Create and save new player
    newPlayer = Player(owning_user=user,
                       name=newPlayerName,
                       sorting_algo=sortingAlgo,
                       external_library=externalLib)
    newPlayer.save()

    #If password provided, create and save password
    if 'password' in newPlayerJSON:
        PlayerPassword(player=newPlayer,
                       password_hash=hashPlayerPassword(
                           newPlayerJSON['password'])).save()

    #If locaiton provided, geocode it and save it
    if 'location' in newPlayerJSON:
        location = newPlayerJSON['location']
        if isValidLocation(location):
            try:
                setPlayerLocation(location, newPlayer)
            except LocationNotFoundError:
                return HttpResponseBadRequest('Location not found')
        else:
            return HttpResponseBadRequest('Bad location')

    return HttpJSONResponse(json.dumps({'player_id': newPlayer.id}),
                            status=201)