# -*- coding: utf-8 # Copyright 2001, 2002 by IVA Team and contributors # # This file is part of IVA. # # IVA is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # IVA is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with IVA; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import AccessControl import OFS, Globals from OFS import SimpleItem import types import time from TraversableWrapper import Traversable from Globals import Persistent from AccessControl import ClassSecurityInfo from Cruft import Cruft from common import add_dtml, translate #import TestiYlesanne import YlVahendus from YlVahendus import YlVahendus import YlAlus import YlTyybid import YlMeta import YlHoidla #from TestiYlesanne import TestiYlesanne class YlTest( OFS.Folder.Folder, OFS.SimpleItem.Item, Persistent, AccessControl.Role.RoleManager, Traversable, Cruft ): "Ülesannetest koosnev test" meta_type='YlTest' pealkiri="" nr=0 avatudTaitmiseks=0 juhuslikJarjekord=0 security=ClassSecurityInfo() security.declareObjectPublic() def __init__(self): "Alustus" self.koigiLuba=LahendusLuba() self.koigiLuba.id='koigiLuba' self.grupiLoad=LahendusLoad() self.grupiLoad.id='grupiLoad' self.isikuLoad=LahendusLoad() self.isikuLoad.id='isikuLoad' self.vahendus=YlVahendus() self.vahendus.id='vahendus' self.lisaTestiMeta() def lisaYlesanne(self, yl): "uus ülesanne testis" if yl is None: return self.nr=self.nr+1 yl.id="yl"+str(self.nr) tulem = self._setObject(yl.id, yl) return tulem def lisaYlesanded(self, ylmassiiv): "Lisatakse ülesannete massiiv" for x in ylmassiiv: self.lisaYlesanne(x) def ylesandedTekstina(self): "Väljastab ülesanded HotPotatos ekspordina" tulemus="" yl=self.ylesanded() for i in range(len(yl)): tulemus=tulemus+yl[i].kirjutaYlesanneTekstiks(self.pealkiri, i+1) return tulemus def kysimused(self): "Küsimuste loetelu" k=[] for x in self.ylesanded(): k.append(x.kysimus) return k def ylesanded(self): "Ülesannete loetelu" return self.objectValues() def annaPealkiri(self): "Testi nimi" try: if len(self.pealkiri)>0: return self.pealkiri return self.getId() except: return self.getId() def pealkiriHTML(self, REQUEST): "Pealkiri HTMLina" return asendaHTML(self.annaPealkiri()) def pealkirjaEsitlus(self, REQUEST): "Nimi menüüs" if self.pealkiriHTML(REQUEST)!="": return self.pealkiriHTML(REQUEST) else: return self.getId() def seaPealkiri(self, pealkiri): "Pealkirja salvestus" self.pealkiri=pealkiri def annaKirjeldus(self): "Testi kirjeldus" if hasattr(self, 'kirjeldus'): return self.kirjeldus return "" def seaKirjeldus(self, kirjeldus): "Kirjelduse salvestus" self.kirjeldus=kirjeldus def kirjeldusHTML(self, REQUEST): "Kirjeldus HTMLina" return asendaHTML(self.annaKirjeldus()) def pealkirjaMuutmisVormHTML(self, REQUEST, liikumisURL): "Leht pealkirja muutuse sisestuseks" tulemus=leheAlgus(self, REQUEST) tulemus=tulemus+self.pealkirjaMuutmisVorm(REQUEST, liikumisURL) tulemus=tulemus+leheLopp(self, REQUEST) return tulemus def pealkirjaMuutmisVorm(self, REQUEST, liikumisURL=""): "Vorm pealkirja, kirjelduse ja tüübi muutmiseks" self.get_lang(('ivatests',), REQUEST) t= "

"+REQUEST['L_it_editing_settings']+"

" t+="\n" t+="\n" t+="\n" t+="" t+="" t+="" t+="" t+="" # j2rgmine t+="" t+="" #J2rgmine t+="" t+="" #J2rgmine t+="" t+="" t+="
"+REQUEST['L_it_quiz_title']+"
"+REQUEST['L_it_quiz_descr']+"
"+REQUEST['L_it_quiz_type']+"
"+REQUEST['L_it_test_randomize']+"

"+REQUEST['L_it_description_of_permissions']+":

 " else: t+="> " t+=REQUEST['L_it_notpublic']+"
 " else: t+="> " t+=REQUEST['L_it_for_all']+" "+REQUEST['L_it_timelimit']+" " if self.koigiLuba.algusAeg!=-1: t+=""+REQUEST['L_it_restrictions']+"" t+="
 " else: t+="> " t+=REQUEST['L_it_for_subgroups']+" " if len(self.grupiLoad.objectValues())!=0: t+=""+REQUEST['L_it_restrictions']+"" t+="
 " else: t+="> " t+=REQUEST['L_it_for_persons']+" " if len(self.isikuLoad.objectValues())!=0: t+=""+REQUEST['L_it_restrictions']+"" t+="
" t+="\n \n \n \n" return t def pealkirjaMuutmisLeht(self, REQUEST, pealkiri, kirjeldus, tyyp, nahtavus, liikumisURL="", juhujarjestus='', testipass=''): "Pealkirja salvestus" if testipass: self.seaPass(testipass, REQUEST) self.seaPealkiri(pealkiri) self.seaKirjeldus(kirjeldus) self.seaTyyp(REQUEST, int(tyyp)) self.seaKysimusteJuhuslikJarjekord(juhujarjestus) self.seaVastusteNahtavus(nahtavus) if liikumisURL=='': liikumisURL='ylesandedMuutmisTabelina'; REQUEST.RESPONSE.redirect('pealkirjaMuutmisVormHTML?liikumisURL='+liikumisURL) # REQUEST.RESPONSE.redirect(liikumisURL) def seaPass(self,testipass, REQUEST): # closing test if testipass!='koigile': self.avatudTaitmiseks=0 if testipass!='ajapiirang': self.koigiLuba.algusAeg=-1 if testipass!='sisegr': for x in self.grupiLoad.nimedeLoetelu(): self.grupiLoad._delObject(x) if testipass!='isikuline': for x in self.isikuLoad.nimedeLoetelu(): self.isikuLoad._delObject(x) # seting permissions if testipass=='koigile': self.avatudTaitmiseks=1 pass if testipass=='ajapiirang': self.prooviRegistreeridaTestKodutooks(REQUEST) import time if self.koigiLuba.algusAeg==-1: self.koigiLuba.algusAeg=time.time() self.koigiLuba.loppAeg=time.time()+3000000 print testipass pass if testipass=='sisegr': if len(self.grupiLoad.objectValues())==0: dummy = LahendusLuba() dummy.id = 'DuMmY67891' self.grupiLoad._setObject(dummy.id, dummy) print testipass pass if testipass=='isikuline': if len(self.isikuLoad.objectValues())==0: dummy = LahendusLuba() dummy.id = 'DuMmY67891' self.isikuLoad._setObject(dummy.id, dummy) print testipass pass return def kysiVastusteNahtavus(self): "Teatatakse kood, millal õppur võib testi lahendusi näha" if hasattr(self, 'vastusteNahtavus'): return self.vastusteNahtavus return 0 def seaVastusteNahtavus(self, kood): "Salvestus" self.vastusteNahtavus=int(kood) def vastusteNahtavusedTekstina(self, REQUEST): "Massiiv nimetustega" m=[translate(self, 'L_it_ca_onclosing', target=self.giveLanguage(REQUEST)), translate(self, 'L_it_ca_always', target=self.giveLanguage(REQUEST)), translate(self, 'L_it_ca_never', target=self.giveLanguage(REQUEST))] return m def jooksevNahtavusTekstina(self, REQUEST): "Praegune seisund" m=self.vastusteNahtavusedTekstina(REQUEST) return m[self.kysiVastusteNahtavus()] def kasLubatudLahendusiVaadata(self, REQUEST): "Kas konkreetsel kasutajal on õigus oma lahenduste tulemusi näha" kood=self.kysiVastusteNahtavus() if kood==2: return 0 if kood==1: return 1 if kood==0: return not self.kasLubatudLahendada(REQUEST) def kasKirjasKodutoona(self, REQUEST): "Kas test asub juba kodutööde loetelus" m=self.aq_parent.kodutood.objectValues() leidub=0 for x in m: if x.tyyp==0: if hasattr(x, 'testiID'): if x.testiID==self.id: leidub=1 return leidub def prooviRegistreeridaTestKodutooks(self, REQUEST): "Registreeritakse juhul, kui tüübiks on test ning vastav test pole veel kodutoo" if self.kasKirjasKodutoona(REQUEST): return 0 if self.kysiTyyp(REQUEST)!=0: return 0 too=self.aq_parent.kodutood.lisaKodutoo(REQUEST, 0) too.pealkiri=self.annaPealkiri() too.normPunkte = self.normPunktiSumma() too.kirjeldus = self.annaKirjeldus() too.testiID=self.id return 1 def ylesanneteArv(self): "Ülesannete arv" return len(self.ylesanded()) def normPunktiSumma(self): "Väärtused, mis annavad kokku 100%" summa=0.0 for x in self.ylesanded(): if x.kasPunktiArvutus(): summa=summa+x.annaNormPunktid() return summa def tutvustus(self): "Testi tutvutus" return "Lahendamiseks mõeldud test" def kasKysimusteJuhuslikJarjekord(self): "Kas lahendamisel järjestatakse küsimused juhuslikult" if hasattr(self, 'juhuslikJarjekord'): return self.juhuslikJarjekord return 0 def seaKysimusteJuhuslikJarjekord(self, jarjekord): "Muutuja seadmine" if jarjekord: self.juhuslikJarjekord=1 else: self.juhuslikJarjekord=0 return str(self.juhuslikJarjekord) def muudaKysimusteJuhuslikJarjekord(self): "Järjekorra muutmine" if self.kasKysimusteJuhuslikJarjekord(): self.seaKysimusteJuhuslikJarjekord(0) else: self.seaKysimusteJuhuslikJarjekord(1) return str(self.kasKysimusteJuhuslikJarjekord()) def kasLubatudLahendada(self, REQUEST): "Arvutus lubade kaudu" try: if self.kasAvatudTaitmiseks()==1: return 1 n=self.lahendusKordadeArv(REQUEST) if self.koigiLuba.kasLubatudLahendada(REQUEST, n):return 1 if hasattr(self.isikuLoad, str(REQUEST.AUTHENTICATED_USER)): if getattr(self.isikuLoad, str(REQUEST.AUTHENTICATED_USER)).kasLubatudLahendada(REQUEST, n): return 1 for x in self.find_course().sisegrupid.objectValues(): m=x.get_local_roles() leitud=0 for t in m: if t[0]==str(REQUEST.AUTHENTICATED_USER): leitud=1 if leitud: try: if hasattr(self.grupiLoad, x.id): if getattr(self.grupiLoad, x.id).kasLubatudLahendada(REQUEST, n): return 1 except: pass return 0 except: return 1 def kasLubatudLahendadaTekst(self, REQUEST): "Abifunktsioon" return str(self.kasLubatudLahendada(REQUEST)) # def lubadeViited(self, REQUEST): # "Viited lubadele" # self.get_lang(('ivatests',), REQUEST) # tulemus=leheAlgus(self, REQUEST)+"

"+REQUEST['L_it_description_of_permissions']+"

" t+=" "+\ "\n" t+="
" for x in m: tulemus=tulemus+"\n"+\ ""+\ "" tulemus=tulemus+"
"+x.esitlusHTML(REQUEST)+""+\ ""+x.vaatamineHTML(REQUEST)+""+x.marksonadHTML(REQUEST)+""+x.ylesanne.ylesandeNimetus(REQUEST)+"
" return tulemus+leheLopp(self, REQUEST) def ylesandedMuutmisTabelina2(self, REQUEST): "Ülesanded koos viidetega kustutamiseks ja muutmiseks" self.get_lang(('ivatests',), REQUEST) tulemus=leheAlgus(self, REQUEST)+self.vahendus.ylesanneteTyybidValikuna(REQUEST) if len(self.ylesanded())>0: tulemus=tulemus+"
" tulemus=tulemus+"\n" tulemus=tulemus+"" for x in self.ylesanded(): try: tulemus=tulemus+"\n"+\ ""+\ ""+\ ""+\ ""+\ ""+\ ""+\ "" except: print "Invalid question" tulemus=tulemus+"
"+REQUEST['L_it_deletion']+""+REQUEST['L_it_question'] tulemus=tulemus+""+REQUEST['L_it_answer']+""+REQUEST['L_it_type']+"" tulemus=tulemus+REQUEST['L_it_points']+""+REQUEST['L_it_change']+"
"+""+x.esitlusHTML(REQUEST)+""+x.vaatamineHTML(REQUEST)+""+x.ylesandeNimetus(REQUEST)+""+x.normPunktidHTML(REQUEST)+""+REQUEST['L_it_change']+"
\n\n" tulemus=tulemus+" \n
\n" tulemus=tulemus+" \n" tulemus=tulemus+"
" return tulemus+leheLopp(self, REQUEST) def kustuta_leht(self, REQUEST, kustuta=None): "ülesannete kustutamise leht" if kustuta is None: kustuta=() if type(kustuta) is types.StringType: kustuta=(kustuta,) for x in kustuta: self._delObject(x) REQUEST.RESPONSE.redirect('ylesandedMuutmisTabelina') def ylTyyp(self, REQUEST, ylid): "Küsitud ID-ga ülesande tüüp" if hasattr(self, ylid): return self.ylid.ylesandeNimetus(REQUEST) return None def taidaVorm(self, REQUEST): "Täitmisvorm" self.get_lang(('ivatests',), REQUEST) tulemus=leheAlgus(self, REQUEST)+"

" if self.tyyp==1: tulemus=tulemus+self.pealkirjaEsitlus(REQUEST) else: tulemus=tulemus+REQUEST['L_it_solving_test'] % self.pealkirjaEsitlus(REQUEST) tulemus=tulemus+"

" k=self.salvestusAsukoht(REQUEST, self.id) if not hasattr(k, 'algusaeg') and self.tyyp!=1: tulemus+="

"+REQUEST['L_it_warning_quiz'] k.algusaeg=time.time() else: if self.tyyp!=1: tulemus+=REQUEST['L_it_quiz_started']+time.strftime(REQUEST['L_timestamp_format'], time.localtime(k.algusaeg)) tulemus=tulemus+"
\n\n" kirjutusyl=[] for x in self.ylesanded(): kirjutusyl.append(x) if self.kasKysimusteJuhuslikJarjekord(): import random random.shuffle(kirjutusyl) for x in kirjutusyl: tulemus=tulemus+"\n"+\ "" tulemus=tulemus+"
"+x.esitlusHTML(REQUEST)+""+x.taitmineHTML(REQUEST, x.id) + "
\n" tulemus=tulemus+"\n \n \n \n
" tulemus=tulemus+"\n" tulemus=tulemus+"
" return tulemus+leheLopp(self, REQUEST) def testiSelgitusLeht(self, REQUEST): "Leht, kus antakse teada, et esimesel lahendamisel registreeritakse kasutaja aeg" self.get_lang(('ivatests',),REQUEST) t=leheAlgus(self, REQUEST) k=self.salvestusAsukoht(REQUEST, self.id) if not hasattr(k, 'algusaeg'): t+="

"+REQUEST['L_it_warning_quiz'] else: t+=REQUEST['L_it_quiz_started']+": "+time.strftime(REQUEST['L_timestamp_format'], time.localtime(k.algusaeg)) t+="
" t+=self.fle_html_footer(self, REQUEST) return t def alustus(self, REQUEST): "Juhatus lahendusele vastavalt testi tüübile" tyyp=self.kysiTyyp(REQUEST) if tyyp==0: return self.testiSelgitusLeht(REQUEST) if tyyp==1: return self.taidaVorm(REQUEST) if tyyp==2: return self.harjutusVorm(REQUEST) return "Unknown type" def index_html(self, REQUEST): "Peegel veebi" if self.kas_opetaja(REQUEST): #return self.ylesandedMuutmisTabelina(REQUEST) REQUEST.RESPONSE.redirect(self.absolute_url()+"/ylesandedMuutmisTabelina") else: return self.taidaVorm(REQUEST) def loeAndmedLehelt(self, REQUEST): "Veebilt tulevad andmed talde" self.get_lang(('ivatests',), REQUEST) tulemus="" if not hasattr(REQUEST, 'salvestusnupp'): return leheAlgus(self, REQUEST)+\ REQUEST['L_it_click_to_save']+\ leheLopp(self, REQUEST) t=TestiVastused() t.testinimi=self.id for x in self.ylesanded(): vastus=None if hasattr(REQUEST, x.id): vastus=getattr(REQUEST, x.id) tulemus=tulemus+"!"+x.id+" "+str(vastus) t._setObject(x.id, x.salvestaPakutu(vastus)) self.paigutaTestiVastus(REQUEST, t) return leheAlgus(self, REQUEST)+"
"+REQUEST['L_it_answers_saved']+""+leheLopp(self, REQUEST) def salvestusAsukoht(self, REQUEST, testinimi='nimetu'): "Koht testi tulemuste salvestamiseks" kasutajajuur=getattr(self.fle_root().fle_users,\ str(REQUEST.AUTHENTICATED_USER)) try: kasutaja=getattr(kasutajajuur.webtop,\ 'c'+kasutajajuur.get_jooksev_kursus()) except: kasutaja=kasutajajuur.webtop if not hasattr(kasutaja, 'testivastused'): kasutaja.manage_addProduct['OFSP'].manage_addFolder('testivastused') kasutaja.testivastused.id='testivastused' if not hasattr(kasutaja.testivastused.aq_self, testinimi): kasutaja.testivastused.manage_addProduct['OFSP'].manage_addFolder(testinimi) testikataloog=getattr(kasutaja.testivastused, testinimi) testikataloog.id=testinimi testikataloog.variandinr=0 testikataloog=getattr(kasutaja.testivastused, testinimi) #return self.get_url_to_object(testikataloog) return testikataloog def paigutaTestiVastus(self, REQUEST, vastus): "Paigutab variandi uue id alla" self.get_lang(('ivatests',), REQUEST) k=self.salvestusAsukoht(REQUEST, vastus.testinimi) k.variandinr=k.variandinr+1 vastus.id="variant"+str(k.variandinr) k._setObject(vastus.id, vastus) self.lisaSyndmus(REQUEST, 'testeLahendatud') return str(k.variandinr) def lahendusKordadeArv(self, REQUEST): "Mitu varianti on kasutaja vastavat testi lahendanud" k=self.salvestusAsukoht(REQUEST, self.id) return len(k.objectValues()) def kasutajateTulemused(self, REQUEST, kommentaarid=0): "Testi tulemused" self.get_lang(('ivatests',), REQUEST) tulemus=leheAlgus(self, REQUEST)+"

\n

"+(REQUEST['L_it_test_answers'] % self.id)+"

\n" kommentaarid=int(kommentaarid) if kommentaarid==0: tulemus=tulemus+"

"+REQUEST['L_it_show_comments']+"

\n" else: tulemus=tulemus+"

"+REQUEST['L_it_hide_comments']+"

\n" try: kasutajad=self.get_all_users() except: return tulemus+REQUEST['L_it_problem_in_finding_user'] tulemus=tulemus+"\n\n" for x in kasutajad: tulemus=tulemus+"\n\n\n" except Exception, probleem: tulemus=tulemus+"" tulemus+="\n
"+str(x.id)+"\n" try: k=getattr(x.webtop, 'c'+str(self.find_course().get_id())) #tulemus=tulemus+"j"+k.absolute_url() if hasattr(k, 'testivastused'): #tulemus=tulemus+"k" if hasattr(k.testivastused, self.id): t=getattr(k.testivastused, self.id) for y in t.objectValues(): # print type(y) tulemus=tulemus+""+str(y.id)+" " if kommentaarid: tulemus=tulemus+str(y.lyhiKokkuvoteOpetajale(REQUEST)) else: tulemus=tulemus+str(y.punktiArvutusHTML(REQUEST)) tulemus=tulemus+"
\n" tulemus=tulemus+"\n

\n" tulemus+=""+REQUEST['L_it_quiz_stats']+"" tulemus+=leheLopp(self, REQUEST) return tulemus def harjutusVorm(self, REQUEST, ylid=None): "Vorm harjutusülesande näitamiseks" t = "" if ylid is None: ylesanded=self.ylesanded() if len(ylesanded)==0: t+="Empty/Tyhi" t+=self.fle_html_footer(self, REQUEST) return t ylid=ylesanded[0].id y=getattr(self, ylid) t=self.hdr(self, REQUEST)+self.leivaPuru(REQUEST)+"

"+REQUEST['L_it_type_selftest']+": "+self.pealkiri+"

" + t t+="
\n" t+=" \n\n
" t+="" t+=y.esitlusHTML(REQUEST)+"" t+=y.taitmineHTML(REQUEST, 'vastus') t+="
\n

" t+=self.fle_html_footer(self, REQUEST) return t def harjutusLeht(self, REQUEST, ylid, vastus=None): "Harjutusülesannete vastuse näitus" self.get_lang(('ivatests',),REQUEST) t=self.hdr(self, REQUEST)+self.leivaPuru(REQUEST)+"

"+REQUEST['L_it_feedback']+"

" y=getattr(self, ylid) ylesanded=self.ylesanded() t+="\n\n\n\n\n\n \n
" t+=REQUEST['L_it_question']+": "+y.esitlusHTML(REQUEST)+"
" t+=REQUEST['L_it_you_answered']+""+y.pakutudHTML(REQUEST, vastus)+"
" t+=REQUEST['L_it_right_answer']+""+y.tegelikHTML(REQUEST) t+="
" nr=0 koht=-1 while nr" else: id=ylesanded[koht+1].id t+="

"+REQUEST['L_it_selftest_next']+"" t+=self.fle_html_footer(self, REQUEST) return t def seaTyyp(self, REQUEST, tyyp): "Testi tüübi sättimine" self.tyyp=tyyp def kysiTyyp(self, REQUEST): "Väljastatakse testi tüüp" if not hasattr(self, 'tyyp'): return 0 return self.tyyp def kysiTyypideNimed(self, REQUEST): "Tüüpide tõlgitud nimed" # self.get_lang(('ivatests',),REQUEST) # m=[REQUEST['L_it_type_quiz'], REQUEST['L_it_type_survey'], REQUEST['L_it_type_selftest']] # m=(translate(self, 'quiz', target=self.giveLanguage(REQUEST)), # translate(self, 'survey', target=self.giveLanguage(REQUEST)), # translate(self, 'selftest', target=self.giveLanguage(REQUEST))) m=[translate(self, 'quiz', target=self.giveLanguage(REQUEST)), translate(self, 'survey', target=self.giveLanguage(REQUEST)), translate(self, 'selftest', target=self.giveLanguage(REQUEST))] return m def kysiTyypTekstina(self, REQUEST): "Jooksva testi tüüp" return self.kysiTyypideNimed(REQUEST)[self.kysiTyyp(REQUEST)] def lahendusteArvud(self, REQUEST): "Lahendamise statistika: kohal 0: lahendajate arv, kohal 2 lahenduste arv" try: kasutajad=self.get_all_users() taitjaid=0 lahendusi=0 for x in kasutajad: if hasattr(x.webtop, 'c'+str(self.find_course().get_id())): k=getattr(x.webtop, 'c'+str(self.find_course().get_id())) if hasattr(k, 'testivastused'): if hasattr(k.testivastused, self.id): t=getattr(k.testivastused, self.id) if len(t.objectValues())>0: taitjaid=taitjaid+1 lahendusi=lahendusi+len(t.objectValues()) return (taitjaid, " ", lahendusi) except: return ('x', ' ', 'x') def lahendusteStatistika(self, REQUEST): "Statistika testilahenduste kohta" self.get_lang(('ivatests',),REQUEST) t=self.hdr(self, REQUEST)+self.leivaPuru(REQUEST) t+="

"+REQUEST['L_it_quiz_stats']+"

" t+="\n" kataloogid=self.lahendusteKataloogid(REQUEST) m=self.ylesanded() for x in m: t+="" t+="
" t+="

"+x.annaKirjeldavTekst(REQUEST)+"
"+x.kysimusHTML(REQUEST)+"

" #t+="		 " t+="

"+self.lahendusedStatistikaVastavaltTyybile(REQUEST, kataloogid, x) t+="
" t+=REQUEST['L_it_submissions']+str(len(kataloogid)) t+=self.fle_html_footer(self, REQUEST) return t def lahendusteKataloogid(self, REQUEST): "Õppurite lahenduste kataloogid statistika tarbeks" kataloogid=[] kasutajad=self.get_all_users() for x in kasutajad: if hasattr(x.webtop, 'c'+str(self.find_course().get_id())): k=getattr(x.webtop, 'c'+str(self.find_course().get_id())) if hasattr(k, 'testivastused'): if hasattr(k.testivastused, self.id): t=getattr(k.testivastused, self.id) if hasattr(t, 'variant1'): kataloogid.append(t.variant1) return kataloogid def lahendusteYlesanded(self, REQUEST, kataloogid, ylesanne): "Ette antakse õppurite vastava testivariandi lahenduskataloogide massiiv.. Väljastatakse kataloogi seest etteantud nimega ülesannete massiiv" tulemus=[] for k in kataloogid: if hasattr(k, ylesanne.id): tulemus.append(getattr(k, ylesanne.id)) return tulemus def lahendusedStatistikaVastavaltTyybile(self, REQUEST, kataloogid, ylesanne): "" self.get_lang(('ivatests',),REQUEST) ylesanded=self.lahendusteYlesanded(REQUEST, kataloogid, ylesanne) if ylesanne.meta_type=="YksikvalikYlesanne": return self.lahendusedStatistikaMitmikvalik(REQUEST, ylesanded, ylesanne) if ylesanne.meta_type=="MitmikvalikYlesanne": return self.lahendusedStatistikaOigedVariandid(REQUEST, ylesanded, ylesanne) if ylesanne.meta_type=="ValikYlesanne": return self.lahendusedStatistikaJahEi(REQUEST, ylesanded, ylesanne) if ylesanne.meta_type=="OigeTekstivastusegaYlesanne": return self.lahendusedStatistikaLyhivastus(REQUEST, ylesanded, ylesanne) if ylesanne.meta_type=="ArvuvahemikuliseVastusegaYlesanne" or ylesanne.meta_type=="ProtsentYlesanne": return self.lahendusedStatistikaArvuvahemik(REQUEST, ylesanded, ylesanne) if ylesanne.meta_type=="TekstivastusegaYlesanne": return self.lahendusedStatistikaTekstivastus(REQUEST, ylesanded, ylesanne) return REQUEST['L_it_no_stats'] def lahendusedStatistikaMitmikvalik(self, REQUEST, ylesanded, ylesanne): "Väljundiks HTML-tabel: valik/pakutud kordade arv. sisendiks kõigi lahendajate vastavad ülesanded" self.get_lang(('ivatests',),REQUEST) v=[] vigu=0 pihtas=0 for i in range(len(ylesanne.valikud)): v.append(0) for x in ylesanded: try: v[int(x.pakutudAndmed)]+=1 if x.kasPihtas():pihtas+=1 except: vigu+=1 t="\n" t+="\n" for i in range(len(ylesanne.valikud)): t+="\n" t+="
"+REQUEST['L_it_stat_choice']+""+REQUEST['L_it_stat_count']+"
"+ylesanne.valikud[i]+""+str(v[i])+"
" t+=REQUEST['L_it_stat_err']+": "+str(vigu)+"
" if ylesanne.oigeValik!=-1: #Kui leidub õige vastus t+=REQUEST['L_it_stat_hits']+": "+str(pihtas) return t def lahendusedStatistikaOigedVariandid(self, REQUEST, ylesanded, ylesanne): "Väljundiks HTML-tabel: valik/pakutud kordade arv. sisendiks kõigi lahendajate vastavad ülesanded" self.get_lang(('ivatests',),REQUEST) v=[] p=[] vigu=0 for i in range(len(ylesanne.valikud)): v.append(0) p.append(0) for x in ylesanded: # try: vastused=None if x.pakutudAndmed is None: vastused=() if type(x.pakutudAndmed) == types.StringType: vastused=(int(x.pakutudAndmed)) if vastused is None: # if type(x.pakutudAndmed) == types.TupleType or type(x.pakutudAndmed)==types.DictType: vastused=map(int, x.pakutudAndmed) for vastus in vastused: v[int(vastus)]+=1 for i in range(len(ylesanne.valikud)): if i in ylesanne.oigedValikud and i in vastused: p[i]+=1 if (i not in ylesanne.oigedValikud) and (i not in vastused): p[i]+=1 # except: # vigu+=1 t="\n " t+="" t+="\n" for i in range(len(ylesanne.valikud)): t+="" if len(ylesanne.oigedValikud)>0: t+="" t+="\n" t+="
"+REQUEST['L_it_stat_choice']+""+REQUEST['L_it_stat_count']+""+REQUEST['L_it_stat_hits']+"
"+ylesanne.valikud[i]+""+str(v[i])+""+str(p[i])+"
" t+=REQUEST['L_it_stat_err']+": "+str(vigu) return t def lahendusedStatistikaJahEi(self, REQUEST, ylesanded, ylesanne): "Väljundiks HTML-tabel: valik/pakutud kordade arv. sisendiks kõigi lahendajate vastavad ülesanded" self.get_lang(('ivatests',),REQUEST) kokku=0 pihtas=0 for x in ylesanded: if x.pakutudAndmed=="on": kokku+=1 if x.kasPihtas(): pihtas+=1 return REQUEST['L_it_stat_count']+": "+str(kokku)+", "+REQUEST['L_it_stat_hits']+": "+str(pihtas) def lahendusedStatistikaLyhivastus(self, REQUEST, ylesanded, ylesanne): "Väljundiks HTML-tabel: valik/pakutud kordade arv. sisendiks kõigi lahendajate vastavad ülesanded" self.get_lang(('ivatests',),REQUEST) kokku=0 pihtas=0 for x in ylesanded: if len(x.pakutudAndmed)>0: kokku+=1 if x.kasPihtas(): pihtas+=1 return REQUEST['L_it_stat_count']+": "+str(kokku)+", "+REQUEST['L_it_stat_hits']+": "+str(pihtas) def lahendusedStatistikaArvuvahemik(self, REQUEST, ylesanded, ylesanne): "Väljundiks HTML-tabel: valik/pakutud kordade arv. sisendiks kõigi lahendajate vastavad ülesanded" self.get_lang(('ivatests',),REQUEST) punkteSaanud=0 punktiSumma=0 for x in ylesanded: if x.automaatPunkte()>0: punkteSaanud+=1 punktiSumma+=x.automaatPunkte() return REQUEST['L_it_stat_scored']+str(punkteSaanud)+REQUEST['L_it_stat_total']+str(punktiSumma)+"/"+str(len(ylesanded)*ylesanne.normPunktid) def lahendusedStatistikaTekstivastus(self, REQUEST, ylesanded, ylesanne): "Väljundiks HTML-tabel: valik/pakutud kordade arv. sisendiks kõigi lahendajate vastavad ülesanded" self.get_lang(('ivatests',),REQUEST) vastanud=0 t=REQUEST['L_it_submissions']+"
" for x in ylesanded: if len(x.pakutudAndmed.strip())>0: vastanud+=1 t+="

"+x.pakutudHTML(REQUEST)+"

" return t+REQUEST['L_it_stat_notempty']+str(vastanud) def leivaPuru(self, REQUEST, viimane=0): "Teekond üles" self.get_lang(('ivatests',),REQUEST) nimi=self.id if not hasattr(self,'tyyp'): self.tyyp=0 nimi=self.kysiTyypideNimed(REQUEST)[self.tyyp] if viimane: tekst=nimi else: tekst=nimi if self.kas_opetaja(self, REQUEST): return " > "+REQUEST["L_it_hdr_tests"]+" > " + tekst return " > "+tekst def lisaYlesandedHoidlasse(self, REQUEST): "Kõik loodud/täiendatud ülesanded hoidlasse" self.fle_root().lisaYlHoidla() loendur=0 for x in self.objectValues(): if x.meta.ex_changed: self.fle_root().ylhoidla.lisaYlesanne(REQUEST, x) loendur=loendur+1 return "lisati "+str(loendur) Globals.InitializeClass(YlTest) class LahendusLoad(Persistent, OFS.Folder.Folder, Traversable): "Lahenduslubade kogum" def leivaPuru(self, REQUEST, viimane=0): "Teekond üles" nimi=self.id+" " if viimane: tekst=nimi else: tekst=""+nimi+"" return self.aq_parent.leivaPuru(REQUEST)+" > lubade haldus > "+tekst def kustutusLeht(self, REQUEST, kustuta=None): "õiguslubade kustutamine" if kustuta is not None: if type(kustuta)==types.StringType: kustuta=(kustuta,) for x in kustuta: self._delObject(x) REQUEST.RESPONSE.redirect('index_html') def kustutaKoikLoad(self): "Plats puhtaks" for x in self.nimedeLoetelu(): self._delObject(x) def nimedeLoetelu(self): "Elementide nimed tekstina" nimed=[] for x in self.objectValues(): nimed.append(x.id) return nimed def index_html(self, REQUEST): "Lubade loetelu" self.get_lang(('ivatests',), REQUEST) tulemus=leheAlgus(self, REQUEST) if len(self.objectValues())>0: tulemus=tulemus+"
    " for x in self.objectValues(): tulemus=tulemus+"\n
  • "+x.id+"
    • " tulemus=tulemus+"
" else: tulemus=tulemus+"Lubasid pole jagatud" tulemus=tulemus+leheLopp(self, REQUEST) return tulemus class LahendusLuba(Persistent, OFS.SimpleItem.Item, Traversable): "õigused testi lahendamiseks" kordadeArv=-1 #arvu ei piirata algusAeg=-1 #Pole avatud lahendamiseks loppAeg=-1 #Kestust ei piirata import time def kasLahendusAeg(self): "jah/ei praeguse hetke kohta" if self.algusAeg==-1: return 0 if self.algusAeg>time.time():return 0 if self.loppAeg==-1:return 1 if self.loppAeg>time.time():return 1 else: return 0 def kasLubatudLahendada(self, REQUEST, tehtudKordadeArv): "Jah/ei" if self.kasLahendusAeg()==0:return 0 if self.kordadeArv==-1: return 1 return int(tehtudKordadeArv)" x=algus while x<=ots: tulemus=tulemus+"\n " x=x+samm tulemus=tulemus+"\n" return tulemus def aegTekstina(self, REQUEST, aeg): "tekstiesitus" self.get_lang(('common',), REQUEST) if aeg==-1: return "*" return time.strftime(REQUEST['L_timestamp_format'], time.localtime(aeg)) def loaAndmedTekstina(self, REQUEST): "Loa kirjeldus ekraanil. Ajavahemik, kordade arv." self.get_lang(('ivatests',), REQUEST) tulemus="" if self.algusAeg==-1: tulemus=tulemus+" "+REQUEST['L_it_timelimit'] return tulemus tulemus=tulemus+self.aegTekstina(REQUEST, self.algusAeg)+"-" if self.loppAeg==-1: tulemus="igavesti" else: tulemus=tulemus+self.aegTekstina(REQUEST, self.loppAeg) if self.kordadeArv==-1: tulemus=tulemus+" piiramata arv" else: tulemus=tulemus+" "+str(self.kordadeArv) tulemus=tulemus+" x" return tulemus def ajaMuutmisElemendid(self, elemendinimi, aeg=-1): "Valikute kogum" if aeg==-1:aeg=time.time() m=time.localtime(aeg) tulemus=self.looValik(elemendinimi+"Aasta", m[0]-5, m[0]+10, m[0]) tulemus=tulemus+"-"+\ self.looValik(elemendinimi+"Kuu", 1, 12, m[1]) tulemus=tulemus+"-"+\ self.looValik(elemendinimi+"Paev", 1, 31, m[2]) tulemus=tulemus+"   "+\ self.looValik(elemendinimi+"Tund", 0, 23, m[3]) tulemus=tulemus+":"+\ self.looValik(elemendinimi+"Minut", 0, 59, m[4], samm=5) return tulemus def ajaPyydmisLeht(self, REQUEST, elemendinimi): "Saabuvad parameetrid ajaks" m=(int(getattr(REQUEST, elemendinimi+"Aasta")), int(getattr(REQUEST, elemendinimi+"Kuu")), int(getattr(REQUEST, elemendinimi+"Paev")), int(getattr(REQUEST, elemendinimi+"Tund")), int(getattr(REQUEST, elemendinimi+"Minut")),0,0,0,-1) return time.mktime(m) def muutmisVorm(self, REQUEST, liikumisURL=''): "Väljund veebilehele" self.get_lang(('ivatests',), REQUEST) tulemus=leheAlgus(self, REQUEST)+\ "
" korratekst=REQUEST['L_it_unlimited'] if self.kordadeArv!=-1: korratekst=str(self.kordadeArv) tulemus=tulemus+"

"+REQUEST['L_it_start_time']+"

"+\ self.ajaMuutmisElemendid("algusAeg", self.algusAeg)+\ "

"+REQUEST['L_it_end_time']+"

"+\ self.ajaMuutmisElemendid("loppAeg", self.loppAeg)+\ "

"+REQUEST['L_it_repeat']+"

"+\ ""+\ "
" tulemus=tulemus+"
"+leheLopp(self, REQUEST) return tulemus def muutmisLeht(self, REQUEST, liikumisURL=''): "Tulemuste talletus" self.algusAeg=self.ajaPyydmisLeht(REQUEST, "algusAeg") self.loppAeg=self.ajaPyydmisLeht(REQUEST, "loppAeg") try: self.kordadeArv=int(REQUEST['kordadearv']) except: self.kordadeArv=-1 if liikumisURL!='': REQUEST.RESPONSE.redirect(liikumisURL) else: REQUEST.RESPONSE.redirect('muutmisVorm') def index_html(self, REQUEST,liikumisURL=''): "Avaleht" return self.muutmisVorm(REQUEST,liikumisURL) def leivaPuru(self, REQUEST, viimane=0): "Teekond üles" nimi=self.id+" lahendusaeg" if viimane: tekst=nimi else: tekst=""+nimi+"" return self.aq_parent.leivaPuru(REQUEST)+" > "+tekst class TestiVastused( OFS.Folder.Folder, Persistent, AccessControl.Role.RoleManager, Traversable, Cruft ): "Testi vastusvariant" testinimi="" koguKommentaar="" def ylesanded(self): "Ülesannete kogum" return self.objectValues() def vastusteTabel(self, REQUEST): "Ülesannete vastused tabelina" self.get_lang(('ivatests',), REQUEST) tulemus=leheAlgus(self, REQUEST) tulemus=tulemus+"

"+REQUEST['L_it_quiz_responses']+"

" tulemus=tulemus+"\n" tulemus=tulemus+"" for x in self.ylesanded(): try: p="x" if x.kasPunktiArvutus(): p=str(x.punkte())+"/"+str(x.normPunktid) tulemus=tulemus+"\n" except: tulemus=tulemus+"" tulemus=tulemus+"
"+REQUEST['L_it_an_question']+""+REQUEST['L_it_an_user_answer'] tulemus=tulemus+""+REQUEST['L_it_an_teacher_answer']+""+REQUEST['L_it_an_points'] tulemus=tulemus+""+REQUEST['L_it_an_comment']+"
"+x.esitlusHTML(REQUEST)+""+\ x.pakutudHTML(REQUEST)+""+x.tegelikHTML(REQUEST)+""+p+""+x.opetajaKommentaarHTML(REQUEST)+"
"+REQUEST['L_it_stat_err']+"

"+REQUEST['L_it_totalpoints']+self.punktiArvutusHTML(REQUEST) tulemus=tulemus+"
"+REQUEST['L_it_an_comment']+": "+self.koguKommentaarHTML(REQUEST)+"
" if self.kas_opetaja(self, REQUEST): tulemus=tulemus+""+REQUEST['L_it_an_answer_commenting_table']+"" return tulemus+leheLopp(self, REQUEST) def vastusteKommenteeritavTabel(self, REQUEST): "Ülesannete vastused tabelina" self.get_lang(('ivatests',), REQUEST) tulemus=leheAlgus(self, REQUEST)+\ "
"+\ ""+\ ""+\ "" for x in self.ylesanded(): opunktid="" if x.annaOpetajaPunktid() is not None: opunktid=x.annaOpetajaPunktid() else: if x.kasPunktiArvutus(): opunktid=x.automaatPunkte() tulemus=tulemus+"\n" tulemus=tulemus+""+\ ""+\ "" tulemus=tulemus+\ ""+\ ""+\ "" tulemus=tulemus+"
"+REQUEST['L_it_anc_question']+""+REQUEST['L_it_anc_user_answer']+""+REQUEST['L_it_anc_teacher_answer']+""+REQUEST['L_it_anc_automatic_points']+""+REQUEST['L_it_anc_nominal_points']+\ ""+REQUEST['L_it_anc_teacher_points']+""+REQUEST['L_it_anc_teachers_comment']+\ ""+REQUEST['L_it_anc_point_reading']+"
"+x.esitlusHTML(REQUEST)+""+\ x.pakutudHTML(REQUEST)+""+x.tegelikHTML(REQUEST)+""+str(x.automaatPunkte())+""+str(x.normPunktid)+""+str(x.kasPunktiArvutus())+"

"+\ self.punktiArvutusHTML(REQUEST)+"
"+REQUEST['L_it_anc_comment_to_whole_answer']+":
"+\ "" tulemus+="\n" tulemus+=" \n \n \n
\n \n" tulemus+="
\n
" return tulemus+leheLopp(self, REQUEST) def kommentaarideSalvestusLeht(self, REQUEST): "Õpetaja kommentaaride salvestus" import re for x in self.ylesanded(): if hasattr(REQUEST, 'opetajapunktid'+x.id) and len(getattr(REQUEST,'opetajapunktid'+x.id))>0: try: x.seaOpetajaPunktid(float(re.sub(",", ".", getattr(REQUEST,'opetajapunktid'+x.id)))) x.seaPunktiArvutus(1) except: x.seaPunktiArvutus(0) else: x.seaOpetajaPunktid(None) x.seaPunktiArvutus(0) if hasattr(REQUEST, 'opetajakommentaar'+x.id): x.seaOpetajaKommentaar(getattr(REQUEST, 'opetajakommentaar'+x.id)) self.seaKoguKommentaar(REQUEST.koguKommentaar) REQUEST.RESPONSE.redirect('vastusteKommenteeritavTabel') def seaKoguKommentaar(self, koguKommentaar): "Salvestatakse õpetaja kommentaar kogu lahendusvariandile" self.koguKommentaar=koguKommentaar def kysiKommentaar(self,REQUEST=None): return self.annaKoguKommentaar() def annaKoguKommentaar(self): "Kommentaari väljastus" return self.koguKommentaar def koguKommentaarHTML(self, REQUEST): "Kogu kommentaar HTML-ina" return asendaHTML(self.annaKoguKommentaar()) def lyhiKokkuvoteOpetajale(self, REQUEST): "Kokkuvote" tulemus=self.punktiArvutusHTML(REQUEST) for x in self.ylesanded(): if len(x.annaOpetajaKommentaar())>0: tulemus=tulemus+"
\n"+x.opetajaKommentaarHTML(REQUEST) if len(self.koguKommentaarHTML(REQUEST))>0: tulemus=tulemus+"

"+self.koguKommentaarHTML(REQUEST) return tulemus def pihtasSumma(self): "Tabamusega ylesannete summa" summa=0 for x in self.ylesanded(): if x.kasPihtas(): summa=summa+1 return summa def punktiSumma(self): "Ülesannete punktisumma" summa=0 for x in self.ylesanded(): try: if x.kasPunktiArvutus(): summa=summa+x.punkte() except Exception, probleem: print str(probleem) + " punkte " + x.absolute_url() return summa def normPunktiSumma(self): "Väärtused, mis annavad kokku 100%" summa=0 for x in self.ylesanded(): if x.kasPunktiArvutus(): summa=summa+x.annaNormPunktid() return summa def punktiProtsent(self, REQUEST): "%" self.get_lang(('ivatests',), REQUEST) if self.normPunktiSumma()==0: return "Protsendiarvutus puudub" return str(round(self.punktiSumma()*100/self.normPunktiSumma(), 2))+" %" def punktiArvutusHTML(self, REQUEST): "Tulemuste väljastus" self.get_lang(('ivatests',), REQUEST) return str(round(self.punktiSumma(),2))+" / "+str(round(self.normPunktiSumma(), 2))+\ ", "+self.punktiProtsent(REQUEST) def punktiArvutusLyhiHTML(self, REQUEST): "Tulemuste väljastus" self.get_lang(('ivatests',), REQUEST) return str(round(self.punktiSumma(), 2))+" / "+str(self.normPunktiSumma()) def leivaPuru(self, REQUEST, viimane=0): "Teekond üles" self.get_lang(('ivatests',),REQUEST) nimi=self.testinimi if viimane: tekst=nimi else: tekst=""+nimi+"" if self.fle_root().kas_opetaja(self, REQUEST): testipuru=""+REQUEST['L_it_tests']+"" else: testipuru=REQUEST['L_it_tests'] return " > "+testipuru+" > "+tekst+" > "+REQUEST['L_it_answers']+" " def index_html(self, REQUEST): "Peegel veebi" return self.vastusteTabel(REQUEST) Globals.InitializeClass(TestiVastused) Globals.default__class_init__(TestiVastused) def asendaHTML(sona): try: sona=sona.replace("&", "&") sona=sona.replace(">", ">") sona=sona.replace("<", "<") return sona; except: return "error: "+sona #def leheAlgus(obj, REQUEST): # return obj.fle_root().hdr(obj, REQUEST)+obj.leivaPuru(REQUEST)+"
" def leheAlgus(obj, REQUEST): return ""+obj.leivaPuru(REQUEST)+"
" #def leheLopp(obj, REQUEST): # return obj.fle_html_footer(obj, REQUEST) def leheLopp(obj, REQUEST): return ""