def play(request):
obj = None
user_id = None
if request.POST:
if "user_id" in request.COOKIES:
user_id = request.COOKIES["user_id"]
user = User.objects.get(id=user_id)
else:
user = User()
user.save()
if "image-data" in request.POST:
obj = Drawing()
obj.image = request.POST["image-data"]
elif "caption" in request.POST:
obj = Caption()
obj.content = request.POST["caption"]
if "previous-id" in request.POST:
obj.previous_id = request.POST["previous-id"]
obj.user = user
obj.save()
is_drawing = obj.__class__ == Caption
response = render(request, 'index.html', {
'drawing': is_drawing,
'obj': obj
})
if user_id is None and request.POST:
response.set_cookie("user_id", user.id)
return response
def sinalogin(request):
"""a method for sina login"""
#use the access_token to get uid from sina server
#TODO:this appkey should be written in the conf file
appkey = "2600055104"
access_token = request.POST['access_token']
payload = {'source': appkey, 'access_token': access_token}
r = requests.get('https://api.weibo.com/2/account/get_uid.json', params = payload)
response = r.json()
if ("uid" in response):
uid = str(response['uid'])
else:
result = __resultToJson('1', '', {})
return HttpResponse(result, content_type = 'application/json')
#get the userinfo according to the access_token and uid
payload = {'source': appkey, 'access_token': access_token, 'uid': uid}
r = requests.get('https://api.weibo.com/2/users/show.json', params = payload)
userinfo = r.json()
if ('name' in userinfo):
count = User.objects.filter(uid = uid).count()
if (count == 0):
user = User(uid, userinfo['name'], userinfo['profile_image_url'])
user.save()
request.session["mid"] = uid
result = __resultToJson('0', '', {'uid': uid, 'nickname': userinfo['name'], 'imageUrl': userinfo['profile_image_url']})
return HttpResponse(result, content_type = 'application/json')
else:
result = __resultToJson('2', '', {})
return HttpResponse(result, content_type = 'application/json')
def qqlogin(request):
"""a method for qq login"""
#use the access_token to get the openid from qq server
access_token = request.POST['access_token']
payload = {'access_token': access_token}
r = requests.get("https://graph.qq.com/oauth2.0/me", params = payload)
callback = r.text
if (callback.find("openid") == -1):
result = __resultToJson('1', '', {})
return HttpResponse(result, content_type = 'application/json')
try:
openid = str(callback.split("{")[1].split("}")[0].split(",")[1].split(":")[1].split("\"")[1])
except:
result = __resultToJson('2', '', {})
return HttpResponse(result, content_type = 'application/json')
#get the userinfo according to the access_token and openid
#TODO:this appid should be written in the conf file
appid = "100510779"
payload = {'access_token': access_token, 'oauth_consumer_key': appid, 'openid': openid}
r = requests.get('https://graph.qq.com/user/get_user_info?', params = payload)
userinfo = r.json()
if ("nickname" in userinfo):
count = User.objects.filter(uid = openid).count()
if (count == 0):
user = User(openid, userinfo['nickname'], userinfo['figureurl'])
user.save()
request.session['mid'] = openid
result = __resultToJson('0', '', {'uid':openid, 'nickname': userinfo['nickname'], 'imageUrl': userinfo['figureurl']})
return HttpResponse(result, content_type = 'application/json')
else:
result = __resultToJson('2', '', {})
return HttpResponse(result, content_type = 'application/json')
def create_room(nickname):
room = Room(code=generate_room_code(), state=Room.WAITING)
room.save()
user = User(room=room,
nickname=nickname,
is_owner=True,
unique_id=uuid.uuid4().__str__())
user.save()
return CreateRoomResult(room, user)
def register(request):
if request.GET:
username = request.GET.get('username')
pwd = request.GET.get('password')
email = request.GET.get('email')
u = User.objects.filter(UserName=username)
if u:
return HttpResponse("The name has already been used.")
else:
u = User(UserName=username, Password=pwd, Email=email)
u.save()
return HttpResponseRedirect("/game/")
def register(request):
if request.GET:
username = request.GET.get('username')
pwd = request.GET.get('password')
email = request.GET.get('email')
u = User.objects.filter(UserName = username)
if u:
return HttpResponse("The name has already been used.")
else:
u = User(UserName = username,Password = pwd,Email = email)
u.save()
return HttpResponseRedirect("/game/")
def register(self):
# register a new player account
email = self.get_post('em', '')
name = self.get_post('nm', '')
password = self.get_post('pw', '')
if len(email)<3 or not game._email_re.match(email) or not mail.is_email_valid(email):
self.respond("0Please enter a valid e-mail address. This is important to retrieve your password if you forget it."); return
if len(password)<5 or len(password)>15:
self.respond("0Please enter a password of between 5 and 15 characters."); return
if len(name)<5 or len(name)>15 or not game._name_re.match(name):
self.respond("0Please enter a public name of between 5 and 15 characters. Only letters and numbers allowed."); return
email = email.lower()
success, info = User.create_user(auth_id='own:' + email,
unique_properties=['name_lower'],
password_raw=password,
email=email,
name=name,
name_lower=name.lower()
)
if success:
self.respond("1"); return
else:
if 'auth_id' in info: # email is used as auth_id/user/login name
self.respond('0That e-mail address is in use. Use password recovery if you forgot your password.'); return
if 'name_lower' in info:
self.respond('0That public name is in use, please choose another one.'); return
self.respond('0')
def post(self):
if not self.auth():
self.respond('!') # not authenticated
return
self.out = '0'
if self.user.friends:
players = User.get_multi_by_id(self.user.friends)
if players:
# now lookup statuses
check_t = int(time.time() - 90) # 1.5 minutes
q = UserToken.query(UserToken.uid.IN(self.user.friends), UserToken.last_chat_refresh >= check_t)
q.order(-UserToken.updated)
tokens = q.fetch()
self.out = '1'
for p in players:
uid = int(p.get_id())
st = '0' # check if player is - 0:offline, 1:online, 2:bussy, 3:unknown
if tokens:
for t in tokens:
if t.uid == uid:
st = '1' # is online
if t.location != 'L': # not in lobby
st = '2' # but is bussy (ingame)
break
self.out += '|' + str(uid) + ',' + st + ',' + p.name
self.respond()
def post(self):
if not self.auth():
self.respond('!') # not authenticated
return
name = self.get_post('u', '')
self.out = '0'
if name:
# find the player's uid since I work with UIDs and not names
q = User.query(User.name_lower == name.lower())
user = q.get()
if not user:
self.respond('0'); return # not found
uid = int(user.get_id())
if uid == self.uid:
self.respond('0'); return # cant add self
self.out = '1'
# check if not allready in friend list
if self.user.friends:
for f in self.user.friends:
if f == uid:
self.respond('1'); return; # found the friend in list, return
self.user.friends.append(uid) # not found ,add
self.out += str(uid) + ',' + user.name
else:
self.user.friends = [uid] # create list since it was None
self.out += str(uid) + ',' + user.name
self.user.put() # save
self.respond()
def post(self, action=None):
if 'find_button' in self.request.POST:
find_email = self.request.POST['email']
q = User.query(User.email==find_email)
user = q.get()
if user:
key = user.key.urlsafe()
if key:
form = UserOwnsForm()
form.init_with_model(user)
context['form'] = form
context['edit_key'] = key
context['player_name'] = user.name
self.render_response("admin/shop_edit.html", **context)
return
elif 'save_button' in self.request.POST:
form = UserOwnsForm(self.request.POST)
if form.validate():
key = model.Key(urlsafe=self.request.POST['edit_key'])
bmplayer = key.get()
bmplayer.shop=['0']
form.update_model(bmplayer)
bmplayer.put()
form = UserFindForm()
context['form'] = form
self.render_response("admin/shop_index.html", **context)
def index(request):
if request.method == 'POST':
post = (request.POST)
form = GameForm(post)
if form.is_valid():
#create the user if they don't exist already
user = User.objects.filter(name=post['name'])[:1]
if not user:
new_user = User(name=post['name'])
new_user.save()
try:
user = User.objects.get(name=post['name'])
except User.DoesNotExist:
return HttpResponse('database error', status=404)
#create the game including minefield then save it to database
if post['difficulty'] == 'beginner':
game = Game(width=9,height=9,number_of_mines=10,difficulty='beginner',user=user)
elif post['difficulty'] == 'intermediate':
game = Game(width=16,height=16,number_of_mines=40,difficulty='intermediate',user=user)
elif post['difficulty'] == 'expert':
game = Game(width=30,height=16,number_of_mines=99,difficulty='expert',user=user)
game.create_minefield()
game.fields_left = game.width * game.height
game.save()
#redirect to the game page
args = {'name': user.name, 'game_id': str(game.id)}
return HttpResponseRedirect(reverse('game_start', kwargs=args))
else:
form = GameForm()
top_beginner_users = User.objects.filter(game__difficulty='beginner', game__won=True).order_by('game__won')
beginner_dict = create_high_scores(top_beginner_users)
top_inter_users = User.objects.filter(game__difficulty='intermediate', game__won=True)
inter_dict = create_high_scores(top_inter_users)
top_expert_users = User.objects.filter(game__difficulty='expert', game__won=True)
expert_dict = create_high_scores(top_expert_users)
return render(request, 'index.html', {
'form': form,
'beginner_dict': beginner_dict,
'inter_dict': inter_dict,
'expert_dict': expert_dict
})
def register():
# Imports the register form from the file forms.py
form = RegisterForm(request.form)
# When the form is submitted:
if request.method == 'POST':
if form.validate_on_submit():
# Input that needs to be validated
name = request.form['username']
passwd = request.form['password']
email = request.form['email']
# Check that the username is a alphanumeric string
# between 4 and 25 characters long (whitelist)
if not re.search("^[0-9a-zA-Z]{4,25}$", name):
flash('Username must contain 4-25 alphanumeric characters.')
return redirect(url_for('auth.register'))
# Check that the password is a alphanumeric string
# between 6 and 40 characters long (whitelist)
if not re.search("^[0-9a-zA-Z]{6,40}$", passwd):
flash('Password must contain 6-40 alphanumeric characters.')
return redirect(url_for('auth.register'))
# Check that the email is a alphanumeric string
# between 1 and 50 characters long (whitelist)
# this one is less restrictive because email is never used
if not re.search("^[0-9a-zA-Z@.]{5,50}$", email):
flash('Wrong email.')
return redirect(url_for('auth.register'))
# Check that the username is not registered already
exists = db.session.query(
User.id).filter_by(username=name).scalar()
if exists is not None:
flash('Username already in use.')
return redirect(url_for('auth.register'))
# Check that the email is not registered already
exists = db.session.query(User.id).filter_by(email=email).scalar()
if exists is not None:
flash('Email already in use.')
return redirect(url_for('auth.register'))
# User is registered in the DB
user = User(username=name,
password=bcrypt.generate_password_hash(passwd),
email=email,
wins=0,
losses=0)
db.session.add(user)
db.session.commit()
# Redirect to login
flash('New user registered. Try to login.')
return redirect(url_for('auth.login'))
return render_template('auth/register.html', form=form)
def insert_user(username, last_action):
user = User(username=username,
x=DEFAULT_X,
y=DEFAULT_Y,
map_id=DEFAULT_MAP,
last_login=last_action,
shirt=0,
hair=0,
skin=0,
eyes=0,
pants=0,
shoes=0,
hair_accessory=0)
user.settings = {k: v[0] for k, v in SETTINGS.items()}
db.session.add(user)
db.session.commit()
return user
def _create_new_user(rm, device_id):
"""
Creates a new user and returns its instance
:param rm:
:param device_id:
:return: user object (django model),
"""
while True:
try:
with transaction.atomic():
temp_room = Room.objects.select_for_update().filter(
id=rm.id).first()
tablet_id = ConnectedTablet.objects.filter(
device_id=device_id).first().tablet_id
player_id = temp_room.counter
pseudo = parameters.pseudos[player_id]
u = User(player_id=player_id,
pseudo=pseudo,
room_id=rm.id,
training_done=False,
score=0,
training_score=0,
state=game.room.state.states.WELCOME,
tablet_id=tablet_id)
u.save()
u.production_good = _get_user_production_good(rm, u)
# prod i - 1 rule
u.consumption_good = (u.production_good + 1) % rm.n_type
u.save(update_fields=["production_good", "consumption_good"])
temp_room.counter += 1
temp_room.save(update_fields=['counter'])
return u
except (django.db.IntegrityError, django.db.OperationalError,
django.db.utils.OperationalError, psycopg2.IntegrityError,
psycopg2.OperationalError) as e:
print("*" * 50)
print("INTEGRITY ERROR" + "!" * 10)
print(str(e))
print("*" * 50)
threading.Event().wait(1 + np.random.random() * 4)
continue
def join_room(roomCode, nickname):
room = Room.objects.filter(code=roomCode).first()
if not room:
raise NotFound()
if room.state == room.PLAYING:
raise APIException(code=400)
if room.user_set.count() > 8:
raise APIException(code=400)
user = User(room=room,
nickname=nickname,
is_owner=False,
unique_id=uuid.uuid4().__str__())
user.save()
return JoinRoomResult(room, user)
def login(self):
""" Login erquested from within game client """
nm = self.get_post('nm', '!').lower()
pw = self.get_post('pw', '!')
self.out = '0'
self.a_user = None
try:
a = auth.get_auth()
self.a_user = a.get_user_by_password("own:" + nm, pw, remember=True, save_session=True)
except auth.InvalidAuthIdError:
self.out = '0Invalid E-mail'
except auth.InvalidPasswordError:
self.out = '0Invalid Password'
# user found and password checked out
if self.a_user:
self.out = '0Server error. Please try again in a few minutes.'
self.user_token = UserToken.get(user=self.a_user['user_id'], subject='auth', token=self.a_user['token'])
if not self.user_token:
self.out = '0Server error 1. Please try again in a few minutes.'
self.user = User.get_by_id(self.a_user['user_id'])
if not self.user:
self.out = '0Server error 2. Please try again in a few minutes.'
if self.user and self.user_token:
uid = int(self.user.get_id())
# update the token
now = int(time.time())
self.user_token.uid = uid
self.user_token.plrname = self.user.name
self.user_token.location = 'L' # in lobby
self.user_token.last_game_refresh = now
self.user_token.last_chat_refresh = now
self.user_token.put();
self.out = '1'
# send the auth cookie in the body too just incase i cant read it from header
self.out += 'auth='+self.session_store.serializer.serialize('auth', a.session)
# output player name
self.out += '^' + self.user.name + '^'
# tell client which parts of game the player own
#for s in self.user.shop.values():
# self.out += s
self.out += ''.join(self.user.shop) + '^'
# send settings
self.out += '1^' if self.user.email_bmchallenge else '0^'
self.respond()
def register():
if current_user.is_authenticated:
return redirect(url_for('main'))
form = RegistrationForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')
user = User(username=form.username.data, password=hashed_password)
db.session.add(user)
db.session.commit()
flash(f'Account created for {form.username.data}!', 'success')
return redirect(url_for('login'))
return render_template('register.html', form=form)
def recoverpw(self):
email = self.get_post('em', '')
if not mail.is_email_valid(email):
self.respond("0Please enter a valid e-mail address."); return
# find the user from e-mail
email = email.lower()
user = User.get_by_auth_id(auth_id='own:' + email)
if user:
game_name = webapp2.get_app().config['APP_INFO']['NAME']
game_url = webapp2.get_app().config['APP_INFO']['URL']
new_pass = security.generate_random_string(length=5)
user.password = security.generate_password_hash(new_pass, length=12)
try:
user.put()
except:
self.respond("0Password recovery failed. Please try again later.")
return
subject = game_name + " login password recovery"
body = """
Dear %s
This is an automated response. A request was made for your login password used with %s
Your new password is: %s
Use this new password to login to the game. You may change the password in your profile section.
For more information, visit %s
Thank you
""" % (user.name, game_name, new_pass, game_url)
# send the email via tasqueue so this request can return now and not wait for mail api
taskqueue.add(queue_name='prioritymail', url='/work/mailer/', params={
'email':email,
'subject':subject,
'body':body,
})
if webapp2.get_app().debug:
self.respond("1<pre>"+body+"</pre>")
else:
self.respond("1")
return
else:
self.respond("0We do not have a record of that e-mail address. You may register to join this game.")
return
self.respond("0")
def create():
form = CreateGame()
if form.validate_on_submit():
print(form.errors)
noguess = form.guess_num.data
username = form.username.data
timeRem = form.timerem.data
roomCode = genRoomCode()
roomInst = Room(room_code=roomCode,
num_teams=2,
scorecard=False,
full_time=timeRem,
time_remaining=timeRem,
names_per=noguess,
roundNo=0,
ct=0,
timer_started=0,
game_started=0)
db.session.add(roomInst)
db.session.commit()
room = Room.query.filter_by(room_code=roomCode).first()
client = User(username=username,
room_id=room.id,
team=0,
play_order=0,
in_play=0)
db.session.add(client)
db.session.commit()
user = User.query.filter_by(username=username, room_id=room.id).first()
# getColours(form.teams_num.data) # WILL ADD AT LATER DATE
# Sets Cookie for User
resp = make_response(redirect(url_for('addnames', roomCode=roomCode)))
resp.set_cookie('user_id', str(user.id))
return resp
return render_template('create.html',
legend='Create a New Game',
form=form)
def setUp(self):
db.create_all()
# Add tester
db.session.add(User(
email = MAIN_TESTER['email'],
password = generate_password_hash(MAIN_TESTER['password'], 'sha256'),
nick = MAIN_TESTER['nick'],
created = date.today()
))
# Add tester's colony
colony = Colony(
name = MAIN_TESTER['colony_name'],
owner = 1,
created = date.today(),
build_now = dict(),
last_harvest = datetime.now()
)
colony.starter_pack()
db.session.add(colony)
db.session.commit()
def home():
form = JoinGame()
if form.validate_on_submit():
room = Room.query.filter_by(room_code=form.roomcode.data).first()
if not room:
flash(f'That is not a valid room code.', 'danger')
else:
username = form.username.data
client = User(username=username,
room_id=room.id,
team=0,
play_order=0,
in_play=0)
db.session.add(client)
db.session.commit()
# Sets Cookie for User
resp = make_response(
redirect(url_for('addnames', roomCode=form.roomcode.data)))
resp.set_cookie('user_id', str(client.id))
return resp
return render_template('home.html', form=form, legend='Name Game')
def save_user(self, user):
db = self.application.settings.get('engine')
local_user = None
pictures = {}
referred_id = uuid4().hex
try:
big_picture = yield self.facebook_request(
'/me/picture',
type='square',
width='200',
height='200',
redirect=False,
access_token=user.get('access_token'))
pictures['small'] = user.get('picture', {}).get('data',
{}).get('url')
if 'data' not in big_picture.keys():
big_picture = None
else:
pictures['big'] = big_picture.get('data', {}).get('url')
except Exception as e:
big_picture = None
log.info(big_picture)
try:
local_user = db.query(User).filter(
User.facebook_id == user.get('id')).one()
log.info(local_user)
if local_user and not local_user.avatar:
local_user.avatar = pictures
db.sync(local_user)
life = local_user = db.query(Life).filter(
Life.user_id == local_user.id).one()
if life.last_dec:
self.session['last_dec'] = life.last_dec
except flywheel.query.EntityNotFoundException:
try:
email = user.get('email')
if not email:
email = '{}@nomail.me'.format(user.get('id'))
local_user = User()
local_user.id = uuid4().hex
local_user.facebook_id = int(user.get('id'))
local_user.facebook_token = user.get('access_token')
local_user.facebook_data = user
local_user.email = email
local_user.name = user.get('name')
local_user.referral = referred_id
local_user.avatar = pictures
local_user.created_at = datetime.utcnow()
db.sync(local_user)
user_life = Life()
user_life.user_id = local_user.id
user_life.created_at = datetime.utcnow()
db.sync(user_life)
referral = ReferralRequest()
referral.user_id = local_user.id
referral.id = referred_id
referral.created_at = datetime.utcnow()
db.sync(referral)
except Exception as e:
log.error(e)
raise
self.referred(local_user, db)
try:
self.application.db_conn.get('ping').incr('user_count')
except Exception as e:
log.warn('User incr not completed: {}'.format(e))
try:
if 'nomail.me' not in local_user.email:
mail = self.application.settings.get('mailer')
path = '{}/assets'.format(
self.application.settings.get('instance',
{}).get('front'))
lShare = quote('{}/r/{}'.format(
self.application.settings.get('instance',
{}).get('api_email'),
referred_id))
log.info(lShare)
# faceid = self.application.settings.get('facebook_api_key')
mail.send(to=local_user.email,
format='html',
subject="Bem-vindo ao Desafio Next!",
body=self.render_string("template-welcome.html",
userName=local_user.name,
path=path,
shareFacebook=lShare,
shareTwitter=lShare))
log.info('Email sent')
else:
log.warning('User has no mail')
except Exception as e:
log.warn('EMAIL ERROR: {}'.format(e))
except Exception as e:
raise e
finally:
return local_user
def post(self):
"""
Create fake users for boxes
:return: Boll
"""
nn = datetime.utcnow()
for u in ['teddy', 'pipocando']:
local_user = User()
local_user.id = u
local_user.facebook_id = len(u)
local_user.facebook_token = '098123098123'
local_user.facebook_data = {'name': u}
local_user.email = '{}@next.com'.format(u)
local_user.name = u.capitalize()
local_user.referral = u
local_user.avatar = {'big': 'a', 'small': 'b'}
local_user.created_at = nn
self.db.sync(local_user)
user_life = Life()
user_life.user_id = local_user.id
user_life.created_at = datetime.utcnow()
self.db.sync(user_life)
referral = ReferralRequest()
referral.user_id = local_user.id
referral.id = u
referral.created_at = nn
self.db.sync(referral)
return {
"message": "",
"status": "success",
}
def save_player(self, username, room):
self.user = User(game=Game.objects.get(room_name=room),
username=username,
date_created=datetime.datetime.now())
self.user.save()
return self.user
class IRepositoryPlayer:
def __init__(self):
self.user = None
def save_player(self, username, room):
self.user = User(game=Game.objects.get(room_name=room),
username=username,
date_created=datetime.datetime.now())
self.user.save()
return self.user
def get_player_by_id(self, user_id):
self.user = User.objects.get(id=user_id)
return self.user
def get_players_by_username_and_room(self, username, room):
self.user = User.objects.filter(
username=username, game=Game.objects.get(room_name=room).id)
return self.user
def update_player_username_by_id(self, user_id, name):
self.user = User.objects.get(id=user_id)
self.user.username = name
self.user.save()
return self.user
def update_player_username_by_username(self, username, name):
self.user = User.objects.get(username=username)
self.user.username = name
self.user.save()
return self.user
def update_player_monster_name_by_id(self, user_id, monster):
self.user = User.objects.get(id=user_id)
self.user.monster_name = monster
self.user.save()
return self.user
def update_player_monster_name_by_username(self, username, monster):
self.user = User.objects.get(username=username)
self.user.monster_name = monster
self.user.save()
return self.user
def delete_player_by_id(self, user_id):
self.user = User.objects.get(id=user_id)
self.user.delete()
return None
def delete_player_by_username(self, username):
self.user = User.objects.get(username=username)
self.user.delete()
return None
def post(self):
if not self.auth():
self.respond('!') # not authenticated
return
name = self.get_post('u', '')
channel_ids = self.get_post('n', '')
self.out = '0' #default is error
# player wants to join/create a private channel with another player
if name:
# find the player's uid since I work with UIDs and not names
q = User.query(User.name_lower == name.lower())
user = q.get()
if not user:
self.respond('0'); return # not found
uid = int(user.get_id())
if uid == self.uid:
self.respond('0'); return # cant PM self
# first check if the channel between the two players dont exist, else create it
# check for channel(s) where this user and target is in the uids and it is pm_channel
q = ChatChannel.query(ChatChannel.pm_channel == True, ChatChannel.uids == uid, ChatChannel.uids == self.uid)
channel = q.get() # get first result
if channel:
# there is a channel, update its created date so it is fresh and then send it to player
channel.created = datetime.datetime.now()
channel.put()
self.out = '1' + str(channel.key.id())
else:
# first check if requested user exist
target = User.get_by_id(uid)
# create the channel
if target:
channel = ChatChannel(pm_channel = True, uids = [uid, self.uid] )
key = channel.put()
if key:
self.out = '1' + str(key.id())
# player wants the names for channels
elif channel_ids:
sids = channel_ids.split(',')
cids = [int(s) for s in sids if s]
channels = ChatChannel.get_multi_by_id(cids) if cids else None
if channels:
self.out = '1'
for channel in channels:
# send the name as is if the channel has one
if channel.name:
self.out += '|' + str(channel.key.id()) + ',' + channel.name
# else try and find the name it should be, prolly a player name for pm channel
else:
uid = 0 # find the other player's id in the list
for idd in channel.uids:
if idd != self.uid:
uid = idd
break
if uid > 0:
player = User.get_by_id(uid)
if player:
self.out += '|' + str(channel.key.id()) + ',' + player.name
self.respond()
