def test_given_aAdminReviewerTryingToReviewAsAdmin_ItShouldSucceed(self):
setReviewTimeUnit(0)
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test1"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
createPlayer("reviewer1", "reviewer1")
admin = getAdmin()
admin.playerList.append('reviewer1')
setAdmin(admin)
service.getRandomScore("reviewer1")
response = service.reviewScore("reviewer1", {'score':3, 'time': 0}, True)
self.assertTrue('result' in response)
playerKey = Key.from_path('Player', playerId)
verifiedScoreWrapper = VerifiedScoreWrapper.get_by_key_name('verifiedScore', parent=playerKey)
verifiedScore = verifiedScoreWrapper.verified
self.assertEqual(verifiedScore.value, 3)
self.assertEqual(verifiedScore.approvedByAdmin, True)
def test_given_score_and_ThreeDisapprovingReviewerOfWhichTwoAgree_then_NonAgreeingReviewerAndPLayerAreCheater(self):
score = {'score' : 99, 'proof' : "sdsd", 'time' : 0}
playerId = "test"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
playerKey = Key.from_path('Player', playerId)
createReviewerAndReview("test2", playerKey, {'score':3, 'time': 0})
createReviewerAndReview("test3", playerKey, {'score':999, 'time': 0})
createReviewerAndReview("test4", playerKey, {'score':3, 'time': 0})
verifiedScore = VerifiedScore.get_by_key_name("verified", parent=playerKey)
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertTrue(verifiedScore is None or verifiedScore.value == 0)
self.assertEqual(playerRecord.numCheat, 1)
playerKey = Key.from_path('Player', 'test3')
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 1)
def testWrongSessionSignedRequestForPlayer(self):
playerId = "test"
createPlayer(playerId, "test")
createPlayerSession(playerId, 'signedRequest')
signedRequest = createSignedRequest(playerId, "wrong secret", 'score.service.echo', 'hello')
response = signedRequestCall(signedRequest)
self.assertTrue('error' in response and response['error']['code'] == INVALID_SIGNATURE_ERROR['code'])
def test_given_aAdminReviewerTryingToReviewAsAdmin_ItShouldSucceedAndDeclareNonAgreeingConflictingReviewerAsCheaters(self):
setReviewTimeUnit(0)
score = {'score' : 99, 'proof' : "sdsd", 'time' : 0}
playerId = "test"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
playerKey = Key.from_path('Player', playerId)
createReviewerAndReview("test2", playerKey, {'score':3, 'time': 0})
createReviewerAndReview("test3", playerKey, {'score':999, 'time': 0})
createReviewerAndReview("test4", playerKey, {'score':3, 'time': 0}, True)
verifiedScore = VerifiedScore.get_by_key_name("verified", parent=playerKey)
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertTrue(verifiedScore is None or verifiedScore.value == 0)
self.assertEqual(playerRecord.numCheat, 1)
playerKey = Key.from_path('Player', 'test3')
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 1)
playerKey = Key.from_path('Player', 'test2')
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 0)
def testNonExistingMethodSignedRequestCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'signedRequest')
signedRequest = createSignedRequest(playerId, session.secret, 'nonExisitingMehtod')
response = signedRequestCall(signedRequest)
self.assertTrue('error' in response and response['error']['code'] == UNKNOW_SERVICE_CALL_ERROR['code'])
def test_given_score_and_TwoDisapprovingButNonAgreeingReviewerAndOneApprovingReviewer_then_NonApprovingReviewerAreCheater_and_playerVerifiedScoreIsUpdated(self):
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
playerKey = Key.from_path('Player', playerId)
createReviewerAndReview("test2", playerKey, {'score':99, 'time': 0})
createReviewerAndReview("test3", playerKey, {'score':999, 'time': 0})
createReviewerAndReview("test4", playerKey, {'score':3, 'time': 0})
verifiedScoreWrapper = VerifiedScoreWrapper.get_by_key_name('verifiedScore', parent=playerKey)
verifiedScore = verifiedScoreWrapper.verified
self.assertEqual(verifiedScore.value, 3)
playerKey = Key.from_path('Player', 'test2')
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 1)
playerKey = Key.from_path('Player', 'test3')
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 1)
def test_given_reviewerVerifyingScore_if_playerSetNewScoreInTheMeanTime_when_reviewerSetReviewItShouldBeDiscarded(self):
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
playerKey = Key.from_path('Player', playerId)
reviewer = createPlayer("reviewer", "reviewer")
assignScoreReview(reviewer, playerKey)
reviewer2 = createPlayer("reviewer2", "reviewer2")
scoreToReview = assignScoreReview(reviewer2, playerKey)
score = {'score' : 4, 'proof' : "sdsd", 'time' : 0}
service.start(playerId)
service.setScore(playerId, score)
service.reviewScore("reviewer", {'score':4, 'time': 0})
service.reviewScore("reviewer2", {'score':3, 'time': 0})
verifiedScore = VerifiedScore.get_by_key_name("verified", parent=playerKey)
self.assertEqual(verifiedScore, None)
# TDO : move to another test?
scoreToReview = db.get(scoreToReview.key())
self.assertEqual(scoreToReview, None)
def testExpiredSessionTokenCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'token', datetime=datetime.datetime.now() - DEFAULT_MAX_SESSION_LIFE_TIME)
response = sessionTokenCall(session.token, playerId, 'score.service.echo', 'hello')
self.assertTrue('error' in response and response['error']['code'] == SESSION_EXPIRED_ERROR['code'])
def testCorrectSessionTokenCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'token')
message = 'hello'
answer = sessionTokenCall(session.token, playerId, 'score.service.echo', message)
self.assertEqual(answer['result'], str(playerId) + ':' + message)
def testWrongSessionMethod(self):
playerId = "test"
createPlayer(playerId, "test")
createPlayerSession(playerId, 'token')
signedRequest = createSignedRequest(playerId, "wrong secret", 'score.service.echo', 'hello')
response = signedRequestCall(signedRequest)
self.assertTrue('error' in response and response['error']['code'] == SIGNED_REQUEST_METHOD_ERROR['code'])
def test_newPlayerWithoutReviewAssigned_shouldGetNoReviews(self):
playerId = "test"
createPlayer(playerId, playerId)
playerKey = Key.from_path('Player', playerId)
reviewSession = ReviewSession.get_by_key_name('reviewSession', parent=playerKey)
self.assertEqual(reviewSession, None)
def post(self):
userId = self.request.get('userId')
if config.passwordUserAllowed is None or userId not in config.testMasters:
self.error(403)
return
password = self.request.get('password')
method = self.request.get('method')
testUserId = self.request.get('testUserId')
passwordUser = PasswordUser.get_by_key_name(userId)
if passwordUser is not None:
if passwordUser.password != password:
self.error(403)
return
playerId = passwordUser.playerId
else:
player = createPlayer('passwordUser' + userId, "nickName" + userId)
playerId = player.key().id_or_name()
passwordUser = PasswordUser(key_name=userId,
playerId=playerId,
password=password)
passwordUser.put()
testUser = TestUser.get_by_key_name(testUserId)
if testUser is not None:
testPlayerId = testUser.playerId
else:
testPlayer = createPlayer('testUser' + testUserId,
"nickName" + testUserId)
testPlayerId = testPlayer.key().id_or_name()
testUser = TestUser(key_name=testUserId, playerId=testPlayerId)
testUser.put()
if method is None:
if self.request.scheme == 'https':
method = 'signedRequest'
else:
method = 'token'
session = createPlayerSession(testPlayerId, method)
if method == 'token':
data = {
u'method': 'token',
u'sessionToken': session.token,
u'playerId': testPlayerId
}
elif method == 'signedRequest':
data = {
u'method': 'signedRequest',
u'secret': session.secret,
u'playerId': testPlayerId
}
data = json.dumps(data)
self.response.out.write(data)
def testExpiredSessionSignedRequestCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'signedRequest', datetime=datetime.datetime.now() - DEFAULT_MAX_SESSION_LIFE_TIME)
signedRequest = createSignedRequest(playerId, session.secret, 'score.service.echo', 'hello')
response = signedRequestCall(signedRequest)
self.assertTrue('error' in response and response['error']['code'] == SESSION_EXPIRED_ERROR['code'])
def testWrongSessionTokenForPlayer(self):
playerId = "test"
createPlayer(playerId, "test")
createPlayerSession(playerId, 'token')
response = sessionTokenCall("wrong token", playerId,
'score.service.echo', 'hello')
self.assertTrue('error' in response and response['error']['code']
== INVALID_SESSION_TOKEN_ERROR['code'])
def testCorrectSessionTokenCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'token')
message = 'hello'
answer = sessionTokenCall(session.token, playerId,
'score.service.echo', message)
self.assertEqual(answer['result'], str(playerId) + ':' + message)
def testNonExistingMethodTokenCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'token')
response = sessionTokenCall(session.token, playerId,
'nonExisitingMehtod')
self.assertTrue(
'error' in response
and response['error']['code'] == UNKNOW_SERVICE_CALL_ERROR['code'])
def testWrongSessionMethod(self):
playerId = "test"
createPlayer(playerId, "test")
createPlayerSession(playerId, 'token')
signedRequest = createSignedRequest(playerId, "wrong secret",
'score.service.echo', 'hello')
response = signedRequestCall(signedRequest)
self.assertTrue('error' in response and response['error']['code']
== SIGNED_REQUEST_METHOD_ERROR['code'])
def testCorrectSessionSignedRequestCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'signedRequest')
message = 'hello'
signedRequest = createSignedRequest(playerId, session.secret, 'score.service.echo', message)
answer = signedRequestCall(signedRequest)
self.assertEqual(answer['result'], str(playerId) + ':' + message)
def testNonExistingMethodSignedRequestCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'signedRequest')
signedRequest = createSignedRequest(playerId, session.secret,
'nonExisitingMehtod')
response = signedRequestCall(signedRequest)
self.assertTrue(
'error' in response
and response['error']['code'] == UNKNOW_SERVICE_CALL_ERROR['code'])
def test_given_aScoreSubmitedTooEarly_ItShouldNotBeSubmited(self):
score = {'score' : 3, 'proof' : "sdsd", 'time' : 10000}
playerId = "test"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
playerKey = Key.from_path('Player', playerId)
pendingScore = PendingScore.get_by_key_name('pendingScore', parent=playerKey)
self.assertEqual(pendingScore, None)
def testWrongSessionSignedRequestForPlayer(self):
playerId = "test"
createPlayer(playerId, "test")
createPlayerSession(playerId, 'signedRequest')
signedRequest = createSignedRequest(playerId, "wrong secret",
'score.service.echo', 'hello')
response = signedRequestCall(signedRequest)
self.assertTrue(
'error' in response
and response['error']['code'] == INVALID_SIGNATURE_ERROR['code'])
def testCorrectSessionSignedRequestCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'signedRequest')
message = 'hello'
signedRequest = createSignedRequest(playerId, session.secret,
'score.service.echo', message)
answer = signedRequestCall(signedRequest)
self.assertEqual(answer['result'], str(playerId) + ':' + message)
def testExpiredSessionTokenCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId,
'token',
datetime=datetime.datetime.now() -
DEFAULT_MAX_SESSION_LIFE_TIME)
response = sessionTokenCall(session.token, playerId,
'score.service.echo', 'hello')
self.assertTrue(
'error' in response
and response['error']['code'] == SESSION_EXPIRED_ERROR['code'])
def test_given_score_and_approvingReviewer_then_playerVerifiedScoreIsUpdated(self):
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
playerKey = Key.from_path('Player', playerId)
createReviewerAndReview("test2", playerKey, {'score':3, 'time': 0})
verifiedScoreWrapper = VerifiedScoreWrapper.get_by_key_name('verifiedScore', parent=playerKey)
verifiedScore = verifiedScoreWrapper.verified
self.assertEqual(verifiedScore.value, score['score'])
def testExpiredSessionSignedRequestCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId,
'signedRequest',
datetime=datetime.datetime.now() -
DEFAULT_MAX_SESSION_LIFE_TIME)
signedRequest = createSignedRequest(playerId, session.secret,
'score.service.echo', 'hello')
response = signedRequestCall(signedRequest)
self.assertTrue(
'error' in response
and response['error']['code'] == SESSION_EXPIRED_ERROR['code'])
def test_given_aAdminReviewerDisapprovingAnAlreadyVerifiedScore_ItShouldDeclareVerifierAsACheaterAndOtherAsNonCheaters(self):
setReviewTimeUnit(0)
score = {'score' : 99, 'proof' : "sdsd", 'time' : 0}
playerId = "test"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
playerKey = Key.from_path('Player', playerId)
createReviewerAndReview("test2", playerKey, {'score':3, 'time': 0})
createReviewerAndReview("test3", playerKey, {'score':999, 'time': 0})
createReviewerAndReview("test4", playerKey, {'score':99, 'time': 0}) # verified
verifiedScoreWrapper = VerifiedScoreWrapper.get_by_key_name('verifiedScore', parent=playerKey)
verifiedScore = verifiedScoreWrapper.verified
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertTrue(verifiedScore.value == 99)
self.assertEqual(playerRecord.numCheat, 0)
createPlayer('admin1', 'admin1')
admin = getAdmin()
admin.playerList.append('admin1')
setAdmin(admin)
service.getHighestNonApprovedScore('admin1')
service.approveScore('admin1', {'score':3, 'time': 0})
verifiedScoreWrapper = VerifiedScoreWrapper.get_by_key_name('verifiedScore', parent=playerKey)
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertTrue(verifiedScoreWrapper is None)
self.assertEqual(playerRecord.numCheat, 1)
playerKey = Key.from_path('Player', 'test3')
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 0)
playerKey = Key.from_path('Player', 'test2')
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 0)
playerKey = Key.from_path('Player', 'test4')
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 1)
def test_given_aReviewerTryingToReviewAsAdmin_ItShouldBeGivenAnError(self):
setReviewTimeUnit(0)
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test1"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
createPlayer("reviewer1", "reviewer1")
service.getRandomScore("reviewer1")
response = service.reviewScore("reviewer1", {'score':3, 'time': 0}, True)
self.assertTrue('error' in response and response['error']['code'] == ADMIN_ONLY['code'])
def test_given_goodScoreWithWrongTime_thenPlayerIsCheater(self):
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
playerKey = Key.from_path('Player', playerId)
createReviewerAndReview("test2", playerKey, {'score':3, 'time': 3})
createReviewerAndReview("test3", playerKey, {'score':3, 'time': 3})
verifiedScore = VerifiedScore.get_by_key_name("verified", parent=playerKey)
self.assertTrue(verifiedScore is None or verifiedScore.value == 0)
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 1)
def test_given_score_and_twoDisapprovingButAgreeingReviewers_then_playerIsCheater_and_verfiedScoreDoNotChange(self):
score = {'score' : 99, 'proof' : "sdsd", 'time' : 0}
playerId = "test"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
playerKey = Key.from_path('Player', playerId)
createReviewerAndReview("test2", playerKey, {'score':3, 'time': 0})
createReviewerAndReview("test3", playerKey, {'score':3, 'time': 0})
verifiedScore = VerifiedScore.get_by_key_name("verified", parent=playerKey)
self.assertTrue(verifiedScore is None or verifiedScore.value == 0)
playerRecord = Record.get_by_key_name('record', parent=playerKey)
self.assertEqual(playerRecord.numCheat, 1)
def createReviewerAndReview(reviewerId, playerKey, scoreValue, adminMode = False):
reviewer = createPlayer(reviewerId, reviewerId)
if adminMode:
admin = getAdmin()
admin.playerList.append(reviewerId)
setAdmin(admin)
scoreToReview = assignScoreReview(reviewer, playerKey)
service.reviewScore(reviewerId, scoreValue, adminMode)
return scoreToReview
def test_whetherTimeUnitIsUpdatedProperly(self):
setReviewTimeUnit(0)
for i in range(0,10):
playerId = 'test' + str(i)
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, {'score' : 3, 'proof' : "sdsd", 'time' : 0})
for i in range(10,20):
playerId = 'test' + str(i)
createPlayer(playerId, playerId)
service.getRandomScore(playerId)
service.reviewScore(playerId, {'score' : 3, 'time' : 0})
config.nbPlayerPerTimeUnit = 10
setCurrentUser('*****@*****.**', 'test', True)
response = self.updateReviewTimeUnitApp.get('/cron/updateReviewTimeUnit')
responseValue = int(response.body)
self.assertTrue(responseValue > 0 and responseValue < 10000)
def test_given_aReviewerReviewingTwoTimesTooQuickly_ItShouldBeAskedToRetryLater(self):
setReviewTimeUnit(2000)
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test1"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test2"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
createPlayer("reviewer1", "reviewer1")
sleep(3)
service.getRandomScore("reviewer1")
service.reviewScore("reviewer1", {'score':3, 'time': 0})
response= service.getRandomScore("reviewer1")
self.assertTrue('result' in response and response['result']['retry'] > 0)
def get(self):
user = users.get_current_user()
if user is None:
self.error(403)
return
userId = user.user_id()
googleUser = GoogleUser.get_by_key_name(userId)
if googleUser is not None:
playerId = googleUser.playerId
else:
player = createPlayer('googleUser_' + userId, "nickName" + userId)
playerId = player.key().id_or_name()
googleUser = GoogleUser(key_name=userId, playerId=playerId)
googleUser.put()
method = self.request.get("method", default_value=None)
if method is None:
if self.request.scheme == 'https':
method = 'signedRequest'
else:
method = 'token'
session = createPlayerSession(playerId, method)
if method == 'token':
flashvars = {
u'method': 'token',
u'sessionToken': session.token,
u'playerId': playerId
}
elif method == 'signedRequest':
flashvars = {
u'method': 'signedRequest',
u'secret': session.secret,
u'playerId': playerId
}
name = "googleUser"
data = {}
data[u'flashvars'] = json.dumps(flashvars)
data[u'title'] = u'FJump (XJump remasterized)'
self.response.out.write(
template.render(config.templatesPath + name + '.html', data))
def get(self):
user = users.get_current_user()
if user is None :
self.error(403)
return
userId = user.user_id()
googleUser = GoogleUser.get_by_key_name(userId)
if googleUser is not None:
playerId = googleUser.playerId
else:
player = createPlayer('googleUser_' + userId, "nickName" + userId)
playerId = player.key().id_or_name()
googleUser = GoogleUser(key_name=userId, playerId=playerId)
googleUser.put();
method = self.request.get("method", default_value=None)
if method is None:
if self.request.scheme == 'https':
method = 'signedRequest'
else:
method = 'token'
session = createPlayerSession(playerId, method)
if method == 'token':
flashvars = {u'method' : 'token', u'sessionToken' : session.token, u'playerId' : playerId}
elif method == 'signedRequest':
flashvars = {u'method' : 'signedRequest', u'secret' : session.secret, u'playerId' : playerId}
name = "googleUser"
data = {}
data[u'flashvars'] = json.dumps(flashvars)
data[u'title'] = u'FJump (XJump remasterized)'
self.response.out.write(template.render(
config.templatesPath + name + '.html',
data))
def test_given_aReviewerGettingRandomScoreQuickly_ItShouldNotBeAskedToRetryLater(self):
setReviewTimeUnit(2000)
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test1"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
score = {'score' : 3, 'proof' : "sdsd", 'time' : 0}
playerId = "test2"
createPlayer(playerId, playerId)
service.start(playerId)
service.setScore(playerId, score)
createPlayer("reviewer1", "reviewer1")
sleep(3)
service.getRandomScore("reviewer1")
response= service.getRandomScore("reviewer1")
# TODO : expect a KeyError for retry
self.assertFalse('result' in response and response['result']['retry'] > 0)
def testNonExistingMethodTokenCall(self):
playerId = "test"
createPlayer(playerId, "test")
session = createPlayerSession(playerId, 'token')
response = sessionTokenCall(session.token, playerId, 'nonExisitingMehtod')
self.assertTrue('error' in response and response['error']['code'] == UNKNOW_SERVICE_CALL_ERROR['code'])
def testWrongSessionTokenForPlayer(self):
playerId = "test"
createPlayer(playerId, "test")
createPlayerSession(playerId, 'token')
response = sessionTokenCall("wrong token", playerId, 'score.service.echo', 'hello')
self.assertTrue('error' in response and response['error']['code'] == INVALID_SESSION_TOKEN_ERROR['code'])
def post(self):
signedRequest = self.request.get("signed_request")
signature, payload = decode_signedRequest(signedRequest)
data = json.loads(base64_url_decode(payload))
verified = verifySignature(signature, payload, FACEBOOK_APP_SECRET,
data.get('algorithm').upper())
if (not verified or ('user_id' not in data)):
args = {
'client_id': FACEBOOK_APP_ID,
'redirect_uri': FACEBOOK_CANVAS_PAGE_URL
}
url = "https://www.facebook.com/dialog/oauth?" + urllib.urlencode(
args)
self.response.out.write(
'<script language="javascript">top.location.href="' + url +
'"</script>')
return
userId = data['user_id']
oauthToken = data['oauth_token']
facebookUser = FacebookUser.get_by_key_name(userId)
if facebookUser is not None:
if facebookUser.oauthToken != oauthToken:
facebookUser.oauthToken = oauthToken
facebookUser.put()
playerId = facebookUser.playerId
else:
player = createPlayer('facebook_' + userId, "nickName" + userId)
playerId = player.key().id_or_name()
facebookUser = FacebookUser(key_name=userId,
playerId=playerId,
oauthToken=oauthToken)
facebookUser.put()
if self.request.scheme == 'https':
method = 'signedRequest'
else:
method = 'token'
session = createPlayerSession(playerId, method)
if method == 'token':
flashvars = {
u'method': 'token',
u'sessionToken': session.token,
u'playerId': playerId,
u'facebookOauthToken': oauthToken
}
elif method == 'signedRequest':
flashvars = {
u'method': 'signedRequest',
u'secret': session.secret,
u'playerId': playerId,
u'facebookOauthToken': oauthToken
}
data = {}
data[u'flashvars'] = json.dumps(flashvars)
data[u'title'] = u'FJump (XJump remasterized)'
data[u'facebookAppId'] = FACEBOOK_APP_ID
self.response.out.write(
template.render(config.templatesPath + 'facebookCanvas.html',
data))
