Example #1
0
def quota_stat(request):
    adm_round = AdmissionRound.get_recent()

    additional_results = AdditionalResult.objects.all()

    STATUS_DISPLAY = {
        'unknown': u'ยังไม่ยืนยันสิทธิ์',
        'waived': u'สละสิทธิ์',
        'waived-for-direct': u'สละสิทธิ์ไปโครงการรับตรง',
        'confirmed': u'ยืนยันสิทธิ์แล้ว'
    }

    for r in additional_results:
        r.status = 'unknown'
        if r.is_waived:
            r.status = 'waived'
        applicant = r.applicant
        registration = applicant.get_student_registration()
        if registration:
            if applicant.get_latest_admission_result() and (
                    not AdmissionWaiver.is_waived(applicant)):
                r.status = 'waived-for-direct'
            else:
                r.status = 'confirmed'
        r.status_text = STATUS_DISPLAY[r.status]
        r.is_confirmed = r.status == 'confirmed'

    return render_to_response('confirmation/quota_stat.html',
                              {'additional_results': additional_results})
Example #2
0
def result_index(request):
    submission_info = request.applicant.submission_info
    applicant = request.applicant
    current_round = AdmissionRound.get_recent()

    admission_result = None
    admitted_major = None

    if current_round:
        results = list(applicant.admission_results.filter(round_number=current_round.number).all())
        if len(results)!=0:
            admission_result = results[0]
            if admission_result.admitted_major_id != None:
                admitted_major = Major.get_major_by_id(admission_result.admitted_major_id)

    confirmation_start_date = settings.CONFIRMATION_START_DATE

    last_round = settings.LAST_ROUND_RESULT
    return render_to_response("application/status/index_result_only.html",
                              {'applicant': applicant,
                               'submission_info': submission_info,
                               'current_round': current_round,
                               'admission_result': admission_result,
                               'admitted_major': admitted_major,
                               'confirmation_start_date':
                                   confirmation_start_date,
                               'last_round': last_round,
                               'can_log_out': True })
Example #3
0
File: views.py Project: jittat/adm2
def request_nomove(request, is_nomove):
    applicant = request.applicant
    admitted = applicant.is_admitted()

    if not admitted:
        return HttpResponseForbidden()

    first_admission = (applicant.admission_results.count() == 1)
    if first_admission:
        return HttpResponseForbidden()
    
    if request.method != 'POST':
        return HttpResponseForbidden()

    # check for deadline
    if admission_major_pref_deadline_passed():
        return render_to_response('confirmation/pref_deadline_passed.html')

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number
    admission_pref = applicant.get_admission_major_preference(round_number)

    if not admission_pref:
        return HttpResponseForbidden()

    admission_pref.is_nomove_request = is_nomove
    admission_pref.save()

    Log.create("request nomove (%s) - from: %s" %
               (str(is_nomove),
                request.META['REMOTE_ADDR']),
               applicant_id=applicant.id,
               applicantion_id=applicant.submission_info.applicantion_id)

    return redirect('status-index')
Example #4
0
def adm_submission_deadline_warning():
    time_left = time_to_submission_deadline()
    if (time_left > timedelta(0)) and (time_left < timedelta(hours=3)):
        return ('<div class="deadline-bar"><span class="deadline">เหลือเวลาอีก %d ชั่วโมง %d นาที ก่อนหมดเวลารับสมัคร</span></div>' %
                (time_left.seconds/3600, time_left.seconds%3600/60))
    supplement_time_left = time_to_supplement_submission_deadline()
    if (supplement_time_left > timedelta(0)) and (supplement_time_left < timedelta(hours=3)):
        return ('<div class="deadline-bar"><span class="deadline">เหลือเวลาอีก %d ชั่วโมง %d นาที ก่อนหมดเวลายื่นหลักฐานเพิ่มเติม</span></div>' %
                (supplement_time_left.seconds/3600, 
                 supplement_time_left.seconds%3600/60))
    round2_time_left = time_to_round2_confirmation_deadline()
    if (round2_time_left > timedelta(0)) and (round2_time_left < timedelta(hours=3)):
        return ('<div class="deadline-bar"><span class="deadline">เหลือเวลาอีก %d ชั่วโมง %d นาที ก่อนหมดเวลายืนยันการเข้าพิจารณาคัดเลือกโครงการรับตรง (รอบที่ 2) ลำดับสำรอง</span></div>' %
                (round2_time_left.seconds/3600, 
                 round2_time_left.seconds%3600/60))

    from result.models import AdmissionRound

    admission_major_pref_time_left = AdmissionRound.time_to_recent_round_deadline()
    if (admission_major_pref_time_left > timedelta(0)) and (admission_major_pref_time_left < timedelta(hours=3)):
        return ('<div class="deadline-bar"><span class="deadline">เหลือเวลาอีก %d ชั่วโมง %d นาที ก่อนหมดเวลายืนยันสิทธิ์</span></div>' %
                (admission_major_pref_time_left.seconds/3600, 
                 admission_major_pref_time_left.seconds%3600/60))

    return ''
Example #5
0
File: views.py Project: jittat/adm2
def request_nomove(request, is_nomove):
    applicant = request.applicant
    admitted = applicant.is_admitted()

    if not admitted:
        return HttpResponseForbidden()

    first_admission = (applicant.admission_results.count() == 1)
    if first_admission:
        return HttpResponseForbidden()

    if request.method != 'POST':
        return HttpResponseForbidden()

    # check for deadline
    if admission_major_pref_deadline_passed():
        return render_to_response('confirmation/pref_deadline_passed.html')

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number
    admission_pref = applicant.get_admission_major_preference(round_number)

    if not admission_pref:
        return HttpResponseForbidden()

    admission_pref.is_nomove_request = is_nomove
    admission_pref.save()

    Log.create("request nomove (%s) - from: %s" %
               (str(is_nomove), request.META['REMOTE_ADDR']),
               applicant_id=applicant.id,
               applicantion_id=applicant.submission_info.applicantion_id)

    return redirect('status-index')
Example #6
0
def adm_submission_deadline_warning():
    time_left = time_to_submission_deadline()
    if (time_left > timedelta(0)) and (time_left < timedelta(hours=3)):
        return (
            '<div class="deadline-bar"><span class="deadline">เหลือเวลาอีก %d ชั่วโมง %d นาที ก่อนหมดเวลารับสมัคร</span></div>'
            % (time_left.seconds / 3600, time_left.seconds % 3600 / 60))
    supplement_time_left = time_to_supplement_submission_deadline()
    if (supplement_time_left > timedelta(0)) and (supplement_time_left <
                                                  timedelta(hours=3)):
        return (
            '<div class="deadline-bar"><span class="deadline">เหลือเวลาอีก %d ชั่วโมง %d นาที ก่อนหมดเวลายื่นหลักฐานเพิ่มเติม</span></div>'
            % (supplement_time_left.seconds / 3600,
               supplement_time_left.seconds % 3600 / 60))
    round2_time_left = time_to_round2_confirmation_deadline()
    if (round2_time_left > timedelta(0)) and (round2_time_left <
                                              timedelta(hours=3)):
        return (
            '<div class="deadline-bar"><span class="deadline">เหลือเวลาอีก %d ชั่วโมง %d นาที ก่อนหมดเวลายืนยันการเข้าพิจารณาคัดเลือกโครงการรับตรง (รอบที่ 2) ลำดับสำรอง</span></div>'
            % (round2_time_left.seconds / 3600,
               round2_time_left.seconds % 3600 / 60))

    from result.models import AdmissionRound

    admission_major_pref_time_left = AdmissionRound.time_to_recent_round_deadline(
    )
    if (admission_major_pref_time_left > timedelta(0)) and (
            admission_major_pref_time_left < timedelta(hours=3)):
        return (
            '<div class="deadline-bar"><span class="deadline">เหลือเวลาอีก %d ชั่วโมง %d นาที ก่อนหมดเวลายืนยันสิทธิ์</span></div>'
            % (admission_major_pref_time_left.seconds / 3600,
               admission_major_pref_time_left.seconds % 3600 / 60))

    return ''
Example #7
0
def request_nomove(request, is_nomove):
    applicant = request.applicant
    admitted = applicant.is_admitted()

    if not admitted:
        return HttpResponseForbidden()

    first_admission = (applicant.admission_results.count() == 1)
    if first_admission:
        return HttpResponseForbidden()
    
    if request.method != 'POST':
        return HttpResponseForbidden()

    # check for deadline
    if admission_major_pref_deadline_passed():
        return render_to_response('confirmation/pref_deadline_passed.html')

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number
    admission_pref = applicant.get_admission_major_preference(round_number)

    if not admission_pref:
        return HttpResponseForbidden()

    admission_pref.is_nomove_request = is_nomove
    admission_pref.save()
    return redirect('status-index')
Example #8
0
def quota_stat(request):
    adm_round = AdmissionRound.get_recent()
    
    additional_results = AdditionalResult.objects.all()

    STATUS_DISPLAY = {
        'unknown': u'ยังไม่ยืนยันสิทธิ์',
        'waived': u'สละสิทธิ์',
        'waived-for-direct': u'สละสิทธิ์ไปโครงการรับตรง',
        'confirmed': u'ยืนยันสิทธิ์แล้ว'
        }

    for r in additional_results:
        r.status = 'unknown'
        if r.is_waived:
            r.status = 'waived'
        applicant = r.applicant
        registration = applicant.get_student_registration()
        if registration:
            if applicant.get_latest_admission_result() and (not AdmissionWaiver.is_waived(applicant)):
                r.status = 'waived-for-direct'
            else:
                r.status = 'confirmed'
        r.status_text = STATUS_DISPLAY[r.status]
        r.is_confirmed = r.status == 'confirmed'

    return render_to_response('confirmation/quota_stat.html',
                              {'additional_results': additional_results})
Example #9
0
File: views.py Project: jittat/adm2
def quota_confirm(request):
    """
    confirmation page for quota-only applicants
    """
    applicant = request.applicant

    if not applicant.has_additional_result:
        return HttpResponseForbidden()

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number

    admission_result = applicant.get_latest_admission_result()

    if admission_result and not AdmissionWaiver.is_waived(applicant):
        return quota_choice(request, applicant, admission_result)

    additional_result = applicant.additional_result
    is_result_for_current_round = (
        additional_result.round_number == round_number)

    can_edit = (not admission_major_pref_deadline_passed()
                ) and is_result_for_current_round

    registration = applicant.get_student_registration()

    if request.method == 'POST' and not can_edit:
        return render_to_response('confirmation/pref_deadline_passed.html',
                                  {'admission_round': current_round})

    if request.method == 'POST' and 'submit' in request.POST:
        form = StudentRegistrationForm(request.POST, instance=registration)
        if form.is_valid():
            registration = form.save(commit=False)
            registration.applicant = applicant
            registration.save()
            return redirect('confirmation-quota-index')
    elif request.method == 'POST' and 'waive' in request.POST:
        if registration:
            registration.delete()
        return redirect('confirmation-quota-index')
    else:
        form = StudentRegistrationForm(instance=registration)

    return render_to_response(
        'confirmation/quota/student_registration.html', {
            'applicant': applicant,
            'can_edit': can_edit,
            'form': form,
            'additional_result': additional_result,
            'admission_result': admission_result,
            'registration': registration,
            'can_log_out': True
        })
Example #10
0
def list_confirmed_applicants(request, major_number):
    major = Major.objects.get(number=major_number)
    adm_round = AdmissionRound.get_recent()

    results = (AdmissionResult.
               objects.
               filter(round_number=adm_round.number).
               filter(admitted_major=major).
               select_related(depth=1).
               all())

    applicants = [r.applicant for r in results]
    app_dict = dict([(r.applicant_id,r.applicant) for r in results])

    adm_major_pref = (AdmissionMajorPreference.
                      objects.
                      filter(round_number=adm_round.number).
                      filter(applicant__in=applicants))

    # confirmation statistics
    confirmations = (AdmissionConfirmation.
                     objects.
                     filter(applicant__in=applicants))

    for a in applicants:
        a.confirmed_amount = 0
    for c in confirmations:
        if c.applicant_id in app_dict:
            app_dict[c.applicant_id].confirmed_amount += c.paid_amount

    for a in applicants:
        a.has_confirmed = (a.confirmed_amount >= major.confirmation_amount)

    confirmed_applicants = [[],[],[],[]]
    for p in adm_major_pref:
        t = p.get_pref_type().ptype - 1
        confirmed_applicants[t].append(app_dict[p.applicant_id])

    for t in range(4):
        confirmed_applicants[t] = sorted(confirmed_applicants[t],
                                         cmp=lambda x,y: cmp(-x.confirmed_amount, -y.confirmed_amount))
        

    titles = [u'ไม่ขอเลื่อนอันดับ',
              u'ยืนยันสิทธิ์ ขอพิจารณาเลื่อนอันดับ ถ้าไม่ได้เลื่อนขอรักษาสิทธิ์',
              u'ยืนยันสิทธิ์ ขอพิจารณาเลื่อนอันดับ ถ้าไม่ได้เลื่อนขอสละสิทธิ์',
              u'สละสิทธิ์']

    return render_to_response('confirmation/list_applicants.html',
                              { 'admisison_round': adm_round,
                                'major': major,
                                'confirmed_apps_groups':
                                    zip(titles, confirmed_applicants),
                                'results': results })
Example #11
0
def prepare_round_data():
    current_round = AdmissionRound.get_recent()
    if current_round:
        last_round = settings.LAST_CALLUP_ROUND_NUMBER == current_round.number
    else:
        last_round = False

    return {
        'last_round': last_round,
        'current_round': current_round,
        }
Example #12
0
 def get_latest_admission_result(self):
     from result.models import AdmissionRound
     adm_round = AdmissionRound.get_recent()
     if adm_round:
         results = list(
             self.admission_results.filter(
                 round_number=adm_round.number))
         if len(results)>0:
             return results[0]
         else:
             return None
     else:
         return None
 def get_latest_admission_result(self):
     from result.models import AdmissionRound
     adm_round = AdmissionRound.get_recent()
     if adm_round:
         results = list(
             self.admission_results.filter(
                 round_number=adm_round.number))
         if len(results)>0:
             return results[0]
         else:
             return None
     else:
         return None
Example #14
0
File: views.py Project: jittat/adm2
def quota_confirm(request):
    """
    confirmation page for quota-only applicants
    """
    applicant = request.applicant

    if not applicant.has_additional_result:
        return HttpResponseForbidden()

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number

    admission_result = applicant.get_latest_admission_result()

    if admission_result and not AdmissionWaiver.is_waived(applicant):
        return quota_choice(request, applicant, admission_result)

    additional_result = applicant.additional_result
    is_result_for_current_round = (additional_result.round_number == round_number)

    can_edit = (not admission_major_pref_deadline_passed()) and is_result_for_current_round

    registration = applicant.get_student_registration()

    if request.method=='POST' and not can_edit:
        return render_to_response('confirmation/pref_deadline_passed.html',
                                  {'admission_round': current_round})

    if request.method=='POST' and 'submit' in request.POST:
        form = StudentRegistrationForm(request.POST,
                                       instance=registration)
        if form.is_valid():
            registration = form.save(commit=False)
            registration.applicant = applicant
            registration.save()
            return redirect('confirmation-quota-index')
    elif request.method=='POST' and 'waive' in request.POST:
        if registration:
            registration.delete()
        return redirect('confirmation-quota-index')
    else:
        form = StudentRegistrationForm(instance=registration)

    return render_to_response('confirmation/quota/student_registration.html',
                              { 'applicant': applicant,
                                'can_edit': can_edit,
                                'form': form,
                                'additional_result': additional_result,
                                'admission_result': admission_result,
                                'registration': registration,
                                'can_log_out': True })
Example #15
0
def list_confirmed_applicants(request, major_number):
    major = Major.objects.get(number=major_number)
    adm_round = AdmissionRound.get_recent()

    results = (AdmissionResult.objects.filter(
        round_number=adm_round.number).filter(
            admitted_major=major).select_related(depth=1).all())

    applicants = [r.applicant for r in results]
    app_dict = dict([(r.applicant_id, r.applicant) for r in results])

    adm_major_pref = (AdmissionMajorPreference.objects.filter(
        round_number=adm_round.number).filter(applicant__in=applicants))

    # confirmation statistics
    confirmations = (AdmissionConfirmation.objects.filter(
        applicant__in=applicants))

    for a in applicants:
        a.confirmed_amount = 0
    for c in confirmations:
        if c.applicant_id in app_dict:
            app_dict[c.applicant_id].confirmed_amount += c.paid_amount

    for a in applicants:
        a.has_confirmed = (a.confirmed_amount >= major.confirmation_amount)

    confirmed_applicants = [[], [], [], []]
    for p in adm_major_pref:
        t = p.get_pref_type().ptype - 1
        confirmed_applicants[t].append(app_dict[p.applicant_id])

    for t in range(4):
        confirmed_applicants[t] = sorted(
            confirmed_applicants[t],
            cmp=lambda x, y: cmp(-x.confirmed_amount, -y.confirmed_amount))

    titles = [
        u'ไม่ขอเลื่อนอันดับ',
        u'ยืนยันสิทธิ์ ขอพิจารณาเลื่อนอันดับ ถ้าไม่ได้เลื่อนขอรักษาสิทธิ์',
        u'ยืนยันสิทธิ์ ขอพิจารณาเลื่อนอันดับ ถ้าไม่ได้เลื่อนขอสละสิทธิ์',
        u'สละสิทธิ์'
    ]

    return render_to_response(
        'confirmation/list_applicants.html', {
            'admisison_round': adm_round,
            'major': major,
            'confirmed_apps_groups': zip(titles, confirmed_applicants),
            'results': results
        })
Example #16
0
def prepare_confirmation_data(applicant, admitted_major):
    confirmations = list(applicant.admission_confirmations.all())
    if len(confirmations)!=0:
        confirmation_complete = True
        recent_confirmation = confirmations[0]
    else:
        confirmation_complete = False
        recent_confirmation = None

    is_confirmation_time_left = (AdmissionRound.time_to_recent_round_deadline() > timedelta(0))

    return {
        'confirmation_complete': confirmation_complete,
        'recent_confirmation': recent_confirmation,
        'is_confirmation_time_left': is_confirmation_time_left,
        }
Example #17
0
def index(request):
    adm_round = AdmissionRound.get_recent()

    pref_stat = build_pref_stat(adm_round)
    total_pref_stat = build_total_stat(pref_stat)

    if 'notice' in request.session:
        notice = request.session['notice']
        del request.session['notice']
    else:
        notice = ''

    return render_to_response('confirmation/review_main.html',
                              { 'pref_stat': pref_stat,
                                'total_pref_stat': total_pref_stat,
                                'admission_round': adm_round,
                                'notice': notice })
Example #18
0
File: views.py Project: jittat/adm2
def quota_reset_choice(request):
    """
    reset choice between quota & direct
    """
    applicant = request.applicant

    if not applicant.has_additional_result:
        return HttpResponseForbidden()
    additional_result = applicant.additional_result

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number

    admission_result = applicant.get_latest_admission_result()

    if additional_result.round_number != round_number:
        return HttpResponseForbidden()

    if not admission_result: 
        return HttpResponseForbidden()
    
    if request.method!='POST':
        return HttpResponseForbidden()

    # remove from quota waived
    AdmissionWaiver.unwaive_applicant(applicant)

    # remove from direct waived
    additional_result.is_waived = False
    additional_result.save()
    AdmissionConfirmation.delete_for(applicant,
                                     current_round.number)
    AdmissionMajorPreference.objects.filter(applicant=applicant,
                                            round_number=current_round.number).delete()

    registration = applicant.get_student_registration()
    if registration:
        registration.delete()

    Log.create("Reset quota/direct waiver applicant %s from %s" % 
               (applicant.id, request.META['REMOTE_ADDR']),
               applicant_id=applicant.id)

    return redirect('status-index')
Example #19
0
File: views.py Project: jittat/adm2
def quota_reset_choice(request):
    """
    reset choice between quota & direct
    """
    applicant = request.applicant

    if not applicant.has_additional_result:
        return HttpResponseForbidden()
    additional_result = applicant.additional_result

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number

    admission_result = applicant.get_latest_admission_result()

    if additional_result.round_number != round_number:
        return HttpResponseForbidden()

    if not admission_result:
        return HttpResponseForbidden()

    if request.method != 'POST':
        return HttpResponseForbidden()

    # remove from quota waived
    AdmissionWaiver.unwaive_applicant(applicant)

    # remove from direct waived
    additional_result.is_waived = False
    additional_result.save()
    AdmissionConfirmation.delete_for(applicant, current_round.number)
    AdmissionMajorPreference.objects.filter(
        applicant=applicant, round_number=current_round.number).delete()

    registration = applicant.get_student_registration()
    if registration:
        registration.delete()

    Log.create("Reset quota/direct waiver applicant %s from %s" %
               (applicant.id, request.META['REMOTE_ADDR']),
               applicant_id=applicant.id)

    return redirect('status-index')
Example #20
0
def index(request):
    adm_round = AdmissionRound.get_recent()

    pref_stat = build_pref_stat(adm_round)
    total_pref_stat = build_total_stat(pref_stat)

    if 'notice' in request.session:
        notice = request.session['notice']
        del request.session['notice']
    else:
        notice = ''

    return render_to_response(
        'confirmation/review_main.html', {
            'pref_stat': pref_stat,
            'total_pref_stat': total_pref_stat,
            'admission_round': adm_round,
            'notice': notice
        })
Example #21
0
File: views.py Project: jittat/adm2
def quota_choice(request, applicant, admission_result):
    current_round = AdmissionRound.get_recent()
    round_number = current_round.number

    additional_result = applicant.additional_result
    is_result_for_current_round = (
        additional_result.round_number == round_number)
    can_edit = (not admission_major_pref_deadline_passed()
                ) and is_result_for_current_round

    student_registration = applicant.get_student_registration()

    if request.method == 'POST' and not can_edit:
        return render_to_response('confirmation/pref_deadline_passed.html',
                                  {'admission_round': current_round})

    if request.method == 'POST':
        if request.POST['major_select'] == 'quota':
            AdmissionWaiver.waive_applicant(applicant)
            Log.create("Waive applicant %s to quota from %s" %
                       (applicant.id, request.META['REMOTE_ADDR']),
                       applicant_id=applicant.id)
            return redirect('status-index')

        if request.POST['major_select'] == 'direct':
            additional_result.is_waived = True
            additional_result.save()
            Log.create("Waive applicant %s to direct from %s" %
                       (applicant.id, request.META['REMOTE_ADDR']),
                       applicant_id=applicant.id)
            return redirect('status-index')

    return render_to_response(
        'confirmation/quota/choices.html', {
            'applicant': applicant,
            'admission_result': admission_result,
            'additional_result': additional_result,
            'student_registration': student_registration,
            'can_edit': can_edit,
            'can_log_out': True
        })
Example #22
0
def confirmation_ticket(request):
    applicant = request.applicant
    admitted = applicant.is_admitted()

    if not admitted:
        raise Http404

    if not request.applicant.is_submitted:
        return render_to_response('application/submission/ticket_not_submitted.html')

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number
    admission_result = applicant.get_latest_admission_result()
    admission_pref = applicant.get_admission_major_preference(round_number)

    if not admission_pref:
        raise Http404

    confirmations = applicant.admission_confirmations.all()
    total_amount_confirmed = sum([c.paid_amount for c in confirmations])

    amount = admission_result.admitted_major.confirmation_amount - total_amount_confirmed
    if amount < 0:
        amount = 0

    if amount in AMOUNT_STRINGS:
        amount_str = AMOUNT_STRINGS[amount]
    else:
        amount_str = str(amount)

    deadline = current_round.last_date
    msg = u'ยืนยันสิทธิ์การเข้าศึกษาต่อในสาขา' + admission_result.admitted_major.name

    verification = request.applicant.verification_number(settings.CONFIRMATION_HASH_MAGIC)
    return render_to_response('application/payin/ticket.html',
                              {'amount': amount,
                               'amount_str': amount_str,
                               'applicant': request.applicant,
                               'verification': verification,
                               'deadline': deadline,
                               'msg': msg })
Example #23
0
File: views.py Project: jittat/adm2
def quota_choice(request, applicant, admission_result):
    current_round = AdmissionRound.get_recent()
    round_number = current_round.number

    additional_result = applicant.additional_result
    is_result_for_current_round = (additional_result.round_number == round_number)
    can_edit = (not admission_major_pref_deadline_passed()) and is_result_for_current_round

    student_registration = applicant.get_student_registration()

    if request.method=='POST' and not can_edit:
        return render_to_response('confirmation/pref_deadline_passed.html',
                                  {'admission_round': current_round})

    if request.method=='POST':
        if request.POST['major_select']=='quota':
            AdmissionWaiver.waive_applicant(applicant)
            Log.create("Waive applicant %s to quota from %s" % 
                       (applicant.id, request.META['REMOTE_ADDR']),
                       applicant_id=applicant.id)
            return redirect('status-index')           

        if request.POST['major_select']=='direct':
            additional_result.is_waived = True
            additional_result.save()
            Log.create("Waive applicant %s to direct from %s" % 
                       (applicant.id, request.META['REMOTE_ADDR']),
                       applicant_id=applicant.id)
            return redirect('status-index')           

    return render_to_response('confirmation/quota/choices.html',
                              { 'applicant': applicant,
                                'admission_result': admission_result,
                                'additional_result': additional_result,
                                'student_registration': student_registration,
                                'can_edit': can_edit,
                                'can_log_out': True })
Example #24
0
def index(request):
    notice = ''
    if 'notice' in request.session:
        notice = request.session['notice']
        del request.session['notice']

    submission_info = request.applicant.submission_info
    random_seed = 1000000 + randint(0,8999999)

    applicant = request.applicant

    admission_result = None
    admission_major_pref = None
    admitted_major = None
    latest_admission_major_pref = None
    latest_admission_result = None
    is_adm_major_pref_copied_from_prev_round = False
    student_registration = None

    accepting_majors = None

    first_admission = False

    current_round = AdmissionRound.get_recent()

    is_last_round = True

    if current_round:
        admission_result = applicant.get_latest_admission_result()

        first_admission = (applicant.admission_results.count() == 1)

        admission_major_pref = applicant.get_admission_major_preference(current_round.number)

        if not admission_major_pref:
            all_major_prefs = list(applicant.admission_major_preferences.all())
            if len(all_major_prefs)>0:
                latest_admission_major_pref = all_major_prefs[0]

                if admission_result:
                    # accepted, copy previous pref
                    admission_major_pref = copy_previous_adm_major_pref(
                        latest_admission_major_pref, 
                        applicant,
                        admitted_major,
                        current_round.number)
                    admission_major_pref.save()

        if admission_major_pref:
            accepting_majors = admission_major_pref.get_accepted_majors(check_admitted=False)
        elif latest_admission_major_pref:
            # for those who picked choice 3
            accepting_majors = latest_admission_major_pref.get_accepted_majors(check_admitted=False)
            

        if admission_result:
            admitted_major = admission_result.admitted_major
            student_registration = applicant.get_student_registration()

        if not admission_result:
            results = applicant.admission_results.filter(round_number__lte=current_round.number).all()
            if len(results)>0:
                latest_admission_result = results[len(results)-1]

    confirmations = applicant.admission_confirmations.all()
    total_amount_confirmed = sum([c.paid_amount for c in confirmations])

    if admitted_major and (total_amount_confirmed >= admitted_major.confirmation_amount):
        confirmation_complete = True
        additional_payment = 0
    else:
        confirmation_complete = False
        if admitted_major:
            additional_payment = admitted_major.confirmation_amount - total_amount_confirmed
        else:
            additional_payment = 0

    if len(confirmations)!=0:
        recent_confirmation = confirmations[0]
    else:
        recent_confirmation = None

    is_confirmation_time_left = (AdmissionRound.time_to_recent_round_deadline() > timedelta(0))

    return render_to_response("application/status/index.html",
                              { 'applicant': request.applicant,
                                'submission_info': submission_info,
                                'admission_result': admission_result,
                                'first_admission': first_admission,
                                'latest_admission_result':
                                    latest_admission_result,
                                'admission_major_pref': admission_major_pref,
                                'accepting_majors': accepting_majors,
                                'latest_admission_major_pref':
                                    latest_admission_major_pref,
                                'is_adm_major_pref_copied_from_prev_round':
                                    is_adm_major_pref_copied_from_prev_round,

                                'confirmation_complete': confirmation_complete,
                                'recent_confirmation': recent_confirmation,
                                'confirmations': confirmations,
                                'total_amount_confirmed': total_amount_confirmed,
                                'additional_payment': additional_payment,

                                'student_registration':
                                    student_registration,

                                'current_round': current_round,
                                'is_last_round': is_last_round,
                                'is_confirmation_time_left': is_confirmation_time_left,
                                'random_seed': random_seed,
                                'notice': notice,
                                'can_log_out': True })
Example #25
0
File: utils.py Project: jittat/adm2
def admission_major_pref_deadline_passed():
    from result.models import AdmissionRound

    time_to_deadline = AdmissionRound.time_to_recent_round_deadline()

    return time_to_deadline <= timedelta(0)
Example #26
0
File: views.py Project: jittat/adm2
def main(request, is_edit_registration=False):
    if settings.SHOW_ONLY_RESULTS:
        return HttpResponseForbidden()

    applicant = request.applicant
    admitted = applicant.is_admitted()

    if not admitted:
        return HttpResponseForbidden()

    first_admission = (applicant.admission_results.count() == 1)
    if not first_admission:
        return HttpResponseForbidden()

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number
    is_last_round = False

    # check for deadline
    if admission_major_pref_deadline_passed():
        return render_to_response('confirmation/pref_deadline_passed.html',
                                  {'admission_round': current_round})

    admission_result = applicant.get_latest_admission_result()

    preferred_majors = applicant.preference.get_major_list()
    higher_majors = get_higher_ranked_majors(preferred_majors,
                                             admission_result.admitted_major)
    is_best_major = (len(higher_majors) == 0)

    if AdmissionWaiver.is_waived(applicant):
        waiver = applicant.admission_waiver
    else:
        waiver = None

    registration = applicant.get_student_registration()
    if request.method == 'GET' and registration and not is_edit_registration and not is_best_major:
        return redirect('confirmation-pref')

    if request.method == 'POST' and 'confirm' in request.POST:
        form = StudentRegistrationForm(request.POST, instance=registration)
        if form.is_valid():
            registration = form.save(commit=False)
            registration.applicant = applicant
            registration.save()

            AdmissionConfirmation.create_for(applicant, current_round.number)

            send_admission_confirmation_by_email(applicant)

            if not is_best_major:
                Log.create("Confirm applicant %s from %s" %
                           (applicant.id, request.META['REMOTE_ADDR']),
                           applicant_id=applicant.id)

                return redirect('confirmation-pref')
            else:
                Log.create("Confirm applicant %s (for best) from %s" %
                           (applicant.id, request.META['REMOTE_ADDR']),
                           applicant_id=applicant.id)

                save_best_admission_major_pref(applicant, current_round,
                                               admission_result)
                return redirect('status-index')

    elif request.method == 'POST' and 'waive' in request.POST:

        AdmissionWaiver.waive_applicant(applicant)
        if registration:
            registration.delete()
        AdmissionConfirmation.delete_for(applicant, current_round.number)
        save_waive_admission_major_pref(applicant, current_round)

        Log.create("Waive applicant %s from %s" %
                   (applicant.id, request.META['REMOTE_ADDR']),
                   applicant_id=applicant.id)

        send_admission_waive_by_email(applicant)

        request.session[
            'notice'] = u'คุณได้สละสิทธิ์การเข้าศึกษาต่อผ่านโครงการรับตรงแล้ว'
        return redirect('status-index')

    elif request.method == 'POST' and 'unwaive' in request.POST:

        AdmissionWaiver.unwaive_applicant(applicant)
        AdmissionMajorPreference.objects.filter(
            applicant=applicant, round_number=current_round.number).delete()

        Log.create("Unwaive applicant %s from %s" %
                   (applicant.id, request.META['REMOTE_ADDR']),
                   applicant_id=applicant.id)

        send_admission_unwaive_by_email(applicant)

        return redirect('confirmation-app-index')

    elif request.method == 'POST' and 'cancel' in request.POST:
        return redirect('status-index')

    else:
        form = StudentRegistrationForm(instance=registration)

    return render_to_response(
        'confirmation/index.html', {
            'applicant': applicant,
            'admission_result': admission_result,
            'current_round': current_round,
            'is_last_round': is_last_round,
            'is_best_major': is_best_major,
            'registration': registration,
            'waiver': waiver,
            'form': form,
            'can_log_out': True
        })
Example #27
0
File: views.py Project: jittat/adm2
def pref(request):
    if settings.SHOW_ONLY_RESULTS:
        return HttpResponseForbidden()

    applicant = request.applicant
    admitted = applicant.is_admitted()

    if not admitted:
        return HttpResponseForbidden()

    first_admission = (applicant.admission_results.count() == 1)
    if not first_admission:
        return HttpResponseForbidden()

    registration = applicant.get_student_registration()
    if not registration:
        return HttpResponseForbidden()

    # check for deadline
    if admission_major_pref_deadline_passed():
        return render_to_response('confirmation/pref_deadline_passed.html')

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number
    is_last_round = False

    admission_result = applicant.get_latest_admission_result()

    preferred_majors = applicant.preference.get_major_list()
    higher_majors = get_higher_ranked_majors(preferred_majors, 
                                             admission_result.admitted_major)

    admission_pref = applicant.get_admission_major_preference(round_number)

    if admission_pref:
        pref_type = admission_pref.get_pref_type()
        accepted_major_ids = [m.id for m in admission_pref.get_accepted_majors()]
        is_accepted_list = [(m.id in accepted_major_ids)
                            for m in higher_majors]
    else:
        pref_type = AdmissionMajorPreference.PrefType.new_empty()
        try:
            is_accepted_list = [False] * len(higher_majors)
        except:
            Log.create("Error: empty higher majors: %d" % (applicant.id,))
            raise

    form_check_message = ''

    if request.method=='POST':
        if 'submit' in request.POST:
            check_result, form_check_message = check_form_submission(request.POST, higher_majors)
            if check_result:
                admission_pref = update_admission_major_preference(
                    admission_pref,
                    applicant, preferred_majors,
                    higher_majors, 
                    round_number,
                    request.POST)
                admission_pref.set_ptype_cache(save=False)

                if is_last_round and (
                    admission_pref.get_pref_type().is_move_up_inclusive() or
                    admission_pref.get_pref_type().is_move_up_strict()):
                    return HttpResponseForbidden()

                admission_pref.save()
                request.session['notice'] = 'เก็บข้อมูลการยืนยันอันดับการเลือกสาขาวิชาแล้ว'

                Log.create("confirmation - from: %s,type: %d (%s), val: %s" %
                           (request.META['REMOTE_ADDR'],
                            admission_pref.get_pref_type().ptype,
                            request.POST['pref_type'],
                            str(admission_pref.is_accepted_list)),
                           applicant_id=applicant.id,
                           applicantion_id=applicant.submission_info.applicantion_id)

                return HttpResponseRedirect(reverse('status-index'))
        else:
            if admission_pref:
                request.session['notice'] = 'ยกเลิกการแก้ไขอันดับการเลือกสาขาวิชา'
            else:
                request.session['notice'] = 'ยกเลิกการยืนยันอันดับการเลือกสาขาวิชา'

            Log.create("confirmation: cancel",
                       applicant_id=applicant.id,
                       applicantion_id=applicant.submission_info.applicantion_id)

            return HttpResponseRedirect(reverse('status-index'))
    else:
        pass

    return render_to_response('confirmation/pref.html',
                              { 'applicant': applicant,
                                'admission_result': admission_result,
                                'current_round': current_round,
                                'is_last_round': is_last_round,
                                'registration': registration,
                                'higher_majors': higher_majors,
                                'majors_with_is_accepted':
                                    zip(higher_majors, is_accepted_list),
                                'admission_pref': admission_pref,
                                'pref_type': pref_type,
                                'form_check_message': form_check_message })
Example #28
0
File: utils.py Project: jittat/adm2
def admission_major_pref_deadline_passed():
    from result.models import AdmissionRound

    time_to_deadline = AdmissionRound.time_to_recent_round_deadline()

    return time_to_deadline <= timedelta(0)
Example #29
0
File: views.py Project: jittat/adm2
def main(request, is_edit_registration=False):
    if settings.SHOW_ONLY_RESULTS:
        return HttpResponseForbidden()

    applicant = request.applicant
    admitted = applicant.is_admitted()

    if not admitted:
        return HttpResponseForbidden()

    first_admission = (applicant.admission_results.count() == 1)
    if not first_admission:
        return HttpResponseForbidden()

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number
    is_last_round = False

    # check for deadline
    if admission_major_pref_deadline_passed():
        return render_to_response('confirmation/pref_deadline_passed.html',
                                  {'admission_round': current_round})

    admission_result = applicant.get_latest_admission_result()

    preferred_majors = applicant.preference.get_major_list()
    higher_majors = get_higher_ranked_majors(preferred_majors, 
                                             admission_result.admitted_major)
    is_best_major = (len(higher_majors)==0)

    if AdmissionWaiver.is_waived(applicant):
        waiver = applicant.admission_waiver
    else:
        waiver = None

    registration = applicant.get_student_registration()
    if request.method=='GET' and registration and not is_edit_registration and not is_best_major:
        return redirect('confirmation-pref')

    if request.method=='POST' and 'confirm' in request.POST:
        form = StudentRegistrationForm(request.POST,
                                       instance=registration)
        if form.is_valid():
            registration = form.save(commit=False)
            registration.applicant = applicant
            registration.save()

            AdmissionConfirmation.create_for(applicant,
                                             current_round.number)

            send_admission_confirmation_by_email(applicant)

            if not is_best_major:
                Log.create("Confirm applicant %s from %s" % 
                           (applicant.id,request.META['REMOTE_ADDR']),
                           applicant_id=applicant.id)

                return redirect('confirmation-pref')
            else:
                Log.create("Confirm applicant %s (for best) from %s" % 
                           (applicant.id,request.META['REMOTE_ADDR']),
                           applicant_id=applicant.id)

                save_best_admission_major_pref(applicant, 
                                               current_round,
                                               admission_result)
                return redirect('status-index')

    elif request.method=='POST' and 'waive' in request.POST:

        AdmissionWaiver.waive_applicant(applicant)
        if registration:
            registration.delete()
        AdmissionConfirmation.delete_for(applicant,
                                         current_round.number)
        save_waive_admission_major_pref(applicant,
                                        current_round)

        Log.create("Waive applicant %s from %s" % 
                   (applicant.id,request.META['REMOTE_ADDR']),
                   applicant_id=applicant.id)

        send_admission_waive_by_email(applicant)

        request.session['notice'] = u'คุณได้สละสิทธิ์การเข้าศึกษาต่อผ่านโครงการรับตรงแล้ว'
        return redirect('status-index')
        
    elif request.method=='POST' and 'unwaive' in request.POST:

        AdmissionWaiver.unwaive_applicant(applicant)
        AdmissionMajorPreference.objects.filter(applicant=applicant,
                                                round_number=current_round.number).delete()

        Log.create("Unwaive applicant %s from %s" % 
                   (applicant.id,request.META['REMOTE_ADDR']),
                   applicant_id=applicant.id)

        send_admission_unwaive_by_email(applicant)

        return redirect('confirmation-app-index')

    elif request.method=='POST' and 'cancel' in request.POST:
        return redirect('status-index')

    else:
        form = StudentRegistrationForm(instance=registration)

    return render_to_response('confirmation/index.html',
                              { 'applicant': applicant,
                                'admission_result': admission_result,
                                'current_round': current_round,
                                'is_last_round': is_last_round,
                                'is_best_major': is_best_major,
                                'registration': registration,
                                'waiver': waiver,
                                'form': form,
                                'can_log_out': True})
Example #30
0
File: views.py Project: jittat/adm2
def pref(request):
    if settings.SHOW_ONLY_RESULTS:
        return HttpResponseForbidden()

    applicant = request.applicant
    admitted = applicant.is_admitted()

    if not admitted:
        return HttpResponseForbidden()

    first_admission = (applicant.admission_results.count() == 1)
    if not first_admission:
        return HttpResponseForbidden()

    registration = applicant.get_student_registration()
    if not registration:
        return HttpResponseForbidden()

    # check for deadline
    if admission_major_pref_deadline_passed():
        return render_to_response('confirmation/pref_deadline_passed.html')

    current_round = AdmissionRound.get_recent()
    round_number = current_round.number
    is_last_round = False

    admission_result = applicant.get_latest_admission_result()

    preferred_majors = applicant.preference.get_major_list()
    higher_majors = get_higher_ranked_majors(preferred_majors,
                                             admission_result.admitted_major)

    admission_pref = applicant.get_admission_major_preference(round_number)

    if admission_pref:
        pref_type = admission_pref.get_pref_type()
        accepted_major_ids = [
            m.id for m in admission_pref.get_accepted_majors()
        ]
        is_accepted_list = [(m.id in accepted_major_ids)
                            for m in higher_majors]
    else:
        pref_type = AdmissionMajorPreference.PrefType.new_empty()
        try:
            is_accepted_list = [False] * len(higher_majors)
        except:
            Log.create("Error: empty higher majors: %d" % (applicant.id, ))
            raise

    form_check_message = ''

    if request.method == 'POST':
        if 'submit' in request.POST:
            check_result, form_check_message = check_form_submission(
                request.POST, higher_majors)
            if check_result:
                admission_pref = update_admission_major_preference(
                    admission_pref, applicant, preferred_majors, higher_majors,
                    round_number, request.POST)
                admission_pref.set_ptype_cache(save=False)

                if is_last_round and (
                        admission_pref.get_pref_type().is_move_up_inclusive()
                        or admission_pref.get_pref_type().is_move_up_strict()):
                    return HttpResponseForbidden()

                admission_pref.save()
                request.session[
                    'notice'] = 'เก็บข้อมูลการยืนยันอันดับการเลือกสาขาวิชาแล้ว'

                Log.create(
                    "confirmation - from: %s,type: %d (%s), val: %s" %
                    (request.META['REMOTE_ADDR'],
                     admission_pref.get_pref_type().ptype,
                     request.POST['pref_type'],
                     str(admission_pref.is_accepted_list)),
                    applicant_id=applicant.id,
                    applicantion_id=applicant.submission_info.applicantion_id)

                return HttpResponseRedirect(reverse('status-index'))
        else:
            if admission_pref:
                request.session[
                    'notice'] = 'ยกเลิกการแก้ไขอันดับการเลือกสาขาวิชา'
            else:
                request.session[
                    'notice'] = 'ยกเลิกการยืนยันอันดับการเลือกสาขาวิชา'

            Log.create(
                "confirmation: cancel",
                applicant_id=applicant.id,
                applicantion_id=applicant.submission_info.applicantion_id)

            return HttpResponseRedirect(reverse('status-index'))
    else:
        pass

    return render_to_response(
        'confirmation/pref.html', {
            'applicant': applicant,
            'admission_result': admission_result,
            'current_round': current_round,
            'is_last_round': is_last_round,
            'registration': registration,
            'higher_majors': higher_majors,
            'majors_with_is_accepted': zip(higher_majors, is_accepted_list),
            'admission_pref': admission_pref,
            'pref_type': pref_type,
            'form_check_message': form_check_message
        })