def init_models():
import models
session = db_session()
try:
admin = models.User(identityNum=130132199709102554,
realname='李泽康')
admin.set_password("15927573538")
session.add(admin)
session.commit()
except Exception as e:
session.rollback()
session.close()
def test_interval_hr():
connect("mongodb://vcm-3502.vm.duke.edu:27017/heart_rate_app")
email = "*****@*****.**"
now = datetime.datetime.now()
test_user = models.User(email, 22, [], [])
test_user.heart_rate.append(66)
test_user.heart_rate_times.append(now)
test_user.save()
time.sleep(0.500)
then = datetime.datetime.now()
add_heart_rate(email, 78, then)
assert interval_hr(email, time2str(now)) == 72
def register():
if current_user.is_authenticated:
return redirect('/')
form = RegistrationForm()
if form.validate_on_submit():
user = models.User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('Congratulations, you are now a registered user!')
return redirect(url_for('login'))
return render_template('register.html', form=form)
def get_pretest():
if 'user_id' not in session:
print "got here"
session['user_id'] = str(uuid.uuid4())
else:
print "already user id:", session['user_id']
user = models.User(session['user_id'])
db_session.add(user)
db_session.commit()
form = forms.generate_survey_instance_form(
"pre") #basic_form.RegistrationForm()
return render_template('pretest_survey.html', form=form)
def register(self, message):
params = message.params
user_model = models.User(self.db_name)
users = user_model.filter(username=params.get("username"))
if len(users) > 0:
raise ProtonError("Given user already exists.")
username = params.get("username")
password = params.get("password")
user_model.create(username=username, password=password)
users = user_model.first(username=username)
return users
def register():
if current_user.is_authenticated:
return redirect(url_for('frontPage'))
form = RegistrationForm()
if form.validate_on_submit():
user = models.User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('You are now registered!')
return redirect(url_for('logIn'))
return render_template('register.html', title='Register', form=form)
def adduser():
method = request.args if request.method == 'GET' else request.form
user = models.User(method)
if user.exist_user():
user.add_user()
ok = True
result = "添加成功"
return json.dumps({'ok': True, 'result': result})
else:
ok = False
result = "添加失败"
return json.dumps({'ok': False, 'result': result})
def create_user(email, age, heart_rate):
"""
Creates user with email, age and heart_rate parameters and saves it within the database
:param email: str type parameter of specified user, contains email address
:param heart_rate: int type parameter of the heart rate of the specified user at a particular time
:param age: int type parameter of the age of the specified user
"""
u = models.User(email, age, [], []) # create a new User instance
u.heart_rate.append(heart_rate) # add initial heart rate
u.heart_rate_times.append(
datetime.datetime.now()) # add initial heart rate time
u.save() # save the user to the database
def setup_database(app):
"""Create database.
:param app: current app in use
"""
with app.app_context():
db.create_all()
gio_user = mod.User(email='*****@*****.**', name='giorgia')
gio_user.set_password('giorgia')
db.session.add_all([gio_user])
db.session.commit()
async def line_oauth(code: str, db: Session = Depends(get_db)):
"""
For Line Oauth
"""
data = {
"client_id": config.Line.CLIENT_ID,
"client_secret": config.Line.CLIENT_SECRET,
"grant_type": "authorization_code",
"code": code,
"redirect_uri": config.Line.REDIRECT_URL,
}
async with aiohttp.ClientSession() as session:
r1 = await session.post(
config.Line.API_ENDPOINT + "/oauth/accessToken",
data=data,
headers={"Content-Type": "application/x-www-form-urlencoded"},
)
resp = await r1.json()
if resp.get("access_token") != None:
r2 = await session.get(
"https://api.line.me/v2/profile",
headers={"Authorization": "Bearer " + resp["access_token"]})
resp = await r2.json()
else:
raise HTTPException(400, "Line Oauth Handle Failed")
# check if user exist
OauthDetail = (db.query(
models.OauthDetail).filter(models.OauthDetail.platform == 2).filter(
models.OauthDetail.id == resp["userId"]).first())
# not exist, create one
if not OauthDetail:
newUser = models.User(avatar=f"{resp.get('pictureUrl')}.png",
name=resp["displayName"])
db.add(newUser)
db.flush()
OauthDetail = models.OauthDetail(platform=2,
id=resp["userId"],
user_id=newUser.id)
db.add(OauthDetail)
db.commit()
else:
# check if user have been banned
if OauthDetail.user.status != 0:
raise HTTPException(403, "Account Has Been Banned")
# update account
OauthDetail.user.avatar = f"{resp.get('pictureUrl')}.png"
OauthDetail.user.name = resp["displayName"]
db.commit()
# create jwt token, expire after 7 days
return generate_jwt_token(OauthDetail.user_id)
def register():
form = forms.RegistrationForm()
if form.validate_on_submit():
user = models.User(email=form.email.data,
username=form.username.data,
password=form.password.data)
current_app.db.session.add(user)
current_app.db.session.commit()
flash('You can now login.')
return redirect(url_for('auth.login'))
return render_template('auth/register.html', form=form)
def create_test_db():
t = models.Notice("Game Start!")
db_session.add(t)
t = models.User("admin", "admin", "admin", 2)
t.is_admin = True
db_session.add(t)
for i in xrange(5):
t = models.User("guest%d" % i, "guest", "guest", 1)
db_session.add(t)
r = config.category
for i in xrange(16):
cate = r[0] if i < 4 else (r[1] if i < 8 else
(r[2] if i < 12 else
(r[3] if i < 15 else r[4])))
t = models.Problem("prob" + str(i), "AAAA", cate, "flag%d" % i)
db_session.add(t)
db_session.commit()
def modules():
if 'user_id' not in session or session['user_id'] == '':
return redirect(url_for('login'))
user = models.User(session['user_id'])
try:
mods = ivle.get_modules_list(user)
except Exception as e:
return "IVLE is not responding. Please try again later."
selected_modules = [course['Code'] for course in user.modules]
return render_template('modules.html',
modules=mods,
selected_modules=selected_modules)
def db_start():
create_engine('sqlite:///tmp/test.db', convert_unicode=True)
db.create_all()
db.session.commit()
user = models.User()
user.username = "******"
user.password = bcrypt.generate_password_hash('pppp1234')
user.email = '*****@*****.**'
user.admin = True
user.poweruser = True
db.session.add(user)
db.session.commit()
def help_user(msg):
user = models.User(msg.author.name)
if user.is_registered():
msg.reply(
Template(lang.message_help + lang.message_footer).render(
username=msg.author.name, address=user.address))
else:
bot_logger.logger.info('user %s not registered (command : help) ' %
msg.author.name)
msg.reply(
Template(lang.message_need_register +
lang.message_footer).render(username=msg.author.name))
def user(i):
u = models.User(
email='filod' + str(i) + '@q.com',
pwd=
'833f10702b774c469bf1f1b219226979$a8a55cb1855d706b998fd3e8e022308bc3da3e79',
displayname='filod' + str(i),
uniquename='filod' + str(i),
sex=random.randint(0, 1),
stat='active',
mtype='user',
ctime=util.now())
return u
def create_user(email, age, heart_rate):
"""Function that creates new user
:param email: string that defines user email
:param age: float or int that defines user age
:param heart_rate: float or int that defines user heart rate
"""
u = models.User(email, age, [], []) # create a new User instance
u.heart_rate.append(heart_rate) # add initial heart rate
u.heart_rate_times.append(datetime.datetime.now())
# add initial heart rate time
u.save() # save the user to the database
def post(self):
arg = request.json
duplicated_user = models.User.query.filter_by(user_id = arg['usrId']).first()
# 같은 id의 유저가 DB에 있는지 확인
if not duplicated_user:
user = models.User(user_id=arg['usrId'], is_super=arg['isStaff'])
user.set_password(arg['password'])
session.add(user)
session.commit()
return 201
else:
return Response(status = 409)
def post(self):
"""用户注册"""
user = self.parser.parse_args()
username = user['username']
pre_user = models.User.query.filter_by(username=username).first()
if pre_user is not None:
return config.USERNAME_CONFLICT
user_model = models.User()
for key, value in user.iteritems():
setattr(user_model, key, value)
db.session.add(user_model)
def addUser(email, password, conf, valid=0, guest=0):
o = M.User()
o.email = email
o.password = password
o.confkey = conf
o.valid = valid
o.guest = guest
o.save()
if o.guest:
gh = M.GuestHistory(user=o)
gh.save()
return o
def register():
form = RegForm()
if form.validate_on_submit():
user = models.User(name=form.name.data,
email=form.email.data,
active=True)
user.set_password(form.password.data)
db.sqla.session.add(user)
db.sqla.session.commit()
return flask.redirect("/")
return render_template("register.html", form=form)
def register_view(self):
form = RegistrationForm(request.form)
if helpers.validate_form_on_submit(form):
user = models.User()
form.populate_obj(user)
user.save()
login.login_user(user)
return redirect(url_for('.index'))
link = '<p>Already have an account? <a href="' + url_for('.login_view') + '">Click here to log in.</a></p>'
self._template_args['form'] = form
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
def make_one_user(email):
with session_scope() as session:
user = session.query(
models.User).filter(models.User.email == email).first()
if user is not None:
print('already exists', user.access_uuid)
return
user = models.User()
user.email = email
user.access_uuid = uuid.uuid4().hex
session.add(user)
print('created: ', user.access_uuid)
def create_user(email, name):
# Check whether a record already exists for this user.
user = models.User.query.filter(models.User.email==email).first()
if user:
return user
# If no record exists, create the user.
user = models.User(name=name, email=email, date_created=datetime.datetime.now(pytz.utc))
db.session.add(user)
db.session.commit()
return user
def create_default_adm(db: Session = Depends(database.get_db)):
response = 'Already Created'
email = '*****@*****.**'
adm = db.query(models.User).filter(models.User.email==email).first()
if not adm:
hashedPassword = utils.pwd_cxt.hash('pass')
new_user= models.User(name='admin',email=email,password=hashedPassword,role=authentication.roles[0])
db.add(new_user)
db.commit()
db.refresh(new_user)
response = 'Created'
return response
def post(self):
#checking if user is logged in or not. If not, request is not served and
# instead redirected to login page, then req sent again.
# Generally this shouldnt be the case since the guy was asked to
# sign in when visiting the complaint page.
# user = users.get_current_user();
# if not user:
# self.redirect(users.create_login_url(self.request.uri))
# i don't think we need to user_id from the frontend anymore.
google_id = self.request.get('user_id')
# this is google id
# checking if user already exists
q = ndb.gql('SELECT * FROM User WHERE google_id = :1', google_id)
user = q.get() # returns first result or None
if user is None: #need to create new user
name = self.request.get('name')
email = self.request.get('email')
pic = self.request.get('pic')
newuser = models.User(id=google_id,
name=name,
email=email,
google_id=google_id,
pic=pic)
newuser.put()
userKey = newuser.key
print ">>>>> New user created."
else:
userKey = user.key
print ">>>>> Old user."
title = self.request.get('title')
lat = float(self.request.get('lat'))
lon = float(self.request.get('lon'))
subtitle = self.request.get('subtitle')
content = self.request.get('content')
tags = json.loads(self.request.get('tags'))
img_links = json.loads(self.request.get('img_links'))
smallAdd = self.request.get('smallAdd')
bigAdd = self.request.get('bigAdd')
#### Added New
location = ndb.GeoPt(lat=lat, lon=lon)
newcomplaint = models.Complaint(user_id=userKey,
title=title,
location=location,
subtitle=subtitle,
content=content,
tags=tags,
img_links=img_links,
bigAdd=bigAdd,
smallAdd=smallAdd)
newcomplaint.put()
def form_valid(self, form):
auth_user = auth_models.User.objects.create_user(
form.cleaned_data['login'], form.cleaned_data['email'],
form.cleaned_data['password'])
user = models.User(
rating=0,
user=auth_user,
)
user.save()
auth_user = auth.authenticate(username=form.cleaned_data['login'],
password=form.cleaned_data['password'])
auth.login(self.request, auth_user)
return http.HttpResponseRedirect(self.get_success_url())
def send_user(recipient):
"""
Send a message to a user.
"""
if not request.form:
abort(400)
if not "username" in request.form:
return {"message": "Field 'username' was not specified."}, 400
if not "content" in request.form:
return {"message": "Field 'content' was not specified."}, 400
sender = models.User(request.form["username"])
recipient = models.User(recipient)
msg = models.Message(models.new_id("message"),
sender=sender.id,
content=request.form["content"])
msg.new()
msg.send_users([recipient.id])
app.logger.info("[PM] %s -> %s" % (recipient.id, sender.id))
return "", 200
def create_user(username, password):
# hashed_pass = cl.hash_password(args.password)
# print()
if len(password) < 8:
print('password too short!')
return
user = m.User(username, password)
msg = user.load_user_by_name(cursor, username)
if msg is None:
user.safe_to_db(cursor)
else:
print('already exists')
return 'already exists'
def create_user(email, age, heart_rate, time):
"""
Creates a user with the specified email and age. If the user already exists in the DB this WILL
overwrite that user. It also adds the specified heart_rate to the user
:param email: str email of the new user
:param age: number age of the new user
:param heart_rate: number initial heart_rate of this new user
:param time: datetime of the initial heart rate measurement
"""
u = models.User(email, age, [], []) # create a new User instance
u.heart_rate.append(heart_rate) # add initial heart rate
u.heart_rate_times.append(time) # add initial heart rate time
u.save() # save the user to the database
