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
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
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
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
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
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
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
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
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
def load_grafico_ica_for_competicao(self, competicao):
acuc = classes.getAcumuladorCompeticao(competicao, config.VERSAO_ACUMULADOR, "ica")
if acuc:
self.grafico = acuc.acuc_content["ica"]
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
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
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"]
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
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
