コード例 #1
0
	def checkCacheFreshen(self):
		
		data_cache = None # data do HTML gerado em cache
		
		self.softcache_html =  memcache.get(self.cache_url, namespace=self.cache_namespace)
		if self.softcache_html:
			data_cache = self.softcache_html['date']
		else:
			self.hardcache_html = CacheHTML.all().filter("cch_url = ",self.cache_url).get()
			if self.hardcache_html:
				data_cache = self.hardcache_html.cch_date
	
		self.acu_class_real = memcache.get("acumulador-%s-%s" % (self.competicao, config.VERSAO_ACUMULADOR), namespace="classificacao_real")
		if not self.acu_class_real:
			self.acu_class_real = classes.getAcumuladorCompeticao(
				self.competicao,  config.VERSAO_ACUMULADOR,"classificacao_real")
		if data_cache and self.acu_class_real and self.acu_class_real.acuc_date > data_cache:
			self.refreshen_cache = True
		
		self.acu_class_virtual = memcache.get("acumulador-%s-%s" % (self.competicao, config.VERSAO_ACUMULADOR), namespace="classificacao_virtual")
		if not self.acu_class_real:
			self.acu_class_real = classes.getAcumuladorCompeticao(
				self.competicao,  config.VERSAO_ACUMULADOR,"classificacao_virtual")
		if data_cache and self.acu_class_virtual and self.acu_class_virtual.acuc_date > data_cache:
			self.refreshen_cache = True
コード例 #2
0
	def renderDados(self):
		acumulador = None
		if self.acuc_obj:
			acumulador = self.acuc_obj.acuc_content[self.nspace]
		else:
			acumulador = classes.getAcumuladorCompeticao(self.competicao, config.VERSAO_ACUMULADOR, self.nspace).acuc_content[self.nspace]
		
		arb_ids = []
		hash_arbitros = {}
		
		for key, list_values in acumulador.items():
			for idx, val in enumerate(acumulador[key]):
				if not acumulador[key][idx]["arb"] in arb_ids:
					arb_ids.append(acumulador[key][idx]["arb"])
	
		# converter ids em Arbitros
		arb_objs = Arbitro.get_by_id(arb_ids)
		for arb in arb_objs:
			hash_arbitros[arb.key().id()] = arb
			
		for key, list_values in acumulador.items():
			for idx, val in enumerate(acumulador[key]):
				acumulador[key][idx]["arbitro"] = hash_arbitros[acumulador[key][idx]["arb"]]

		return acumulador
コード例 #3
0
	def renderDados(self):
		acumulador = None
		if self.acue_obj:
			acumulador = self.acue_obj.acue_content[self.nspace]
		else:
			acumulador =  classes.getAcumuladorEpoca( 
			 self.epoca, config.VERSAO_ACUMULADOR, self.nspace).acue_content[self.nspace]
		
		# agora vamos obter os objectos (clubes) que fazem parte da LIGA desta época
		#, e fazer uma hash invertida.
		liga = self.epoca.epo_competicoes.filter("cmp_tipo = ","Liga").get()

		ac = classes.getAcumuladorCompeticao(liga, config.VERSAO_ACUMULADOR, "clube")
		clus = {}		
		
		if ac:
			clubes_liga_ids = ac.acuc_content["clube"].keys()
		
			clubes = Clube.get_by_id(clubes_liga_ids)

			for clube in clubes: 
				clus[clube.key().id()] = clube
		
		# no HTML, escrever só as entradas que tem clube. 
		# se não tiver, são de clubes acessórios e não importantes
		if acumulador:
			for key, list_values in acumulador.items():
				for idx, val in enumerate(acumulador[key]):
					if clus.has_key(acumulador[key][idx]["clu"]):
						acumulador[key][idx]["clube"] = clus[acumulador[key][idx]["clu"]]
					
		return acumulador
コード例 #4
0
	def checkCacheFreshen(self):
		
		data_cache = None # data do HTML gerado em cache
		
		self.softcache_html =  memcache.get(self.cache_url, namespace=self.cache_namespace)
		if self.softcache_html:
			data_cache = self.softcache_html['date']
		else:
			self.hardcache_html = CacheHTML.all().filter("cch_url = ",self.cache_url).get()
			if self.hardcache_html != None:
				data_cache = self.hardcache_html.cch_date
	
		self.acumulador_icc = memcache.get("acumulador-%s-%s" % (self.competicao, config.VERSAO_ACUMULADOR),
		 namespace=self.nspace1)
		
		if not self.acumulador_icc:
			self.acumulador_icc = classes.getAcumuladorCompeticao(self.competicao, config.VERSAO_ACUMULADOR, self.nspace1)

		if data_cache and self.acumulador_icc and self.acumulador_icc.acuc_date > data_cache:
			self.refreshen_cache = True
			
		self.acumulador_ica = memcache.get("acumulador-%s-%s" % (self.competicao, config.VERSAO_ACUMULADOR),
		 namespace=self.nspace3)

		if not self.acumulador_ica:
			self.acumulador_ica = classes.getAcumuladorCompeticao(self.competicao, config.VERSAO_ACUMULADOR, self.nspace3)

		if data_cache and self.acumulador_ica and self.acumulador_ica.acuc_date > data_cache:
			self.refreshen_cache = True
		
		self.acumulador_tabela_icc = memcache.get("acumulador-%s-%s" % (self.competicao, config.VERSAO_ACUMULADOR),
		 namespace=self.nspace2)
		
		if not self.acumulador_tabela_icc:
			self.acumulador_tabela_icc = classes.getAcumuladorCompeticao(self.competicao, config.VERSAO_ACUMULADOR, self.nspace2)

		if data_cache and self.acumulador_tabela_icc and self.acumulador_tabela_icc.acuc_date > data_cache:
			self.refreshen_cache = True
コード例 #5
0
	def renderDados(self):

		acumulador = None
		dados = {}
		
		limit_mais_golos = 10
		limit_maiores_goleadas = 10
		limit_mais_indisciplina = 10
		limit_mais_icc = 10
		
		if self.acuc_obj:
			acumulador = self.acuc_obj.acuc_content[self.nspace]
		else:
			acumulador = classes.getAcumuladorCompeticao(self.competicao, config.VERSAO_ACUMULADOR, self.nspace).acuc_content[self.nspace]

		dados["jogos"] = self.competicao.cmp_jogos.order("-jog_data").fetch(1000)
		
		# aproveito e gero uma hash invertida
		jogs = {}
		for jogo in dados["jogos"]: 
			jogs[jogo.key().id()] = jogo
		
		# no HTML, escrever só as entradas que tem clube. 
		# se não tiver, são de clubes acessórios e não importantes
		for key, list_values in acumulador.items():
			for idx, val in enumerate(acumulador[key]):
				acumulador[key][idx]["jogo"] = jogs[acumulador[key][idx]["jog"]]
					 		
		calendario_competicao, jogos_calendario =  calendario.gera_calendario_epoca(self.competicao.cmp_epoca, dados["jogos"])	

		dados["calendario_competicao"] = calendario_competicao
		dados["jogos_calendario"] = jogos_calendario
			
		howmany = len(acumulador["mais_golos"]) if len(acumulador["mais_golos"]) <= limit_mais_golos else limit_mais_golos
		dados["mais_golos"] = acumulador["mais_golos"][:howmany]
		howmany = len(acumulador["maiores_goleadas"]) if len(acumulador["maiores_goleadas"]) <= limit_maiores_goleadas else limit_maiores_goleadas
		dados["maiores_goleadas"] = acumulador["maiores_goleadas"][:howmany]
		howmany = len(acumulador["mais_indisciplina"]) if len(acumulador["mais_indisciplina"]) <= limit_mais_indisciplina else limit_mais_indisciplina
		dados["mais_indisciplina"] = acumulador["mais_indisciplina"][:howmany]
		howmany = len(acumulador["mais_icc"]) if len(acumulador["mais_icc"]) <= limit_mais_icc else limit_mais_icc
		dados["mais_icc"] = acumulador["mais_icc"][:howmany]
	
		# jornadas
		dados["jornadas"] = self.competicao.cmp_jornadas.order("jor_ordem").fetch(1000)

		return dados
コード例 #6
0
	def renderDados(self):
		acumulador = None
		if self.acuc_obj:
			acumulador = self.acuc_obj.acuc_content[self.nspace]
		else:
			acumulador = classes.getAcumuladorCompeticao( 
			 self.competicao, config.VERSAO_ACUMULADOR, self.nspace)

		clubes = listas.get_lista_clubes()
		clus = {}
		for clube in clubes: 
			clus[clube.key().id()] = clube
		
		# no HTML, escrever só as entradas que tem clube. 
		# se não tiver, são de clubes acessórios e não importantes
		for key, list_values in acumulador.items():
			for idx, val in enumerate(acumulador[key]):
				if clus.has_key(acumulador[key][idx]["clu"]):
					acumulador[key][idx]["clube"] = clus[acumulador[key][idx]["clu"]]

		return acumulador
コード例 #7
0
	def renderDados(self):
		acumulador = None
		if self.acuc_obj:
			acumulador = self.acuc_obj.acuc_content[self.nspace]
		else:
			acumulador = classes.getAcumuladorCompeticao(self.competicao, config.VERSAO_ACUMULADOR, self.nspace).acuc_content[self.nspace]

		# vamos recolher os ids de todos os jogadores
		ids = []
		for item in acumulador["mais_golos"]:
			# item = {jgd:1L, gol:1L}
			if not item["jgd"] in ids:
				ids.append(item["jgd"])
		for item in acumulador["mais_cartoes"]:
			# item = {jgd:1L, crt:{ca:, cda: cv: tot:}}
			if not item["jgd"] in ids:
				ids.append(item["jgd"])
		for item in acumulador["mais_lances"]:
			# item = {jgd:1L, crt:{ca:, cda: cv: tot:}}
			if not item["jgd"] in ids:
				ids.append(item["jgd"])
		
		# agora vamos obter os objectos, e fazer uma hash invertida.
		jogadores = Jogador.get_by_id(ids)
		jgds = {}
		for jogador in jogadores: 
			jgds[jogador.key().id()] = jogador
		
		# agora vamos substituir os ids pelos objectos
		for idx, val in enumerate(acumulador["mais_golos"]):
			acumulador["mais_golos"][idx]["jogador"] = jgds[val["jgd"]]
		for idx, val in enumerate(acumulador["mais_cartoes"]):
			acumulador["mais_cartoes"][idx]["jogador"] = jgds[val["jgd"]]
		for idx, val in enumerate(acumulador["mais_lances"]):
			acumulador["mais_lances"][idx]["jogador"] = jgds[val["jgd"]]
	
		return acumulador
コード例 #8
0
	def renderDados(self):

		competicoes = []
		melhores_marcadores = []
		mais_indisciplinados = []
					
		top_list_melhores_marcadores = 5
		top_list_mais_indisciplinados = 5
		
		# top jogadores: 
		acumulador = classes.getAcumuladorEpoca(self.epoca, 
			config.VERSAO_ACUMULADOR, "top_jogadores")
		
		top_jogadores = acumulador.acue_content["top_jogadores"]

		howmany = len(top_jogadores["mais_golos"]) if len(top_jogadores["mais_golos"]) <= top_list_melhores_marcadores else top_list_melhores_marcadores
		for linha in top_jogadores["mais_golos"][:howmany]:
			melhores_marcadores.append(linha)

		howmany = len(top_jogadores["mais_cartoes"]) if len(top_jogadores["mais_cartoes"]) <= top_list_mais_indisciplinados else top_list_mais_indisciplinados
		for linha in top_jogadores["mais_cartoes"][:howmany]:
			mais_indisciplinados.append(linha)

		# vamos recolher os ids de todos os jogadores
		ids = []
		for item in melhores_marcadores:
			# item = {jgd:1L, gol:1L}
			if not item["jgd"] in ids:
				ids.append(item["jgd"])
		for item in mais_indisciplinados:
			# item = {jgd:1L, crt:{ca:, cda: cv: tot:}}
			if not item["jgd"] in ids:
				ids.append(item["jgd"])
		
		# agora vamos obter os objectos, e fazer uma hash invertida.
		jogadores = Jogador.get_by_id(ids)
		jgds = {}
		for jogador in jogadores: 
			jgds[jogador.key().id()] = jogador
		
		# agora vamos substituir os ids pelos objectos
		for idx, val in enumerate(melhores_marcadores):
			melhores_marcadores[idx]["jogador"] = jgds[val["jgd"]]
		for idx, val in enumerate(mais_indisciplinados):
			mais_indisciplinados[idx]["jogador"] = jgds[val["jgd"]]
		
		for competicao in self.epoca.epo_competicoes:

			acumulador = classes.getAcumuladorCompeticao(competicao, 
				config.VERSAO_ACUMULADOR, "classificacao_real")
			
			classificacao_total = None
				
			if acumulador and acumulador.acuc_content.has_key("classificacao_real"):
				classificacao_total = acumulador.acuc_content["classificacao_real"]["total"]
			# vamos tirar a linha que interessa...
			
			competicoes.append({
				"competicao":competicao, 
				"dados":classificacao_total[0] if classificacao_total else None,
				"clube":Clube.get_by_id(classificacao_total[0]["clu"]) if classificacao_total else None
			})
					
		dados = {"competicoes":competicoes,
					"melhores_marcadores":melhores_marcadores,
					"mais_indisciplinados":mais_indisciplinados}

		return dados
コード例 #9
0
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
コード例 #10
0
ファイル: grafico_ica.py プロジェクト: NunoCardoso/foipenalti
 def load_grafico_ica_for_competicao(self, competicao):
     acuc = classes.getAcumuladorCompeticao(competicao, config.VERSAO_ACUMULADOR, "ica")
     if acuc:
         self.grafico = acuc.acuc_content["ica"]
コード例 #11
0
ファイル: homepage.py プロジェクト: NunoCardoso/foipenalti
	def renderDados(self):
		
		blogpost_limit = 4

# CRIAR CARROSSEL JORNADAS
		now = datetime.datetime.now()
	#	now_plus_one_day = now + datetime.timedelta(days=1)
		jornadas_passadas = Jornada.all().filter("jor_competicao = ", self.competicao ).filter("jor_data <= ",now).order("-jor_data")
		jornadas_futuras = Jornada.all().filter("jor_competicao = ", self.competicao ).filter("jor_data > ",now).order("jor_data")
		
		jornadas_anteriores = [] 
		for j in jornadas_passadas.fetch(2):
			jornadas_anteriores.append(j)
		jornadas_posteriores = []
		for j in jornadas_futuras.fetch(2):
			jornadas_posteriores.append(j)
			
		jornada_corrente = None
		jornada_posterior = None
		jornada_anterior = None
		
# qual é a jornada corrente? Se a jornada futura já tem jogos de hoje...
		corrente = False
		if len(jornadas_posteriores) > 0:
			for jogo in jornadas_posteriores[0].jor_jogos:
				if jogo.jog_data < now:
					corrente = True
		
		if corrente:
			if len(jornadas_posteriores) > 0:
				jornada_corrente = jornadas_posteriores[0]
			if len(jornadas_posteriores) > 1:
				jornada_posterior = jornadas_posteriores[1]
			if len(jornadas_anteriores) > 0:
				jornada_anterior = jornadas_anteriores[0]
		else:
			if len(jornadas_anteriores) > 0:
				jornada_corrente = jornadas_anteriores[0]
			if len(jornadas_posteriores) > 0:
				jornada_posterior = jornadas_posteriores[0]
			if len(jornadas_anteriores) > 1:
				jornada_anterior = jornadas_anteriores[1]

		jor = DetalheJornada()
		jor_posterior_dados = None
		jor_corrente_dados = None
		jor_anterior_dados = None
		
		if jornada_anterior != None:
			jor.jornada=jornada_anterior
			jor_anterior_dados = jor.renderDados()
		if jornada_corrente != None:
			jor.jornada=jornada_corrente
			jor_corrente_dados = jor.renderDados()
		if jornada_posterior != None:
			jor.jornada=jornada_posterior
			jor_posterior_dados = jor.renderDados()

# CRIAR CARROSSEL CALENDÁRIO
		jogos_calendario, last_month, last_year, today_month, today_year, \
			next_month, next_year = self.gera_carrossel_calendario()
		
# CRIAR CARROSSEL CLASSIFICAÇÃO
		acu_class_real = classes.getAcumuladorCompeticao(self.competicao, config.VERSAO_ACUMULADOR,"classificacao_real")
		cl_real = None
		cl_virtual = None
		
		if acu_class_real:
			cl_real = acu_class_real.acuc_content["classificacao_real"]
		
		acu_class_virtual = classes.getAcumuladorCompeticao(self.competicao, config.VERSAO_ACUMULADOR,"classificacao_virtual")
		if acu_class_virtual:
			cl_virtual = acu_class_virtual.acuc_content["classificacao_virtual"]
			
		lista_clubes = listas.get_lista_clubes()
		clus = {}
		for clube in lista_clubes: 
			clus[clube.key().id()] = clube
	
		if cl_real:
			for idx, item in enumerate(cl_real["total"]):
				cl_real["total"][idx]["clube"] = clus[cl_real["total"][idx]["clu"]]
		if cl_virtual:
			for idx, item in enumerate(cl_virtual["total"]):
				cl_virtual["total"][idx]["clube"] = clus[cl_virtual["total"][idx]["clu"]]

# CRIAR BLOG POSTS		
		posts = Post.all().order('-pub_date').fetch(blogpost_limit)

# CRIAR TOPS CLUBES ICC
		grafico = GraficoICC()
		grafico.load_grafico_icc_for_epoca(self.epoca)

		top_clubes_beneficiados_icc = grafico.get_top_beneficiados(3)
		top_clubes_prejudicados_icc =  grafico.get_top_prejudicados(3)
		
		for idx, val in enumerate(top_clubes_beneficiados_icc):
			top_clubes_beneficiados_icc[idx]["clube"] = Clube.get_by_id(top_clubes_beneficiados_icc[idx]["clu"])
		for idx, val in enumerate(top_clubes_prejudicados_icc):
			top_clubes_prejudicados_icc[idx]["clube"] = Clube.get_by_id(top_clubes_prejudicados_icc[idx]["clu"])	

# CRIAR TOPS ARBITROS ICA
		grafico_ica = GraficoICA()
		grafico_ica.load_grafico_ica_for_epoca(self.epoca)

		top_arbitros_bons_ica = grafico_ica.get_top_bons(3)
		top_arbitros_maus_ica = grafico_ica.get_top_maus(3)

		for idx, val in enumerate(top_arbitros_bons_ica):
			top_arbitros_bons_ica[idx]["arbitro"] = Arbitro.get_by_id(top_arbitros_bons_ica[idx]["arb"])
		for idx, val in enumerate(top_arbitros_maus_ica):
			top_arbitros_maus_ica[idx]["arbitro"] = Arbitro.get_by_id(top_arbitros_maus_ica[idx]["arb"])	

# CRIAR TOPS 3 GRANDES/ÁRBITROS (TABELA ICC)	
		tabela_icc = TabelaICC()
		tabela_icc.load_tabela_icc_for_epoca(self.epoca)
		top_tabela_icc_3_grandes = tabela_icc.get_top_arbitros_para_3_grandes()

		dados = {
			"cl_real":cl_real["total"],
			"cl_virtual":cl_virtual["total"],
			
			"jogos_calendario":jogos_calendario,
			
			"last_month":last_month, 
			"last_year":last_year, 
			"today_month":today_month,
			"today_year":today_year, 
			"next_month":next_month, 
			"next_year":next_year,
			
			"posts":posts,
			
			"top_clubes_beneficiados_icc":top_clubes_beneficiados_icc,
			"top_clubes_prejudicados_icc":top_clubes_prejudicados_icc,
			
			"top_tabela_icc_3_grandes":top_tabela_icc_3_grandes,
			
			"top_arbitros_bons_ica":top_arbitros_bons_ica,
			"top_arbitros_maus_ica":top_arbitros_maus_ica,
			
			"jogadores_populares":listas.get_top_jogadores_populares(),
			"clubes_populares":listas.get_top_clubes_populares(),
			"jogos_populares":listas.get_top_jogos_populares(),
			"lances_populares":listas.get_top_lances_populares(),
			"arbitros_populares":listas.get_top_arbitros_populares(),

			"jogadores_recentes":listas.get_top_jogadores_recentes(),
			"jogos_recentes":listas.get_top_jogos_recentes(),
			"lances_recentes":listas.get_top_lances_recentes(),
			"arbitros_recentes":listas.get_top_arbitros_recentes(),
		}
		
		if jornada_anterior != None:
			dados["jornada_anterior"] = jornada_anterior
		dados["jornada_corrente"]=jornada_corrente
		if jornada_posterior != None:
			dados["jornada_posterior"]=jornada_posterior
			
		if jor_anterior_dados != None:
			dados["jornada_anterior_dados"]=jor_anterior_dados["jornada"]
		if jor_corrente_dados != None:
			dados["jornada_corrente_dados"]=jor_corrente_dados["jornada"]
		if jor_posterior_dados != None:
			dados["jornada_posterior_dados"]=jor_posterior_dados["jornada"]

		return dados
コード例 #12
0
    def renderDados(self):

        dados = {}
        competicoes = []
        melhores_marcadores = []
        mais_indisciplinados = []

        top_list_melhores_marcadores = 5
        top_list_mais_indisciplinados = 5

        # primeiro, vamos saber quais são os jogadores deste clube
        # e fazer uma hash
        jgd_ids = []
        hash_jogadores = {}
        clu_id = self.clube.key().id()
        jogadores = Jogador.all().filter("jgd_clube_actual = ", self.clube)

        for j in jogadores:
            jgd_id = j.key().id()
            jgd_ids.append(jgd_id)
            hash_jogadores[jgd_id] = j

        acumulador = classes.getAcumuladorEpoca(self.epoca, config.VERSAO_ACUMULADOR, "top_jogadores")

        if acumulador:
            top_jogadores = acumulador.acue_content["top_jogadores"]

            so_far = 0
            for linha in top_jogadores["mais_golos"]:
                if linha["jgd"] in jgd_ids and so_far < top_list_melhores_marcadores:
                    # adiciona o obj a partir do id
                    linha["jogador"] = hash_jogadores[linha["jgd"]]
                    melhores_marcadores.append(linha)
                    so_far += 1

            so_far = 0
            for linha in top_jogadores["mais_cartoes"]:
                if linha["jgd"] in jgd_ids and so_far < top_list_mais_indisciplinados:
                    # adiciona o obj a partir do id
                    linha["jogador"] = hash_jogadores[linha["jgd"]]
                    mais_indisciplinados.append(linha)
                    so_far += 1

                    # total para as competições
            total_competicoes = {"jr": 0, "vr": 0, "er": 0, "dr": 0, "gmr": 0, "gsr": 0, "pr": 0}

            for competicao in self.epoca.epo_competicoes:

                acuc = classes.getAcumuladorCompeticao(competicao, config.VERSAO_ACUMULADOR, "classificacao_real")

                if acuc:
                    classificacao_total = acuc.acuc_content["classificacao_real"]["total"]

                    for linha in classificacao_total:
                        if linha["clu"] == clu_id:
                            competicoes.append({"competicao": competicao, "stats": linha})

                            total_competicoes["jr"] += linha["jr"]
                            total_competicoes["vr"] += linha["vr"]
                            total_competicoes["er"] += linha["er"]
                            total_competicoes["dr"] += linha["dr"]
                            total_competicoes["gmr"] += linha["gmr"]
                            total_competicoes["gsr"] += linha["gsr"]

            dados = {
                "competicoes": competicoes,
                "total_competicoes": total_competicoes,
                "melhores_marcadores": melhores_marcadores,
                "mais_indisciplinados": mais_indisciplinados,
            }

        return dados
コード例 #13
0
ファイル: tabela_icc.py プロジェクト: NunoCardoso/foipenalti
	def load_tabela_icc_for_competicao(self, competicao):
		acuc = classes.getAcumuladorCompeticao(competicao, config.VERSAO_ACUMULADOR,"tabela_icc")
		if acuc:
			self.tabela = acuc.acuc_content["tabela_icc"]
コード例 #14
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
コード例 #15
0
	def renderDados(self):
		
		# classificacao
		classificacao_real = None
		if self.acu_class_real:
			classificacao_real = self.acu_class_real.acuc_content["classificacao_real"]
		else:
			acuc = classes.getAcumuladorCompeticao(
				self.competicao, config.VERSAO_ACUMULADOR,"classificacao_real")
			if acuc:
			   classificacao_real = acuc.acuc_content["classificacao_real"]
			
		classificacao_virtual = None			
		if self.acu_class_virtual:
			classificacao_virtual = self.acu_class_virtual.acuc_content["classificacao_virtual"]
		else:
			acuc = classes.getAcumuladorCompeticao(
				self.competicao, config.VERSAO_ACUMULADOR,"classificacao_virtual")
			if acuc:
				classificacao_virtual = acuc.acuc_content["classificacao_virtual"]
		
		clubes = {}
		
		if classificacao_real and classificacao_real.has_key("total"):
			for idx, item in enumerate(classificacao_real["total"]):
				# fill out clubes.
				c = Clube.get_by_id(classificacao_real["total"][idx]["clu"])
				classificacao_real["total"][idx]["clube"] = c
				clubes[c.key().id()] = {"id":c.key().id(), "nome":c.clu_nome_curto, "logo":c.clu_link_logo} 
		
		if classificacao_virtual and classificacao_virtual.has_key("total"):
			for idx, item in enumerate(classificacao_virtual["total"]):
				classificacao_virtual["total"][idx]["clube"] = Clube.get_by_id(classificacao_virtual["total"][idx]["clu"])
		
		# tenho de enviar uma lista de clubes e a sua info, para que o javascript de desenho 
		# da classificação possa fazer nas classificações parciais. Não é inteligente adicionar 
		# objectos clubes em cada versão de classificação parcial

		# top jogadores
		melhores_marcadores = []
		mais_indisciplinados = []
		top_jogadores = None
					
		top_list_melhores_marcadores = 5
		top_list_mais_indisciplinados = 5
		
		# top jogadores: 
		acuc = classes.getAcumuladorCompeticao(self.competicao, 
			config.VERSAO_ACUMULADOR, "top_jogadores")
		if acuc:
			top_jogadores = acuc.acuc_content["top_jogadores"]
		
		if top_jogadores:
			howmany = len(top_jogadores["mais_golos"]) if len(top_jogadores["mais_golos"]) <= top_list_melhores_marcadores else top_list_melhores_marcadores
			for linha in top_jogadores["mais_golos"][:howmany]:
				melhores_marcadores.append(linha)

			howmany = len(top_jogadores["mais_cartoes"]) if len(top_jogadores["mais_cartoes"]) <= top_list_mais_indisciplinados else top_list_mais_indisciplinados
			for linha in top_jogadores["mais_cartoes"][:howmany]:
				mais_indisciplinados.append(linha)

			# vamos recolher os ids de todos os jogadores
			ids = []
			for item in melhores_marcadores:
				# item = {jgd:1L, gol:1L}
				if not item["jgd"] in ids:
					ids.append(item["jgd"])
			for item in mais_indisciplinados:
				# item = {jgd:1L, crt:{ca:, cda: cv: tot:}}
				if not item["jgd"] in ids:
					ids.append(item["jgd"])
		
			# agora vamos obter os objectos, e fazer uma hash invertida.
			jogadores = Jogador.get_by_id(ids)
			jgds = {}
			for jogador in jogadores: 
				jgds[jogador.key().id()] = jogador
		
			# agora vamos substituir os ids pelos objectos
			for idx, val in enumerate(melhores_marcadores):
				melhores_marcadores[idx]["jogador"] = jgds[val["jgd"]]
			for idx, val in enumerate(mais_indisciplinados):
				mais_indisciplinados[idx]["jogador"] = jgds[val["jgd"]]
		
		dados = {
			"melhores_marcadores":melhores_marcadores,
			"mais_indisciplinados":mais_indisciplinados,
			"clubes":clubes
		}
		
		if classificacao_real and classificacao_real.has_key("total"):
			dados["classificacao_real"] = classificacao_real["total"] 
			
		if classificacao_real and classificacao_real.has_key("parcial"):
			dados["classificacao_real_parcial"] = classificacao_real["parcial"] 
		
		if classificacao_virtual and classificacao_virtual.has_key("total"):
			dados["classificacao_virtual"] = classificacao_virtual["total"]

		if classificacao_virtual and classificacao_virtual.has_key("parcial"):
			dados["classificacao_virtual_parcial"] = classificacao_virtual["parcial"] 

		return dados