def login(cls, email, pwd):
# 아이디, pwd 확인
cls.logger.info("login 진입")
cls.logger.info(email)
cls.logger.info(pwd)
with session_scope() as session:
customer = session.query(Customer).filter(
Customer.email == email).first()
cls.logger.info("{} 조회성공".format(customer.email))
if customer is None:
response = set_response("99", {"errorMsg": "존재하지 않는 이메일입니다."})
return response
try:
cid = customer.cid
cus_pwd = customer.password
salt = customer.salt
pwd = AccountUtils.set_pwd(pwd, salt)
isauth = AccountUtils.chk_pwd(pwd, cus_pwd)
if isauth:
cus = {'email': email, 'uid': cid}
access_token = AccountUtils.get_token(cus)
response = set_response("00", {"token": access_token})
else:
response = set_response("99", {"errorMsg": '회원정보가 틀렸습니다.'})
except BaseException as e:
cls.logger.warning("크리티컬 이슈")
cls.logger.warning(e)
response = set_response("99", {"errorMsg": '토큰 생성 실패'})
cls.logger.info("login response==")
cls.logger.info(response)
return response
def get(self, post_id=None):
try:
parser = reqparse.RequestParser()
parser.add_argument('is_grade') # 채점여부
parser.add_argument('is_teacher_view') # 선생확인여부
parser.add_argument('is_grade_view') # 내가 확인함
filters = parser.parse_args()
user_type = request.args.get('user_type')
if user_type is not None and user_type == "cus":
filters['author'] = g.uid
elif user_type == "teacher":
if post_id is None:
response = set_response("77", "잘못된 접근입니다.")
return response
else:
answer_post = AnswerPostService.mysql_fetch_answer_post_p(post_id, True)
response = set_response("00", {"answer_post": answer_post})
return response
if post_id is not None:
answer_post = AnswerPostService.mysql_fetch_answer_post_p(post_id)
response = set_response("00", {"answer_post": answer_post})
return response
count, answer_post = AnswerPostService.mysql_fetch_answer_post(filters)
response = set_response("00", {"answer_post": answer_post, "count": count})
except BaseException as e:
self.logger.warning("answer get error")
self.logger.warning(e)
response = set_response("77", {"errorMsg": "답안 요청중 에러가 발생했습니다."})
return response
def create_user(cls, email, pwd):
cls.logger.info("create_user")
cus = None
try:
salt = AccountUtils.getn_salt()
hashed_pwd = AccountUtils.set_pwd(pwd, salt)
cid = AccountUtils.get_timestamp('CUS')
with session_scope() as session:
customer = Customer()
customer.cid = cid
customer.salt = salt
customer.email = email
customer.password = hashed_pwd
session.add(customer)
cus = {'email': email, 'uid': cid}
except BaseException as e:
cls.logger.warning("유저 생성중 문제가 발생했습니다.")
cls.logger.warning(e)
return set_response("99", {"errorMsg": "유저 생성중 문제가 발생했습니다."})
try:
access_token = AccountUtils.get_token(cus)
except BaseException as e:
cls.logger.warning("토큰 생성중 에러가 발생했습니다.")
cls.logger.warning(e)
return set_response("99", {"errorMsg": "토큰 생성중 에러가 발생했습니다."})
return set_response("00", {'token': access_token})
def create_user(cls, email, pwd):
cls.logger.info("create_user Teacher")
cls.logger.info(email)
cls.logger.info(pwd)
cus = None
try:
salt = AccountUtils.getn_salt()
hashed_pwd = AccountUtils.set_pwd(pwd, salt)
tid = AccountUtils.get_timestamp('TEA')
with session_scope() as session:
teacher = Teacher()
teacher.tid = tid
teacher.salt = salt
teacher.email = email
teacher.password = hashed_pwd
session.add(teacher)
tea = {
'email': email,
'uid': tid
}
except BaseException as e:
cls.logger.warning("유저 생성중 문제가 발생했습니다.")
cls.logger.warning(e)
return set_response("99", {"errorMsg": "유저 생성중 문제가 발생했습니다."})
try:
access_token = AccountUtils.get_token(tea)
except BaseException as e:
cls.logger.warning("토큰 생성중 에러가 발생했습니다.")
cls.logger.warning(e)
return set_response("99", {"errorMsg": "토큰 생성중 에러가 발생했습니다."})
return set_response("00", {'token': access_token})
def mysql_update_answer_post(cls, post_id, comment, score):
with session_scope() as session:
answer_model = session.query(AnswerPost).filter(
AnswerPost.id == post_id).first()
if answer_model.is_grade == True:
response = set_response("77", {"errorMsg": "이미 첨삭된 답안입니다."})
answer_model.is_grade = True
answer_model.score = score
answer_model.comment = comment
response = set_response("00", {"successMsg": "성공적으로 채점되었습니다."})
return response
def get(self):
filters = request.args
try:
problem_posts = ProblemPostService.mysql_fetch_problem_post(
filters)
response = set_response("00", {"problem_posts": problem_posts})
except BaseException as e:
self.logger.warning("problem post get error")
self.logger.warning(e)
response = set_response("88", {"errorMsg": "알수없는 에러"})
return response
def post(self):
try:
params = request.get_json()
email = params['email']
pwd = params['pwd']
# 이메일 존재하는지
if not TeaAuthService.IsUseAccount(email):
response = TeaAuthService.create_user(email, pwd) # 존재 하지 않다면 회원가입
else:
response = set_response("C01", "이미 존재하는 이메일 입니다.")
except BaseException as e:
error_msg = "시스템 에러가 발생했습니다."
self.logger.warning(error_msg)
self.logger.warning(e)
response = set_response("01", error_msg)
return jsonify(response)
def put(self, post_id=None):
try:
params = request.get_json()
comment = params['comment']
score = params['score']
response = AnswerPostService.mysql_update_answer_post(post_id, comment, score)
except BaseException as e:
self.logger.warning(e)
self.logger.warning("answer put!")
response = set_response("88", {"errorMsg": "문제 채점중 에러가 발생했습니다."})
return response
def login(cls, email, pwd):
# 아이디, pwd 확인
with session_scope() as session:
teacher = session.query(Teacher).filter(Teacher.email == email).first()
if teacher is None:
response = set_response("99", {"errorMsg": "존재하지 않는 이메일입니다."})
return response
tid = teacher.tid
cus_pwd = teacher.password
salt = teacher.salt
pwd = AccountUtils.set_pwd(pwd, salt)
isauth = AccountUtils.chk_pwd(pwd, cus_pwd)
if isauth:
cus = {
'email': email,
'uid': tid
}
access_token = AccountUtils.get_token(cus)
response = set_response("00", {"token": access_token})
else:
response = set_response("99", {"errorMsg": '회원정보가 틀렸습니다.'})
return response
def post(self):
try:
params = request.get_json()
email = params['email']
pwd = params['pwd']
# 로그인
response = TeaAuthService.login(email, pwd)
except BaseException as e:
error_msg = "시스템 에러가 발생했습니다."
self.logger.warning(error_msg)
self.logger.warning(e)
response = set_response("01", error_msg)
return jsonify(response)
def mysql_create_answer_post(cls, params, file=None):
answer_post = {}
if file is not None:
img_path = upload_img('answers', file)
params['answer_img'] = img_path
with session_scope() as session:
now = int(dt.now().timestamp() * 10000000)
params['created_at'] = now
params['updated_at'] = now
answer_post_model = AnswerPost(**params)
session.add(answer_post_model)
response = set_response("00", {"img_url": img_path})
cls.logger.info(response)
return response
def mysql_create_problem_post(cls, params, file=None):
problem_post = {}
if file is not None:
img_path = upload_img('problems', file)
params['problem_img'] = img_path
with session_scope() as session:
now = int(dt.now().timestamp() * 10000000)
params['view'] = 0
params['created_at'] = now
params['updated_at'] = now
problem_post_model = ProblemPost(**params)
session.add(problem_post_model)
response = set_response("00", {"successMsg": "성공적으로 등록되었습니다."})
return response
def post(self):
self.logger.info("---> ProblemPost create")
try:
params = request.get_json()
self.logger.info(params)
if params is None:
parser = reqparse.RequestParser()
parser.add_argument('max_time')
parser.add_argument('title')
parser.add_argument('sub_title')
parser.add_argument('subject')
parser.add_argument('category')
parser.add_argument('author')
parser.add_argument('affiliation')
args = parser.parse_args()
self.logger.info(args)
params = {
'max_time': args.max_time,
'title': args.title,
'sub_title': args.sub_title,
'subject': args.subject,
'category': args.category,
'author': args.author,
'affiliation': args.affiliation
}
self.logger.info("파라미터")
self.logger.info(params)
file = request.files['file']
self.logger.info(params)
self.logger.info(file)
response = ProblemPostService.mysql_create_problem_post(
params, file)
print(file)
except BaseException as e:
self.logger.info("problemPost create params error")
self.logger.info(e)
response = set_response("88", {"errorMsg": "문제를 생성중 에러가 발생했습니다."})
return response
def post(self, post_id=None):
self.logger.info("---> ProblemPost create")
author = g.uid
if author is None:
return abort(401)
try:
params = request.get_json()
self.logger.info(params)
if params is None:
parser = reqparse.RequestParser()
parser.add_argument('time')
parser.add_argument('is_over')
parser.add_argument('problem_post')
args = parser.parse_args()
self.logger.info(args)
params = {
'time': args.time,
'is_over': True if args.is_over == "true" else False,
'problem_post': args.problem_post,
'author': author
}
self.logger.info("파라미터")
self.logger.info(params)
file = request.files['file']
self.logger.info(params)
self.logger.info(file)
response = AnswerPostService.mysql_create_answer_post(params, file)
print(file)
except BaseException as e:
self.logger.info("answer create params error")
self.logger.info(e)
response = set_response("88", {"errorMsg": "문제를 생성중 에러가 발생했습니다."})
return response
