Example #1
0
def select_top_coder():
    # Top Coder Layer
    try:
        # 오늘 요일 월1 ~ 일7
        dayOfWeekNum = datetime.now().isoweekday()
        # 요일 별 제출 기간 추려내기
        minusDays = {1: -1, 2: -2, 3: -3, 4: -4, 5: -5, 6: -6, 7: -0}
        addDays = {1: 5, 2: 4, 3: 3, 4: 2, 5: 1, 6: 0, 7: 6}
        # 금주의 시작일과 끝일 구함
        submissionDatePeriod = dayOfWeek(minusDays=minusDays[dayOfWeekNum],
                                         addDays=addDays[dayOfWeekNum])
        # 이번주에 낸 제출 목록
        ranks = select_ranks(
            select_between_days_last_submissions(
                select_last_submissions(memberIdIndex=None,
                                        problemIndex=None).subquery(),
                submissionDatePeriod).subquery()).subquery()
        ranks = join_member_id(
            ranks, subMemberIdIndex=ranks.c.memberIdIndex).subquery()
        # 랭킹 동률 처리
        topCoders = ranks_sorted(rankTieProcess(ranks).subquery()).all()

    except Exception:
        topCoders = []

    return topCoders
def select_top_coder():
    # Top Coder Layer
    try:
        # 오늘 요일 월1 ~ 일7
        dayOfWeekNum = datetime.now().isoweekday()
        # 요일 별 제출 기간 추려내기
        minusDays = {1: -1, 2: -2, 3: -3, 4: -4, 5: -5, 6: -6, 7: -0}
        addDays = {1: 5, 2: 4, 3: 3, 4: 2, 5: 1, 6: 0, 7: 6}
        # 금주의 시작일과 끝일 구함
        submissionDatePeriod = dayOfWeek(minusDays=minusDays[dayOfWeekNum], addDays=addDays[dayOfWeekNum])
        # 이번주에 낸 제출 목록
        topCoderId = (
            ranks_sorted(
                select_ranks(
                    select_between_days_last_submissions(
                        select_last_submissions().subquery(), submissionDatePeriod
                    ).subquery()
                ).subquery()
            )
            .first()
            .memberId
        )
    except Exception:
        topCoderId = None

    return topCoderId
Example #3
0
def get_submission_info(memberIdIndex, problemIndex):
    try:
        submissionInfo = select_last_submissions(memberIdIndex = memberIdIndex,
                                                 problemIndex = problemIndex).first()
        
        submissionCount = submissionInfo.submissionCount + 1
        solutionCheckCount = submissionInfo.solutionCheckCount

    except:
        submissionCount = 1
        solutionCheckCount = 0

    return submissionCount, solutionCheckCount
def get_submission_info(memberId, courseId, problemId):
    try:
        submissionInfo = select_last_submissions(MemberCourseProblemParameter(memberId = memberId, 
                                                                              courseId = courseId, 
                                                                              problemId = problemId)).first()
        
        submissionCount = submissionInfo.submissionCount + 1
        solutionCheckCount = submissionInfo.solutionCheckCount
        viewCount = submissionInfo.viewCount
    except:
        submissionCount = 1
        solutionCheckCount = 0
        viewCount = 0
    return submissionCount, solutionCheckCount, viewCount
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 select_top_coder():
    # Top Coder Layer
    try:
        # 오늘 요일 월1 ~ 일7
        dayOfWeekNum = datetime.now().isoweekday()
        # 요일 별 제출 기간 추려내기
        minusDays = {1: -1,
                                         2: -2,
                                         3: -3,
                                         4: -4,
                                         5: -5,
                                         6: -6,
                                         7: -0}
        addDays = {1: 5,
                                    2: 4,
                                    3: 3,
                                    4: 2,
                                    5: 1,
                                    6: 0,
                                    7: 6}
                # 금주의 시작일과 끝일 구함
        submissionDatePeriod = dayOfWeek(minusDays = minusDays[dayOfWeekNum],
                                         addDays = addDays[dayOfWeekNum])
                # 이번주에 낸 제출 목록 
        ranks = select_ranks(select_between_days_last_submissions(select_last_submissions(memberIdIndex = None,
                                                                                          problemIndex = None).subquery(),
                                                                  submissionDatePeriod).subquery()).subquery()
        ranks = join_member_id(ranks,
                               subMemberIdIndex = ranks.c.memberIdIndex).subquery()                                                   
                # 랭킹 동률 처리
        topCoders= ranks_sorted(rankTieProcess(ranks).subquery()).all()
                                         
    except Exception:
        topCoders = []
        
    return topCoders
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 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)
Example #9
0
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 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)     
Example #11
0
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)
Example #12
0
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)
Example #13
0
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 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 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)
Example #16
0
def submission_code(memberId, courseId, problemId, error = None):
    
    try:
        # Get endDateOfSubmission of Problem
        try:
            endDateOfSubmission = select_problems_of_course(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
                                                                                                                        courseId = courseId,
                                                                                                                        problemId = problemId)).first().\
                                                            endDateOfSubmission
        except Exception:
            endDateOfSubmission = 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 endDateOfSubmission <= datetime.now():
            
            # last Submissions Info
            lastSubmission = select_last_submissions(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = memberId,
                                                                                                                 courseId = courseId,
                                                                                                                 problemId = problemId)).subquery()
            # Code View Count Up
            update_submission_code_view_count(lastSubmission,
                                              memberCourseProblemParameter = MemberCourseProblemParameter(memberId = memberId,
                                                                                                          courseId = courseId,
                                                                                                          problemId = problemId))
            # Commit Exception
            try:
                dao.commit()
            except Exception:
                dao.rollback()
                error = get_message('updateFailed')
                
            # Problem Information (LimitedTime, LimitedMemory
            try:
                problemName = select_problem_informations(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
                                                                                                                      courseId = None,
                                                                                                                      problemId = problemId)).first().\
                                                                     problemName
            except Exception:
                problemName = None
                
            # Problem Solved Users
            try:
                # last Submissions Info
                submissions = select_all_submissions(lastSubmission,
                                                     memberCourseProblemParameter = MemberCourseProblemParameter(memberId = memberId,
                                                                                                                 courseId = courseId,
                                                                                                                 problemId = problemId)).subquery()
                problemSolvedMemberRecords = select_solved_submissions(submissions).first()
            except Exception:
                problemSolvedMemberRecords = []
                
            # Submitted Files Information
            try:
                submittedFileRecords = select_submitted_files(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = memberId, 
                                                                                                                          courseId = courseId,
                                                                                                                          problemId = problemId)).all()
                fileData = []
                for raw in submittedFileRecords:
                    # Open
                    filePath = raw.filePath + '/' +raw.fileName
                    file = open(filePath)
                    # Read
                    data = file.read()
                    
                    # Close
                    file.close()
                    fileData.append(data)
            except Exception:
                submittedFileRecords = []
                fileData = []
                
            return render_template(HTMLResources().const.SUBMISSION_CODE_HTML,
                                   SETResources = SETResources,
                                   SessionResources = SessionResources,
                                   LanguageResources = LanguageResources,
                                   submittedFileRecords = submittedFileRecords,
                                   fileData = fileData,
                                   problemName = problemName,
                                   problemSolvedMemberRecords = problemSolvedMemberRecords,
                                   error = error)
        #Access Rejection
        else:
            flash('코드를 볼 권한이 없습니다!!!')
            return redirect(url_for(RouteResources().const.PROBLEM_RECORD,
                                    courseId = courseId,
                                    problemId = problemId,
                                    sortCondition = OtherResources().const.RUN_TIME))
    except Exception:
        return unknown_error()
Example #17
0
def problem_record(courseId, problemId, sortCondition = OtherResources().const.RUN_TIME):
    """
    navbar - class - Record of problem
    """
    try:
        # Chart View Value Text
        chartSubmissionDescriptions = ['Tried People',
                                       'Solved People',
                                       'Submission Count',
                                       'Solved',
                                       'Wrong Answer',
                                       'Time Over',
                                       'Compile Error',
                                       'Runtime Error']
        
        # last Submissions Info
        submissions = select_all_submissions(lastSubmission = select_last_submissions(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
                                                                                                                                                  courseId = courseId,
                                                                                                                                                  problemId = problemId)).subquery(),
                                            memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
                                                                                                        courseId = courseId,
                                                                                                        problemId = problemId)).subquery()
        try:
            # Submitted Members Count
            sumOfSubmissionPeopleCount = select_submissions_peoples_counts(submissions).subquery()
            # Solved Members Count
            sumOfSolvedPeopleCount = select_solved_peoples_counts(submissions).subquery()
            # Problem Rrecord
            problemSubmittedRecords = select_submitted_records_of_problem(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
                                                                                                                                      courseId = courseId,
                                                                                                                                      problemId = problemId)).subquery()
            # Chart SubmissionRecords
            chartSubmissionRecords = select_problem_chart_submissions(sumOfSubmissionPeopleCount,
                                                                      sumOfSolvedPeopleCount,
                                                                      problemSubmittedRecords).first()
        except:
            print 'SubmittedRecordsOfProblems table is empty'
            chartSubmissionRecords = []
            
        # Problem Information (LimitedTime, LimitedMemory
        try:
            problemInformationRecords = select_problem_informations(memberCourseProblemParameter = MemberCourseProblemParameter(memberId = None,
                                                                                                                                courseId = None,
                                                                                                                                problemId = problemId)).first()
        except Exception:
            problemInformationRecords = []
        # Problem Solved Users
        try:
            # Problem Solved Member
            problemSolvedMemberRecords = submissions_sorted(select_solved_submissions(submissions).subquery(),
                                                            sortCondition = sortCondition).all()
                
        except Exception:
            problemSolvedMemberRecords = []
        
        return render_template(HTMLResources().const.PROBLEM_RECORD_HTML,
                               SETResources = SETResources,
                               SessionResources = SessionResources,
                               LanguageResources = LanguageResources,
                               courseId = courseId,
                               problemSolvedMemberRecords = problemSolvedMemberRecords,
                               problemInformationRecords = problemInformationRecords,
                               chartSubmissionDescriptions = chartSubmissionDescriptions,
                               chartSubmissionRecords = chartSubmissionRecords)
    except Exception:
        return unknown_error()