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 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 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 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 _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 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 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 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 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 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_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 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
