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 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 plan_update_all_seasons(request):
logging.info("update_all_seasons")
seasons = Season.list()
for s in seasons:
logging.info("season %s"%s.key())
cdbsync.plan_cdb_put(s)
return HttpResponse('ok')
def create(request):
season = Season()
if request.method == 'POST':
form = SeasonForm(request.POST, instance=season)
if form.is_valid():
logging.info('edit season before %s'% season)
form.save(commit=False)
logging.info('edit season after %s'% season)
season.save()
cdbsync.plan_cdb_put(season)
rebuild_seasons()
return redirect('..')
else:
form = SeasonForm(instance=season)
return render_to_response('admin/seasons_create.html', RequestContext(request, {'form':form}))
def update_all_students(request):
logging.info("update_all_students")
logging.info(request.POST)
seasons = Season.list()
for s in seasons:
logging.info("season %s"%s.key())
taskqueue.add(url='/task/update_all_students_for_season/', params={'season_id':s.key().id()})
return HttpResponse('ok')
def delete(request, season_id):
season = Season.get_by_id(int(season_id))
if season is None:
raise Http404
season.delete()
rebuild_seasons()
return redirect('../..')
def udpate_folder_stats(request):
logging.info('adding tasks for stats update')
folders = Folder.list()
seasons = Season.list()
for s in seasons:
for f in folders:
logging.info('stats task season %s and folder %s' %(s,f))
taskqueue.add(url='/task/update_folder_stats/', params={'season_key':str(s.key()), 'folder_key': str(f.key())})
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 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 edit(request, season_id):
season = Season.get_by_id(int(season_id))
if season is None:
raise Http404
if request.method == 'POST':
form = SeasonForm(request.POST, instance=season)
if form.is_valid():
logging.info('edit season before %s'% season)
form.save(commit=False)
logging.info('edit season after %s'% season)
season.save()
cdbsync.plan_cdb_put(season)
rebuild_seasons()
return redirect('../..')
else:
form = SeasonForm(instance=season)
return render_to_response('admin/seasons_edit.html', RequestContext(request, {'form':form}))
def valid_value(self, value):
self._set_choices(Season.get_SEASON_CHOICES())
return super(SeasonField, self).valid_value(value)
def index(request):
course_list = None
season = None
folder = None
if request.method == "POST":
form = SeasonCategoryFilterForm(request.POST)
if form.is_valid():
season = Season.get(str(form.cleaned_data["season_key"]))
folder = Folder.get(str(form.cleaned_data["folder_key"]))
if not season is None:
request.session["course_season_key"] = str(season.key())
if not folder is None:
request.session["course_folder_key"] = str(folder.key())
else:
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 (season is None) or (folder is None):
form = SeasonCategoryFilterForm()
else:
form = SeasonCategoryFilterForm({"season_key": str(season.key()), "folder_key": str(folder.key())})
if (season is None) or (folder is None):
course_list = None
if request.GET.get("all", None):
logging.info("all mode")
course_list = Course.list()
else:
if request.GET.get("all", None):
logging.info("all mode")
course_list = Course.list()
else:
course_list = Course.list_filter(str(season.key()), str(folder.key()))
tc_em = 0
tc_ef = 0
tc_e = 0
tc_pm = 0
tc_pf = 0
tc_p = 0
tc_ppm = 0
tc_ppf = 0
tc_pp = 0
tc_npm = 0
tc_npf = 0
tc_np = 0
tc_sum = 0
if course_list is not None:
for c in course_list:
tc_em += c.stat_e_m
tc_ef += c.stat_e_f
tc_e += c.usage
tc_pm += c.stat_fp_m
tc_pf += c.stat_fp_f
tc_p += c.stat_fp_m + c.stat_fp_f
tc_ppm += c.stat_pp_m
tc_ppf += c.stat_pp_f
tc_pp += c.stat_pp_m + c.stat_pp_f
tc_npm += c.stat_np_m
tc_npf += c.stat_np_f
tc_np += c.stat_np_m + c.stat_np_f
tc_sum += c.stat_paid
return render_to_response(
"admin/courses_index.html",
RequestContext(
request,
{
"form": form,
"course_list": course_list,
"tc_em": tc_em,
"tc_ef": tc_ef,
"tc_e": tc_e,
"tc_pm": tc_pm,
"tc_pf": tc_pf,
"tc_p": tc_p,
"tc_ppm": tc_ppm,
"tc_ppf": tc_ppf,
"tc_pp": tc_pp,
"tc_npm": tc_npm,
"tc_npf": tc_npf,
"tc_np": tc_np,
"tc_sum": tc_sum,
},
),
)
def __init__(self, data=None, **kwargs):
super(self.__class__, self).__init__(data, **kwargs)
self.fields["season_key"]._set_choices(Season.get_SEASON_CHOICES())
def index(request):
season_list=Season.list()
return render_to_response('admin/seasons_index.html', RequestContext(request, { 'season_list': season_list }))
def import_students(request,file_id, seq_id=None):
f = FileBlob.get_by_id(int(file_id))
if f is None:
raise Http404
d = cStringIO.StringIO(f.data)
r = UnicodeReader(d)
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':
form = TargetPickForm(request.POST,courses = cc)
info = []
seq = 0
curr = None
line = 0
for row in r:
if len(row)>6 and (row[0].startswith('#export kurz') or row[0].startswith('#zaloha kurz')):
logging.info(row)
if not curr is None:
curr["end_line"]=line
info.append(curr)
curr = dict()
curr["seq"]=seq
seq+=1
curr["start_line"]=line+1
curr["code"]=row[1]
curr["folder"]=row[2]
curr["season"]=row[3]
curr["students"]=0
curr["info"]=row[6]
elif len(row)>19 and not row[0].startswith('#'):
curr["students"]+=1
line+=1
if not curr is None:
curr["end_line"]=line
info.append(curr)
else:
### no header detected.
curr = dict()
curr["seq"]=0
curr["start_line"]=0
curr["end_line"]=line
info.append(curr)
selected = None
if not seq_id is None:
for c in info:
if c["seq"]==int(seq_id):
selected = c
break
if selected is None:
raise Http404
if form is None:
form = TargetPickForm(courses = cc, initial={'start_line':selected['start_line'], 'end_line':selected['end_line']})
else:
if form.is_valid():
course = Course.get(form.cleaned_data['course_key'])
if course is None:
raise Http404
return render_to_response('admin/import_students.html', RequestContext(request, { 'info': info, 'form':form, 'selected':selected, 'course':course, 'season':season, 'folder':folder}))
def index(request):
season = None
if request.method == 'POST':
form = SeasonFilterForm(request.POST)
if form.is_valid():
season = Season.get(str(form.cleaned_data['season_key']))
if not season is None:
request.session['course_season_key']=str(season.key())
else:
cskey = request.session.get('course_season_key',None)
if not cskey is None:
season = Season.get(str(cskey))
if (season is None):
form = SeasonFilterForm()
else:
form = SeasonFilterForm({'season_key':str(season.key())})
logging.info(season)
prev_season = None
if not season is None:
prev_season = season.get_prev()
logging.info(prev_season)
prev_prev_season = None
if not prev_season is None:
prev_prev_season = prev_season.get_prev()
logging.info(prev_prev_season)
folder_stats = []
if not season is None:
folder_stats = list(FolderStats.list_by_season(str(season.key())))
if not prev_season is None:
prev_folder_stats = FolderStats.list_by_season(str(prev_season.key()))
for fs,ps in izip(folder_stats,prev_folder_stats):
fs.prev_season_sum_1 = ps.stat_sum
if not prev_prev_season is None:
prev_prev_folder_stats = FolderStats.list_by_season(str(prev_prev_season.key()))
for fs,ps in izip(folder_stats,prev_prev_folder_stats):
fs.prev_season_sum_2 = ps.stat_sum
ts_em = 0
ts_ef = 0
ts_e = 0
ts_pm = 0
ts_pf = 0
ts_p = 0
ts_ppm = 0
ts_ppf = 0
ts_pp = 0
ts_npm = 0
ts_npf = 0
ts_np = 0
ts_sum = 0
ts_prev_s1 = 0
ts_prev_s2 = 0
for fs in folder_stats:
ts_em = ts_em + fs.stat_em
ts_ef = ts_ef + fs.stat_ef
ts_e = ts_e + fs.stat_e
ts_pm = ts_pm + fs.stat_pm
ts_pf = ts_pf + fs.stat_pf
ts_p = ts_p + fs.stat_p
ts_ppm = ts_ppm + fs.stat_ppm
ts_ppf = ts_ppf + fs.stat_ppf
ts_pp = ts_pp + fs.stat_pp
ts_npm = ts_npm + fs.stat_npm
ts_npf = ts_npf + fs.stat_npf
ts_np = ts_np + fs.stat_np
ts_sum = ts_sum + fs.stat_sum
ts_prev_s1 = ts_prev_s1 + fs.prev_season_sum_1
ts_prev_s2 = ts_prev_s2 + fs.prev_season_sum_2
return render_to_response('admin/index.html', RequestContext(request, {
'form': form, 'folder_stats':folder_stats,
'ts_em': ts_em, 'ts_ef': ts_ef, 'ts_e': ts_e,
'ts_pm': ts_pm, 'ts_pf': ts_pf, 'ts_p': ts_p,
'ts_ppm': ts_ppm, 'ts_ppf': ts_ppf, 'ts_pp': ts_pp,
'ts_npm': ts_npm, 'ts_npf': ts_npf, 'ts_np': ts_np,
'ts_sum':ts_sum, 'ts_prev_s1': ts_prev_s1, 'ts_prev_s2': ts_prev_s2,
's': season, 'prev_s1': prev_season, 'prev_s2': prev_prev_season
}))
