mamweb/seminar/testutils.py

# -*- coding: utf-8 -*-

import datetime
from pytz import timezone
import random
import lorem
import django.contrib.auth
from django.db import transaction
import unidecode
import logging

from seminar.models import Skola, Resitel, Rocnik, Cislo, Problem, Reseni, PrilohaReseni, Nastaveni, Soustredeni, Soustredeni_Ucastnici, Soustredeni_Organizatori, Osoba, Organizator, Prijemce, Tema, Uloha, Konfera, KonferaNode, TextNode, UlohaVzorakNode, RocnikNode, CisloNode, TemaVCisleNode, Text, Hodnoceni, UlohaZadaniNode, Novinky

from django.contrib.flatpages.models import FlatPage
from django.contrib.sites.models import Site

User = django.contrib.auth.get_user_model()
zlinska = None # tohle bude speciální škola, které později dodáme kontaktní osobu

logger = logging.getLogger(__name__)

# testuje unikátnost vygenerovaného jména
def __unikatni_jmeno(osoby, jmeno, prijmeni):
	for os in osoby:
		if os.jmeno == jmeno and os.prijmeni == prijmeni:
			return 0
	else: return 1

def gen_osoby(rnd, size):
	logger.info('Generuji osoby (size={})...'.format(size))

	jmena_m = ['Aleš', 'Tomáš', 'Martin', 'Jakub', 'Petr', 'Lukáš', 'Cyril', 'Pavel Karel']
	jmena_f = ['Eva', 'Karolína', 'Zuzana', 'Sylvie', 'Iva', 'Jana', 'Marie', 
		'Marta Iva', 'Shu Shan']
	prijmeni_m = ['Novotný', 'Svoboda', 'Pecha', 'Kořen', 'Holan', 'Uhlíř', 'Chytráček', 
			'Pokora', 'Koch', 'Szegedy', 'Rudý', "von Neumann", "d'Este"]
	prijmeni_f = ['Novotná', 'Svobodová', 'Machová', 'Zelená', 'Yu-Xin', 'Mlsná', 'Dubná', 
			'Mrkvová', 'Suchá', 'Lovelace', 'Holcová', 'Rui']
	prezdivky = ['Kaki', 'Hurdur', 'Maracuja', 'Bobbo', "", "", "", "", "", 
			"", "", 'Riki', 'Sapa', "", '', '---', 'Koko']
	domain = ['example.com', 'dolujeme.eu', 'mff.cuni.cz', 'strcprstskrzkrk.cz', 
			'british.co.uk', 'splachni.to', 'haha.org']
	seznam_ulic = ['Krátká', 'Vlhká', 'Jungmanova', '17. listopadu', '4. října', 'Roztocká', 
			'Forstova', 'Generála Františka Janouška', 'Náměstí Války', 
			'Svratecké náměstí', 'Zelená lhota', 'Z Plynu', 'K Jezeru', 'U Kocourkova',
			'Uštěpačná', 'Ostrorepská', 'Zubří']
	seznam_mest = ['Praha', 'Brno', 'Ostrava', 'Horní Jelení', 'Dolní Zábrdovice', 'Prdelkov', 
			'Stará myslivna', 'Kocourkov', 'Šalingrad', 'Medvědí hora', 'Basilej', 
			'Unterschiedlich', 'Old York', 'Lancastershire', 'Vóloďháza']

	osoby = []
	# 30 je náhodná konstanta, size je použité na víc místech a 
	# říká, jak velká asi chceme testovací data
	for i in range(30 * size): 
		pohlavi = rnd.randint(0,1)
		jmeno = rnd.choice([jmena_m, jmena_f][pohlavi])
		prijmeni = rnd.choice([prijmeni_m, prijmeni_f][pohlavi])
		pokusy = 0
		max_pokusy = 120*size
		while (not __unikatni_jmeno and pokusy < max_pokusy):
		# pokud jméno a příjmení není unikátní, zkoušíme generovat nová
		# do daného limitu (abychom se nezacyklili do nekonečna při málo jménech a příjmeních
		# ze kterých se generuje)
			jmeno = rnd.choice([jmena_m, jmena_f][pohlavi])
			prijmeni = rnd.choice([prijmeni_m, prijmeni_f][pohlavi])
			pokusy = pokusy + 1
		if pokusy >= max_pokusy:
			print("Chyba, na danou velikost testovacích dat příliš málo možných"
				" jmen a příjmení")
			exit
		prezdivka = rnd.choice(prezdivky)
		email = "@".join([unidecode.unidecode(jmeno), rnd.choice(domain)])
		telefon = "".join([str(rnd.choice([k for k in range(10)])) for i in range(9)])
		narozeni = datetime.date(rnd.randint(1980, 2020), rnd.randint(1, 12), 
						rnd.randint(1, 28))
		ulic = rnd.choice(seznam_ulic)
		cp = rnd.randint(1, 99)
		ulice = " ".join([ulic, str(cp)])
		mesto = rnd.choice(seznam_mest)
		psc = "".join([str(rnd.choice([k for k in range(10)])) for i in range(5)])
		osoby.append(Osoba.objects.create(jmeno = jmeno, prijmeni = prijmeni, 
				prezdivka = prezdivka, pohlavi_muz = pohlavi, email = email, 
				telefon = telefon, datum_narozeni = narozeni, ulice = ulice, 
				mesto = mesto, psc = psc, 
				datum_registrace = datetime.date(rnd.randint(2019, 2029), 
					rnd.randint(1, 12), rnd.randint(1, 28))))
		#TODO pridat foto male a velke. Jak?
				# Pavel tvrdí, že to necháme a přidáme až do adminu

	return osoby
	


def gen_skoly(): #TODO někdy to přepsat, aby jich bylo více
	logger.info('Generuji školy...')

	skoly = []
	prvnizs = Skola.objects.create(mesto='Praha', stat='CZ', psc='101 00', 
		ulice='Krátká 5', nazev='První ZŠ', je_zs=True, je_ss=False)
	skoly.append(prvnizs)
	skoly.append(Skola.objects.create(mesto='Praha', stat='CZ', psc='101 00', 
		ulice='Krátká 5', nazev='První SŠ', je_zs=False, je_ss=True))
	skoly.append(Skola.objects.create(mesto='Praha', stat='CZ', psc='102 00', 
		ulice='Dlouhá 5', nazev='Druhá SŠ', je_zs=False, je_ss=True))
	skoly.append(Skola.objects.create(mesto='Praha', stat='CZ', psc='103 00', 
		ulice='Široká 3', nazev='Třetí SŠ a ZŠ', je_zs=True, je_ss=True))
	skoly.append(Skola.objects.create(mesto='Ostrava', stat='CZ', psc='700 00', 
		ulice='Hluboká 42', nazev='Hutní gympl', je_zs=False, je_ss=True))
	skoly.append(Skola.objects.create(mesto='Humenné', stat='SK', psc='012 34', 
		ulice='Pltká 1', nazev='Sredná škuola', je_zs=False, je_ss=True))
	global zlinska
	zlinska = Skola.objects.create(mesto = 'Zlín', stat='CZ', psc='76001', 
		ulice='náměstí T.G. Masaryka 2734-9', 
		nazev='Gymnázium a Střední jazyková škola s právem SJZ', 
		kratky_nazev="GaSJŠspSJZ", je_zs=True, je_ss=True)
	skoly.append(zlinska)
	return skoly

def gen_resitele(rnd, osoby, skoly):
	logger.info('Generuji řešitele...')

	resitele = []
	for os in osoby:
		rand = rnd.randint(0, 8)
		if not (rand % 8 == 0):
			resitele.append(Resitel.objects.create(osoba=os, skola=rnd.choice(skoly), 
				rok_maturity=rnd.randint(2019, 2029), 
				zasilat=rnd.choice(Resitel.ZASILAT_CHOICES)[0]))
	return resitele

def gen_prijemci(rnd, osoby, kolik=10):
	logger.info('Generuji příjemce (kolik={})...'.format(kolik))
	prijemci = []
	for i in rnd.sample(osoby, kolik):
		prijemci.append(Prijemce.objects.create(osoba=i))
	return prijemci

def gen_organizatori(rnd, osoby, last_rocnik, users):
	logger.info('Generuji organizátory...')
	organizatori = []
	for os in osoby:
		rand = rnd.randint(0, 8)
		if (rand % 8 == 0):
			pusobnost = rnd.randint(1, last_rocnik)
			od = datetime.datetime(
				year=1993 + pusobnost,
				month=rnd.randint(1, 12),
				day=rnd.randint(1, 28),
				tzinfo=timezone('CET'),
				)
			do = datetime.datetime(
				year=od.year + rnd.randint(1, 6),
				month=rnd.randint(1, 12),
				day=rnd.randint(1, 28),
				tzinfo=timezone('CET'),
				)
			#aktualni organizatori jeste nemaji vyplnene organizuje_do
			if do.year > datetime.datetime.now().year:
				do = None
			organizatori.append(Organizator.objects.create(osoba=os, 
					organizuje_od=od, organizuje_do=do))
	return organizatori

def gen_ulohy_do_cisla(rnd, organizatori, resitele, rocnik_cisla, rocniky, size):
	logger.info('Generuji úlohy do čísla (size={})...'.format(size))

	# ulohy resene v cisle
	jaka = ["Šachová", "Černá", "Větrná", "Dlouhá", "Křehká", "Rychlá", 
		"Zákeřná", "Fyzikální"]
	co = ["kostka", "smršť", "díra", "zrada", "toulka", "tyč", 
		"úloha", "blecha"]
	sloveso = ["Najděte", "Spočítejte", "Zapište", "Změřte", "Odhadněte"]
	koho = ["délku", "počet", "množství", "dílky"]
	ceho = ["všech", "správných", "konstatních", "zelených"]
	jmeno = ["řešení", "tahů", "čísel", "kalhot", "koulí", "hadů"]
	kde = ["na zemi", "ve vesmíru", "ve vzduchu", "na šňůře", "v letadle"]
	obor = ["M", "F", "I", "O", "B"]
	reseni = ["to je přece jasné", "triviální", "omlouváme se," 
		"otevřený problém", "neřešitelné", "triviálně triviální", 
		"použitím věty z prvního semestru na matfyzu", 
		"jednoduše pomocí látky z druhého semestru na matfyzu",
		"netriviální aplikace diferenciálních rovnic", "zadání je vnitřně"
		"sporné", "nepopsatelně jednoduché", "pokud jste na to nepřišli,"
		"tak jste fakt hloupí"]
	k = 0
	for rocnik in rocniky:
		k+=1
		print("Generuji {}. číslo.".format(k))
		cisla = rocnik_cisla[k-1]
		for ci in range(3, len(cisla)+1): # pro všechna čísla
			resitele_size = round(7/8 * 30 * size) # očekáváný celkový počet řešitelů
			poc_res = rnd.randint(round(resitele_size/8), round(resitele_size/4))
 			# dané číslo řeší něco mezi osminou a čtvrtinou všech řešitelů
			# (náhodná hausnumera, možno změnit)
			# účelem je, aby se řešení generovala z menší množiny řešitelů a tedy
			# bylo více řešení od jednoho řešitele daného čísla
			resitele_cisla = rnd.sample(resitele, poc_res)
			for pi in range(1, ((size + 1) // 2) + 1):

				poc_op = rnd.randint(1, 4) # počet opravovatelů
				poc_oboru = rnd.randint(1, 2)
				p = Uloha.objects.create(
					# atributy třídy Problem
					nazev=" ".join([rnd.choice(jaka), rnd.choice(co)]),
					stav=Problem.STAV_ZADANY,
					zamereni=rnd.sample(["M", "F", "I", "O", "B"], poc_oboru),
					autor=rnd.choice(organizatori), 
					garant=rnd.choice(organizatori), 
					kod=str(pi), 
					# atributy třídy Uloha
					cislo_zadani=cisla[ci-2-1], 
					cislo_reseni=cisla[ci-1], 
					cislo_deadline=cisla[ci-1], 
					max_body = rnd.randint(1, 8)
				)

				text_zadani = Text.objects.create(
					na_web = " ".join(
					[rnd.choice(sloveso), 
					rnd.choice(koho), 
					rnd.choice(ceho), 
					rnd.choice(jmeno), 
					rnd.choice(kde)]
					),
					do_cisla = " ".join(
					[rnd.choice(sloveso), 
					rnd.choice(koho), 
					rnd.choice(ceho), 
					rnd.choice(jmeno), 
					rnd.choice(kde)]
					)
				)
				zad = TextNode.objects.create(text = text_zadani)
				uloha_zadani = UlohaZadaniNode.objects.create(uloha=p, first_child = zad)
				p.ulohazadaninode = uloha_zadani
				otec_syn(cisla[ci-2-1].cislonode, uloha_zadani)
			
				# generování vzorového textu
				text_vzoraku = Text.objects.create(
					na_web = rnd.choice(reseni),
					do_cisla = rnd.choice(reseni)
				)
				vzorak = TextNode.objects.create(text = text_vzoraku)
				uloha_vzorak = UlohaVzorakNode.objects.create(uloha=p, first_child = vzorak)
				p.ulohavzoraknode = uloha_vzorak
				otec_syn(cisla[ci-1].cislonode, uloha_vzorak)

				p.opravovatele.set(rnd.sample(organizatori,poc_op))
				p.save()

				# generování řešení
				poc_reseni = rnd.randint(poc_res, poc_res * 4)
				# generujeme náhodný počet řešení vzhledem k počtu řešitelů čísla
				for ri in range(poc_reseni):
					#print("Generuji {}-té řešení".format(ri))
					if rnd.randint(1, 10) == 6:
					# cca desetina řešení od více řešitelů
						res_vyber = rnd.sample(resitele_cisla, rnd.randint(2, 5))
					else:
						res_vyber = rnd.sample(resitele_cisla, 1)
					res = Reseni.objects.create(forma=rnd.choice(Reseni.FORMA_CHOICES)[0])
					# problem a resitele přiřadíme později, ManyToManyField
					# se nedá vyplnit v create()
					res.resitele.set(res_vyber)
					res.save()
					hod = Hodnoceni.objects.create(
						body=rnd.randint(0, p.max_body),
						cislo_body=cisla[ci-1],
						reseni=res,
						problem=p
					)
						
	return

def gen_soustredeni(rnd, resitele, organizatori):
	logger.info('Generuji soustředění...')

	soustredeni = []
	for _ in range(1, 10): #FIXME Tu range si změňte jak chcete, nevím, co přesně znamená size (asi Anet?)
		datum_zacatku=datetime.date(rnd.randint(2000, 2020), rnd.randint(1, 12), rnd.randint(1, 28))
		working_sous = Soustredeni.objects.create(
			rocnik=Rocnik.objects.order_by('?').first(),
			verejne_db=rnd.choice([True, False]),
			misto=rnd.choice(['Kremrolovice', 'Indiánov', 'U zmzliny', 'Vafláreň', 'Větrník', 'Horní Rakvička', 'Dolní cheesecake']),
			typ=rnd.choice(['jarni', 'podzimni', 'vikend']),
			datum_zacatku=datum_zacatku,
			datum_konce=datum_zacatku + datetime.timedelta(days=7))
		ucastnici = rnd.sample(resitele, min(len(resitele), 20))
		working_sous.ucastnici.set(ucastnici)
		#for res in rnd.sample(resitele, min(len(resitele), 20)):
		#	Soustredeni_Ucastnici.objects.create(resitel=res, soutredeni=working_sous)
		orgove_vyber = rnd.sample(organizatori, min(len(organizatori), 20))
		working_sous.organizatori.set(orgove_vyber)
		#for org in rnd.sample(organizatori, min(len(organizatori), 20)):
		#	Soustredeni_Organizatori.objects.create(organizator=org, soutredeni=working_sous)
		working_sous.save()
		soustredeni.append(working_sous)
	return soustredeni

def gen_rocniky(last_rocnik, size):
	logger.info('Generuji ročníky (size={})...'.format(size))

	rocniky = []
	node = None
	for ri in range(min(last_rocnik - size, 1), last_rocnik + 1):
		rocnik = Rocnik.objects.create(prvni_rok = 1993 + ri, rocnik = ri)
		node2 = RocnikNode.objects.create(rocnik = rocnik, succ = node)
		rocnik.save()
		node = node2
		rocniky.append(rocnik)
	return rocniky

def gen_konfery(size, rnd, organizatori, resitele, soustredeni):
	logger.info('Generuji konfery (size={})...'.format(size))

	konfery = []
	for _ in range(1, size): #FIXME Tu range si změňte jak chcete, nevím, co přesně znamená size (asi Anet?)
		# Anet: size je parametr udávající velikost testovacích dat a dá se pomocí ní škálovat, 
		# kolik dat se nageneruje 
		konfera = Konfera.objects.create(
			nazev=rnd.choice(['Pozorování', 'Zkoumání', 'Modelování', 'Počítání', 'Zkoušení']) + rnd.choice([' vlastností', ' jevů', ' charakteristik']) + rnd.choice([' vektorových prostorů', ' kinetické terorie látek', ' molekulární biologie', ' syntentických stromů']),
			anotace=lorem.paragraph(),
			abstrakt=lorem.paragraph(),
			organizator=rnd.choice(organizatori),
			soustredeni=rnd.choice(soustredeni),
			typ_prezentace=rnd.choice(['veletrh', 'prezentace']))
		ucastnici_sous = list(konfera.soustredeni.ucastnici.all())
		ucastnici = rnd.sample(ucastnici_sous, min(len(ucastnici_sous), rnd.randint(3, 6)))
		konfera.ucastnici.set(ucastnici)
		#for res in rnd.sample(ucastnici, min(len(ucastnici), rnd.randint(3, 6))):
		#	Konfery_Ucastnici.objects.create(resitel=res, konfera=konfera)
		konfera.save()
		konfery.append(konfera)
		
		konferanode = KonferaNode.objects.create(konfera=konfera)
		konferanode.save()
	return konfery

def gen_cisla(rnd, rocniky):
	logger.info('Generuji čísla...')

	rocnik_cisla = []
	for rocnik in rocniky:
		otec = True
		cisla = []
		cisel = rnd.randint(4, 8)
		node = None
		for ci in range(1, cisel + 1):
			# první číslo vydáváme typicky okolo prázdnin
			# (ci - 1)*2 zaručuje první číslo v červnu a všechna
			# další po dvou měsících (což je rozumná aproximace)
			mesic_vydani = (ci - 1)*2 + 6
			# celociselné dělení mi řekne, jestli to je první nebo druhý rok ročníku
			vydano = datetime.date(rocnik.prvni_rok + mesic_vydani // 12,
				(mesic_vydani - 1) % 12 + 1, 
				rnd.randint(1, 28))
			deadline = datetime.date(rocnik.prvni_rok + (mesic_vydani + 2) // 12, 
				(mesic_vydani + 1) % 12 + 1, 
				rnd.randint(1, 28)) 
			
			# posledni 2 cisla v rocniku nemaji deadline
			if (ci + 2 > cisel):
				deadline = None
			
			cislo = Cislo.objects.create(
				rocnik = rocnik,
				poradi = str(ci), 
				datum_vydani=vydano,
				datum_deadline=deadline, 
				verejne_db=True
			)
			node2 = CisloNode.objects.create(cislo = cislo, succ = node)
			cislo.save()
			node = node2
			if otec:
				otec = False
				rocnik.rocniknode.first_child = node
				rocnik.save()
			
			cisla.append(cislo)
		rocnik_cisla.append(cisla)
	return rocnik_cisla

def gen_temata(rnd, rocniky, rocnik_cisla, organizatori):
	logger.info('Generuji témata...')

	jake = ["Hravé", "Fyzikální", "Nejlepší", "Totálně masakrální",
					"Šokující", "Magnetické", "Modré", "Překvapivé", 
					"Plasmatické", "Novoroční"]
	co = ["téma", "záření", "stavení", "jiskření", "jelito",
					"drama", "kuře", "moře", "klání", "proudění", "čekání"]
	poc_oboru = rnd.randint(1, 2)
	poc_op = rnd.randint(1, 3)		

	rocnik_temata = []
	k = 0
	for rocnik in rocniky:
		k+=1
		n = 0
		temata = []
		cisla = rocnik_cisla[k-1]
		for ci in range(1, 3):
			n+=1
			t = Tema.objects.create(
				# atributy třídy Problem
				nazev=" ".join([rnd.choice(jake), rnd.choice(co)]),
				stav=Problem.STAV_ZADANY,
				zamereni=rnd.sample(["M", "F", "I", "O", "B"], poc_oboru),
				autor=rnd.choice(organizatori), 
				garant=rnd.choice(organizatori), 
				kod=str(n),
				# atributy třídy Téma
				tema_typ=rnd.choice(Tema.TEMA_CHOICES)[0],
				rocnik=rocnik,
				abstrakt = "Abstrakt tematka {}".format(n)
			)
			konec_tematu = min(rnd.randint(ci, 7), len(cisla))
			for i in range(ci, konec_tematu+1):
				node = TemaVCisleNode.objects.create(tema = t)
				otec = cisla[i-1].cislonode
				otec_syn(otec, node)

			t.opravovatele.set(rnd.sample(organizatori, poc_op))
			t.save()
			temata.append((ci, konec_tematu, t))
		rocnik_temata.append(temata)
	return rocnik_temata


def gen_ulohy_k_tematum(rnd, rocniky, rocnik_cisla, rocnik_temata, organizatori):
	logger.info('Generuji úlohy k tématům...')

	# ulohy resene v cisle
	jaka = ["Šachová", "Černá", "Větrná", "Dlouhá", "Křehká", "Rychlá", 
		"Zákeřná", "Fyzikální"]
	co = ["kostka", "smršť", "díra", "zrada", "toulka", "tyč", 
		"úloha", "blecha"]
	sloveso = ["Najděte", "Spočítejte", "Zapište", "Změřte", "Odhadněte"]
	koho = ["délku", "počet", "množství", "dílky"]
	ceho = ["všech", "správných", "konstatních", "zelených"]
	jmeno = ["řešení", "tahů", "čísel", "kalhot", "koulí", "hadů"]
	kde = ["na zemi", "ve vesmíru", "ve vzduchu", "na šňůře", "v letadle"]
	obor = ["M", "F", "I", "O", "B"]
	reseni = ["to je přece jasné", "triviální", "omlouváme se," 
		"otevřený problém", "neřešitelné", "triviálně triviální", 
		"použitím věty z prvního semestru na matfyzu", 
		"jednoduše pomocí látky z druhého semestru na matfyzu",
		"netriviální aplikace diferenciálních rovnic", "zadání je vnitřně"
		"sporné", "nepopsatelně jednoduché", "pokud jste na to nepřišli,"
		"tak jste fakt hloupí"]
	k = 0
	for rocnik in rocniky:
		k+=1
		cisla = rocnik_cisla[k-1]
		temata = rocnik_temata[k-1]
		for ci in range(len(cisla)):
			print("Generuji {}-té číslo".format(ci))
			cislo = cisla[ci-1]	
			mozna_tema_vcn = cislo.cislonode.first_child
			# kdybyste nad tím někdo taky přemýšleli, tak vcn == VCisleNode :)
			while mozna_tema_vcn != None:
				if type(mozna_tema_vcn) != TemaVCisleNode:
					mozna_tema_vcn = mozna_tema_vcn.succ
					continue
				else:
					tema = mozna_tema_vcn.tema
					
				if not temata[int(tema.kod)-1][1] >= ci+2:
					mozna_tema_vcn = mozna_tema_vcn.succ
					continue
					
				for i in range(1, rnd.randint(1, 4)):
					poc_op = rnd.randint(1, 4)
					poc_oboru = rnd.randint(1, 2)
					p = Uloha.objects.create(
						nazev=": ".join([tema.nazev, 
							"úloha {}.".format(i)]),
						nadproblem=tema,
						stav=Problem.STAV_ZADANY,
						zamereni=tema.zamereni,
						autor=tema.autor, 
						garant=tema.garant, 
						kod=str(i), 
						cislo_zadani=cislo, 
						cislo_reseni=cisla[ci+2-1], 
						cislo_deadline=cisla[ci+2-1], 
						max_body = rnd.randint(1, 8)
					)
					
					p.opravovatele.set(rnd.sample(organizatori, poc_op))  
					
					text_zadani = Text.objects.create(
						na_web = " ".join(
						[rnd.choice(sloveso), 
						rnd.choice(koho), 
						rnd.choice(ceho), 
						rnd.choice(jmeno), 
						rnd.choice(kde)]
						),
						do_cisla = " ".join(
						[rnd.choice(sloveso), 
						rnd.choice(koho), 
						rnd.choice(ceho), 
						rnd.choice(jmeno), 
						rnd.choice(kde)]
						)
					)
					zad = TextNode.objects.create(text = text_zadani)
					uloha_zadani = UlohaZadaniNode.objects.create(uloha=p, first_child = zad)
					p.ulohazadaninode = uloha_zadani
					otec_syn(mozna_tema_vcn, uloha_zadani) 
					# TODO dělá se podproblém takto??? TODO
					
					text_vzoraku = Text.objects.create(
						na_web = rnd.choice(reseni),
						do_cisla = rnd.choice(reseni)
					)
					vzorak = TextNode.objects.create(text = text_vzoraku)
					uloha_vzorak = UlohaVzorakNode.objects.create(uloha=p, first_child = vzorak)
					p.UlohaVzorakNode = uloha_vzorak
					res_tema_vcn = cisla[ci+2-1].cislonode.first_child
					while res_tema_vcn.tema != tema:
						res_tema_vcn = res_tema_vcn.succ
					otec_syn(res_tema_vcn, uloha_vzorak)
					
					p.save()
			
				mozna_tema_vcn = mozna_tema_vcn.succ
	return

def gen_novinky(rnd, organizatori):
	logger.info('Generuji novinky...')


	jake = ["zábavné", "veselé", "dobrodružné", "skvělé"]
	co = ["soustředění", "Fyziklání", "víkendové setkání"]
	kde = ["na Šumavě", "v Praze", "u Plzně", "na Marsu"]
	kdy = ["Zítra bude", "10. 10. 2020 bude", "V prosinci bude", "V létě bude"]

	for i in range(5):
		text_novinky = " ".join([rnd.choice(kdy),rnd.choice(kde),rnd.choice(jake),rnd.choice(co)])
		novinka = Novinky.objects.create(id=i,autor=rnd.choice(organizatori),text=(text_novinky+", těšíme se na vás!"),zverejneno=rnd.choice([True,False]))
		novinka.save()
	return
				    
def otec_syn(otec, syn):
	bratr = otec.first_child
	syn.ucc = bratr
	otec.first_child = syn
	syn.save()
	otec.save()

@transaction.atomic
def create_test_data(size = 6, rnd = None):
	logger.info('Vyrábím testovací data (size={})...'.format(size))

	assert size >= 1
	# pevna pseudo-nahodnost
	rnd = rnd or random.Random(x=42)

	# static URL stranky
	# FIXME: nakopirovat sem vsechny z produkcni databaze
	s = Site.objects.filter(name="example.com")
	f = FlatPage.objects.create(url="/", title="Seminář M&M", 
		content = "<p>V&iacute;tejte na str&aacute;nce semin&aacute;ře MaM!</p>")
	print(s)
	f.sites.add(s[0])
	f.save()

	# users
	admin = User.objects.create_superuser(username='admin', email='', password='admin')

	usernames = ['anet', 'bara', 'cyril', 'david', 'eva', 'filip']
	users = []
	for usr in usernames[:size]:
		u = User.objects.create(username=usr, password=usr)
		u.first_name = usr.capitalize()
		u.save()
		users.append(u)
	print(users)

	# skoly
	skoly = gen_skoly()

	# osoby
	osoby = gen_osoby(rnd, size)

	# resitele a organizatori
	last_rocnik = 25
	resitele = gen_resitele(rnd, osoby, skoly)
	organizatori = gen_organizatori(rnd, osoby, last_rocnik, users)

	#generování novinek
	novinky = gen_novinky(rnd, organizatori)

	# prijemci
	prijemci = gen_prijemci(rnd, osoby)
	
	global zlinska
	zlinska.kontaktni_osoba=rnd.choice(osoby)
	zlinska.save()

	# rocniky
	rocniky = gen_rocniky(last_rocnik, size)
	
	# cisla
	rocnik_cisla = gen_cisla(rnd, rocniky)	
	
	# generování obyčejných úloh do čísel
	gen_ulohy_do_cisla(rnd, organizatori, resitele, rocnik_cisla, rocniky, size)
	
	# generování témat, zatím v prvních třech číslech po jednom
	# FIXME: více témat
	# rocnik_temata je pole polí trojic (první číslo :int, poslední číslo :int, téma:Tema), přičemž každé vnitřní pole odpovídá ročníku a FIXME: je to takhle fuj a když to někdo vidí poprvé, tak je z toho smutný, protože vůbec neví, co se děje a co má čekat.
	rocnik_temata = gen_temata(rnd, rocniky, rocnik_cisla, organizatori)
	
	# generování úloh k tématům ve všech číslech
	gen_ulohy_k_tematum(rnd, rocniky, rocnik_cisla, rocnik_temata, organizatori)
	
	#generování soustředění
	soustredeni = gen_soustredeni(rnd, resitele, organizatori)
	
	#generování konfer
	konfery = gen_konfery(size, rnd, organizatori, resitele, soustredeni)
	
			# TODO: nastavi správně, kolik se čeho generuje, aby rozsahy přibližně odpovídaly
			# FIXME: misto typu ruzne typy objektu a vnoreni do sebe (Tom nechápe, co je tímto fixme míněno)
			# TODO: vytvorit temata s ruznymi vlakny
			# TODO: nagenerovat starsim rocnikum pohadku
			# TODO: nagenerovat články
			# TODO: vecpat obrázky všude, kde to jde
			# TODO: mezičíslo node
			# TODO: přidat ke konferám řešení a dát je do čísel



	# obecné nastavení semináře, musí být už přidané ročníky a čísla, jinak se nastaví divně
	nastaveni = Nastaveni.objects.create(
			aktualni_cislo = Cislo.objects.all()[1])