def work():
sql_execute(
'''ALTER TABLE "user" ALTER COLUMN number SET DEFAULT nextval('user_count_seq');'''
)
sql_execute(
'ALTER TABLE "user" ADD phone_verified boolean DEFAULT FALSE NULL;')
sql_execute(
'ALTER TABLE "user" ADD change_nickname_chance int DEFAULT 0 NULL;')
sql_execute('ALTER TABLE "user" ALTER COLUMN email DROP NOT NULL;')
sql_execute('ALTER TABLE "user" ALTER COLUMN email SET DEFAULT NULL;')
sql_execute('ALTER TABLE "user" ALTER COLUMN phone DROP NOT NULL;')
sql_execute('ALTER TABLE "user" ALTER COLUMN phone SET DEFAULT null;')
sql_execute('CREATE UNIQUE INDEX user_phone ON "user" (phone);')
sql_execute('ALTER TABLE "user" ALTER COLUMN nickname DROP NOT NULL;')
sql_execute('ALTER TABLE "user" RENAME COLUMN reputation TO repute;')
sql_execute(
'ALTER TABLE "user" ADD is_new_user BOOLEAN DEFAULT TRUE NOT NULL;')
# 注册的激活机制改了，变通一下吧
for i in UserModel.select().where(UserModel.group == USER_GROUP.INACTIVE):
i.group = USER_GROUP.NORMAL
i.save()
# 老用户全部设置为非新用户
for i in UserModel.select().where(UserModel.is_new_user == False):
i.is_new_user = True
i.save()
def get_user_info(user_id: int):
response = HttpUtils.make_get_request(
"{}/{}".format(USER_MICROSERVICE_URL, user_id)
)
if response is None:
return HttpUtils.error_message(500, "Can't retrieve info about yourself")
user = UserModel()
user.fill_from_json(response)
return user
def test_db():
main_dir = os.path.split(os.path.abspath(__file__))[0]
db_engine = sa.create_engine(f'sqlite:///{os.path.join(main_dir, "data/adarith.db?check_same_hread=False")}', echo=True)
Base.metadata.create_all(db_engine)
db_session = sessionmaker(bind=db_engine)
db_session = db_session()
UserModel.init_user(db_session)
SettingModel.init_setting(db_session)
QuestionModel.init_question(db_session)
def __init__(self):
"""
initialize the
loads imported functions into self parameters
"""
self.view = CLIView()
self.cli_model = CLIModel('model/cli_account_model.csv')
self.accounts = AccountModel()
self.user_model = UserModel('model/user_model.csv')
self.transaction_model = TransactionModel()
self.state = 0
self.uid = ''
self.account_number = ''
self.account_type = ''
def update_password(self):
try:
um = UserModel(self.ansible_json)
except Exception as error:
gen_log.error(error.args)
raise Exception('Args Wrong:%s' % error.args)
else:
play_tasks_list = list()
play_tasks_list.append(um.change_password())
try:
result = yield self.run(play_tasks_list)
except Exception as ex:
raise ex
else:
raise Return(result)
async def qn_callback(self):
"""
七牛回调
:return:
"""
from lib import qn
ua = self.headers.get('User-Agent', None)
if not (ua and ua.startswith('qiniu-callback')):
return self.finish(RETCODE.FAILED)
auth = self.headers.get('Authorization', None)
if auth:
content = str(await self._request.content.read(), 'utf-8')
if qn.verify_callback(auth, str(self._request.url), content):
# 鉴权成功，确认为七牛服务器回调
info = json.loads(content)
uid = binhex.to_bin(info['user_id'])
# 说明一下，这个哈希值不是base64 hex等编码，具体比较奇怪看了就知道了
# 总之因此直接使用了TextField来存放
key = info['key']
UploadModel.new(uid, key, info['size'], info['ext'],
info['type_name'], info['image_info'])
if info['type_name'] == 'avatar':
# 更换用户头像
u = UserModel.get_by_pk(uid)
if u:
u.avatar = key
u.save()
return self.finish(RETCODE.SUCCESS, key)
self.finish(RETCODE.FAILED)
async def on_update(cls,
info: QueryInfo,
values: 'ValuesToWrite',
when_before_update: List[Callable[[IDList],
Awaitable]],
when_complete: List[Callable[[], Awaitable]],
perm: PermInfo = None):
if 'password' in values:
ret = UserModel.gen_password_and_salt(values['password'])
values.update(ret)
async def signup_confirm_by_email(self):
""" 确认并创建账户 """
vpost: SignupConfirmByEmailDataModel = self._.validated_post
password = await UserModel.check_reg_code_by_email(vpost.email, vpost.code)
if not password:
return self.finish(RETCODE.FAILED, '验证码不正确')
u = UserModel.new(None, password, {'email': vpost.email}, auto_nickname=True)
await self.signup_cleanup(u)
def post(self):
user = UserModel()
user_json = json_decode(self.request.body)
user.user_name = user_json['user_name']
user.name = user_json['user_name_cn']
user.user_password = user_json['user_password']
user.email = user_json['email']
user.mobile = user_json['mobile']
user.join_date = user_json['date']
result = yield user.add_user()
if result == 1:
self.write(self.return_json(0, '已注册'))
elif result == -1:
self.write(self.return_json(-1, '用户名已存在'))
async def signup_by_direct(self):
if self.current_user:
return self.finish(RETCODE.PERMISSION_DENIED) # 已登录用户凑什么热闹
vpost: SignupDirectDataModel = self._.validated_post
extra_values = {
'email': vpost.email,
'ip_registered': await get_fuzz_ip(self)
}
u = UserModel.new(vpost.nickname, vpost.password, extra_values=extra_values, is_for_tests=False, auto_nickname=False)
await self.signup_cleanup(u)
def work():
try:
db.execute_sql(
'ALTER TABLE public.comment ADD reply_to_cmt_id BYTEA NULL;')
except:
db.rollback()
for i in UserModel.select().execute():
try:
UserNotifRecord.create(id=i.id, update_time=int(time.time()))
except peewee.IntegrityError:
db.rollback()
async def change_password(self):
if self.current_user:
vpost: ChangePasswordDataModel = self._.validated_post
u: UserModel = self.current_user
if UserModel.auth_by_mail(u.email, vpost.old_password):
u.set_password(vpost.password)
k = u.refresh_key()
self.finish(RETCODE.SUCCESS, k['key'])
else:
self.finish(RETCODE.FAILED, {'old_password': ['旧密码不正确']})
else:
self.finish(RETCODE.PERMISSION_DENIED)
def es_update_topic(id):
post: TopicModel = TopicModel.get_by_id(id)
if not post: return
u: UserModel = UserModel.get_by_id(post.user_id)
if not u: return
body = get_post_base_body(post)
body.update({
'user_nickname': u.nickname,
'content': post.content,
'brief': post.content[:100]
})
es.index(index=INDEX_NAME, doc_type="doc", id=to_hex(post.id), body=body)
def signup():
"""회원가입"""
# flask request 값 가져오기
username = request.form["username"]
password = request.form["password"]
name = request.form["name"]
email = request.form["email"]
# sqlalchemy를 이용하여 db에 사용자 저장하기
user = UserModel(username, password, name, email)
session.add(user)
session.commit()
return "SUCCESS"
def post(self):
attrib = reqparse.RequestParser()
attrib.add_argument('username', type=str, required=True)
attrib.add_argument('password', type=str, required=True)
data = attrib.parse_args()
user = UserModel.find_user_by_username(data['username'])
if (user):
res = user.verify_password(data['password'], user.password)
if (res):
access_token = create_access_token(identity=user.user_id)
return {"token": access_token}, 200
return {"message": "Username or Password is incorrect"}, 401
def es_update_wiki(id):
post: WikiArticleModel = WikiArticleModel.get_by_id(id)
if not post: return
if post.flag: return
u: UserModel = UserModel.get_by_id(post.user_id)
if not u: return
body = get_post_base_body(post)
body.update({
'user_nickname': u.nickname,
'content': post.content,
'ref': post.ref,
'brief': post.content[:100]
})
es.index(index=INDEX_NAME, doc_type="doc", id=to_hex(post.id), body=body)
def es_update_comment(id):
post: CommentModel = CommentModel.get_by_id(id)
if not post: return
u: UserModel = UserModel.get_by_id(post.user_id)
if not u: return
p = POST_TYPES.get_post(post.related_type, post.related_id)
body = get_post_base_body(post)
body.update({
'user_nickname': u.nickname,
'content': post.content,
'brief': post.content[:100],
'related_title': p.get_title() if p else None,
'related_type': post.related_type,
'related_id': to_hex(post.related_id)
})
es.index(index=INDEX_NAME, doc_type="doc", id=to_hex(post.id), body=body)
def work():
sql_execute(
'ALTER TABLE "topic" ADD COLUMN "update_time" BIGINT NULL DEFAULT NULL ;'
)
sql_execute(
'ALTER TABLE "user" ADD COLUMN "ip_registered" inet NULL DEFAULT NULL;'
)
sql_execute('drop table "notif";')
sql_execute('drop table "mention";')
sql_execute('drop table "user_notif_record";')
db.create_tables([UserNotifLastInfo], safe=True)
for i in UserModel.select().execute():
try:
UserNotifLastInfo.create(id=i.id, update_time=int(time.time()))
except peewee.IntegrityError as e:
print(e)
db.rollback()
def signup():
"""회원가입"""
# flask request 값 가져오기
username = request.json["username"]
password = request.json["password"]
name = request.json["name"]
email = request.json["email"]
user = session.query(UserModel).filter(UserModel.username == username).one_or_none()
if user is not None:
return Response("이미 존재하는 username입니다.", status=400)
# sqlalchemy를 이용하여 db에 사용자 저장하기
user = UserModel(username, password, name, email)
session.add(user)
session.commit()
return Response("SUCCESS", status=201)
async def validate_password_reset(self):
"""
忘记密码后，进入重设流程时，通过此接口提交校验码和新密码
:return:
"""
vpost: ValidatePasswordResetPostDataModel = self._.validated_post
user = await UserModel.check_reset_key(vpost.uid, vpost.code)
if user:
info = UserModel.gen_password_and_salt(vpost.password)
user.password = info['password']
user.salt = info['salt']
user.reset_key = None
user.save()
UserToken.clear_by_user_id(user.id)
t: UserToken = await self.setup_user_token(user.id)
self.finish(RETCODE.SUCCESS, {'id': user.id, 'nickname': user.nickname, 'access_token': t.get_token()})
else:
self.finish(RETCODE.FAILED)
def create_user(self, req):
try:
user_resp = UserModel(**req).save()
return json.dumps({'id': str(user_resp.id)})
except NotUniqueError as notUniqueErr:
logger.exception('******** Erro ao criar um usuário: ' + str(req))
logger.exception('Trace: ' + str(notUniqueErr) + '\n')
return json.dumps(errors['EmailAlreadyExistsError'])
except FieldDoesNotExist as notExistErr:
logger.exception('******** Erro ao criar um usuário: ' + str(req))
logger.exception('Trace: ' + str(notExistErr) + '\n')
return json.dumps(errors['FieldDoesNotExist'])
except SchemaValidationError as schemaVal:
logger.exception('******** Erro ao criar um usuário: ' + str(req))
logger.exception('Trace: ' + str(schemaVal) + '\n')
return json.dumps(errors['SchemaValidationError'])
except Exception as genericErr:
logger.exception('******** Erro ao criar um usuário: ' + str(req))
logger.exception('Trace: ' + str(genericErr) + '\n')
return json.dumps(errors['InternalServerError'])
async def request_password_reset(self):
"""
申请重置密码 / 忘记密码
:return:
"""
vpost: RequestResetPasswordDataModel = self._.validated_post
try:
user: UserModel = UserModel.get(UserModel.nickname == vpost.nickname, UserModel.email == vpost.email)
except UserModel.DoesNotExist:
user = None
if user:
if await user.can_request_reset_password():
key = user.gen_reset_key()
user.reset_key = key
user.save()
await mail.send_password_reset(user)
return self.finish(RETCODE.SUCCESS, {'id': user.id, 'nickname': user.nickname})
self.finish(RETCODE.FAILED)
def post(self):
user = UserModel()
user_json = json_decode(self.request.body)
user.user_name = user_json['user_name']
user.user_password = user_json['user_password']
user_exist = yield user.get_id_by_name()
if user_exist == 0:
self.write(self.return_json(-1, '用户名不存在'))
return
eq_password = yield user.get_password()
if eq(eq_password, user.user_password):
user_name = self.request.headers['User-Name']
session_id = self.create_signed_value('user-key', user_name)
session = SessionUtil(session_id,
self.application.async_session_pool)
yield session.set_session()
self.set_secure_cookie('user-key', user_name, expires_days=1)
self.write(self.return_json(0, 'login'))
else:
self.write(self.return_json(1, '用户名或者密码错误'))
def createdb():
db.create_all()
admin = {"username": "******", "password": "******"}
user = UserModel(**admin)
user.save_user()
def get_current_user(self):
email = self.get_argument("email", "")
token = self.get_argument("token", "")
user = UserModel.get_current_user(email, token)
self.user = user
return bool(self.user)
from model.state_model import StateModel
from model.user_model import UserModel
from model.transaction_model import TransactionModel
from model.account_model import AccountModel
from controller.button_controller import ButtonController
from controller.login_controller import LoginController
from controller.transaction_controller import TransactionController
from constants import *
if __name__ == "__main__":
root = Tk()
atm_View = atm_view(root)
state_model = StateModel()
account_model = AccountModel()
trans_model = TransactionModel()
usr_db = UserModel(USER_DB_FILE)
atm_btn_controller = ButtonController(atm_View, state_model)
atm_login_ctrl = LoginController(atm_View, state_model, usr_db)
atm_trans_ctrl = TransactionController(atm_View, state_model, account_model, trans_model)
state_model.state = "Card"
cwd = os.getcwd()
print(cwd)
mainloop()
async def get_user_data(self):
code = self.params
print(code)
code = code['code']
if code == 'undefined':
self.finish(RETCODE.FAILED)
return
otoken, _ = await self.github.get_access_token(code)
github = GithubClient(
client_id=config.CLIENT_ID,
client_secret=config.CLIENT_SECRET,
access_token=otoken,
)
response = await github.request('GET', 'user')
# response = json.loads(response)
if response['id']:
try:
account = UserOAuth.get(UserOAuth.login_id == response['id'],
UserOAuth.platform == 'github')
except UserOAuth.DoesNotExist:
account = None
if account:
if account.user_id: # 返回用户已有信息
u = UserModel.get_by_pk(account.user_id)
if u:
expires = 30
u.refresh_key()
self.setup_user_key(u.key, expires)
self.finish(
RETCODE.SUCCESS, {
'oauthcode': 0,
'user_id': account.user_id,
'state': account.state,
'access_token': u.key
})
else:
self.finish(
RETCODE.SUCCESS, {
'oauthcode': 1,
'state': account.state,
'oauth_id': account.id,
'login_id': account.login_id,
'platform': account.platform
})
else:
ins = [{
'login_id': response['id'],
'time': time.time(),
'platform': 'github',
'state': POST_STATE.APPLY
}]
if not isinstance(config.LONG_ID_GENERATOR,
config.SQLSerialGenerator):
ins[0]['id'] = config.LONG_ID_GENERATOR().to_bin()
UserOAuth.insert_many(ins).execute()
self.finish(
RETCODE.SUCCESS, {
'oauthcode': 1,
'oauth_id': ins[0]['id'],
'state': ins[0]['state'],
'login_id': ins[0]['login_id'],
'platform': ins[0]['platform']
})
else:
self.finish(RETCODE.NOT_FOUND)
def get_user_by_token(self: Union['BaseUserViewMixin', 'BaseView'],
token) -> Type[BaseUser]:
t = UserToken.get_by_token(token)
if t: return UserModel.get_by_pk(t.user_id)
def post(self):
email = self.get_argument("email", None)
password = self.get_argument("password", None)
result = UserModel.sign_in(email, password)
self.write(result)
def send_possible_covid_contact():
"""
This is the unique method to send the possible covid19 contacts email.
:return: the flask response that looks like {"result": "OK"} with status code 200
{
"friends": ["[email protected]],
"contacts": [{
"email": user.email,
"name": user.firstname,
"restaurant_name": restaurant.name,
"date": start,
}],
"past_restaurants": [{
"email": restaurant["owner_email"],
"name": restaurant["name"],
"date": start,
}],
"reservation_restaurants": [{
"email": restaurant["owner_email"],
"name": restaurant["name"],
"date": date,
"customer_email": customer_email,
}],
}
"""
json_request = request.get_json()
current_app.logger.debug("Request with body\n{}".format(json_request))
json_friends = json_request["friends"]
current_app.logger.debug("List of friend is: {}".format(json_friends))
for json_friend in json_friends:
DispatcherMessage.send_message(
EMAIL_TO_FRIEND,
[
json_friend,
"",
"",
],
)
# A message to the friends, it take the following paramiters
# to_email, date_possible_contact, restaurant_name
json_users = json_request["contacts"]
contacts = []
for json_user in json_users:
user_positive = UserModel()
user_positive.fill_from_json(json_user)
contacts.append(user_positive)
# A message to the restaurants booking
# to_email, to_name, email_user, restaurant_name
json_restaurant = json_request["past_restaurants"]
restaurants = []
for json_rest in json_restaurant:
restaurant = PastRestaurantsModel()
restaurant.fill_from_json(json_rest)
restaurants.append(restaurant)
DispatcherMessage.send_message(
NEW_POSITIVE_WAS_IN_RESTAURANT,
[
restaurant.owner_email,
restaurant.owner_email,
str(restaurant.date_booking),
restaurant.name,
],
)
json_restaurant = json_request["reservation_restaurants"]
restaurants = []
for json_rest in json_restaurant:
restaurant = FutureRestaurantsModel()
restaurant.fill_from_json(json_rest)
restaurants.append(restaurant)
DispatcherMessage.send_message(
NEW_COVID_TO_RESTAURANT_BOOKING,
[
restaurant.owner_email,
restaurant.owner_email,
str(restaurant.date_booking),
restaurant.name,
],
)
return {"result": "OK"}, 200
def nickname_exists_check(name):
if list(UserModel.select().where(UserModel.nickname == name)):
raise ValidationError('此昵称已被占用')
return True
def email_exists_check(email):
if list(UserModel.select().where(UserModel.email == email)):
raise ValidationError('此邮箱已注册')
return True
