def makecopy_students(request):
logging.info(request.POST)
job_id = request.POST['job_id']
job = Job.get_by_id(int(job_id))
job.start()
job.save()
student_ids = request.POST.getlist('student_ids')
target_course_id = request.POST['target_course_id']
source_course_id = request.POST['source_course_id']
target_course = Course.get_by_id(int(target_course_id))
if target_course is None:
logging.info('missing target course')
job.finish(error=True)
job.save()
return HttpResponse('error')
source_course = Course.get_by_id(int(source_course_id))
if source_course is None:
logging.info('missing source course')
job.finish(error=True)
job.save()
return HttpResponse('error')
logging.info('student list %s'%student_ids)
pr = dict()
for student_id in student_ids:
(old_refkey,new) = makecopy_student(int(student_id), target_course)
pr[old_refkey]=new
logging.info('stage 2 done')
for n in pr.values():
np = pr.get(n.partner_ref_code,None)
if not np is None:
logging.info('update partner_ref_code %s -> %s'%(n.partner_ref_code,np.ref_key))
n.partner_ref_code=np.ref_key
n.save()
cdbsync.plan_cdb_put(n)
taskqueue.add(url='/task/recount_capacity/', params={'course_id':target_course.key().id()})
job.finish()
job.save()
return HttpResponse('ok')
def transfer_students(request):
logging.info(request.POST)
job_id = request.POST['job_id']
job = Job.get_by_id(int(job_id))
job.start()
job.save()
student_ids = request.POST.getlist('student_ids')
target_course_id = request.POST['target_course_id']
source_course_id = request.POST['source_course_id']
target_course = Course.get_by_id(int(target_course_id))
if target_course is None:
logging.info('missing target course')
job.finish(error=True)
job.save()
return HttpResponse('error')
source_course = Course.get_by_id(int(source_course_id))
if source_course is None:
logging.info('missing source course')
job.finish(error=True)
job.save()
return HttpResponse('error')
logging.info('student list %s'%student_ids)
for student_id in student_ids:
transfer_student(int(student_id), target_course)
recount_course_capacity(source_course)
source_course.save()
logging.info(source_course)
cdbsync.plan_cdb_put(source_course)
taskqueue.add(url='/task/recount_capacity/', params={'course_id':target_course.key().id()})
job.finish()
job.save()
return HttpResponse('ok')
def import_school(request,file_id):
f = FileBlob.get_by_id(int(file_id))
if f is None:
raise Http404
d = cStringIO.StringIO(f.data)
r = UnicodeReader(d,encoding='utf8', delimiter=',', quotechar='"')
form = None
course = None
season = None
cskey = request.session.get('course_season_key',None)
if not cskey is None:
season = Season.get(str(cskey))
folder = None
cfkey = request.session.get('course_folder_key',None)
if not cfkey is None:
folder = Folder.get(str(cfkey))
logging.info('cfkey %s cskey %s'%(cskey,cfkey))
logging.info('folder: %s'%folder)
logging.info('season: %s'%season)
if folder and season:
cc = Course.get_COURSE_FILTER_CHOICES(str(season.key()),str(folder.key()))
else:
cc = Course.get_COURSE_CHOICES()
logging.info('cc:%s'%cc)
if request.method == 'POST':
logging.info('meth post, filling form')
form = TargetPickForm2(request.POST,courses = cc)
if form.is_valid():
course = Course.get(form.cleaned_data['course_key'])
if course is None:
raise Http404
else:
logging.info('meth get, blank form')
form = TargetPickForm2(courses = cc)
selected = None
info = []
return render_to_response('admin/import_school.html', RequestContext(request, { 'info': info, 'form':form, 'course':course, 'season':season, 'folder':folder}))
def show(request,ref_code):
student = Student.get_by_ref_key(ref_code)
if student:
course = Course.get(student.course_key)
else:
course = None
return render_to_response('enroll/show.html', RequestContext(request, { 'course': course, 'student':student, 'ref_code':ref_code }))
def confirm(request,confirm_code):
student = Student.get_by_confirm_key(confirm_code)
if student:
course = Course.get(student.course_key)
else:
course = None
if (student is None) or (course is None):
status = False
else:
status = True
if status:
if student.status == 'n':
if course.can_enroll():
student.status = 'e'
student.init_enroll()
student.save()
plan_send_student_email('ENROLL_OK_PAY_REQUEST',student)
else:
student.status = 's'
student.save()
plan_send_student_email('ENROLL_OK_SPARE',student)
plan_send_enroll_form(student)
plan_update_course(course)
elif not student.status in ['e','s']:
status = False
return render_to_response('enroll/confirm.html', RequestContext(request, { 'course': course, 'student':student, 'confirm_code':confirm_code, 'status':status }))
def confirm_pair(request,confirm_code1,confirm_code2):
student1 = Student.get_by_confirm_key(confirm_code1)
if student1:
course = Course.get(student1.course_key)
else:
course = None
student2 = Student.get_by_confirm_key(confirm_code2)
if (student1 is None) or (student2 is None) or (course is None):
status = False
else:
status = True
if status:
if student1.status == 'n':
if course.can_enroll():
student1.status = 'e'
student1.init_enroll()
student1.save()
plan_send_student_email('ENROLL_OK_PAY_REQUEST',student1)
else:
student1.status = 's'
student1.save()
plan_send_student_email('ENROLL_OK_SPARE',student1)
plan_send_enroll_form(student1)
status1 = True
elif not student1.status in ['e','s']:
status1 = False
else:
status1 = True
if student2.status == 'n':
if course.can_enroll():
student2.status = 'e'
student2.init_enroll()
student2.save()
plan_send_student_email('ENROLL_OK_PAY_REQUEST',student2)
else:
student2.status = 's'
student2.save()
plan_send_student_email('ENROLL_OK_SPARE',student2)
plan_send_enroll_form(student2)
status2 = True
elif not student2.status in ['e','s']:
status2 = False
else:
status2 = True
status = status1 or status2
if status:
plan_update_course(course)
return render_to_response('enroll/confirm_pair.html', RequestContext(request, { 'course': course, 'student1':student1, 'student2':student2, 'confirm_code1':confirm_code1, 'confirm_code2':confirm_code2 , 'status':status }))
def get_offer_list(folder_id = None):
if folder_id is None:
folders_query=Folder.list()
else:
folders_query = []
f = Folder.get_by_id(int(folder_id))
if f:
folders_query.append(f)
courses_query=Course.list_for_enroll()
folders= set([])
courses = []
result = []
for course in courses_query:
folders.add(course.folder_key)
courses.append(course)
logging.info(folders)
logging.info(courses)
for folder in folders_query:
fk = str(folder.key())
logging.info('fk:%s'%fk)
if fk in folders:
logging.info('in')
sub_list = [c for c in courses if fk==c.folder_key]
result.append({'folder':folder, 'courses':sub_list })
pass
return result
def index(request):
season = None
if request.method == 'POST':
filter_form = SeasonFilterForm(request.POST)
if filter_form.is_valid():
season = Season.get(str(filter_form.cleaned_data['season_key']))
if not season is None:
request.session['backup_season_key']=str(season.key())
else:
bskey = request.session.get('backup_season_key',None)
if not bskey is None:
season = Season.get(str(bskey))
if season is None:
filter_form = SeasonFilterForm()
else:
filter_form = SeasonFilterForm({'season_key':str(season.key())})
if season is None:
course_list = None
else:
course_list = Course.list_season(str(season.key()))
return render_to_response('admin/backup_index.html', RequestContext(request, { 'filter_form':filter_form, 'course_list': course_list}))
def plan_update_all_courses(request):
logging.info("update_all_courses")
courses = Course.list()
for c in courses:
logging.info("course %s"%c.key())
cdbsync.plan_cdb_put(c)
return HttpResponse('ok')
def create(request):
course = Course()
season = None
folder = None
cskey = request.session.get("course_season_key", None)
if not cskey is None:
season = Season.get(str(cskey))
cfkey = request.session.get("course_folder_key", None)
if not cfkey is None:
folder = Folder.get(str(cfkey))
if not ((folder is None) or (Season is None)):
course.folder_key = cfkey
course.season_key = cskey
if request.method == "POST":
form = CourseForm(request.POST, instance=course)
if form.is_valid():
logging.info("edit course before %s" % course)
form.save(commit=False)
logging.info("edit course after %s" % course)
course.mark_as_modify()
course.save()
cdbsync.plan_cdb_put(course)
return HttpResponseRedirect("..")
else:
form = CourseForm(instance=course)
return render_to_response("admin/courses_create.html", RequestContext(request, {"form": form}))
def recount(request, course_id):
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
taskqueue.add(url="/task/recount_capacity/", params={"course_id": course.key().id()})
return HttpResponseRedirect("../..")
def index_course(request, course_id):
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
logging.info('course: %s'%course)
backup_list = CourseBackup.list_for_course(str(course.key()))
return render_to_response('admin/backup_list.html', RequestContext(request, { 'backup_list': backup_list, 'course':course}))
def show_pair(request,ref_code1, ref_code2):
student1 = Student.get_by_ref_key(ref_code1)
if student1:
course = Course.get(student1.course_key)
else:
course = None
student2 = Student.get_by_ref_key(ref_code2)
return render_to_response('enroll/show_pair.html', RequestContext(request, { 'course': course, 'student1':student1, 'ref_code1':ref_code1, 'student2':student2, 'ref_code2':ref_code2 }))
def plan_fullsync(request,course_id):
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
logging.info('course: %s'%course)
taskqueue.add(url='/task/course_fullsync/', params={'course_id':course.key().id()})
return HttpResponseRedirect('../..')
def plan_course_backup(request):
if not cfg.getConfigBool('BACKUP_ON',False):
logging.info('BACKUP_ON is OFF!')
return HttpResponse('ok')
course_list = Course.list_for_backup().fetch(100)
for c in course_list:
logging.info('course: %s'%c)
taskqueue.add(url='/task/course_backup/', params={'course_id':c.key().id()})
return HttpResponse('ok')
def all_courses(request):
########## hromadne vypnuti slevy
course_list=Course.list()
for c in course_list:
if c.cost_sale:
logging.info('course %s sale off'%(c.code))
c.cost_sale = False
c.save()
#############
return HttpResponse('ok')
def attend_force_single(request,course_id):
if not config.getConfigBool('ENROLL_ENROLL_ON',False):
raise Http404
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
if not course.is_open():
raise Http404
return attend_single(request,course)
def delete(request, course_id):
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
taskqueue.add(url="/task/hide_course_students/", params={"course_id": course.key().id()})
course.hidden = True
course.mark_as_modify()
course.save()
return redirect("../..")
def course_fullsync(request):
logging.info(request.POST)
course_id = request.POST['course_id']
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
cdbsync.plan_cdb_put(course)
logging.info('course=%s'%course)
students = Student.list_for_course(course.key())
for s in students:
logging.info("student %s" % s.key())
cdbsync.plan_cdb_put(s)
logging.info("all done")
return HttpResponse('ok')
def course_backup(request):
logging.info(request.POST)
course_id = request.POST['course_id']
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
logging.info('course=%s'%course)
student_list_to_enroll=Student.list_for_course_to_enroll(course.key())
student_list_enrolled=Student.list_for_course_enrolled(course.key())
if course.group_mode == 'Single':
student_list_to_enroll = sort_students_spare_single(student_list_to_enroll)
student_list_enrolled = sort_students_single(student_list_enrolled)
elif course.group_mode == 'School':
student_list_to_enroll = sort_students_spare_school(student_list_to_enroll)
student_list_enrolled = sort_students_school(student_list_enrolled)
elif course.group_mode == 'Pair':
student_list_to_enroll = sort_students_spare_pair(student_list_to_enroll)
student_list_enrolled = sort_students_pair(student_list_enrolled)
students = []
students.extend(student_list_enrolled)
students.extend(student_list_to_enroll)
data = [ ['#zaloha kurz',course.code,course.folder_name(),course.season_name()]]
for s in students:
if not s.x_pair_empty_slot:
data.append(s.as_csv_row())
out = cStringIO.StringIO()
dump_to_csv(data,out)
# logging.info(out)
cb = CourseBackup()
cb.init(out.getvalue(),course=course)
cb.save()
course.mark_as_backup()
course.save()
if cfg.getConfigBool('BACKUP_EMAIL_ON',False):
taskqueue.add(url='/task/send_backup/', params={'coursebackup_id':cb.key().id()})
logging.info('send task plan ok, cbid=%s'%(cb.key().id()))
else:
logging.info('BACKUP_EMAIL_ON is OFF!')
return HttpResponse('ok')
def manual_confirm(request, ref_code=None):
info = ""
student = None
course = None
status = False
if request.method == "POST":
form = ConfirmForm(request.POST)
if form.is_valid():
ref_code = form.cleaned_data["ref_code"]
confirm_code = form.cleaned_data["confirm_code"]
student = Student.get_by_ref_key(ref_code)
if student is None:
student = Student.get_by_confirm_key(confirm_code)
if student is None:
info = "Přihláška nenalezena"
else:
course = Course.get(student.course_key)
if course is None:
info = "Přihláška obsahuje neplatný kurz"
else:
if student.status == "n":
if course.can_enroll():
student.status = "e"
student.init_enroll()
student.save()
plan_send_student_email("ENROLL_OK_PAY_REQUEST", student)
info = "Přihláška byla potvrzena a zařazena do kurzu"
else:
student.status = "s"
student.save()
plan_send_student_email("ENROLL_OK_SPARE", student)
info = "Přihláška byla potvrzena a zařazena do kurzu mezi náhradníky"
plan_send_enroll_form(student)
plan_update_course(course)
status = True
elif student.status in ["e", "s"]:
info = "Přihláška již byla potrzena"
else:
info = "Přihlášku již nelze potvrdit"
else:
if ref_code is None:
form = ConfirmForm()
else:
form = ConfirmForm({"ref_code": ref_code})
return render_to_response(
"admin/enroll_manual_confirm.html",
RequestContext(request, {"form": form, "student": student, "course": course, "status": status, "info": info}),
)
def get_backup(request, course_id, course_backup_id):
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
course_backup = CourseBackup.get_by_id(int(course_backup_id))
if course_backup is None:
raise Http404
r = HttpResponse(course_backup.data,mimetype='application/vnd.ms-excel')
file_name = urllib.quote(course_backup.filename)
logging.info(file_name)
r['Content-Disposition'] = "attachment; filename*=UTF-8''%s"%file_name
return r
def recount_capacity(request):
logging.info(request.POST)
course_id = request.POST['course_id']
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
recount_course_capacity(course)
course.save()
logging.info(course)
cdbsync.plan_cdb_put(course)
return HttpResponse('ok')
def update_all_students_for_season(request):
logging.info("update_all_students_for_season")
logging.info(request.POST)
season_id = request.POST['season_id']
season = Season.get_by_id(int(season_id))
if season is None:
raise Http404
logging.info("season %s" % season)
cdbsync.plan_cdb_put(season)
courses = Course.list_season(str(season.key()))
logging.info("all courses get")
for c in courses:
logging.info("course %s "%c.key())
taskqueue.add(url='/task/update_all_students_for_course/', params={'course_id':c.key().id()})
return HttpResponse('ok')
def update_all_students_for_course(request):
logging.info(request.POST)
course_id = request.POST['course_id']
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
logging.info('course=%s'%course)
cdbsync.plan_cdb_put(course)
students = Student.list_for_course(course.key())
for s in students:
logging.info("student %s" % s.key())
taskqueue.add(url='/task/update_all_students_do_one/', params={'student_key':s.key()})
logging.info("all done")
return HttpResponse('ok')
def get_offer_list2():
courses_query=Course.list_for_enroll()
folder_courses= dict()
result = []
for course in courses_query:
folder_courses.setdefault(course.folder_key,[]).append(course)
result=[]
folders_query=Folder.list()
for folder in folders_query:
if str(folder.key()) in folder_courses:
result.append({'folder':folder, 'courses':folder_courses[str(folder.key())]})
logging.info(result)
return result
def attend(request,course_id):
if not config.getConfigBool('ENROLL_ENROLL_ON',False):
raise Http404
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
if not course.is_open():
raise Http404
if course.only_pair_enroll():
return attend_pair(request,course)
else:
return attend_single(request,course)
def import_students_do(request,file_id, start_line, end_line, course_id):
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
f = FileBlob.get_by_id(int(file_id))
if f is None:
raise Http404
d = cStringIO.StringIO(f.data)
r = UnicodeReader(d, encoding='utf8', delimiter=';', quotechar='"')
start_line = int(start_line)
end_line = int(end_line)
line = 0
st_list=[]
for row in r:
if (line>=end_line):
break
if (line>=start_line):
st = import_student(course,row)
st_list.append(st)
line+=1
if course.group_mode == 'Pair':
pd = dict()
for s in st_list:
if not s.x_import_no_2 is None:
p = pd.pop(s.x_import_no_2,None)
if p is None:
pd[s.x_import_no_2] = s
else:
s.partner_ref_code = p.ref_key
p.partner_ref_code = s.ref_key
s.save()
p.save()
###
taskqueue.add(url='/task/recount_capacity/', params={'course_id':course.key().id()})
return HttpResponseRedirect('../../../../../')
def hide_course_students(request):
logging.info(request.POST)
course_id = request.POST['course_id']
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
list = Student.list_for_course(course.key())
for s in list:
s.hidden = True
s.save()
cdbsync.plan_cdb_put(s)
course.mark_as_modify()
course.save()
cdbsync.plan_cdb_put(course)
return HttpResponse('ok')
def edit(request, course_id):
course = Course.get_by_id(int(course_id))
if course is None:
raise Http404
if request.method == "POST":
form = CourseForm(request.POST, instance=course)
if form.is_valid():
logging.info("edit course before %s" % course)
form.save(commit=False)
logging.info("edit course after %s" % course)
course.mark_as_modify()
course.save()
cdbsync.plan_cdb_put(course)
taskqueue.add(url="/task/recount_capacity/", params={"course_id": course.key().id()})
return HttpResponseRedirect("../..")
else:
form = CourseForm(instance=course)
return render_to_response("admin/courses_edit.html", RequestContext(request, {"form": form}))
