def game():
if 'username' not in session or not Player.get_by_id(session['username']):
return redirect(url_for('.login'))
else:
game_ent = get_current_game()
player_names = [x.name for x in ndb.get_multi(game_ent.players)]
template_dict = {'player_count': len(game_ent.players)}
username = session['username']
current_player = Player.get_by_id(username)
if current_player.channel_token is None:
# this is a new player
# scheme I'd like to follow for client ID is service:username
token = channel.create_channel('simonsays:' + username)
current_player.channel_token = token
current_player.put()
if len(game_ent.players) > 1:
if not game_ent.started:
# now we're ready to start the game
game_ent.started = True
game_ent.leader = random.choice([x for x in player_names if x != username])
send_channel_update('leader', [game_ent.leader])
send_channel_update('follower', [x for x in player_names if x not in [game_ent.leader, username]])
template_dict['leader'] = game_ent.leader
template_dict['game_round'] = game_ent.round_
template_dict['token'] = current_player.channel_token
template_dict['usernames'] =', '.join(player_names)
return render_template('simonsays.html', **template_dict)
def get(self):
"""
TODO: not yet commented.
"""
client = uuid.uuid4().__str__()
token = channel.create_channel(client)
if Suite.all().count() > 0:
running_since = Suite.all().order('date').get().date
else:
running_since = datetime.now()
number_of_runs = Suite.all().count()
ctfs = {}
# run the test suite
for elem in dir(tests):
if elem.find('ctf_') != -1:
func = getattr(tests, elem)
ctfs[func.__name__] = func.__doc__.strip()
template_values = {
'client': client,
'token': token,
'number_of_runs': number_of_runs,
'running_since': running_since,
'tests': ctfs,
}
path = os.path.join(os.path.dirname(__file__), '../templates/index.html')
self.response.out.write(template.render(path, template_values))
def maybe_update_token(login_record, force=False):
"""Assigns the user a new channel token if needed.
Args:
login_record: Record for the user.
force: Optional. When True, always update the user's token. This is
used when the token is known to be bad on the client side.
Returns:
True if a new token was issued.
"""
now = datetime.datetime.now()
oldest_token_time = (
now - datetime.timedelta(seconds=config.user_token_lifetime_seconds))
if not force and (
login_record.browser_token_issue_time and
login_record.browser_token_issue_time > oldest_token_time):
return False
login_record.browser_token = channel.create_channel(
get_token(login_record.user_id),
# 5 minutes of wiggle room
5 + config.user_token_lifetime_seconds // 60)
login_record.browser_token_issue_time = now
return True
def get(self):
self.response.headers['Content-Type'] = 'text/html'
client_id = str(random.random())
clients.append(client_id)
path = os.path.join(os.path.dirname(__file__) + '/../templates/', 'index.html')
self.response.out.write(template.render(path, {"token": channel.create_channel(client_id)}))
def kpi(request):
na = "N/A"
init_start_date = default_tz_now_min() - timedelta(days=1)
init_end_date = default_tz_now_max()
channel_id = get_uuid()
token = channel.create_channel(channel_id)
from analytics.kpi import calc_kpi_data
return base_datepicker_page(request, calc_kpi_data, 'kpi.html', locals(), init_start_date, init_end_date, async=True)
def get(self):
user = users.get_current_user()
if user:
channel_id = id = user.email()
else:
id = random.randint(1, 10000)
channel_id = 'anonymous(%s)' %id
token = channel.create_channel(channel_id)
tokens = memcache.get('tokens') or {}
tokens[token] = id
memcache.set('tokens', tokens)
self.response.out.write(token)
def post(self):
auth_token = self.request.get("auth_token")
album = self.request.get("album")
auth_pair = models.OAuthPair.gql(
"WHERE verified = :verified and token = :token",
verified=True, token=auth_token).get()
pws = gdata.photos.service.PhotosService()
gdata.alt.appengine.run_on_appengine(pws, store_tokens=False, single_user_mode=True)
oauth_params = gdata.auth.OAuthInputParams(
gdata.auth.OAuthSignatureMethod.HMAC_SHA1,
config.consumer_key,
consumer_secret=config.consumer_secret)
oauth_token = gdata.auth.OAuthToken(
key=auth_pair.token,
secret=auth_pair.secret,
oauth_input_params = oauth_params)
pws.SetOAuthToken(oauth_token)
photo_feed = pws.GetFeed('/data/feed/api/user/%s/albumid/%s?kind=photo' % ("default", album))
photos = photo_feed.entry
photos.sort(key=lambda photo: photo.exif.time.text)
grouped = [list(y) for x, y in groupby(photos, key= lambda photo: self.timestampToYMD(photo.exif.time.text))]
#logging.debug([len(x) for x in grouped])
token = oauth.Token(auth_pair.token, auth_pair.secret)
consumer = oauth.Consumer(config.consumer_key, config.consumer_secret)
client = oauth.Client(consumer, token)
from google.appengine.api.channel import channel
#using auth_token as unique client_id to gen a token
channel_token = channel.create_channel(auth_token)
runner = MidnightRunner()
#passing entity to deferred, nto recommended but acceptable
#as long as we arent updating/storing it
deferred.defer(runner.run, auth_pair, grouped)
#data = [ self.buildTuple(photo) for photo in photos.entry ]
#logging.debug(data)
path = os.path.join(os.path.dirname(__file__), 'templates/sync.html')
template_values = {
'channel_token': channel_token
}
html = template.render(path, template_values)
self.response.out.write(html)
def kpi(request):
na = "N/A"
init_start_date = default_tz_now_min() - timedelta(days=1)
init_end_date = default_tz_now_max()
channel_id = get_uuid()
token = channel.create_channel(channel_id)
from analytics.kpi import calc_kpi_data
return base_datepicker_page(request,
calc_kpi_data,
'kpi.html',
locals(),
init_start_date,
init_end_date,
async=True)
def get(self):
"""
TODO: not yet commented.
"""
template_values = get_base_template(self.request.path)
# generate and retain client id for inbound AJAX channel
template_values['client'] = uuid.uuid4().__str__()
# create channel and retain security token
template_values['token'] = channel.create_channel(template_values['client'])
ctfs = {}
# extract ctf name and descriptions
for ctf in tests.ctfs:
ctfs[ctf.__name__] = ctf.__doc__.strip()
template_values['tests'] = ctfs
# load and render result page
path = os.path.join(os.path.dirname(__file__), '../templates/index.html')
self.response.out.write(template.render(path, template_values))
def post(self):
userChannel = channel.create_channel(self.user.auth_ids[0], 1440)
self.user.channelActive = True
self.user.put()
self.response.write(userChannel)
def post(self):
request_data = request.get_json()
player_token = Util.get_token(request_data['channel_id'])
token = channel.create_channel(player_token)
return {'token': token}, 201
def create_channel_for_current_session():
return channel.create_channel(create_channel_id(users.get_current_session()))