def test_retrieve_rejected(self): # let's create two invites first user_three = User(username='******', email='*****@*****.**') user_three.put() invite_one = Invite(to_player=self.user_one.key, to_player_name=self.user_one.username, from_player=self.user_two.key, from_player_name=self.user_two.username) invite_two = Invite(to_player=self.user_one.key, to_player_name=self.user_one.username, from_player=user_three.key, from_player_name=user_three.username, rejected=True) invite_one.put() invite_two.put() # created. Let's retrieve the invites resp = self.testapp.post( '/_ah/spi/RetrieveInviteHandler.retrieve_invite', params=json.dumps({"jwt_token": self.jwt_token_player_one}), content_type='application/json') self.assertEqual( len(json.loads(resp.body)), 1, 'One invite was not retrieved after creating two and cancelling one' )
def execute(self): """ 1 - Will create the invite in database 2 - Will insert the sender as attendee1 3 - If is anonymous will send the invite for confirmation to the organizer 4 - Else will post the invite to Voiceflows """ invite = Invite() copy_over(self, invite) invite.put() index_invite(invite) addOrganizerCommand = self._get_organizer_attendee(invite) addOrganizerCommand.execute() if not self.user_object: '''is anonymous''' command = SendConfirmationInviteToOrganizerCommand(invite, self.host) command.execute() return invite.unique_id command = PostInviteToVoiceflowsCommand(invite) command.execute() return invite.unique_id
def test_retrieve_invite(self): # let's create two invites first user_three = User(username='******', email='*****@*****.**') user_three.put() invite_one = Invite(to_player=self.user_one.key, to_player_name=self.user_one.username, from_player=self.user_two.key, from_player_name=self.user_two.username) invite_two = Invite(to_player=self.user_one.key, to_player_name=self.user_one.username, from_player=user_three.key, from_player_name=user_three.username) invite_one.put() invite_two.put() # created. Let's retrieve the invites resp = self.testapp.post( '/_ah/spi/RetrieveInviteHandler.retrieve_invite', params=json.dumps({"jwt_token": self.jwt_token_player_one}), content_type='application/json') resp = json.loads(resp.body) self.assertEqual(len(resp['invites']), 2, 'Two invites were not retrieved after being created')
def post(self): title_invite = self.request.get('title') try: count_invite = int(self.request.get('count')) except ValueError: count_invite = 5 url_invite = hashlib.md5(u'%s-%s' % (datetime.now(), count_invite)).hexdigest() invite = Invite(title=title_invite, url=url_invite, count=count_invite) invite.put() self.redirect('/invite_view')
def post(self): name = self.request.get('name') email = self.request.get('email') invite_code = uuid.uuid4().hex[:invite_code_len].upper() while(Invite.query(Invite.code==invite_code).get()): invite_code = uuid.uuid4().hex[:invite_code_len].upper() invite = Invite(code=invite_code, name=name, email=email) invite.put() context = { 'invite': invite, 'invite_url': webapp2.uri_for('invite', invite_code=invite.code) } path = os.path.join(os.path.dirname(__file__), './templates/admin/index.html') self.response.out.write(template.render(path, context))
def test_accept_invite(self): # let's create invite first invite_one = Invite(to_player=self.user_one.key, to_player_name=self.user_one.username, from_player=self.user_two.key, from_player_name=self.user_two.username) invite_one.put() resp = self.testapp.post_json( '/_ah/spi/CreateInviteHandler.create_invite', { "jwt_token": self.jwt_token_player_one, "player_two_key": self.user_two.key.urlsafe() }) self.assertIn('200', resp.status)
def test_send_invite_already_exists(self): # try to send an invite to a user that already has an invite pending please # start by creating the invite invite = Invite(to_player=self.user_one.key, to_player_name=self.user_one.username, from_player=self.user_two.key, from_player_name=self.user_two.username) invite.put() # invite created, so let's have user_two try to send an invite to user_one resp = self.testapp.post('/_ah/spi/CreateInviteHandler.create_invite', params=json.dumps({ "jwt_token": self.jwt_token_player_two, "player_two_key": self.user_one.key.urlsafe() }), content_type='application/json', expect_errors=True) self.assertIn('400', str(resp))
def create_invite(self, request): """ JWT required. Provided the user does not have an active game with the provided player two, creates an invite for player two. If player two has already invited the user to play a game, accepts the invite and creates a game for them. If a game is created, the user will be able to retrieve it from game endpoint and begin playing. """ player_two_key = request.player_two_key payload = token.decode_jwt(request.jwt_token) try: user = Key(urlsafe=payload.get('user_key')).get() # grab player two please player_two = Key(urlsafe=player_two_key).get() except TypeError: raise endpoints.BadRequestException('key was unable to be retrieved') except ProtocolBufferDecodeError: raise endpoints.BadRequestException('key was unable to be retrieved') except Exception as e: raise endpoints.InternalServerErrorException('An error occurred when attempting to take the turn') if player_two is None: raise endpoints.BadRequestException('Player does not exist') # awesome we have player one and two game = Game.query( Game.player_one == user.key, Game.player_two == player_two.key, Game.player_one_completed == False, Game.player_two_completed == False).get() if game is None: game = Game.query(Game.player_one == player_two.key, Game.player_two == user.key, Game.player_one_completed == False, Game.player_two_completed == False).get() # if a game exists between these users, they need to finish it first please if game is not None: # not entirely certain what to set here, as the request wasn't necessarily wrong, but the # user already has a game with player_two raise endpoints.BadRequestException("An existing game must be finished before starting another one") # let's check for an existing invite between these players invite = Invite.query( Invite.from_player == user.key, Invite.to_player == player_two.key, Invite.accepted == False, Invite.rejected == False ).get() if invite is not None: raise endpoints.BadRequestException( "A pending invite must be accepted or declined before creating another one") invite = Invite.query( Invite.from_player == player_two.key, Invite.to_player == user.key, Invite.accepted == False, Invite.rejected == False ).get() if invite is not None: # awesome! the inviter already has an invitation from the invitee. # start a game, and create the turncards for each player try: game = Game( player_one=player_two.key, player_one_name=player_two.username, player_two=user.key, player_two_name=user.username ) game.put() player_one_turncard = TurnCard( owner=player_two.key, game=game.key ) player_two_turncard = TurnCard( owner=user.key, game=game.key ) player_one_turncard.put() player_two_turncard.put() return CreateInviteResponseForm( game_key=game.key.urlsafe(), game=game.to_form() ) except Exception as e: # print e.message raise endpoints.InternalServerErrorException('An error occurred while attempting to create a game') # alright there are no invites between these players yet so let's make one try: invite = Invite( from_player=user.key, from_player_name=user.username, to_player=player_two.key, to_player_name=player_two.username ) invite.put() return CreateInviteResponseForm() except: raise endpoints.InternalServerErrorException('An error occurred while attempting to create an invite')
def create_invite(code, org_name): org = Organization.query(Organization.name == org_name).get() i = Invite(org=org.key, code=code) i.put()