def login(
user_schema: UserSchema = Body(..., embed=True, alias="user"),
session: Session = Depends(get_session),
):
user_service = UserService(session)
auth_service = AuthenticationService(session)
if not user_service.get_by_email(user_schema.email):
raise HTTPException(
status_code=HTTP_404_NOT_FOUND,
detail='E-mail não encontrado'
)
try:
token = auth_service.get_token(
user_schema.email,
user_schema.password
)
except EmailOrPasswordInvalid:
raise HTTPException(
status_code=HTTP_401_UNAUTHORIZED,
detail='E-mail ou senha inválido'
)
return {
'message': 'Login efetuado',
'token': token
}
def post_favorite_tourist_spot(
id: int,
session: Session = Depends(get_session),
authorization: str = Depends(api_key_authorization),
) -> Success:
try:
token = JWT().validate(authorization)
except JWTExceptionExpired:
raise HTTPException(
status_code=HTTP_401_UNAUTHORIZED,
detail='Recurso não autorizado'
)
user_service = UserService(session)
user = user_service.get_by_email(token['email'])
tourist_spot_service = TouristSpotService(session)
try:
tourist_spot = tourist_spot_service.get_by_id(id)
except NoResultFound:
raise HTTPException(
status_code=HTTP_404_NOT_FOUND,
detail='Ponto turistico não encontrado'
)
favorite_service = FavoriteTouristSpotService(session)
favorite_service.insert({
'user_id': user.id,
'tourist_spot_id': tourist_spot.id
})
return Success(
message='Ponto turistico favoritado com sucesso'
)
def delete_user(user_id):
if not UserService.exist_by_id(user_id):
raise NotFoundException(pointer="user", message="not found")
user = UserService.remove_by_id(user_id)
return user.to_dict()
def notes():
token = request.cookies.get('token')
if token:
user = UserService.get_user_info(token)
uid = user['uid']
note_list = UserService.get_notes(uid)
note_list_update = UserService.update_Abbreviation(note_list)
return render_template('notes.html', note_list=note_list_update)
def delete(note_id):
"""uid = UserService.get_uid_by_note_id(note_id)
UserService.delete_note(note_id)
note_list = UserService.get_notes(uid)
note_list_update = UserService.update_Abbreviation(note_list)
return render_template('notes.html', note_list = note_list_update)"""
UserService.delete_note(note_id)
resp = make_response(redirect('/notes', '302'))
return resp
def createnote():
if request.method == 'POST':
title = request.form['title']
content = request.form['content']
token = request.cookies.get('token')
if token:
user = UserService.get_user_info(token)
uid = user['uid']
UserService.createnote(uid, title, content)
resp = make_response(redirect('/', '302'))
return resp
elif request.method == 'GET':
return render_template('note.html')
def join(sid, data):
user = data["user"]
room_id = data["room_id"]
sio.enter_room(sid, room_id)
if not RoomService.exist_by_id(room_id):
sio.emit("not_found_error", "room")
sio.leave_room(sid, room_id)
return
if not UserService.exist_by_id(user["id"]):
sio.emit("not_found_error", "user")
sio.leave_room(sid, room_id)
if ParticipantService.is_creator(room_id, user["id"]):
participant = ParticipantService.by_room_id(room_id)
data = {"participants": participant, "messages": []}
sio.emit("user_connected", data, room=room_id)
return
if ParticipantService.exists_by_user_id_room_id(user["id"], room_id):
sio.emit("conflict_error", "participant")
sio.leave_room(sid, room_id)
return
ParticipantService.add(room_id, user["id"])
participants = ParticipantService.by_room_id(room_id)
messages = MessageService.by_room_id(room_id)
data = {"participants": participants, "messages": messages}
sio.emit("user_connected", data, room=room_id)
return
def post(self):
body = json_body_validator(SignInSchema)
username = body.get("username", "Guest")
email = body["email"]
if UserService.exists_by_email(email):
user = UserService.get_by_email(email)
session["id"] = user.id
return {"data": user.to_dict()}
user = UserService.add(username, email)
session["id"] = user.id
return {"data": user.to_dict()}
def post(self):
if "id" not in session:
raise Unauthorized()
user = UserService.get(session["id"])
return authorization.create_authorization_response(grant_user=user)
def welcome():
token = request.cookies.get('token')
if token:
user = UserService.get_user_info(token)
else:
user = {}
return render_template('welcome.html', user=user)
def create_user():
body = body_validator(UserSchema)
user_name = body["name"]
icon_color = body["icon_color"]
user = UserService.add(user_name, icon_color)
return user.to_dict()
def delete(self):
if "id" not in session:
raise Unauthorized()
user = UserService.get(session["id"])
del session["id"]
return {"data": user.to_dict()}
def signup(
user_schema: UserSchema = Body(..., embed=True, alias="user"),
session: Session = Depends(get_session),
) -> ObjectCreate:
user_service = UserService(session)
if user_service.get_by_email(user_schema.email):
raise HTTPException(
status_code=HTTP_401_UNAUTHORIZED,
detail='Usuário já criado'
)
user = user_service.insert(user_schema.dict())
return ObjectCreate(
message='Usuário criado com sucesso',
object_id=user.id
)
def register():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
user = UserService.register(username, password)
resp = make_response(redirect('/', '302'))
resp.set_cookie('token', user['token'])
return resp
elif request.method == 'GET':
return render_template('register.html')
def get_favorite_tourist_spot(
offset: int = 0,
limit: int = 100,
session: Session = Depends(get_session),
authorization: str = Depends(api_key_authorization),
) -> FavoriteTouristSpotPagedSchema:
try:
token = JWT().validate(authorization)
except JWTExceptionExpired:
raise HTTPException(status_code=HTTP_401_UNAUTHORIZED,
detail='Recurso não autorizado')
user_service = UserService(session)
user = user_service.get_by_email(token['email'])
favorites = user_service.get_favorite_tourist_spots(offset, limit, user.id)
return FavoriteTouristSpotPagedSchema(items=favorites,
total=len(favorites))
def login():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
expire_time = 7 * 24 * 60 * 60
user = UserService.login(username, password, expire_time)
resp = make_response(redirect('/', '302'))
resp.set_cookie('token', user['token'])
return resp
elif request.method == 'GET':
return render_template('login.html')
def __init__(self, *args, **kwargs):
super(BaseHandler, self).__init__(*args, **kwargs)
self.set_header("Access-Control-Allow-Origin", "*")
self.set_header("Access-Control-Allow-Headers", "*")
self.set_header("Access-Control-Allow-Credentials", "true")
self.set_header("Access-Control-Max-Age", "1728000")
self.set_header('Access-Control-Allow-Methods',
'POST, GET, OPTIONS, PUT')
self.user_serv = UserService()
self.index_serv = IndexService()
self._app_err_code = None
def note_delete(note_id):
token = request.cookies.get('token')
if token:
# 根据token获取user_id
uid = UserService.get_user_id_by_token(token)
if request.method == 'POST':
NoteService.delete_note_info(note_id, uid)
resp = make_response(redirect('/note', '302'))
return resp
else:
resp = make_response(redirect('/login', '302'))
return resp
def get(self):
if "id" not in session:
raise Unauthorized()
user = UserService.get(session["id"])
try:
grant = authorization.validate_consent_request(end_user=user)
except OAuth2Error as e:
return e.error
return render_template('authorize.html', user=user, grant=grant)
def note():
# 获取当前token
token = request.cookies.get('token')
if token:
# 根据token获取user_id
uid = UserService.get_user_id_by_token(token)
# user = UserService.get_user_info(token)
# uid = user.get('uid')
# 根据user_id 获取note_list
note_list = NoteService.get_note_list(uid)
return render_template('note_list.html', note_list=note_list)
else:
resp = make_response(redirect('/login', '302'))
return resp
def create_room():
body = body_validator(CreateRoomSchema)
room_name = body["name"]
creator = body["creator"]
if not UserService.exist_by_id(creator):
raise NotFoundException(pointer="user", message="not found")
if RoomService.exist_by_id(room_name):
raise ConflictException(pointer="room", message="exists")
room = RoomService.add(room_name, creator)
ParticipantService.add(room.id, creator, is_creator=True)
return room.to_dict()
def note_detail(note_id):
token = request.cookies.get('token')
if token:
# 根据token获取user_id
uid = UserService.get_user_id_by_token(token)
if request.method == 'POST':
title = request.form['title']
content = request.form['content']
NoteService.update_note_info(note_id, uid, title, content)
resp = make_response(redirect(f'/note/{note_id}', '302'))
return resp
elif request.method == 'GET':
# 通过note_id, user_id查看当前笔记
note_info = NoteService.get_note_info(note_id, uid)
return render_template('note_info.html', note_info=note_info)
else:
resp = make_response(redirect('/login', '302'))
return resp
# encoding: utf-8
"""
首页
@author Yuriseus
@create 2016-8-1 18:09
"""
from service.user import UserService
from .base import BaseHandler
service = UserService()
class IndexHandler(BaseHandler):
def get(self):
pagination = service.get_users()
users = pagination.items
print(users)
self.finish('Hello %s' % self.session['user'])
def logout():
token = request.cookies.get('token')
UserService.delete_token_info(token)
resp = make_response(redirect('/', '302'))
resp.delete_cookie('token')
return resp
from flask import Blueprint, request, jsonify
from service.user import UserService
user = Blueprint("user", __name__)
user_service = UserService()
@user.route("/user", methods=["POST"])
def add_user():
u = request.get_json()
return user_service.add_user(u), 201
@user.route("/user", methods=["GET"])
def get_all_users():
return jsonify(user_service.get_users())
class ServiceMixin(object):
s_test = TestService()
s_login = LoginService()
s_user = UserService()
from colorama import Fore, Style
from getpass import getpass
from service.user import UserService
from service.news import NewsService
from service.role import RoleService
from service.type import TypeService
import os, sys, time, mysql
__user_service = UserService()
__news_service = NewsService()
__role_service = RoleService()
__type_service = TypeService()
def cls():
os.system("cls")
def back_to_previous():
print(Fore.LIGHTRED_EX, "\n\t------------------------------")
print(Fore.LIGHTRED_EX, "\t 任意时刻输入Q/q，返回上一级")
print(Fore.LIGHTRED_EX, "\t------------------------------")
print(Style.RESET_ALL)
def page_bottom():
print(Fore.LIGHTBLUE_EX, "\n\t----------------------------------------")
print(Fore.LIGHTGREEN_EX, "\t%d/%d" % (page, count_page),
" prev.上一页 | next.下一页")
print(Fore.LIGHTBLUE_EX, "\t----------------------------------------")
print(Style.RESET_ALL)
def __init__(self, *args, **kwargs):
super(BaseApiHandler, self).__init__(*args, **kwargs)
self.user_model = UserModel()
self.user_service = UserService()
'path': '../http'
}),
('/.*', Web404Handler),
],
cookie_secret=config.COOKIE_SECRET,
compress_response=True,
debug=config.DEBUG,
autoescape='xhtml_escape',
ui_modules=ui_modules,
xheaders=True,
)
global srv
srv = tornado.httpserver.HTTPServer(app)
if not config.DEBUG: srv.add_sockets(sock)
else: srv.listen(config.PORT)
Service.User = UserService(db, rs)
Service.Problem = ProblemService(db, rs)
Service.Submission = SubmissionService(db, rs)
Service.Testdata = TestdataSerivce(db, rs)
Service.Bulletin = BulletinService(db, rs)
Service.Execute = ExecuteService(db, rs)
Service.Contest = ContestService(db, rs)
Service.Verdict = VerdictService(db, rs)
Service.Group = GroupService(db, rs)
Service.Tags = TagService(db, rs)
Service.School = SchoolService(db, rs)
Service.VerdictString = VerdictStringService(db, rs)
Service.Score = ScoreService(db, rs)
Service.Upload = UploadService(db, rs)
Service.Permission = PermissionService
signal.signal(signal.SIGTERM, sig_handler)
def get_note_content(note_id):
note = UserService.get_note_content(note_id)
return render_template('content.html', note=note)