def gera(competicao, acuc_basico, 
				acuc_classificacao, acuc_tabela_icc, acuc_icc, acuc_top_arbitros,
				acuc_top_jogos, acuc_top_jogadores, acuc_top_clubes):

	stats_parcial = [] # as a list, I have jornadas ordered
	
	if acuc_basico == "on":
		logging.info("acuc_basico está on, vou gerar arbitro, jogador, clube e jogo a partir das estatísticas")

		acumulador_jornadas = AcumuladorJornada.all().filter("acuj_competicao = ", competicao).filter("acuj_versao = ", config.VERSAO_ACUMULADOR).fetch(1000)
		acumulador_jornadas = sorted(acumulador_jornadas, cmp=lambda x,y: cmp(x.acuj_jornada.jor_ordem, y.acuj_jornada.jor_ordem))

		stats_total = {
			"arbitro":{},
			"jogo": {},
			"jogador":{},
			"clube":{}
		}	
		
		for ac in acumulador_jornadas:
			
			parcial = {
				"arbitro":{},
				"jogo": {},
				"jogador":{},
				"clube":{},
				"jornada":ac.acuj_jornada
			}	
				
			# depicle it
			content = ac.acuj_content
		
			logging.info(u"acumulador_competicao: a ler dados do acumulador_jornada %s " % ac.acuj_jornada.__str__())

			doit(content["arbitro"], stats_total["arbitro"])
			doit(content["jogador"], stats_total["jogador"])
			doit(content["jogo"], stats_total["jogo"])		
			doit(content["clube"], stats_total["clube"])
			
			# save copies to the parcial_stats
			parcial["clube"] = deepcopy(stats_total["clube"])
			parcial["arbitro"] = deepcopy(stats_total["arbitro"])
			parcial["jogo"] = deepcopy(stats_total["jogo"])
		#	parcial["jogador"] = deepcopy(stats_total["jogador"])
			stats_parcial.append(parcial)
			
	else:
		
		# não permite parciais, a não ser que os grave, mas como não estou a fazer isso...
		logging.info("acuc_basico está off, vou gerar arbitro, jogador, clube e jogo a partir do acumulador")

		acumuladorcompeticoes = AcumuladorCompeticao.all().filter("acuc_competicao = ", competicao).filter("acuc_versao = ", config.VERSAO_ACUMULADOR)
		stats_total = {}
		
		# teoricamente, só há uma competição
		for acu in acumuladorcompeticoes:
		
			if acu.acuc_namespace == "arbitro":
				stats_total["arbitro"] = acu.acuc_content["arbitro"]
			if acu.acuc_namespace == "clube":
				stats_total["clube"] = acu.acuc_content["clube"]
			if acu.acuc_namespace == "jogador":
				stats_total["jogador"] = acu.acuc_content["jogador"]
			if acu.acuc_namespace == "jogo":
				stats_total["jogo"] = acu.acuc_content["jogo"]

#####################
### CLASSIFICACAO ###
#####################
	
	if acuc_classificacao == "on":
		# passar o objecto de classificação deve servir só para saber quais as 
		# regras de ordenação da classificação. Não usar os dados dos jogos!!!

		tabela_real = None
		tavela_virtual = None
		
		if competicao.cmp_tipo == "Liga":
			tabela_real, tabela_virtual =  Classificacao().gera_classificacao_liga(competicao, stats_parcial, stats_total)

		elif competicao.cmp_tipo == "TacaPortugal":
			tabela_real, tabela_virtual =  Classificacao().gera_classificacao_taca(competicao, stats_parcial, stats_total)

		elif competicao.cmp_tipo == "TacaLiga":
			tabela_real, tabela_virtual =  Classificacao().gera_classificacao_taca(competicao, stats_parcial, stats_total)

		elif competicao.cmp_tipo == "SuperTaca":
			tabela_real, tabela_virtual =  Classificacao().gera_classificacao_taca(competicao, stats_parcial, stats_total)

		stats_total["classificacao_real"] = tabela_real
		stats_total["classificacao_virtual"] = tabela_virtual

##################
### TABELA ICC ###
##################
	
	# independentemente de ser para Liga ou não, isto é só para clubes da Liga
	# se não houver liga ,não faz mal... vai tudo
	# se não houver nada (= início época), deixa ir nada.
	
	liga = competicao.cmp_epoca.epo_competicoes.filter("cmp_tipo = ","Liga").get()
	ac = classes.getAcumuladorCompeticao(liga, config.VERSAO_ACUMULADOR, "clube")
	clubes_liga_ids = None
	
	if ac:
		clubes_liga_ids = ac.acuc_content["clube"].keys()
	else:
		ac = classes.getAcumuladorCompeticao(competicao, config.VERSAO_ACUMULADOR, "clube")
		if ac:
			clubes_liga_ids = ac.acuc_content["clube"].keys()
	
	# se não há nada (= início época), vamos ao cjc
	if not clubes_liga_ids:
		clubes = [] 
		cjcs = ClubeJogaCompeticao.all().filter("cjc_competicao = ", liga)
		for cjc in cjcs:
			clubes.append(cjc.cjc_clube)
	else:
		clubes = Clube.get_by_id(clubes_liga_ids)

	clubes = sorted(clubes, cmp=lambda x,y: cmp(x.clu_numero_visitas, y.clu_numero_visitas), reverse=True)
	
	if acuc_tabela_icc == "on":
		# vamos assumir que sabemos que queremos uma tabela icc / Liga
		stats_total["tabela_icc"] = TabelaICC.gera_nova_tabela_icc(stats_total, clubes)

###########
### ICC ###
###########
	
	if acuc_icc == "on":
		# vamos assumir que sabemos que queremos uma tabela icc / Liga
		arbitros = Arbitro.all().fetch(1000)
		stats_total["icc"] = GraficoICC.gera_novo_grafico_icc(stats_total, stats_parcial, clubes)
		stats_total["ica"] = GraficoICA.gera_novo_grafico_ica(stats_total, stats_parcial, arbitros)
		
############
### TOPS ###
############
	
	if acuc_top_clubes == "on":
		stats_total["top_clubes"] = acumulador.gera_top_clubes(stats_total)
	if acuc_top_arbitros == "on":
		stats_total["top_arbitros"] = acumulador.gera_top_arbitros(stats_total)
	if acuc_top_jogadores == "on":
		stats_total["top_jogadores"] = acumulador.gera_top_jogadores(stats_total, competicao)
	if acuc_top_jogos == "on":
		stats_total["top_jogos"] = acumulador.gera_top_jogos(stats_total)

	return stats_total
예제 #2
0
def gera(epoca, acue_basico, 
				acue_tabela_icc, acue_icc, acue_top_arbitros,
				acue_top_jogos, acue_top_jogadores, acue_top_clubes):

	acuc = AcumuladorCompeticao.all().filter("acuc_epoca = ", epoca).filter("acuc_versao = ", config.VERSAO_ACUMULADOR).fetch(1000)

	stats = {}
	
	if acue_basico == "on":
		logging.info("acue_basico está on, vou gerar arbitro, jogador, clube e jogo a partir das estatísticas")

		stats = {
			"arbitro":{},
			"jogo": {},
			"jogador":{},
			"clube":{},
			"top_arbitros":{},
			"top_jogos": {},
			"top_jogadores":{},
			"top_clubes":{}
		}	
		for ac in acuc:
		
			# depicle it
			content = ac.acuc_content
		
			logging.info(u"acumulador_epoca: a ler dados do acumulador_competicao %s " % ac.acuc_competicao.__str__())

			if (ac.acuc_namespace == "arbitro"):
				doit(content["arbitro"], stats["arbitro"], "arbitro")
			if (ac.acuc_namespace == "jogador"):
				doit(content["jogador"], stats["jogador"], "jogador")
			if (ac.acuc_namespace == "jogo"):
				doit(content["jogo"], stats["jogo"], "jogo")		
			if (ac.acuc_namespace == "clube"):
				doit(content["clube"], stats["clube"], "clube")
			

	else:
		logging.info("acue_basico está off, vou gerar arbitro, jogador, clube e jogo a partir do acumulador")

		acumuladorepocas = AcumuladorEpoca.all().filter("acue_epoca = ", epoca).filter("acue_versao = ", config.VERSAO_ACUMULADOR)
		
		stats_total = {}
		stats = {}
		
		for acu in acumuladorepocas:
		
			if acu.acue_namespace == "arbitro":
				stats["arbitro"] = acu.acue_content["arbitro"]
			if acu.acue_namespace == "clube":
				stats["clube"] = acu.acue_content["clube"]
			if acu.acue_namespace == "jogador":
				stats["jogador"] = acu.acue_content["jogador"]
			if acu.acue_namespace == "jogo":
				stats["jogo"] = acu.acue_content["jogo"]
				
##############
### TABELA ICC ###
##############

	liga = epoca.epo_competicoes.filter("cmp_tipo = ","Liga").get()

	ac = classes.getAcumuladorCompeticao(liga, config.VERSAO_ACUMULADOR, "clube")
	if ac:
		clubes_liga_ids = ac.acuc_content["clube"].keys()
	else:
		ac = classes.getAcumuladorEpoca(epoca, config.VERSAO_ACUMULADOR, "clube")
		clubes_liga_ids = ac.acue_content["clube"].keys()
		
	clubes = Clube.get_by_id(clubes_liga_ids)
	clubes = sorted(clubes, cmp=lambda x,y: cmp(x.clu_numero_visitas, y.clu_numero_visitas), reverse=True)
	
	if acue_tabela_icc == "on":
		# vamos assumir que sabemos que queremos uma tabela icc / Liga
		stats["tabela_icc"] = TabelaICC.gera_nova_tabela_icc(stats, clubes)

###########
### ICC ###
###########
	
	if acue_icc == "on":
		# vamos assumir que sabemos que queremos uma tabela icc / Liga
		arbitros = Arbitro.all().fetch(1000)
		stats["icc"] = GraficoICC.gera_novo_grafico_icc(stats, {}, clubes)
		stats["ica"] = GraficoICA.gera_novo_grafico_ica(stats, {}, arbitros)

############
### TOPS ###
############

# os tops podem ser aglotinações de hashes das competições, não é preciso regerar
	
	
	for ac in acuc:
		
		if acue_top_clubes == "on" and ac.acuc_namespace == "top_clubes":
				doit(ac.acuc_content["top_clubes"], stats["top_clubes"], "top_clubes")
		if acue_top_arbitros == "on" and ac.acuc_namespace == "top_arbitros":
				doit(ac.acuc_content["top_arbitros"], stats["top_arbitros"], "top_arbitros")
		if acue_top_jogadores == "on" and ac.acuc_namespace == "top_jogadores":
				doit(ac.acuc_content["top_jogadores"], stats["top_jogadores"], "top_jogadores")
		if acue_top_jogos == "on" and ac.acuc_namespace == "top_jogos":
				doit(ac.acuc_content["top_jogos"], stats["top_jogos"], "top_jogos")

	return stats