def decorated_function(*args, **kwargs):
try:
# moved from URL, error will occur
if not request.referrer:
return unknown_error(get_message('invalidAccess'))
return f(*args, **kwargs)
except Exception:
return unknown_error ()
def team_information(teamName, error = None):
"""
when you push a team name of team page
"""
try:
# 팀 정보
try:
teamInformation = dao.query(Teams).\
filter(Teams.teamName == teamName,
Teams.isDeleted == ENUMResources().const.FALSE).first()
except Exception:
# None Type Exception
teamInformation = []
# 팀 멤버 정보
try:
teamMemberRecords = dao.query(RegisteredTeamMembers.teamMemberId).\
filter(RegisteredTeamMembers.teamName == teamName,
RegisteredTeamMembers.isDeleted == ENUMResources().const.FALSE).\
order_by(RegisteredTeamMembers.isTeamMaster.asc(),
RegisteredTeamMembers.teamMemberId.asc()).all()
except Exception:
# None Type Exception
teamMemberRecords = []
return render_template(HTMLResources().const.TEAM_INFORMATION_HTML,
SETResources = SETResources,
SessionResources = SessionResources,
LanguageResources = LanguageResources,
teamInformation = teamInformation,
teamMemberRecords = teamMemberRecords)
except Exception:
# Unknown Error
return unknown_error()
def submission_record(memberIdIndex, sortCondition, pageNum):
# Not Accept URL Check
if sortCondition not in (LanguageResources().const.SubmissionDate[1],
LanguageResources().const.Memory[1],
LanguageResources().const.FileSize[1],
LanguageResources().const.Runtime[1]):
return page_not_found()
try:
# Get MemberId
try:
member = select_member(memberIdIndex).first()
except Exception:
member = []
# 모든 제출 정보
submissions = select_all_submissions(memberIdIndex).subquery()
try:
# 차트 정보
chartSubmissionRecords = select_member_chart_submissions(submissions).first()
except Exception:
#None Type Exception
chartSubmissionRecords = []
# Viiew Value Text
chartSubmissionDescriptions = [LanguageResources().const.SolvedProblems,
LanguageResources().const.Count,
LanguageResources().const.Solved,
LanguageResources().const.WrongAnswer,
LanguageResources().const.TimeOver,
LanguageResources().const.MemoryOverflow,
LanguageResources().const.CompileError,
LanguageResources().const.RuntimeError]
try:
# 모든 제출 정보
count = select_count(submissions.c.memberId).first().\
count
# Sorted
submissionRecords = get_page_record(submissions_sorted(submissions,
sortCondition = sortCondition,
DESC = True),
pageNum = pageNum).all()
except Exception:
count = 0
submissionRecords = []
return render_template(HTMLResources().const.SUBMISSION_RECORD_HTML,
memberIdIndex = memberIdIndex,
sortCondition = sortCondition,
member = member,
submissionRecords = submissionRecords,
chartSubmissionDescriptions = chartSubmissionDescriptions,
chartSubmissionRecords = chartSubmissionRecords,
pages = get_page_pointed(pageNum = pageNum,
count = count))
except Exception as e:
# Unknow Error
return unknown_error(e)
def get_member_name(memberIdIndex):
try:
memberName = select_member(memberIdIndex = memberIdIndex).first().\
memberName
return memberName
except:
return unknown_error(get_message('dbError'))
def get_course_name(courseId):
try:
courseName = select_course_information(courseId).first().\
courseName
return courseName
except Exception as e:
return unknown_error(get_message('dbError'))
def get_member_name(memberId):
try:
memberName = select_match_member(MemberCourseProblemParameter(memberId = memberId)).first().\
memberName
return memberName
except Exception as e:
return unknown_error(get_message('dbError'))
def article_notice(filterCondition, keyWord, pageNum):
try:
# get Notice Articles
articlesOnBoard = select_articles().subquery()
# Get MemberId
articlesOnBoard = join_member_id(articlesOnBoard,
subMemberIdIndex = articlesOnBoard.c.\
writerIdIndex).subquery()
# Get Problem Name
articlesOnBoard = join_problems_name(
subquery=articlesOnBoard,
subProblemIndex=articlesOnBoard.c.problemIndex).subquery()
# 과목 공지글
try:
if request.method == 'POST':
for form in request.form:
# FilterCondition
if 'keyWord' != form:
filterCondition = form
keyWord = get_request_value(form=request.form,
name='keyWord')
pageNum = 1
if not keyWord:
keyWord = ' '
# Notices Sorted
articleNoticeRecords = select_sorted_articles(
articlesOnBoard,
FilterFindParameter(filterCondition,
(keyWord if keyWord != ' ' else '')),
isAll=True)
# Get Notices count
count = select_count(articleNoticeRecords.subquery().\
c.\
articleIndex).first().\
count
# Get Notices in Page
articleNoticeRecords = get_page_record(articleNoticeRecords,
pageNum=pageNum).all()
except Exception:
count = 0
articleNoticeRecords = []
return render_template(
HTMLResources().const.ARTICLE_NOTICE_HTML,
articleNoticeRecords=articleNoticeRecords,
pages=get_page_pointed(pageNum, count),
# 검색시 FilterCondition List
Filters=[
LanguageResources().const.All,
LanguageResources().const.Writer,
LanguageResources().const.Title
],
filterCondition=filterCondition,
keyWord=keyWord)
except Exception as e:
return unknown_error(e)
def get_used_language_version(usedLanguage):
try:
usedLanguageVersion = dao.query(Languages.languageVersion).\
first().\
languageVersion
except:
return unknown_error(get_message('dbError'))
return usedLanguageVersion
def get_problem_name(problemIndex):
try:
problemName = select_problem(problemIndex = problemIndex).first().\
problemName
return problemName
except:
return unknown_error(get_message('dbError'))
def id_check(select, error = None):
if request.method == 'POST':
# 암호를 입력 안했을 때
if not request.form['password']:
error ='Password' + get_message('fillData')
else:
try:
memberId = session[SessionResources().const.MEMBER_ID]
password = request.form['password']
check = select_match_member(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = memberId)).first()
# 암호가 일치 할 때
#Checking Success
if check_password_hash (check.password,
TripleDES.encrypt(str(password))):
# for all user
if select == 'account':
return redirect(url_for(RouteResources().const.EDIT_PERSONAL))
# server manager
elif SETResources().const.SERVER_ADMINISTRATOR in session[SessionResources().const.AUTHORITY][0]:
if select == 'server_manage_collegedepartment':
return redirect(url_for('.server_manage_collegedepartment',
collegePageNum = int(1),
departmentPageNum = int(1)))
elif select == 'server_manage_class':
return redirect(url_for('.server_manage_class',
pageNum = int(1)))
elif select == 'server_manage_problem':
return redirect(url_for('.server_manage_problem',
activeTabId = OtherResources().const.ALL,
pageNum = int(1)))
elif select == 'server_manage_user':
return redirect(url_for('.server_manage_user',
activeTabId = OtherResources().const.ALL,
pageNum = int(1)))
elif select == 'server_manage_service':
return redirect(url_for('.server_manage_service'))
# class manager
elif SETResources().const.COURSE_ADMINISTRATOR in session[SessionResources().const.AUTHORITY][0]:
if select == 'user_submit':
return redirect(url_for('.class_user_submit'))
elif select == 'cm_manage_problem':
return redirect(url_for('.class_manage_problem'))
elif select == 'cm_manage_user':
return redirect(url_for('.class_manage_user'))
elif select == 'cm_manage_service':
return redirect(url_for('.class_manage_service'))
else:
return unknown_error()
# 암호가 일치 하지 않을 때
else:
error = get_message('wrongPassword')
except Exception as e:
Log.error(str(e))
raise e
return render_template(HTMLResources().const.ID_CHECK_HTML,
error = error)
def get_member_name(memberId):
try:
memberName = dao.query(Members.memberName).\
filter(Members.memberId == memberId).\
first().\
memberName
return memberName
except Exception as e:
return unknown_error(get_message('dbError'))
def get_course_name(courseId):
try:
courseName = dao.query(RegisteredCourses.courseName).\
filter(RegisteredCourses.courseId == courseId).\
first().\
courseName
return courseName
except Exception as e:
return unknown_error(get_message('dbError'))
def problem(courseId, problemId, pageNum):
"""
use db to get its problem page
now, it moves to just default problem page
"""
try :
# Get startDateOfSubmission of Problem
try:
startDateOfSubmission = select_problems_of_course(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
courseId = courseId,
problemId = problemId)).first().\
startDateOfSubmission
except Exception:
startDateOfSubmission = None
# are Not Access. conditions is an Administrator and endOfSubmission ago
if SETResources().const.SERVER_ADMINISTRATOR in session[SessionResources().const.AUTHORITY]\
or SETResources().const.COURSE_ADMINISTRATOR in session[SessionResources().const.AUTHORITY]\
or startDateOfSubmission <= datetime.now():
try:
from GradeServer.utils.utilCodeSubmissionQuery import select_languages
languageInfoRecords = select_languages(courseId = courseId).all()
except Exception:
languageInfoRecords = []
try:
problemInformation = select_problem_informations(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
courseId = courseId,
problemId = problemId)).first()
except Exception:
problemInformation = []
browserName = request.user_agent.browser
browserVersion = request.user_agent.version
print browserName, browserVersion
return render_template(HTMLResources().const.PROBLEM_HTML,
SETResources = SETResources,
SessionResources = SessionResources,
LanguageResources = LanguageResources,
courseId = courseId,
problemId = problemId,
problemInformation = problemInformation,
problemName = problemInformation.problemName.replace(' ', ''),
languageInfoRecords = languageInfoRecords,
pageNum = pageNum,
browserName = browserName,
browserVersion = browserVersion)
# Access Rejection
else:
flash('제출 기간이 아닙니다!!!')
return redirect(url_for(RouteResources().const.PROBLEM_LIST,
courseId = courseId,
pageNum = pageNum))
except Exception:
return unknown_error()
def get_used_language_index(usedLanguageName):
try:
usedLanguageIndex = dao.query(Languages.languageIndex).\
filter(Languages.languageName == usedLanguageName).\
first().\
languageIndex
except Exception as e:
return unknown_error(get_message('dbError'))
return usedLanguageIndex
def article_notice(filterCondition, keyWord, pageNum):
try:
# get Notice Articles
articlesOnBoard = select_articles().subquery()
# Get MemberId
articlesOnBoard = join_member_id(articlesOnBoard,
subMemberIdIndex = articlesOnBoard.c.\
writerIdIndex).subquery()
# Get Problem Name
articlesOnBoard = join_problems_name(subquery = articlesOnBoard,
subProblemIndex = articlesOnBoard.c.problemIndex).subquery()
# 과목 공지글
try:
if request.method == 'POST':
for form in request.form:
# FilterCondition
if 'keyWord' != form:
filterCondition = form
keyWord = get_request_value(form = request.form,
name = 'keyWord')
pageNum = 1
if not keyWord:
keyWord = ' '
# Notices Sorted
articleNoticeRecords = select_sorted_articles(articlesOnBoard,
FilterFindParameter(filterCondition,
(keyWord if keyWord != ' '
else '')),
isAll = True)
# Get Notices count
count = select_count(articleNoticeRecords.subquery().\
c.\
articleIndex).first().\
count
# Get Notices in Page
articleNoticeRecords = get_page_record(articleNoticeRecords,
pageNum = pageNum).all()
except Exception:
count = 0
articleNoticeRecords = []
return render_template(HTMLResources().const.ARTICLE_NOTICE_HTML,
articleNoticeRecords = articleNoticeRecords,
pages = get_page_pointed(pageNum,
count),
# 검색시 FilterCondition List
Filters = [LanguageResources().const.All,
LanguageResources().const.Writer,
LanguageResources().const.Title],
filterCondition = filterCondition,
keyWord = keyWord)
except Exception as e:
return unknown_error(e)
def get_problem_name(problemId):
try:
problemName = select_problem_informations(MemberCourseProblemParameter(memberId = None,
courseId = None,
problemId = problemId)).first().\
problemName
return problemName
except:
return unknown_error(get_message('dbError'))
def get_used_language_index(usedLanguageName, usedLanguageVersion = None):
try:
usedLanguageIndex = dao.query(Languages.languageIndex).\
filter(Languages.languageName == usedLanguageName,
Languages.languageVersion == usedLanguageVersion).\
first().\
languageIndex
except:
return unknown_error(get_message('dbError'))
return usedLanguageIndex
def get_used_language_version(courseId, usedLanguage):
try:
usedLanguageVersion = dao.query(Languages.languageVersion).\
join(LanguagesOfCourses, LanguagesOfCourses.languageIndex == Languages.languageIndex).\
filter(LanguagesOfCourses.courseId == courseId,
LanguagesOfCourses.languageIndex == usedLanguage).\
first().\
languageVersion
except Exception as e:
return unknown_error(get_message('dbError'))
return usedLanguageVersion
def decorated_function(*args, **kwargs):
try:
from GradeServer.utils.utils import access_authority_check,\
get_request_value
from GradeServer import page_not_found
# Get URL Parameters
problemLevel = get_request_value(kwargs,
'problemLevel')
memberIdIndex = get_request_value(kwargs,
'memberIdIndex')
submissionIndex = get_request_value(kwargs,
'submissionIndex')
problemIndex = get_request_value(kwargs,
'problemIndex')
submissionReplyIndex = get_request_value(kwargs,
'submissionReplyIndex')
articleIndex = get_request_value(kwargs,
'articleIndex')
boardReplyIndex = get_request_value(kwargs,
'boardReplyIndex')
# unusual URL Access Check
if not access_authority_check(problemLevel = (None if problemLevel == LanguageResources().const.All[1]
else problemLevel),
memberIdIndex = (None if memberIdIndex == None
else int(memberIdIndex)),
submissionIndex = (None if submissionIndex == None
else int(submissionIndex)),
problemIndex = (None if problemIndex == None
else int(problemIndex)),
submissionReplyIndex = (None if submissionReplyIndex == None
else int(submissionReplyIndex)),
articleIndex = (None if articleIndex == None
else int(articleIndex)),
boardReplyIndex = (None if boardReplyIndex == None
else int(boardReplyIndex)),
isAdministrator = 'manage' in request.endpoint,
isWrite = (True if 'write' in request.endpoint
else None),
isCode = (True if 'submission_code' in request.endpoint
else None)):
return page_not_found()
# URL direct access and manager case
if not request.referrer and 'manage' in request.endpoint:
return redirect(url_for(RouteResources().const.ID_CHECK,
select = request.endpoint.split('.')[-1]))
return f(*args, **kwargs)
except Exception as e:
return unknown_error (e)
def get_problem_info(problemIndex, problemName):
try:
problemPath, limitedTime, limitedMemory, solutionCheckType, numberOfTestCase = dao.query(Problems.problemPath,
Problems.limitedTime,
Problems.limitedMemory,
Problems.solutionCheckType,
Problems.numberOfTestCase).\
filter(Problems.problemIndex == problemIndex).\
first()
except:
return unknown_error(get_message('dbError'))
return problemPath, limitedTime, limitedMemory, solutionCheckType, numberOfTestCase
def team_record(teamName, error = None):
"""
팀 제출 히스토리
"""
try:
# user.py ->user_history이용
return redirect(url_for(RouteResources().const.USER_HISTORY,
SETResources = SETResources,
memberId = teamName,
sortCondition = OtherResources().const.SUBMISSION_DATE,
pageNum = 1))
except Exception:
# Unknow Error
return unknown_error()
def submission_record(memberId, sortCondition, pageNum):
try:
# 모든 제출 정보
submissions = select_all_submissions(lastSubmission = None,
memberCourseProblemParameter = MemberCourseProblemParameter(memberId = memberId)).subquery()
# List Count
try:
count = select_count(submissions.c.memberId).first().\
count
except Exception:
count = 0
try:
# 차트 정보
chartSubmissionRecords = select_member_chart_submissions(submissions).first()
except Exception:
#None Type Exception
chartSubmissionRecords = []
# Viiew Value Text
chartSubmissionDescriptions = ['Solved Problems',
'Total Submissions',
'Solved',
'Wrong answer',
'Timeover',
'Compile error',
'Runtime error',
'Server error']
try:
# 모든 제출 정보
# Sorted
submissionRecords = get_page_record(submissions_sorted(submissions,
sortCondition = sortCondition),
pageNum = pageNum).all()
except Exception:
#None Type Exception
submissionRecords = []
return render_template(HTMLResources().const.SUBMISSION_RECORD_HTML,
memberId = memberId,
sortCondition = sortCondition,
submissionRecords = submissionRecords,
chartSubmissionDescriptions = chartSubmissionDescriptions,
chartSubmissionRecords = chartSubmissionRecords,
pages = get_page_pointed(pageNum = pageNum,
count = count))
except Exception:
# Unknow Error
return unknown_error()
def get_problem_info(problemId, problemName):
try:
problemPath, limitedTime, limitedMemory, solutionCheckType, isAllInputCaseInOneFile, numberOfTestCase = dao.query(Problems.problemPath,
Problems.limitedTime,
Problems.limitedMemory,
Problems.solutionCheckType,
RegisteredProblems.isAllInputCaseInOneFile,
RegisteredProblems.numberOfTestCase).\
join(RegisteredProblems, Problems.problemId == RegisteredProblems.problemId).\
filter(Problems.problemId == problemId).\
first()
problemCasesPath = '%s/%s_%s_%s' %(problemPath, problemId, problemName, solutionCheckType)
except Exception as e:
return unknown_error(get_message('dbError'))
return problemPath, limitedTime, limitedMemory, solutionCheckType, isAllInputCaseInOneFile, numberOfTestCase, problemCasesPath
def decorated_function(*args, **kwargs):
try:
session_key = \
request.cookies.get(
current_app.config['SESSION_COOKIE_NAME'])
if not (session.sid == session_key and session.__contains__(SessionResources().const.MEMBER_ID)):
session.clear()
return redirect(url_for(RouteResources().const.SIGN_IN))
return f(*args, **kwargs)
except Exception:
from GradeServer.utils.utilMessages import unknown_error
return unknown_error ()
def problem_list(courseId, pageNum):
""" problem submitting page """
try:
# Get Last Submitted History
lastSubmission = select_last_submissions(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = session[SessionResources().const.MEMBER_ID],
courseId = courseId)).subquery()
# Current Submission
submissions = select_current_submissions(lastSubmission).subquery()
# Get Problem Informations
problems = join_problems_names(select_problems_of_course(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
courseId = courseId)).subquery()).subquery()
# Get ProblemList Count
try:
count = select_count(problems.c.problemId).first().\
count
except Exception:
count = 0
# Get ProblemListRecords OuterJoin
try:
problemListRecords = get_page_record(join_problem_lists_submissions(problems,
submissions),
pageNum = pageNum).all()
except Exception:
problemListRecords = []
# Get Course Information
try:
courseRecords = dao.query(RegisteredCourses.courseId,
RegisteredCourses.courseName).\
filter(RegisteredCourses.courseId == courseId).\
first()
except:
courseRecords = []
return render_template(HTMLResources().const.PROBLEM_LIST_HTML,
SETResources = SETResources,
SessionResources = SessionResources,
LanguageResources = LanguageResources,
courseRecords = courseRecords,
problemListRecords = problemListRecords,
pages = get_page_pointed(pageNum = pageNum,
count = count))
except Exception:
return unknown_error()
def decorated_function(*args, **kwargs):
try:
session_key = \
request.cookies.get(
current_app.config['SESSION_COOKIE_NAME'])
if not (session.sid == session_key and session.__contains__(
SessionResources().const.MEMBER_ID)):
session.clear()
return redirect(
url_for(RouteResources().const.SIGN_IN_NEWPAGE,
to=f.__name__,
params=kwargs))
return f(*args, **kwargs)
except Exception:
from GradeServer.utils.utilMessages import unknown_error
return unknown_error()
def problem(problemIndex, pageNum):
"""
use db to get its problem page
now, it moves to just default problem page
"""
try:
# are Not Access. conditions is an Administrator and endOfSubmission ago
# languages of Course
try:
languageInfoRecords = select_all_languages()
except Exception:
languageInfoRecords = []
try:
problemInformation = select_problem(
problemIndex=problemIndex).first()
except Exception:
problemInformation = []
problemName = problemInformation.problemName.replace(' ', '')
pdfExists = os.path.exists(OtherResources().const.PDF_PATH %
(problemName, problemName))
browserName = request.user_agent.browser
browserVersion = request.user_agent.version
return render_template(HTMLResources().const.PROBLEM_HTML,
problemIndex=problemIndex,
problemInformation=problemInformation,
languageInfoRecords=languageInfoRecords,
pdfExists=pdfExists,
problemName=problemName,
pageNum=pageNum,
browserName=browserName,
datetime=datetime.now(),
browserVersion=browserVersion)
except Exception as e:
return unknown_error(e)
def manage_problem(problemLevel, pageNum, error=None):
try:
# Upload Problems Files
if request.method == 'POST':
if is_authority(session[SessionResources().const.AUTHORITY])[0]:
error = post_problem(request)
else:
error = LanguageResources().const.GetOutHere
# GET, POST 공통 사항
problems = select_problems(None if problemLevel == LanguageResources().
const.All[1] else problemLevel)
try:
count = select_count(problems.subquery().c.problemIndex).first().\
count
problemRecords = get_page_record(problems, pageNum=pageNum).all()
except Exception:
count = 0
problemRecords = []
return render_template('/manage_problem.html',
types=[
ENUMResources().const.SOLUTION,
ENUMResources().const.CHECKER
],
levels=[
LanguageResources().const.GoldLevel,
LanguageResources().const.SilverLevel,
LanguageResources().const.BronzeLevel
],
problemLevel=problemLevel,
problemRecords=problemRecords,
pages=get_page_pointed(pageNum, count),
error=error)
except Exception as e:
return unknown_error(e)
def team_invitation(teamName, accept, error = None):
"""
팀 초대 수락 & 거절
"""
try:
# Delete Invitee
dao.query(TeamInvitations).\
filter(TeamInvitations.teamName == teamName,
TeamInvitations.inviteeId == session[SessionResources().const.MEMBER_ID]).\
update(dict(isDeleted = ENUMResources().const.TRUE))
# 초대 수락
if accept == OtherResources().const.ACCEPT:
insert_team_member_id(teamName,
session[SessionResources().const.MEMBER_ID])
# Commit Exception
try:
dao.commit()
flash(teamName + get_message('acceptInvitee'))
except Exception:
dao.rollback()
error = get_message('updateFailed')
# 초대 걱절
else: # elif == REJECT:
# Commit Exception
try:
dao.commit()
flash(teamName + get_message('rejectInvitee'))
except Exception:
dao.rollback()
error = get_message('updateFailed')
return redirect(url_for(RouteResources().const.TEAM,
pageNum = 1,
error = error))
except Exception:
# Unknown Error
return unknown_error()
def problem(problemIndex, pageNum):
"""
use db to get its problem page
now, it moves to just default problem page
"""
try :
# are Not Access. conditions is an Administrator and endOfSubmission ago
# languages of Course
try:
languageInfoRecords = select_all_languages()
except Exception:
languageInfoRecords = []
try:
problemInformation = select_problem(problemIndex = problemIndex).first()
except Exception:
problemInformation = []
problemName = problemInformation.problemName.replace(' ', '')
pdfExists = os.path.exists(OtherResources().const.PDF_PATH %(problemName, problemName))
browserName = request.user_agent.browser
browserVersion = request.user_agent.version
return render_template(HTMLResources().const.PROBLEM_HTML,
problemIndex = problemIndex,
problemInformation = problemInformation,
languageInfoRecords = languageInfoRecords,
pdfExists = pdfExists,
problemName = problemName,
pageNum = pageNum,
browserName = browserName,
datetime = datetime.now(),
browserVersion = browserVersion)
except Exception as e:
return unknown_error(e)
def edit_personal(error = None):
contactNumber, emailAddress, comment = None, None, None
try:
#Get User Information
try:
members = select_member(memberIdIndex = session[SessionResources().const.MEMBER_ID_INDEX]).subquery()
memberInformation = select_member(memberIdIndex = members.c.memberIdIndex).first()
except Exception:
memberInformation = []
#Get Post
if request.method == 'POST':
password = get_request_value(form = request.form,
name = 'password')
passwordConfirm = get_request_value(form = request.form,
name = 'passwordConfirm')
#Get Updating Data
contactNumber = get_request_value(form = request.form,
name = 'contactNumber')
emailAddress = get_request_value(form = request.form,
name = 'emailAddress')
comment = get_request_value(form = request.form,
name = 'comment')
#Password Same
if(password and passwordConfirm) and password == passwordConfirm:
#Generate Password
encryPassword = TripleDES.encrypt(str(password))
passwordConfirm = None
password = generate_password_hash(encryPassword)
#Update DB
update_members(select_member(memberIdIndex = session[SessionResources().const.MEMBER_ID_INDEX]),
password,
contactNumber,
emailAddress,
comment)
#Password Different
elif not password and not passwordConfirm:
#Update DB
update_members(members = select_member(memberIdIndex = session[SessionResources().const.MEMBER_ID_INDEX]),
password = None,
contactNumber = contactNumber,
emailAddress = emailAddress,
comment = comment)
# Commit Exception
try:
dao.commit()
return redirect(url_for(RouteResources().const.SIGN_IN))
except Exception:
dao.rollback()
error = LanguageResources().const.DBFailed
return render_template(HTMLResources().const.EDIT_PERSONAL_HTML,
memberInformation = memberInformation,
contactNumber = contactNumber,
emailAddress = emailAddress,
comment = comment,
error = error)
except Exception as e:
return unknown_error(e)
def article_board(filterCondition, keyWord, pageNum):
try:
# get Articles
articlesOnBoard = select_articles().subquery()
# Get MemberId
articlesOnBoard = join_member_id(articlesOnBoard,
subMemberIdIndex = articlesOnBoard.c.\
writerIdIndex).subquery()
# Get Problem Name
articlesOnBoard = join_problems_name(
articlesOnBoard,
subProblemIndex=articlesOnBoard.c.problemIndex).subquery()
# 과목 공지글
try:
articleNoticeRecords = select_sorted_articles(
articlesOnBoard).all()
except Exception:
articleNoticeRecords = []
# 과목 게시글
try:
# Search Event
if request.method == 'POST':
for form in request.form:
# FilterCondition
if 'keyWord' != form:
filterCondition = form
keyWord = get_request_value(form=request.form,
name='keyWord')
pageNum = 1
if not keyWord:
keyWord = ' '
articlesOnBoardSub = select_sorted_articles(
articlesOnBoard,
FilterFindParameter(filterCondition,
(keyWord if keyWord != ' ' else '')),
articleType=ENUMResources().const.QUESTION)
count = select_count(articlesOnBoardSub.subquery().\
c.articleIndex).first().\
count
articleRecords = get_page_record(articlesOnBoardSub,
pageNum=pageNum,
LIST=int(20)).all()
except Exception:
count = 0
articleRecords = []
return render_template(
HTMLResources().const.BOARD_HTML,
articleRecords=articleRecords,
articleNoticeRecords=articleNoticeRecords,
pages=get_page_pointed(pageNum, count, int(20)),
# 검색시 FilterCondition List
Filters=[
LanguageResources().const.All,
LanguageResources().const.Writer,
LanguageResources().const.Title
],
filterCondition=filterCondition,
keyWord=keyWord)
except Exception as e:
return unknown_error(e)
def write(articleIndex, error=None):
articleType, problemIndex, title, content, articlesOnBoard = None, None, None, None, None
try:
# Modify Case
if articleIndex:
try:
articlesOnBoard = select_article(articleIndex).subquery()
articlesOnBoard = join_problems_name(
subquery=articlesOnBoard,
subProblemIndex=articlesOnBoard.c.problemIndex).first()
except Exception:
articlesOnBoard = []
# 작성시 빈칸 검사
if request.method == 'POST':
if not articleIndex\
or articlesOnBoard.writerIdIndex == session[SessionResources().const.MEMBER_ID_INDEX]:
# Get ProblemIndex
problemIndex = get_request_value(form=request.form,
name='problemIndex')
# Get ArticleType
articleType = get_request_value(form=request.form,
name='articleType')
# 타이틀 가져오기
title = get_request_value(form=request.form, name='title')
# Get Exist Content
content = get_request_value(form=request.form, name='content')
# Success Post
if title and len(title) <= 100\
and content:
updateDate = datetime.now()
updateIp = socket.gethostbyname(socket.gethostname())
# 새로 작성
if not articleIndex:
newPost = insert_articles_on_board(
problemIndex=problemIndex,
memberIdIndex=session[
SessionResources().const.MEMBER_ID_INDEX],
articleType=articleType,
articleParameter=ArticleParameter(
title=title,
content=content,
updateDate=updateDate,
updateIp=updateIp))
dao.add(newPost)
# Commit Exception
try:
dao.commit()
except exc.SQLAlchemyError:
dao.rollback()
error = LanguageResources().const.DBFailed
return redirect(
url_for(RouteResources().const.ARTICLE_BOARD,
filterCondition=' ',
keyWord=' ',
pageNum=1))
# 게시물 수정
else:
# 수정 할 글 정보
update_article_modify(
articleIndex,
problemIndex=problemIndex,
articleType=articleType,
articleParameter=ArticleParameter(
title=title,
content=content,
updateIp=updateIp,
updateDate=updateDate))
# Commit Exception
try:
dao.commit()
except exc.SQLAlchemyError:
dao.rollback()
error = LanguageResources().const.DBFailed
return redirect(
url_for(RouteResources().const.ARTICLE_READ,
articleIndex=articleIndex))
else:
error = LanguageResources().const.GetOutHere
return render_template(HTMLResources().const.ARTICLE_WRITE_HTML,
articlesOnBoard=articlesOnBoard,
articleTypes=[
ENUMResources().const.NOTICE,
ENUMResources().const.QUESTION,
ENUMResources().const.NORMAL
],
articleType=articleType,
problemIndex=problemIndex,
title=title,
content=content,
error=error)
except Exception as e:
# Unknown Error
return unknown_error(e)
def problem_list(pageNum):
""" problem submitting page """
try:
# Get Last Submitted History
lastSubmission = select_last_submissions(memberIdIndex=session[
SessionResources().const.MEMBER_ID_INDEX]).subquery()
# Current Submission
submissions = select_submissions_result(lastSubmission).subquery()
# Get Problem Informations
problems = select_all_problems().subquery()
# Get ProblemList Count
# Get ProblemListRecords OuterJoin
try:
count = select_count(problems.c.problemIndex).first().\
count
problemListRecords = get_page_record(
join_problem_lists_submissions(problems, submissions),
pageNum=pageNum).all()
except Exception:
count = 0
problemListRecords = []
# Get Course Information
browserInformations = request.user_agent.string
if browserInformations.find('Trident') == -1:
if browserInformations.find('MSIE') == -1:
browserVersion = ENUMResources().const.TRUE
else:
browserVersion = ENUMResources().const.FALSE
elif int(browserInformations[browserInformations.find('Trident') +
8]) < 6:
browserVersion = ENUMResources().const.FALSE
else:
browserVersion = ENUMResources().const.TRUE
wrongTestCaseText = {}
for problemListRecord in problemListRecords:
if problemListRecord.wrongTestCaseNumber != 0:
try:
f = open(
make_wrong_test_case_path(
str(problemListRecord.problemPath),
str(problemListRecord.problemName),
str(problemListRecord.solutionCheckType),
str(problemListRecord.wrongTestCaseNumber)), "r")
temp = {problemListRecord.problemName: f.read()}
wrongTestCaseText.update(temp)
f.close()
except:
pass
return render_template(HTMLResources().const.PROBLEM_LIST_HTML,
problemListRecords=problemListRecords,
wrongTestCaseText=wrongTestCaseText,
browserVersion=browserVersion,
datetime=datetime.now(),
pages=get_page_pointed(pageNum=pageNum,
count=count))
except Exception as e:
return unknown_error(e)
def problem_record(status, problemIndex, sortCondition, error=None):
# Not Accept URL Check
if sortCondition not in (LanguageResources().const.SubmissionDate[1],
LanguageResources().const.Memory[1],
LanguageResources().const.FileSize[1],
LanguageResources().const.Runtime[1]):
return page_not_found()
try:
memberId = None
# Request Post
if request.method == 'POST':
# Search Event
if 'memberId' in request.form:
memberId = get_request_value(form=request.form,
name='memberId')
# Chart View Value Text
chartSubmissionDescriptions = [
LanguageResources().const.TriedPeople,
LanguageResources().const.SolvedPeople,
LanguageResources().const.Count,
LanguageResources().const.Solved,
LanguageResources().const.WrongAnswer,
LanguageResources().const.TimeOver,
LanguageResources().const.MemoryOverflow,
LanguageResources().const.CompileError,
LanguageResources().const.RuntimeError
]
# last Submissions of Problem Info
lastSubmission = select_last_submissions(
problemIndex=problemIndex).subquery()
submissions = select_all_submissions(
problemIndex=problemIndex,
lastSubmission=lastSubmission).subquery()
try:
# Submitted Members Count
sumOfSubmissionPeopleCount = select_submissions_peoples_counts(
submissions).subquery()
# Solved Members Count
sumOfSolvedPeopleCount = select_solved_peoples_counts(
submissions).subquery()
# Problem Record
problemSubmittedRecords = select_submitted_records_of_problem(
problemIndex=problemIndex).subquery()
# Chart SubmissionRecords
chartSubmissionRecords = select_problem_chart_submissions(
sumOfSubmissionPeopleCount, sumOfSolvedPeopleCount,
problemSubmittedRecords).first()
except Exception:
chartSubmissionRecords = []
# Problem Information (LimitedTime, LimitedMemory
try:
problemInformation = select_problem(
problemIndex=problemIndex).first()
except Exception:
problemInformation = []
# Problem Solved Users
try:
# Problem Solved Member
problemSolvedMemberRecords = submissions_sorted(
select_solved_submissions(submissions).subquery(),
sortCondition=sortCondition).all()
except Exception:
problemSolvedMemberRecords = []
# Search Failed Problem
if status != ENUMResources().const.SOLVED\
and status != ENUMResources().const.JUDGING\
and status != ENUMResources().const.SERVER_ERROR:
try:
# last Submissions of Problem Info
lastSubmission = select_last_submissions(
memberIdIndex=session[
SessionResources().const.MEMBER_ID_INDEX],
problemIndex=problemIndex).subquery()
submissions = select_all_submissions(
memberIdIndex=session[
SessionResources().const.MEMBER_ID_INDEX],
problemIndex=problemIndex,
lastSubmission=lastSubmission).subquery()
# Current Failed Problem
failedProblem = select_failed_problems(submissions).first()
except Exception:
failedProblem = []
else:
failedProblem = []
return render_template(
HTMLResources().const.PROBLEM_RECORD_HTML,
memberId=memberId,
status=status,
problemSolvedMemberRecords=problemSolvedMemberRecords,
problemInformation=problemInformation,
chartSubmissionDescriptions=chartSubmissionDescriptions,
chartSubmissionRecords=chartSubmissionRecords,
failedProblem=failedProblem,
error=error)
except Exception as e:
return unknown_error(e)
def manage_user(filterCondition, keyWord, sortCondition, pageNum, error=None):
# Not Accept URL Check
if sortCondition not in (LanguageResources().const.ID[1],
LanguageResources().const.Name[1]):
return page_not_found()
try:
# Request Post
if request.method == 'POST':
# Search Event
# FilterCondition
if len(request.form) <= 2 and 'keyWord' in request.form:
for form in request.form:
if 'keyWord' != form:
filterCondition = form
keyWord = get_request_value(form=request.form,
name='keyWord')
pageNum = 1
break
elif is_authority(session[SessionResources().const.AUTHORITY])[0]:
if 'memberDeleted' in request.form:
for form in request.form:
if 'member' not in form and 'keyWord' not in form:
memberIdIndex = form
# Get Folder Path
member = select_member(
memberIdIndex=memberIdIndex).first()
try:
update_member_deleted(memberIdIndex)
dao.commit()
userPath = '{0}/Current/{1}_{2}'.format(
projectPath, member.memberId,
member.memberName)
# Delete Folder
if os.path.exists(userPath):
shutil.rmtree(userPath)
except Exception:
dao.rollback()
error = LanguageResources().const.DBFailed
else:
for form in request.form:
# Insert Indivisual
if 'memberInsert' in form:
insertCount = int(form[len('memberInsert'):]) + 1
for i in range(1, insertCount):
# Get Input Data
detailInformation = get_request_value(
form=request.form,
name='detailInformation{0}'.format(i))
memberId = get_request_value(
form=request.form,
name='memberId{0}'.format(i))
memberName = get_request_value(
form=request.form,
name='memberName{0}'.format(i))
if memberId\
and memberName:
try:
memberIdIndex = select_match_member_id(memberId).first().\
memberIdIndex
except Exception:
memberIdIndex = None
try:
error = insert_member_registration(
memberIdIndex=memberIdIndex,
memberId=memberId,
memberName=memberName,
password=generate_password_hash(
TripleDES.encrypt(
str(memberId))),
detailInformation=detailInformation
)
dao.commit()
# Get Folder Path
userPath = '{0}/Current/{1}_{2}'.format(
projectPath, memberId, memberName)
# make Folders
if not os.path.exists(userPath):
os.makedirs(userPath)
except Exception:
dao.rollback()
error = LanguageResources(
).const.DBFailed
else:
error = LanguageResources(
).const.FormValidation
else:
error = LanguageResources().const.GetOutHere
# Get Users
try:
members = select_members().subquery()
# Filter Case
if filterCondition\
and filterCondition != ' ':
if not keyWord:
keyWord = ' '
members = search_members(
members,
FilterFindParameter(filterCondition=filterCondition,
keyWord=(keyWord if keyWord != ' ' else
''))).subquery()
count = select_count(members.c.memberIdIndex).first().\
count
memberRecords = get_page_record(members_sorted(
members, sortCondition),
pageNum=pageNum)
except Exception:
count = 0
memberRecords = []
return render_template(
'/manage_user.html',
# 검색시 FilterCondition List
Filters=[
LanguageResources().const.All,
LanguageResources().const.ID,
LanguageResources().const.Name
],
sortCondition=sortCondition,
filterCondition=filterCondition,
keyWord=keyWord,
memberRecords=memberRecords,
pages=get_page_pointed(pageNum, count),
count=count,
error=error)
except Exception as e:
return unknown_error(e)
def submission_record(memberIdIndex, sortCondition, pageNum):
# Not Accept URL Check
if sortCondition not in (LanguageResources().const.SubmissionDate[1],
LanguageResources().const.Memory[1],
LanguageResources().const.FileSize[1],
LanguageResources().const.Runtime[1]):
return page_not_found()
try:
# Get MemberId
try:
member = select_member(memberIdIndex).first()
except Exception:
member = []
# 모든 제출 정보
submissions = select_all_submissions(memberIdIndex).subquery()
try:
# 차트 정보
chartSubmissionRecords = select_member_chart_submissions(
submissions).first()
except Exception:
#None Type Exception
chartSubmissionRecords = []
# Viiew Value Text
chartSubmissionDescriptions = [
LanguageResources().const.SolvedProblems,
LanguageResources().const.Count,
LanguageResources().const.Solved,
LanguageResources().const.WrongAnswer,
LanguageResources().const.TimeOver,
LanguageResources().const.MemoryOverflow,
LanguageResources().const.CompileError,
LanguageResources().const.RuntimeError
]
try:
# 모든 제출 정보
count = select_count(submissions.c.memberId).first().\
count
# Sorted
submissionRecords = get_page_record(submissions_sorted(
submissions, sortCondition=sortCondition, DESC=True),
pageNum=pageNum).all()
except Exception:
count = 0
submissionRecords = []
return render_template(
HTMLResources().const.SUBMISSION_RECORD_HTML,
memberIdIndex=memberIdIndex,
sortCondition=sortCondition,
member=member,
submissionRecords=submissionRecords,
chartSubmissionDescriptions=chartSubmissionDescriptions,
chartSubmissionRecords=chartSubmissionRecords,
pages=get_page_pointed(pageNum=pageNum, count=count))
except Exception as e:
# Unknow Error
return unknown_error(e)
def rank(sortCondition, pageNum, error=None):
# Not Accept URL Check
if sortCondition not in (LanguageResources().const.Rate[1],
LanguageResources().const.SolvedProblems[1]):
return page_not_found()
try:
#Searched MemberId
memberId = None
try:
# Auto Complete MemberIds
memberRecords = select_members().all()
except Exception:
memberRecords = []
# Last Submission Max Count
submissions = select_ranks(
select_last_submissions().subquery()).subquery()
submissions = join_member_id(
submissions,
subMemberIdIndex=submissions.c.memberIdIndex).subquery()
# records count
try:
count = select_count(submissions.c.memberIdIndex).first().\
count
except Exception:
count = 0
# Paging Pointed
pages = get_page_pointed(pageNum=pageNum, count=count)
submissions = ranks_sorted(submissions, sortCondition=sortCondition)
# Find MemberId 뷰 호출
if request.method == 'POST':
# Finding MemberId
memberId = get_request_value(form=request.form, name='memberId')
try:
memberIdIndex = select_match_member_id(
memberId).first().memberIdIndex
# 순차 탐색으로 찾아야 함
for i in range(1, pages['allPage'] + 1):
# memberId in Pages
ranks = get_page_record(submissions, pageNum=i).subquery()
# finding MemberId in Pages
if select_match_member_sub(
ranks,
memberIdIndex=memberIdIndex).first() != None:
# Finding move to page
pageNum = i
# searchLine Check
# RePaging Pointed
pages = get_page_pointed(pageNum=pageNum, count=count)
break
except Exception:
error = LanguageResources().const.NotExist
# 랭크 정보
try:
rankMemberRecords = get_page_record(submissions,
pageNum=pageNum).all()
except Exception:
rankMemberRecords = []
return render_template(HTMLResources().const.RANK_HTML,
sortCondition=sortCondition,
memberRecords=memberRecords,
rankMemberRecords=rankMemberRecords,
pages=pages,
memberId=memberId,
error=error) # 페이지 정보
except Exception as e:
return unknown_error(e)
def rank(activeTabCourseId, sortCondition, pageNum, error =None):
try:
findMemberId = None
try:
# Auto Complete MemberIds
memberRecords = select_all_users().all()
except Exception:
memberRecords = []
# Last Submission Max Count
submissions = select_ranks(select_last_submissions(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
courseId = activeTabCourseId)).subquery()).subquery()
# records count
try:
count = select_count(submissions.c.memberId).first().\
count
except Exception:
count = 0
# Paging Pointed
pages = get_page_pointed(pageNum = pageNum,
count = count)
submissions = ranks_sorted(submissions,
sortCondition = sortCondition)
# Find MemberId 뷰 호출
if request.method == 'POST':
# Finding MemberId
findMemberId = request.form['memberId']
# 순차 탐색으로 찾아야 함
for i in range(1, pages['allPage'] + 1):
# memberId in Pages
ranks = get_page_record(submissions,
pageNum = i).subquery()
# finding MemberId in Pages
try:
if select_match_member_sub(ranks,
memberCourseProblemParameter = MemberCourseProblemParameter(memberId = findMemberId)).first().\
memberId:
# Finding move to page
pageNum = i
# searchLine Check
break
except Exception:
pass
else:
# 같은 아이디가 없을 때 메세지
error = get_message('notExists')
# 랭크 정보
try:
rankMemberRecords = get_page_record(submissions,
pageNum = pageNum).all()
except Exception:
rankMemberRecords = []
try:
myCourses = select_accept_courses().all()
except Exception:
myCourses = []
# myCourses Default Add ALL
myCourses.insert(0, OtherResources().const.ALL)
return render_template(HTMLResources().const.RANK_HTML,
activeTabCourseId = activeTabCourseId,
sortCondition = sortCondition,
memberRecords = memberRecords,
rankMemberRecords = rankMemberRecords,
myCourses = myCourses,
pages = pages,
findMemberId = findMemberId,
error = error) # 페이지 정보
except Exception:
return unknown_error()
def board(activeTabCourseId, pageNum):
try:
# 검색시 FilterCondition List
Filters = ['모두', '작성자', '제목 및 내용']
# 허용 과목 리스트
myCourses = select_current_courses(select_accept_courses().subquery()).subquery()
# TabActive Course or All Articles
# get course or All Articles
articlesOnBoard = join_courses_names(# get TabActive Articles
select_articles(activeTabCourseId = activeTabCourseId,
isDeleted = ENUMResources().const.FALSE).subquery(),
myCourses).subquery()
# 과목 공지글
try:
articleNoticeRecords = get_page_record((select_sorted_articles(articlesOnBoard,
isNotice = ENUMResources().const.TRUE)),
pageNum = int(1),
LIST = OtherResources().const.NOTICE_LIST).all()
except Exception:
articleNoticeRecords = []
# 과목 게시글
try:
if request.method == 'POST':
try:
for form in request.form:
# FilterCondition
if 'keyWord' != form:
filterCondition = form
keyWord = request.form['keyWord']
except Exception:
filterCondition = None
keyWord = None
else:
filterCondition = None
keyWord = None
articlesOnBoardSub = select_sorted_articles(articlesOnBoard,
isNotice = ENUMResources().const.FALSE,
filterFindParameter = FilterFindParameter(filterCondition,
keyWord))
count = select_count(articlesOnBoardSub.subquery().\
c.articleIndex).first().\
count
articleRecords = get_page_record(articlesOnBoardSub,
pageNum = pageNum).all()
except Exception:
count = 0
articleRecords = []
try:
myCourses = dao.query(myCourses).all()
except Exception:
myCourses = []
# myCourses Default Add ALL
myCourses.insert(0, OtherResources().const.ALL)
return render_template(HTMLResources().const.BOARD_HTML,
SETResources = SETResources,
SessionResources = SessionResources,
LanguageResources = LanguageResources,
articleRecords = articleRecords,
articleNoticeRecords = articleNoticeRecords,
myCourses = myCourses,
pages = get_page_pointed(pageNum,
count),
Filters = Filters,
activeTabCourseId = activeTabCourseId) # classType, condition은 검색 할 때 필요한 변수
except Exception:
return unknown_error()
def write(activeTabCourseId, articleIndex, error =None):
title, content, articlesOnBoard = None, None, None
try:
# 수강 과목 정보
myCourses = select_current_courses(select_accept_courses().subquery()).subquery()
# Modify Case
if articleIndex > 0:
try:
articlesOnBoard = join_courses_names(select_article(articleParameter = ArticleParameter(articleIndex = articleIndex),
isDeleted = ENUMResources().const.FALSE).subquery(),
myCourses).first()
except Exception:
articlesOnBoard = []
try:
myCourses = dao.query(myCourses).all()
except Exception:
myCourses = []
# 작성시 빈칸 검사
if request.method == 'POST':
# Not None
try:
courseId = request.form['courseId']
# request.form['courseId']가 ex)2015100101 전산학 실습 일경우 중간의 공백을 기준으로 나눔
courseId = courseId.split()[0]
if courseId == OtherResources().const.ALL:
courseId = None
# 타이틀 가져오기
title = request.form['title']
# Get Exist Content
content = request.form['content']
if not title:
error ='제목' +get_message('fillData')
elif not request.form['content']:
error ='내용' +get_message('fillData')
elif len(title) > 50:
error = 'Title is too long. please write less than 50 letters'
# All Fill InputText
else:
isNotice = ENUMResources().const.TRUE
currentDate = datetime.now()
currentIP = socket.gethostbyname(socket.gethostname())
# 새로 작성
if articleIndex == 0:
# Set isNotice
if SETResources().const.USER in session['authority']:
isNotice = ENUMResources().const.FALSE
# user None courseId reject
newPost = ArticlesOnBoard(problemId = None,
courseId = courseId,
writerId = session[SessionResources().const.MEMBER_ID],
isNotice = isNotice,
title = title,
content = content,
writtenDate = currentDate,
writerIp = currentIP)
dao.add(newPost)
# Commit Exception
try:
dao.commit()
flash(get_message('writtenPost'))
except Exception:
dao.rollback()
error =get_message('updateFailed')
return redirect(url_for(RouteResources().const.BOARD,
activeTabCourseId = activeTabCourseId,
pageNum = 1))
# 게시물 수정
else:
# 수정 할 글 정보
articlesOnBoard = select_article(articleParameter = ArticleParameter(articleIndex = articleIndex),
isDeleted = ENUMResources().const.FALSE).update(dict(courseId = courseId,
title = title,
content = content,
writtenDate = currentDate,
writerIp = currentIP))
# Commit Exception
try:
dao.commit()
flash(get_message('modifiedPost'))
except Exception:
dao.rollback()
error =get_message('updateFailed')
return redirect(url_for(RouteResources().const.ARTICLE_READ,
activeTabCourseId = activeTabCourseId,
articleIndex = articleIndex))
except Exception:
# User None Course Posting Rejection
if SETResources().const.USER in session['authority']:
error = get_message('banPosting')
else:
error = get_message()
return render_template(HTMLResources().const.ARTICLE_WRITE_HTML,
SETResources = SETResources,
SessionResources = SessionResources,
LanguageResources = LanguageResources,
myCourses = myCourses,
articlesOnBoard = articlesOnBoard,
title = title,
content = content,
error = error)
except Exception:
# Unknown Error
return unknown_error()
def temp():
try:
print "AAAAAAAAAAAAAAAA"
except Exception:
pass
return unknown_error()
def submission_code(memberIdIndex, status, problemIndex, error=None):
try:
# Get endDateOfSubmission of Problem
# are Not Access. conditions is an Administrator and endOfSubmission ago
if SETResources().const.ADMINISTRATOR in session[SessionResources().const.AUTHORITY]\
or memberIdIndex == session[SessionResources().const.MEMBER_ID_INDEX]:
# Get SubmissionIndex
dataOfSubmissionBoard = select_data_of_submission_board(
None, memberIdIndex, problemIndex)
if dataOfSubmissionBoard.first():
submissionIndex = dataOfSubmissionBoard.first().submissionIndex
# 내가 Code에 누른 좋아요 정보
try:
isLikeCancelled = select_code_is_like(submissionIndex,
memberIdIndex = session[SessionResources().const.MEMBER_ID_INDEX]).first().\
isLikeCancelled
except Exception:
# Non-Exist Case
isLikeCancelled = None
if request.method == 'POST':
authorityCheck = is_authority(
session[SessionResources().const.AUTHORITY])
for form in request.form:
# 댓글 달기
if form == 'writeCodeReply':
# 새로운 댓글 정보articleParameter
codeReplyContent = get_request_value(
form=request.form, name='writeCodeReply')
if codeReplyContent:
dao.add(
insert_replies_on_code(
submissionIndex,
memberIdIndex=session[SessionResources(
).const.MEMBER_ID_INDEX],
articleParameter=ArticleParameter(
title=None,
content=codeReplyContent,
updateIp=socket.gethostbyname(
socket.gethostname()),
updateDate=datetime.now())))
# remove duplicated read count
update_code_view_reply_counting(
submissionIndex,
VIEW_INCREASE=-1,
REPLY_INCREASE=1)
break
# 댓글 삭제
elif 'deleteCodeReply' in form:
# Get Reply Index
replyIndex = len('deleteCodeReply')
submissionReplyIndex = int(form[replyIndex:])
try:
writerIndex = select_replies_on_code(
submissionIndex=None,
submissionReplyIndex=submissionReplyIndex
).first()
except Exception:
writerIndex = None
if (authorityCheck[0] or authorityCheck[1])\
or writerIndex.codeReplierIdIndex == session['memberIdIndex']:
update_replies_on_code_delete(
submissionReplyIndex,
isDeleted=ENUMResources().const.TRUE)
# remove duplicated read count
update_code_view_reply_counting(
submissionIndex,
VIEW_INCREASE=-1,
REPLY_INCREASE=-1)
else:
error = LanguageResources().const.GetOutHere
break
# Commit Modify
elif 'modifyCodeReplyContent' in form:
replyIndex = len('modifyCodeReplyContent')
submissionReplyIndex = int(form[replyIndex:])
try:
writerIndex = select_replies_on_code(
submissionIndex=None,
submissionReplyIndex=submissionReplyIndex
).first()
except Exception:
writerIndex = None
if writerIndex.codeReplierIdIndex == session[
'memberIdIndex']:
submissionReplyContent = get_request_value(
form=request.form,
name='modifyCodeReplyContent{0}'.format(
form[replyIndex:]))
if submissionReplyContent:
#update comment
update_replies_on_code_modify(
submissionReplyIndex,
ArticleParameter(
title=None,
content=submissionReplyContent,
updateIp=socket.gethostbyname(
socket.gethostname()),
updateDate=datetime.now()))
# remove duplicated read count
update_code_view_reply_counting(
submissionIndex, VIEW_INCREASE=-1)
else:
error = LanguageResources().const.GetOutHere
break
# end Loop
# Commit Exception
try:
dao.commit()
except Exception:
dao.rollback()
error = LanguageResources().const.DBFailed
try:
# replies 정보
repliesOnSubmissionRecords = select_replies_on_code(
submissionIndex).subquery()
repliesOnSubmissionRecords = join_member_id(
repliesOnSubmissionRecords,
repliesOnSubmissionRecords.c.codeReplierIdIndex)
# 내가 게시글 리플에 누른 좋아요 정보
repliesOnSubmissionIsLikeRecords = select_replies_on_code_like(
repliesOnSubmissionRecords.subquery(), session[
SessionResources().const.MEMBER_ID_INDEX]).all()
repliesOnSubmissionRecords = repliesOnSubmissionRecords.all(
)
except Exception:
repliesOnSubmissionIsLikeRecords = []
repliesOnSubmissionRecords = []
# 읽은 횟수 카운팅
update_code_view_reply_counting(submissionIndex,
VIEW_INCREASE=1)
# Commit Exception
try:
dao.commit()
except Exception:
dao.rollback()
# Problem Information (LimitedTime, LimitedMemory
try:
problemName = select_problem(problemIndex = problemIndex).first().\
problemName
except Exception:
problemName = None
# Problem Solved Users
try:
# last Submissions Info
lastSubmission = select_last_submissions(
memberIdIndex=memberIdIndex,
problemIndex=problemIndex).subquery()
problemSolvedMemberRecords = select_all_submissions(
memberIdIndex=memberIdIndex,
problemIndex=problemIndex,
lastSubmission=lastSubmission).first()
except Exception:
problemSolvedMemberRecords = []
# Submitted Files Information
import codecs
try:
submittedFileRecords = select_submitted_files(
dataOfSubmissionBoard.subquery()).all()
fileData = []
for raw in submittedFileRecords:
# Open
filePath = '{0}/{1}'.format(raw.filePath, raw.fileName)
# EUC_KR type
try:
with codecs.open(filePath, 'r',
encoding='cp949') as f:
# Read
data = f.read()
fileData.append(data)
# UTF-8 Type
except Exception:
with codecs.open(filePath, 'r',
encoding='utf8') as f:
# Read
data = f.read()
fileData.append(data)
except Exception:
submittedFileRecords = []
fileData = []
return render_template(HTMLResources().const.SUBMISSION_CODE_HTML,
memberIdIndex = memberIdIndex,
submissionIndex = submissionIndex,
submittedFileRecords = submittedFileRecords,
fileData = fileData,
problemName = problemName,
problemSolvedMemberRecords = problemSolvedMemberRecords,
isLikeCancelled = isLikeCancelled,
sumOfLikeCount = dataOfSubmissionBoard.first().\
sumOfLikeCount,
repliesOnSubmissionIsLikeRecords = repliesOnSubmissionIsLikeRecords,
repliesOnSubmissionRecords = repliesOnSubmissionRecords,
browserName = request.user_agent.browser,
browserVersion = request.user_agent.version,
error = error)
#Access Rejection
else:
return redirect(
url_for(
RouteResources().const.PROBLEM_RECORD,
status=status,
problemIndex=problemIndex,
sortCondition=LanguageResources().const.SubmissionDate[1]))
except Exception as e:
return unknown_error(e)
def edit_personal(error=None):
contactNumber, emailAddress, comment = None, None, None
try:
#Get User Information
try:
members = select_member(memberIdIndex=session[
SessionResources().const.MEMBER_ID_INDEX]).subquery()
memberInformation = select_member(
memberIdIndex=members.c.memberIdIndex).first()
except Exception:
memberInformation = []
#Get Post
if request.method == 'POST':
password = get_request_value(form=request.form, name='password')
passwordConfirm = get_request_value(form=request.form,
name='passwordConfirm')
#Get Updating Data
contactNumber = get_request_value(form=request.form,
name='contactNumber')
emailAddress = get_request_value(form=request.form,
name='emailAddress')
comment = get_request_value(form=request.form, name='comment')
#Password Same
if (password and passwordConfirm) and password == passwordConfirm:
#Generate Password
encryPassword = TripleDES.encrypt(str(password))
passwordConfirm = None
password = generate_password_hash(encryPassword)
#Update DB
update_members(
select_member(memberIdIndex=session[
SessionResources().const.MEMBER_ID_INDEX]), password,
contactNumber, emailAddress, comment)
#Password Different
elif not password and not passwordConfirm:
#Update DB
update_members(members=select_member(memberIdIndex=session[
SessionResources().const.MEMBER_ID_INDEX]),
password=None,
contactNumber=contactNumber,
emailAddress=emailAddress,
comment=comment)
# Commit Exception
try:
dao.commit()
return redirect(url_for(RouteResources().const.SIGN_IN))
except Exception:
dao.rollback()
error = LanguageResources().const.DBFailed
return render_template(HTMLResources().const.EDIT_PERSONAL_HTML,
memberInformation=memberInformation,
contactNumber=contactNumber,
emailAddress=emailAddress,
comment=comment,
error=error)
except Exception as e:
return unknown_error(e)
