def add_user():
user1 = User('张三', 'zhangsan', 'password', 1, '1111', 1)
user2 = User('李四', 'lisi', 'password', 0, '1111', 0)
db.session.add(user1)
db.session.add(user2)
db.session.commit()
db.session.close()
return "<p>add succssfully!"
def create_user(username, password):
if check_username_exists(username):
print("username is taken")
return False
user = User()
record = User(username=username,
account=login_session['account_num'],
password_hash=user.hash_password(password))
db.session.add(record)
db.session.commit()
print("user has bee successfully created")
return True
def register():
try:
body = request.form
user_email = body['user_email']
user_name = body['user_name']
user_password = bcrypt.generate_password_hash(
body['user_password']).decode('utf-8')
user = User.query.filter_by(user_email=user_email).first()
if user:
message = 'Error: Account already created with that email!'
return render_template('sign_up.html',
message=message,
mes_color="PaleVioletRed")
elif not user:
new_user = User(user_email, user_name, user_password)
if new_user.save():
log_register_user(user_name, user_email)
message = "Account registered, Thank you!"
return render_template('/login.html',
message=message,
mes_color="greenyellow")
else:
message = 'Error: Problem creating account!'
return render_template('sign_up.html',
message=message,
mes_color="PaleVioletRed")
except Exception as e:
return render_template('sign_up.html')
def test_user_delete(self):
user = User(id=3, username="******", password=hash_password("password"), firstname="firstname", lastname="lastname", role="student")
db.session.add(user)
db.session.commit()
credentials = b64encode(b"delete:password")
test = self.client.delete("/user", headers={"Authorization": f"Basic {credentials}"})
self.assertEqual(204, test.status_code)
def test_teacher_course_get_fail(self):
user = User(id=4, username="******", password=hash_password("password"), firstname="firstname", lastname="lastname", role="teacher")
db.session.add(user)
db.session.commit()
credentials = b64encode(b"fail:password")
test = self.client.get("/course", headers={"Authorization": f"Basic {credentials}"})
self.assertEqual(404, test.status_code)
def create_user(username: str, email: str, phone: str,
avatar_url: str) -> User:
"""
Create a new user.
Args :
data = {username, email, phone, avatar_url}
"""
old_user = (db.session.query(User).filter(
or_(User.email == email, User.phone == phone)).first())
if old_user:
json_abort(
409,
f"User already exists. We do not allow for duplicate phones, emails, or usernames.",
)
user = User(
username=username,
email=email,
phone=phone,
avatar_url=avatar_url,
calorie=0,
)
db.session.add(user)
db.session.commit()
return user
def setUp(self):
db.create_all()
db.session.commit()
student = User(id=11, username="******", password=hash_password("password"), firstname="firstname",
lastname="lastname",
role="student")
db.session.add(student)
teacher = User(id=12, username="******", password=hash_password("password"), firstname="firstname",
lastname="lastname",
role="teacher")
course = Course(id=11, title="title", filling="filling", creator_id=teacher.id)
course2 = Course(id=12, title="title1", filling="filling1", creator_id=teacher.id)
db.session.add(teacher)
db.session.add(course)
db.session.add(course2)
db.session.commit()
def test_user_put(self):
user = User(id=4, username="******", password=hash_password("password"), firstname="firstname", lastname="lastname", role="student")
db.session.add(user)
db.session.commit()
credentials = b64encode(b"username:password")
test = self.client.put("/user", headers={"Authorization": f"Basic {credentials}"}, data={"firstname": "testf", "lastname": "testl", "username": "******", "password": "******"})
print(test.data)
self.assertEqual(200, test.status_code)
def setup():
step = request.args.get("step", type=int)
RES = request.values
if step == 1:
return render_template("setup1.html")
elif step == 2:
host = RES.get('host', '')
username = RES.get('username', '')
passwd = RES.get('passwd', '')
dbname = RES.get('dbname', '')
port = RES.get('port', '')
url = 'postgresql+psycopg2://%s:%s@%s:%s/%s' % (username, passwd, host,
port, dbname)
try:
engine_ = create_engine(url)
connection = engine_.connect()
except:
return render_template("setup-error.html", code=3)
create_config(username, passwd, host, port, dbname)
if os.path.exists(filename):
from models.model import createall
createall(engine_)
return render_template("setup2.html")
return render_template("setup-error.html", code=3)
elif step == 3:
login_id = RES.get('login_id', '')
passwd = RES.get('passwd', '')
try:
from models.model import DBSession, User
session = DBSession()
user = session.query(User).filter_by(username=login_id).first()
if user is not None:
session.query(User).filter(User.username == login_id).update(
{"password": passwd})
session.commit()
session.close()
return render_template('setup.html', code=0)
user = User()
user.username = login_id
user.nickname = login_id
user.password = passwd
session.add(user)
session.commit()
session.close()
return render_template('setup.html', code=0)
except:
return render_template('setup.html', code=3)
return render_template('install.html')
def create(first_name, last_name, username, email, password):
id = str(uuid.uuid4())
new_user = User(id=id,
first_name=first_name,
last_name=last_name,
email=email,
bid_count=100,
password=password)
new_user.add()
return new_user
def register():
if request:
users = User('', '', '', '')
users = users.getMails()
for row in users:
if request.json['email'] == row[0]:
return jsonify({'message':'This mail is already claimed'}), 400
user = User('', '', '', '')
user.createUser()
ids = user.getId(request.json['email'])
return jsonify({
'user_id': ids[0][0],
'email': request.json['email'],
'first_name': request.json['first_name'],
'last_name': request.json['last_name']
}), 201
else:
return jsonify({'message':'Data not found'}), 400
def register():
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, password=form.password.data)
db.session.add(user)
db.session.commit()
flash("thank you for registering")
return redirect(url_for('login'))
return render_template('register.html', form=form)
def createUser(login_session):
"""
takes login session and creates a user
"""
newUser = User(name=login_session['username'],
email=login_session['email'])
session.add(newUser)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).one()
return user.id
def create_user(current_company):
if not current_company.admin:
return jsonify({'message': 'You are not authorized to create a user!'})
data = request.get_json()
print('Data is %s', data)
hashed_pwd = generate_password_hash(data['password'], method='sha256')
new_user = User(public_id=str(uuid.uuid4()), name=data['name'], password=hashed_pwd, admin=False)
db.session.add(new_user)
db.session.commit()
return jsonify(common.trueReturn(data['name'], 'New user created!'))
def signup():
form = SignUpForm()
if form.validate_on_submit():
new_user = User(name=form.name.data, username=form.username.data,
email=form.email.data)
new_user.set_password(form.password.data)
flash(
f'Hey {form.username.data.capitalize()}, you have successfully created a new account! Please login to create and buy events.', 'success')
db.session.add(new_user)
db.session.commit()
return redirect(url_for('index'))
return render_template('signup.html', form=form)
def start(message):
txt = "Hello!"
try:
User.objects.get(telegram_id=str(message.from_user.id))
except DoesNotExist:
User(telegram_id=str(message.from_user.id)).save()
kb = ReplyKeyboardMarkup(resize_keyboard=True)
buttons = [KeyboardButton(button_name) for button_name in START_KB.values()]
kb.add(*buttons)
bot.send_message(message.chat.id, txt, reply_markup=kb)
def registar():
user_name = request.form["user_name"]
user = User.query.filter_by(user_name=user_name).first()
if user:
return redirect(url_for("newcomer", status="exist_user"))
else:
password = request.form["password"]
hashed_password = sha256(
(user_name + password + key.SALT).encode("utf-8")).hexdigest()
user = User(user_name, hashed_password)
db_session.add(user)
db_session.commit()
session["user_name"] = user_name
return redirect(url_for("index"))
def post(self):
args = user_post_args.parse_args()
password = hash_password(args['password'])
user = User(
username=args['username'],
password=password,
firstname=args['firstname'],
lastname=args['lastname'],
role=args['role']
)
user = db.session.merge(user)
user_copy = copy.deepcopy(user)
db.session.add(user)
db.session.commit()
db.session.close()
return user_copy, 201
def upload():
user = User(id='AAA500')
db.session.add(user)
db.session.commit()
session = Session(id='BBB900', user_id='AAA500')
db.session.add(session)
db.session.commit()
action = Action(time="2018-10-18T21:37:28-06:00",
type="CLICK",
properties={
"locationX": 52,
"locationY": 11
},
session_id='BBB900')
db.session.add(action)
db.session.commit()
resultArray = action
return action, 201
def test_usr_add_tsk2_prj(self):
user = User(email='em', name='us', password='******')
db.session.add(user)
db.session.commit()
project = Project(name='n', description='desc')
db.session.add(project)
user.project.append(project)
db.session.commit()
project: Project = User.query.filter_by(email='em').first().project[0]
task = Task(name='n', description='desc')
db.session.add(task)
project.tasks.append(task)
db.session.commit()
assert user.project[0].tasks[0] == task
def post(self):
email = self.get_argument('email', None)
pass_word = self.get_argument('pass_word', None)
if not (email or pass_word):
self.flash('validationError.', 'Error')
return
query = User.objects
user = query(email=email).first()
# 如果没有用户添加进去
if not user and query.count() == 0:
user = User(email=email, name=email, pass_word=pass_word)
user.save()
if user.pass_word != pass_word:
self.flash('password is wrong!', 'Error')
return
self.set_secure_cookie('login_user', email)
self.redirect(self.get_argument('next',
self.reverse_url("admin_home")))
def post(self):
username = request.json.get('username')
password = request.json.get('password')
user = User.findByUsername(username)
if user:
return {'message': 'Existing user'}
newUser = User(username=username,
password=User.hash_password(password))
try:
newUser.save()
access_token = create_access_token(identity=newUser.id)
refresh_token = create_refresh_token(identity=newUser.id)
return {
'message': f'user {newUser.username} created',
'access_token': access_token,
'refresh_token': refresh_token
}
except Exception as err:
return {'message': err}
def signup():
form = SignUp(request.form)
if request.method == 'POST':
if form.validate():
username = request.form['name']
password = request.form['password']
email = request.form['email']
u = User(email=email, username=username, password=password)
db.session.add(u)
db.session.commit()
session['auth'] = {
'name': username,
'email': email,
'timestamp': time.time()
}
return redirect(url_for('index'))
else:
flash('All the form fields are required.', category='error')
return render_template('signup.html', form=form)
def check_user_by_telegram_id(telegram_id, username):
if type(telegram_id) != str:
telegram_id = str(telegram_id)
if not telegram_id:
return None
# user = User.objects(telegram_id=telegram_id).first()
user = session.query(User).filter_by(telegram_id=telegram_id).first()
if not user:
# user = User.objects.create(
# telegram_id=telegram_id,
# username=username if username else 'No user name',
# total=0,
# creation_date=datetime.now()
# )
user = session.add(User(telegram_id=telegram_id,
username=username if username else 'No user name',
total=0,
creation_date=datetime.now()))
session.commit()
return user
def login():
users = User('', '', '', '')
users = users.getUserAndPass()
try:
request.json['password'] or request.json['email']
except:
return jsonify({'message':'Credentials not found'}), 400
for row in users:
if request and request.json['password'] == row[1] and request.json['email'] == row[0]:
token = jwt.encode({
'email' : request.json['email'],
'password' : request.json['password'],
#'exp' : datetime.datetime.utcnow() + datetime.timedelta(days=9999)
}, app.config['SECRET_KEY'])
token = token.decode('utf-8')
response = jsonify({'token':token})
response.headers['x-access-token'] = token
return response
return jsonify({'message':'Login error'}), 401
def deal_register_record(self):
if not is_admin():
return TOKEN_ERROR
try:
data = request.json
IRIid = data.get('IRIid')
willstatus = data.get('willstatus')
except:
return PARAMS_ERROR
info = get_model_return_dict(
self.suser.get_registerrecord_by_IRIid(IRIid))
if not info:
return NOT_FOUND_USER
if willstatus == 2:
session = db_session()
try:
user = self.smycenter.get_user_basicinfo_byphone(
info['IRIprephonenum']) # 插入销售表，有数据就更新
if not user:
raise dberror
user = get_model_return_dict(user)
monthnow = datetime.strftime(datetime.now(),
format_for_db)[0:6]
amount_data = self.saccount.get_user_date(
user['USid'], monthnow)
if amount_data:
amount_data = get_model_return_dict(amount_data)
new_data = {}
new_data['reward'] = amount_data['reward'] + float(
self.conf.get('account', 'reward'))
try:
session.query(Amount).filter(
Amount.USid == user['USid']).update(new_data)
except:
raise dberror
else:
amount = Amount()
amount.USid = user['USid']
amount.AMid = str(uuid.uuid4())
amount.USagentid = user['USagentid']
amount.USname = user['USname']
amount.reward = float(self.conf.get('account', 'reward'))
amount.AMstatus = 1
amount.USheadimg = user['USheadimg']
amount.AMcreattime = datetime.strftime(
datetime.now(), format_for_db)
amount.AMmonth = datetime.strftime(datetime.now(),
format_for_db)[0:6]
session.add(amount)
new_userid = str(uuid.uuid4()) # 插入新用户
new_user = User()
new_user.USid = new_userid
new_user.USname = info['IRIname']
new_user.USpre = user['USid']
new_user.USagentid = get_random_str(12)
new_user.USheadimg = info['IRIpic'] if info['IRIpic'] else 'https://timgsa.baidu.com/timg?image&quality=80&size=b9999_100' \
'00&sec=1540919391&di=91c' \
'1ae656341d5814e63280616ad8ade&imgtype=jpg&er=1&src=http%3A%2F%2Fimg.zcool.cn%2Fcommun' \
'ity%2F0169d55548dff50000019ae9973427.jpg%401280w_1l_2o_100sh.jpg'
new_user.USphonenum = info['IRIphonenum']
new_user.USmount = 0
new_user.USbail = 0
new_user.USwechat = info['IRIwechat']
new_user.idcardnum = info['IRIidcardnum']
new_user.UScreatetime = datetime.strftime(
datetime.now(), format_for_db)
new_user.USpassword = generate_password_hash(
info['IRIpassword'])
session.add(new_user)
reward = Reward() # 插入直推奖励表
reward.REid = str(uuid.uuid4())
reward.RElastuserid = user['USid']
reward.REnextuserid = new_userid
reward.REmonth = datetime.strftime(datetime.now(),
format_for_db)[0:6]
reward.REmount = float(self.conf.get('account', 'reward'))
reward.REcreatetime = datetime.strftime(
datetime.now(), format_for_db)
session.add(reward)
session.query(User).filter(User.USid == user['USid'])\
.update({"USmount": user['USmount'] + float(self.conf.get('account', 'reward'))})
# 写入代理消息
content = u'您推荐的代理已审核通过，直推奖励已发放至余额'
agent_result = self.smessage.create_agentmessage(
session, user['USid'],
datetime.strftime(datetime.now(), format_for_db), content,
2)
if not agent_result:
return SYSTEM_ERROR
USname = info['IRIname'] # 插入默认收货地址
USphonenum = info['IRIphonenum']
USdatails = info['IRIaddress']
areaid = info['IRIarea']
cityid = info['IRIcity']
if areaid:
all_areaid = get_model_return_list(
self.smycenter.get_all_areaid())
area_list = []
for area in all_areaid:
area_list.append(area['areaid'])
if areaid not in area_list:
return BAD_ADDRESS
time_time = datetime.now()
time_str = datetime.strftime(time_time, format_for_db)
uaid = str(uuid.uuid1())
exist_default = self.smycenter.get_default_address_by_usid(
new_userid)
uadefault = True if not exist_default else False
self.smycenter.add_address_selfsession(session, uaid, new_userid, USname, USphonenum, USdatails, \
areaid, uadefault, time_str, None)
else:
all_cityid = get_model_return_list(
self.smycenter.get_all_cityid())
cityid_list = []
for city in all_cityid:
cityid_list.append(city['cityid'])
if cityid not in cityid_list:
return BAD_ADDRESS
time_time = datetime.now()
time_str = datetime.strftime(time_time, format_for_db)
uaid = str(uuid.uuid1())
exist_default = self.smycenter.get_default_address_by_usid(
new_userid)
uadefault = True if not exist_default else False
self.smycenter.add_address_selfsession(session, uaid, new_userid, USname, USphonenum, USdatails, \
None, uadefault, time_str, cityid)
session.commit()
except Exception as e:
print e
session.rollback()
return SYSTEM_ERROR
finally:
session.close()
update = {}
update['IRIstatus'] = int(willstatus)
result = self.suser.update_register_record(IRIid, update)
response = import_status("register_success", "OK")
return response
def add(username, email):
user = User(username=username, email=email)
db.session.add(user)
db.session.commit()
def test_user(self):
user = User(email='em', name='us', password='******')
db.session.add(user)
db.session.commit()
assert user in db.session
def add_user(name, pwd, email, phone):
user = User(name=name, password=pwd, email=email, phone=phone)
db.session.add(user)
db.session.commit()
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.sqlite3'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
with app.app_context():
from models.model import User, TaskModel
db.init_app(app)
db.drop_all()
db.create_all()
user1 = User(
gems=6750,
point=9605,
name="leon",
email_address="*****@*****.**",
password_hash=
"$pbkdf2-sha256$29000$cc557z0HwJjzvpcS4rwX4g$y8dvialUdohm7v1S7x165MzJCf3W2HsYrhL7hFAfIPQ",
user_level=2,
phone_number="60165394625",
has_telegram=True)
user2 = User(
name="baoxuan",
email_address="*****@*****.**",
password_hash=
"$pbkdf2-sha256$29000$r/VeyzlnzNn7H4Ow9j4HIA$3Nxwqa/Msu09lCAYhZd8Ir8zWZvui2PMCaN7tXhx3Hw",
user_level=2,
phone_number="+60169157190",
has_telegram=True)
user3 = User(
name="June",
email_address="*****@*****.**",
