def _getConteudoPublicado(self, id_conteudo=None, mkl=None):
"""
returns the data from a news content
@mkl: overwrites de default render method of links
>>> self._getConteudoPublicado(id_filme=1)
{'id_conteudo':, 'titulo':, 'cartola':, 'descricao':, 'editor':,
'regulamento':, 'imagem_topo_list':, 'imagem_rodape':, 'cor':, 'cadastro_unico':,
'publicado_em':, 'publicado':, 'atualizado_em':, "
'id_destaque':, 'titulo_destaque':, 'descricao_destaque':,
'imagem_destaque':, 'titulo_tree':, 'breadcrump':}
"""
conteudo = None
for conteudo in self.execSql("select_dados",
id_conteudo=int(id_conteudo)):
break
if conteudo:
soup = BeautifulSoup(conteudo["calendario"],
fromEncoding=settings.GLOBAL_ENCODING)
for a in soup.findAll("a"):
href = unquote(a.get("href", "")).strip()
if href.startswith("#h2href:"):
kingkong, dados = href.split("#h2href:", 1)
if mkl:
href, attrs = mkl(dados=decode(dados))
for i in attrs.keys():
a[i] = attrs[i]
else:
href = self._renderLink(dados=dados)
if href.find("javascript") >= 0:
href = href.replace("[target=blank]", "")
elif href.find("target=blank") >= 0:
href = href.replace("[target=blank]", "")
a["target"] = "blank"
a["href"] = href
conteudo["calendario"] = unquote( unicode(soup) )
return conteudo
def _getNoticiaPublicada(self, id_noticia=None, mkl=None):
""" Retorna os dados de uma noticia
"""
noticia = None
portal = Portal(id_site=self.id_site,
request=self.request)
if not noticia:
for noticia in self.execSql("select_noticia_publicada_ultima"):
break
for noticia in self.execSql("select_noticia_publicada",
id_conteudo=int(id_noticia)):
break
if noticia:
soup = BeautifulSoup(noticia["corpo"],
fromEncoding=settings.GLOBAL_ENCODING)
for a in soup.findAll("a"):
href = unquote(a.get("href", "")).strip()
if href.startswith("#h2href:"):
kingkong, dados = href.split("#h2href:", 1)
if mkl:
href, attrs = mkl(dados=decode(dados))
for i in attrs.keys():
a[i] = attrs[i]
else:
href = portal.mklink(dados=dados)
if href.find("javascript") >= 0:
href = href.replace("[target=blank]", "")
elif href.find("target=blank") >= 0:
href = href.replace("[target=blank]", "")
a["target"] = "blank"
a["href"] = href
noticia["corpo"] = unquote( unicode(soup) )
return noticia
def _isSessionActive(self, cookie=None):
"""Retorna se existem um cookie de sessao ativo
"""
cookie = cookie if cookie else COOKIE_NAME
ck = self._getSessionId(cookie)
if len(ck) == 3:
datahora = (datetime.datetime.now() -
datetime.timedelta(hours=1)).strftime("%Y-%m-%d %H:%M:%S")
id_session, nome, email = ck
usuario = {"id_session": None}
for i in self.execSql("select_session_dados",
id_session=id_session,
datahora=datahora):
self.execSqlu("update_session_user",
id_session=id_session)
usuario = i
if (usuario["id_session"]):
usuario["extra"] = decode(usuario["extra"])
return usuario
return False
def getMenuItem(self, id_menu):
"""
"""
menu = self.getMenu(id_menu)
return decode(menu['json'])
def addConteudo(self, id_site, id_treeapp, id_aplicativo,
titulo, descricao, publicado_em, id_estado,
cargo=None, expira_em=None, publicado=None,
titulo_destaque=None, descricao_destaque=None,
imagem_destaque=None, peso_destaque=None,
relacionamento=[], tags="", permissao=None,
exportar_xml=None, exportar_json=None,
exportar=None, descricao_vagas=None,
vagas_especiais=None, descricao_remuneracao=None,
banca_organizadora=None, cadastro_reserva=None,
validade_concurso=None, nivel_escolaridade=None,
data_edital=None, data_inscricao=None,
data_fim_inscricao=None, data_prova=None,
data_resultado=None, media=None, previsto=None,
remuneracao_de=None, remuneracao_ate=None,
total_vagas=None, inscricoes=None):
"""
add conteudo
"""
xml = "xmlcharrefreplace"
arquivos = unquote(media).decode("utf8").encode("latin1",
xml)
arquivos = json.decode(arquivos.replace("\n", "\\n"),
encoding="latin1")
print arquivos
id_estado = unquote(id_estado).decode("utf8").encode("latin1",
xml)
estados = json.decode(id_estado.replace("\n", "\\n"),
encoding="latin1")
dt = publicado_em
publicado = True if publicado else False
previsto = True if previsto else False
tags = tags if tags else None
publicado_em = self.formatDate(publicado_em, True)
expira_em = self.formatDate(expira_em, True)
data_edital = self.formatDate(data_edital)
data_inscricao = self.formatDate(data_inscricao)
data_fim_inscricao = self.formatDate(data_fim_inscricao)
data_prova = self.formatDate(data_prova)
data_resultado = self.formatDate(data_resultado)
# inserir conteudo
id_conteudo = self.execSql("select_nextval_conteudo").next()["id"]
total_vagas = int(total_vagas) if total_vagas else None
remuneracao_de = int(remuneracao_de) if remuneracao_de else None
remuneracao_ate = int(remuneracao_ate) if remuneracao_ate else None
self.execSqlBatch("insert_conteudo",
id_conteudo=id_conteudo,
titulo=titulo,
descricao=descricao,
publicado_em=publicado_em,
cargo=cargo,
total_vagas=total_vagas,
descricao_vagas=descricao_vagas,
vagas_especiais=vagas_especiais,
previsto=previsto,
remuneracao_de=remuneracao_de,
remuneracao_ate=remuneracao_ate,
descricao_remuneracao=descricao_remuneracao,
inscricoes=inscricoes,
banca_organizadora=banca_organizadora,
cadastro_reserva=cadastro_reserva,
validade_concurso=validade_concurso,
nivel_escolaridade=nivel_escolaridade,
data_edital=data_edital,
data_inscricao=data_inscricao,
data_fim_inscricao=data_fim_inscricao,
data_prova=data_prova,
data_resultado=data_resultado,
expira_em=expira_em,
publicado=publicado)
# inserindo os destaques
if titulo_destaque or imagem_destaque or descricao_destaque:
imagem_destaque = self._addFile(arquivo=imagem_destaque,
id_conteudo=id_conteudo,
schema=self.schema,
dt=dt)
if not imagem_destaque:
imagem_destaque = None
try:
peso_destaque = int(peso_destaque)
except:
peso_destaque = 0
self.execSqlBatch("insert_destaque",
id_conteudo=id_conteudo,
titulo=titulo_destaque,
descricao=descricao_destaque,
img=imagem_destaque,
peso=peso_destaque)
self.execSqlCommit()
# inserindo os arquivos
if estados:
for id_estado in estados:
self.execSqlu("insert_estados_concurso",
id_conteudo=int(id_conteudo),
id_estado=int(id_estado))
# inserindo os arquivos
if arquivos:
for arquivo in arquivos:
arquivocam = self._addFile(arquivo=arquivo['valor'],
id_conteudo=id_conteudo,
schema=self.schema,
dt=dt)
self.execSqlu("insert_arquivo",
id_conteudo=int(id_conteudo),
titulo=arquivo['nome'],
arquivo=arquivocam,
tipo=arquivo['tipo'],
permissao=arquivo['permissao'],
categoria=arquivo['categoria'],
descricao=arquivo['descricao'])
# acoes para o portal
dados = self._setDados(id_conteudo=id_conteudo)
self._addContentPortal(env_site=self.id_site,
id_pk=id_conteudo,
schema=self.schema,
meta_type=self.meta_type,
id_aplicativo=id_aplicativo,
id_treeapp=id_treeapp,
peso=peso_destaque,
titulo=titulo,
publicado=publicado,
publicado_em=publicado_em,
expira_em=expira_em,
titulo_destaque=titulo_destaque,
descricao_destaque=descricao_destaque,
imagem_destaque=imagem_destaque,
tags=tags,
permissao=permissao,
relacionamento=relacionamento,
dados=dados)
if exportar_xml or exportar_json or exportar:
self._addLog("Novo conteudo cadastrado e publicado '%s'" % titulo)
self._exportContent(id_aplicativo=id_aplicativo,
id_conteudo=id_conteudo,
schema=self.schema,
id_treeapp=id_treeapp,
html=exportar,
xml=exportar_xml,
json=exportar_json,
dados=dados,
subitems=None,
add=1)
return ("Conteudo cadastrado com sucesso! "
"Publicação iniciada.")
self._addLog("Novo conteudo cadastrada '%s'" % titulo)
return "Conteudo cadastrado com sucesso."
def _getConteudo(self, id_conteudo):
"""
"""
dadosapp = self._getDadosApp()
for i in self.execSql("select_evento",
id_conteudo=int(id_conteudo)):
p = strptime(i["data_inicio"],"%Y-%m-%d %H:%M:%S")
i["data_inicio"] = strftime("%d/%m/%Y", p)
o = strptime(i["data_fim"],"%Y-%m-%d %H:%M:%S")
i["data_fim"] = strftime("%d/%m/%Y", o)
i["categorias"] =[]
for j in self.execSql("select_destaque", id_conteudo=id_conteudo):
i["destaque"] = {"id_destaque": j["id_destaque"],
"titulo_destaque": j["titulo"],
"descricao_destaque": j["descricao"],
"imagem_destaque": j["img"],
"peso_destaque": j["peso"]}
for k in self.execSql("select_categoria_evento", id_conteudo=int(id_conteudo)):
categoria = {"id_categoria":k["id_categoria"],
"nome_categoria":k["nome_categoria"]}
i["categorias"].append(categoria)
for t in self.execSql("select_temp_imagem",
id_destaque=int(i["destaque"]["id_destaque"])):
t["imagem_temp"] = {"id_imagem": t["id_imagem"] if t["id_imagem"] else None,
"tempimg": base64.decodestring(t["imagembin"]) if t["imagembin"] else None,
"type": t["tipoarq"] if t["tipoarq"] else None,
"filename": t["nomearq"] if t["nomearq"] else None}
class FakeReader(object):
def __init__(self, source):
self.source = source
def read(self):
return self.source
class FakeFile(object):
"""Cria um objeto com atributos de um arquivo enviado por wsgi"""
def __init__(self, source, mimetype, filename):
self.type = mimetype
self.filename = filename
self.file = FakeReader(source)
if (t["imagem_temp"]["tempimg"]):
arq = File(request=self.request, id_site=self.id_site)
filesource = t["imagem_temp"]["tempimg"]
filenome = t["imagem_temp"]["filename"]
filetype = t["imagem_temp"]["type"]
filenomeint = "i" + t["imagem_temp"]["filename"]
fakefile = FakeFile(filesource, filetype, filenome)
fakefileint = FakeFile(filesource, filetype, filenome)
arquivo = arq.addFileTemp(arquivo=fakefile)
arquivoint = arq.addFileTemp(arquivo=fakefileint)
cont = self._addFile(arquivo=decode(arquivo)["id"],
id_conteudo=id_conteudo,
schema=self.schema,
dt=i["publicado_em"],
transform={"metodo":dadosapp['redimensionamento'],
"dimenx":dadosapp['dimenx'],
"dimeny":dadosapp['dimeny']})
cont2 = self._addFile(arquivo=decode(arquivoint)["id"],
id_conteudo=id_conteudo,
schema=self.schema,
dt=i["publicado_em"],
transform={"metodo":dadosapp['redimensionamentog'],
"dimenx":dadosapp['dimenxg'],
"dimeny":dadosapp['dimenyg']})
i["destaque"]["imagem_destaque"] = cont
i["imagemint"] = cont2
self.execSqlBatch("update_imagem",
id_conteudo=int(id_conteudo),
imagemint=cont2)
self.execSqlBatch("update_destaque",
id_destaque=i["destaque"]["id_destaque"],
img=cont)
self.execSqlBatch("delete_tempimg",
id_destaque=i["destaque"]["id_destaque"])
self.execSqlCommit()
return i
if imagem_destaque:
if type(imagem_destaque) is str:
try:
imagem_destaque.index("tmp")
arquivo = imagem_destaque
cont = self._addFile(arquivo = arquivo,
id_conteudo=id_conteudo,
schema=self.schema,
dt=dt2)
except:
cont = imagem_destaque
else:
arq = File(request={}, id_site=self.id_site)
arquivo = arq.addFileTemp(arquivo=imagem_destaque)
cont = self._addFile(arquivo=decode(arquivo)["id"],
id_conteudo=id_conteudo,
schema=self.schema,
dt=dt2)
else:
cont = None
self.execSqlBatch("update_evento",
id_conteudo=int(id_conteudo),
titulo=titulo,
imagemint=id_imagem,
telefones = telefones,
email = email,
data_inicio = data_inicio,
data_fim = data_fim,
hora_inicio = hora_inicio,
hora_fim = hora_fim,
