def post(self, registry_id):
user = self.get_current_user()
url = self.get_argument("url","")
if not url:
self.render("modules/bookmarks/newbookmark-form.html", \
NOMEPAG='favoritos', REGISTRY_ID=registry_id, MSG=u"URL não preenchida")
return
if "://" not in url: url = "http://"+url
bookmark_id = model.Bookmarks.searchIdByUrl(registry_id, url)
if bookmark_id:
self._bookmark = model.Bookmarks().retrieve(bookmark_id)
self._bookmark.editBookmark(user, self.get_argument("title",""),
self.get_argument("description",""),
splitTags(self.get_argument("tags","")))
log.model.log(user, u'alterou um link em favoritos de', objeto=registry_id, tipo="bookmarks")
else:
self._bookmarks = model.Bookmarks()
self._bookmarks.url = url
self._bookmarks.owner = self._bookmarks.alterado_por = user
self._bookmarks.registry_id = registry_id
self._bookmarks.title = self.get_argument("title","")
self._bookmarks.description = self.get_argument("description","")
self._bookmarks.tags = splitTags(self.get_argument("tags",""))
self._bookmarks.data_cri = self._bookmarks.data_alt = str(datetime.now())
self._bookmarks.saveBookmark()
log.model.log(user, u'criou um link em favoritos de', objeto=registry_id, tipo="bookmarks")
url = self.get_argument("url", "")
tipo = self.get_argument("tipo","")
if tipo == "popup":
self.render("popup_msg.html", MSG="Favorito adicionado com sucesso!", REGISTRY_ID=registry_id)
else:
self.redirect("/bookmarks/%s" % registry_id)
def post(self, registry_id, name_id):
user = self.get_current_user()
_va = model.Videoaula().retrieve_by_name_id(registry_id, name_id)
if _va:
old_tags = _va.tags
_va.tags = splitTags(self.get_argument("tags",""))
data_tag = str(datetime.now())
for tag in _va.tags:
if tag not in old_tags:
addTag(tag, registry_id, user, "videoaula", registry_id+"/"+name_id, str_limit(remove_html_tags(_va.titulo), 50), data_tag)
for tag in old_tags:
if tag not in _va.tags:
removeTag(remove_diacritics(tag.lower()), "videoaula", id)
_va.data_alt = str(datetime.now())
_va.alterado_por = user
_va.save()
log.model.log(user, u'alterou uma videoaula de', objeto=registry_id, tipo="videoaula")
self.redirect(r"/videoaula/edit/%s/%s" % (registry_id, name_id))
else:
raise HTTPError(404)
def post(self, registry_id, filename):
user = self.get_current_user()
file_id = '/'.join([registry_id,unquote(filename)])
self._file = model.Studio().retrieve(file_id)
if self._file:
if isAllowedToEditObject(user, self._file.owner, file_id):
self._file.editFile(user, self.get_argument("description",""),
splitTags(self.get_argument("tags","")),
self.get_argument("acesso_publico","S"),
self.get_argument("url",""))
log.model.log(user, u'alterou imagem do studio de games', objeto=file_id, tipo="studio")
self.redirect("/studio/info/%s" % file_id)
else:
self.render("home.html", MSG=u"Você não tem permissão para alterar este arquivo.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=user)
else:
self.render("home.html", MSG=u"Erro: Arquivo inexistente!", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
def post(self, registry_id):
user = self.get_current_user()
glossary_item_id = self.get_argument("item_id","")
glossary_id = registry_id+"/"+glossary_item_id
glossary_definition = self.get_argument("definition","")
self._glossary = model.Glossary().retrieve(glossary_id)
if self._glossary != None:
#if isAllowedToEditObject(user, self._glossary.owner, glossary_id):
if isAllowedToWriteObject(user, "glossary", registry_id):
if not glossary_definition:
MSG = u"A definição do termo não pode estar vazia."
self.render("modules/glossary/glossary_item-edit.html", \
NOMEPAG=NOME_PAG_CLOSSARIO, GLOSSARY=self._glossary,
REGISTRY_ID=registry_id, MSG=MSG)
return
else: # glossary_definition != ""
self._glossary.editGlossaryItem(user, glossary_definition, splitTags(self.get_argument("tags","")))
log.model.log(user, u'alterou um termo do glossário de', objeto=registry_id, tipo="glossary")
self.redirect("/glossary/%s" % registry_id)
else:
self.render("home.html", MSG=u"Você não tem permissão para alterar este termo deste glossário.", \
NOMEPAG=NOME_PAG_CLOSSARIO, REGISTRY_ID=user)
else:
self.render("home.html", MSG=u"Erro: termo inexistente no glossário!", \
NOMEPAG=NOME_PAG_CLOSSARIO, REGISTRY_ID=registry_id)
def post(self, registry_id, post_id):
user = self.get_current_user()
doc_id = '/'.join([registry_id, post_id])
self._blog = model.Blog().retrieve(doc_id)
if self._blog:
msg = ""
self._blog.titulo = self.get_argument("titulo","")
if self._blog.titulo == "":
msg += u"O título do Post não pode ser vazio.<br/>"
old_tags = self._blog.tags
self._blog.tags = splitTags(self.get_argument("tags",""))
self._blog.conteudo = self.get_argument("conteudo","")
if self._blog.conteudo == "":
msg += u"O conteúdo do Post não pode ser vazio.<br/>"
if msg:
self.render("modules/blog/blog-form.html", NOMEPAG="blog", REGISTRY_ID=registry_id, BLOGDATA=self._blog, MSG=msg)
return
else:
data_tag = str(datetime.now())
for tag in self._blog.tags:
if tag not in old_tags:
addTag(tag, registry_id, user, "blog", doc_id, self._blog.titulo, data_tag)
for tag in old_tags:
if tag not in self._blog.tags:
removeTag(remove_diacritics(tag.lower()), "blog", doc_id)
# registro da atualização
self._blog.data_alt = str(datetime.now())
self._blog.alterado_por = user
historico_inicial = dict()
historico_inicial["data_alt"] = self._blog.data_alt
historico_inicial["alterado_por"] = user
historico_inicial["conteudo"] = self._blog.conteudo
self._blog.historico.append(historico_inicial)
# limita o número de versões no histórico em BLOG_HISTORY_SIZE
history_len = len(self._blog.historico)
if history_len > BLOG_HISTORY_SIZE:
inicio = history_len - BLOG_HISTORY_SIZE
self._blog.historico = self._blog.historico[inicio:history_len]
self._blog.save()
log.model.log(user, u'alterou o blog', objeto=doc_id, tipo="blog")
self.redirect("/blog/%s" % doc_id)
else:
self.render("home.html", MSG=u"Post não encontrado: ele pode ter sido removido por outro usuário enquanto você editava-o", REGISTRY_ID=registry_id, NOMEPAG="blog")
return
def post(self, registry_id):
user = self.get_current_user()
self._blog = model.Blog()
msg = ""
self._blog.titulo = self.get_argument("titulo","")
if self._blog.titulo == "":
msg += u"O título do Post não pode ser vazio.<br/>"
else:
self._blog.post_id = remove_special_chars(remove_diacritics(self._blog.titulo.replace(" ","_")))
if self._blog.post_id == "":
msg += u"Título do Post inválido<br/>"
self._blog.tags = splitTags(self.get_argument("tags",""))
self._blog.conteudo = self.get_argument("conteudo","")
if self._blog.conteudo == "":
msg += u"O conteúdo do Post não pode ser vazio.<br/>"
if msg:
self.render("modules/blog/blog-form.html", NOMEPAG="blog", REGISTRY_ID=registry_id, BLOGDATA=self._blog, MSG=msg)
return
else:
self._blog.data_cri = str(datetime.now())
self._blog.data_alt = self._blog.data_cri
# A chave _id do documento no couchdb é nome/pagina
doc_id = '/'.join([registry_id,self._blog.post_id])
self._blog.registry_id = registry_id
self._blog.owner = user
historico_inicial = dict()
historico_inicial["data_alt"] = self._blog.data_alt
historico_inicial["alterado_por"] = user
historico_inicial["conteudo"] = self._blog.conteudo
self._blog.historico.append(historico_inicial)
try:
self._blog.save(id=doc_id)
except Exception as detail:
self.render("modules/blog/blog-form.html", NOMEPAG="blog", REGISTRY_ID=registry_id, BLOGDATA=self._blog, \
MSG=u"Já existe um post com este título.")
return
data_tag = str(datetime.now())
for tag in self._blog.tags:
addTag(tag, registry_id, user, "blog", doc_id, self._blog.titulo, data_tag)
log.model.log(user, u'escreveu no blog', objeto=doc_id, tipo="blog")
self.redirect("/blog/%s" % doc_id)
def post(self, registry_id):
user = self.get_current_user()
msg = ""
_topic = model.Topic()
_topic.titulo = self.get_argument("titulo","")
if _topic.titulo == "":
msg += u"O título do tópico não pode ser vazio.<br/>"
else:
_topic.name_id = remove_special_chars(remove_diacritics(_topic.titulo.replace(" ","_")))
if _topic.name_id == "":
msg += u"Título do tópico inválido<br/>"
if model.Topic.exists(registry_id, _topic.name_id):
msg += u"Já existe um tópico com este nome"
_topic.tags = splitTags(self.get_argument("tags",""))
_topic.conteudo = self.get_argument("conteudo","")
if _topic.conteudo == "":
msg += u"O conteúdo do tópico não pode ser vazio.<br/>"
if msg:
self.render("modules/forum/forum-form.html", NOMEPAG="forum", REGISTRY_ID=registry_id, TOPICO=_topic, MSG=msg)
return
else:
_topic.receber_email = self.get_argument("receber_email", "N")
_topic.data_cri = str(datetime.now())
_topic.data_alt = _topic.data_cri
_topic.service = "forum"
_topic.type = "topic"
doc_id = uuid4().hex
_topic.registry_id = registry_id
_topic.owner = user
_topic.alterado_por = user
try:
_topic.save(id=doc_id)
except Exception as detail:
self.render("modules/forum/forum-form.html", NOMEPAG="forum", REGISTRY_ID=registry_id, TOPICO=_topic, \
MSG=u"Já existe um tópico neste forum com este título.")
return
data_tag = str(datetime.now())
for tag in _topic.tags:
addTag(tag, registry_id, user, "forum", registry_id+"/"+_topic.name_id, _topic.titulo, data_tag)
log.model.log(user, u'criou um tópico no forum', objeto=registry_id, tipo="forum")
self.redirect("/forum/%s" % registry_id)
def post(self, registry_id, pagina):
user = self.get_current_user()
doc_id = '/'.join([registry_id, pagina])
self._wiki = model.Wiki().retrieve(doc_id)
if self._wiki:
msg = ""
conteudo_db = ''
tags_db = []
if self._wiki.rev != self.get_argument("revision",""):
# Document Update Conflict.
msg += u"Conflito ao salvar o documento. Enquanto você editava-o, ele foi alterado por outro usuário.<br/>"
msg += u"Compare as duas versões abaixo e refaça as alterações que ainda achar pertinentes.<br/>"
msg += u"Ao final envie novamente o formulário.<br/>"
# preserva os dados alterados pelo outro usuário
conteudo_db = self._wiki.historico[-1]["conteudo"]
tags_db = self._wiki.tags
if self.get_argument("conteudo","") != "" :
conteudo = self.get_argument("conteudo")
else:
msg += u"Conteúdo não preenchido<br/>"
conteudo = " "
old_tags = self._wiki.tags # preserva tags anteriores
self._wiki.tags = splitTags(self.get_argument("tags","")) # suas tags
if msg:
self.write (dict(status=1, msg=msg))
else:
# registro da atualização
self._wiki.historico.append(dict(
conteudo=conteudo,
data_alt = str(datetime.now()),
alterado_por = user
))
# salva o documento alterado
self._wiki.saveWiki(old_tags=old_tags)
# notifica o dono da página alterada
email_msg = u"Página alterada: "+doc_id+"\n"+\
Notify.assinatura(user, registry_id, self._wiki.historico[-1]["data_alt"])+"\n\n"
Notify.email_notify(self._wiki.owner, user, u"alterou uma página criada por você", \
message=email_msg, \
link="wiki/"+doc_id)
log.model.log(user, u'alterou a página', objeto=doc_id, tipo="wiki")
self.redirect("/wiki/%s" % doc_id)
else:
self.write (dict(status=1, msg=u"Documento não encontrado: provavelmente o mesmo foi removido enquanto você editava-o."))
def post(self, registry_id):
user = self.get_current_user()
_va = model.Videoaula()
msg = ""
_va.titulo = self.get_argument("name","")
if _va.titulo == "":
msg += u"Nome da videoaula não preenchido.<br/>"
_va.arqvideo = self.get_argument("arqvideo","")
if _va.arqvideo == "":
msg += u"Arquivo de vídeo não preenchido.<br/>"
_va.tags = splitTags(self.get_argument("tags",""))
_va.service = "videoaula"
_va.type = "videoaula"
_va.registry_id = registry_id
_va.name_id = remove_special_chars(remove_diacritics(_va.titulo.replace(" ","_")))
if model.Videoaula.exists(_va.registry_id, _va.name_id):
msg += u"Já existe uma videoaula com este nome"
if msg:
self.render("modules/videoaula/videoaula-form.html", NOMEPAG="videoaulas", VIDEODATA=_va, \
FOLDERS = files.model.Files.listFolders(user, registry_id, "files/all_data"), \
REGISTRY_ID=registry_id, MSG=msg)
return
else:
doc_id = uuid4().hex
_va.owner = user
#_va.alterado_por = user
_va.data_cri = str(datetime.now())
_va.data_alt = _va.data_cri
_va.save(id=doc_id)
# Adiciona tags da videoaula ao banco de tags.
data_tag = str(datetime.now())
for tag in _va.tags:
addTag(tag, registry_id, user, "videoaula", registry_id+"/"+_va.name_id, str_limit(remove_html_tags(_va.titulo), 50), data_tag)
log.model.log(user, u'criou videoaula em', objeto=registry_id, tipo="videoaula",link="/videoaula/%s/%s"%(registry_id,_va.name_id))
self.redirect("/videoaula/edit/%s/%s" % (registry_id,_va.name_id))
def post(self, registry_id, topic_id):
user = self.get_current_user()
doc_id = '/'.join([registry_id, topic_id])
_topic = model.Topic.retrieve_by_name_id(registry_id, topic_id)
if _topic:
# somente o dono do tópico pode alterá-lo
if _topic.owner != user:
raise HTTPError(403)
return
msg = ""
_topic.titulo = self.get_argument("titulo","")
if _topic.titulo == "":
msg += u"O título do tópico não pode ser vazio.<br/>"
old_tags = _topic.tags # preserva tags anteriores
_topic.tags = splitTags(self.get_argument("tags",""))
_topic.conteudo = self.get_argument("conteudo","")
if _topic.conteudo == "":
msg += u"O conteúdo do tópico não pode ser vazio.<br/>"
if msg:
self.render("modules/forum/forum-form.html", NOMEPAG="forum", REGISTRY_ID=registry_id, TOPICO=_topic, MSG=msg)
return
else:
_topic.receber_email = self.get_argument("receber_email", "N")
_topic.data_alt = str(datetime.now())
_topic.alterado_por = user
_topic.saveTopic(old_tags=old_tags)
log.model.log(user, u'alterou um tópico no forum', objeto=registry_id, tipo="forum")
self.redirect("/forum/%s/%s" % (registry_id, topic_id))
else:
raise HTTPError(404)
def post(self, registry_id):
user = self.get_current_user()
bookmark_id = self.get_argument("id","")
self._bookmark = model.Bookmarks().retrieve(bookmark_id)
if self._bookmark != None:
#if isAllowedToEditObject(user, self._bookmark.owner, registry_id+"/"+bookmark_id):
if isAllowedToWriteObject(user, "bookmarks", registry_id):
self._bookmark.editBookmark(user, self.get_argument("title",""),
self.get_argument("description",""),
splitTags(self.get_argument("tags","")))
log.model.log(user, u'alterou um link de favoritos de', objeto=registry_id, tipo="bookmarks")
self.redirect("/bookmarks/%s" % registry_id)
else:
raise HTTPError(403)
else:
raise HTTPError(404)
def post(self, registry_id):
user = self.get_current_user()
if not isUserOrMember(user, registry_id):
self.render("home.html", MSG=u"Você não tem permissão para criar termos neste glossário.", \
NOMEPAG=NOME_PAG_CLOSSARIO, REGISTRY_ID=registry_id)
return
MSG = ""
glossary_term = self.get_argument("term","")
if not glossary_term:
MSG += u"Termo não pode ser vazio."
glossary_definition = self.get_argument("definition","")
if not glossary_definition:
MSG += u"%sA definição do termo não pode estar vazia." % ("" if not MSG else "<br/>")
if not MSG:
glossary_item_id = remove_special_chars(remove_diacritics(glossary_term.replace(" ","_")))
if model.Glossary.searchItemByRegistryIdAndItemId(user, registry_id, glossary_item_id, False):
MSG += u"Termo já definido neste glossário."
if MSG:
self.render("modules/glossary/new_glossary_item-form.html", \
NOMEPAG=NOME_PAG_CLOSSARIO, DEFINITION=glossary_definition, REGISTRY_ID=registry_id, MSG=MSG)
return
else:
self._glossary = model.Glossary()
self._glossary.id = '/'.join([registry_id,glossary_item_id])
self._glossary.registry_id = registry_id
self._glossary.owner = user
self._glossary.item_id = glossary_item_id
self._glossary.term = self.get_argument("term","")
self._glossary.definition = glossary_definition
self._glossary.tags = splitTags(self.get_argument("tags",""))
self._glossary.data_cri = self._glossary.data_alt = str(datetime.now())
self._glossary.alterado_por = user
self._glossary.saveGlossaryItem(glossary_item_id)
log.model.log(user, u'criou um termo no glossário de', objeto=registry_id, tipo="glossary")
self.redirect("/glossary/%s" % registry_id)
def post(self, registry_id):
user = self.get_current_user()
if self.request.files:
# este split é para resolver o problema do IE, que manda o caminho completo.
filename = self.request.files["arquivo"][0]["filename"].split("\\")[-1]
filename = remove_diacritics(filename)
filename = filename.replace(" ", "_")
if "." not in filename or filename.split(".")[-1].lower() not in ["gif", "jpg", "jpeg", "png"]:
self.render("home.html", MSG=u"Utilize somente arquivos com extensão: gif, jpg, jpeg ou png.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
return
tipo = ""
if registry_id in core.database.REGISTRY:
if not isUserOrMember(user, registry_id):
self.render("home.html", MSG=u"Você não tem permissão para carregar arquivos aqui.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
return
#if len(self.request.files["arquivo"][0]["body"]) + core.database.REGISTRY[registry_id]["upload_size"] > core.database.REGISTRY[registry_id]["upload_quota"]:
# self.render("home.html", MSG=u"Espaço para armazenamento de arquivos excedido.", \
# NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
# return
# A chave _id do documento no couchdb é nome/arquivo
file_id = '/'.join([registry_id,filename])
self._file = model.Studio().retrieve(file_id)
if self._file:
self.render("home.html", MSG=u"Já existe um arquivo com este mesmo nome. Remova-o antes de subir com uma nova versão.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
return
else:
self._file = model.Studio(file_id=file_id)
if self.get_argument("type","")=="":
self.render("home.html", MSG=u"Escolha a fase onde a imagem deve ser armazenada.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
return
self._file.type = int(self.get_argument("type",""))
self._file.description = self.get_argument("description","")
self._file.url = self.get_argument("url","")
self._file.tags = splitTags(self.get_argument("tags",""))
self._file.owner = self._file.alterado_por = user
self._file.registry_id = registry_id
self._file.data_upload = self._file.data_alt = str(datetime.now())
self._file.filename = filename
if not self._file.saveFile(file_id, self.request.files):
self.render("home.html", MSG=u"Erro na leitura do arquivo de imagem.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
return
log.model.log(user, u'criou imagem no studio de games', objeto=file_id, tipo="studio")
self.redirect("/studio/%s" % registry_id)
else:
self.render("home.html", MSG=u"Usuário ou comunidade inexistentes.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=user)
else:
self.render("home.html", MSG=u"Erro: Arquivo inexistente!", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
def post(self, registry_id):
user = self.get_current_user()
if self.request.files:
# este split é para resolver o problema do IE, que manda o caminho completo.
filename = self.request.files["arquivo"][0]["filename"].split("\\")[-1]
#filename = remove_diacritics(filename)
#filename = filename.replace(" ", "_")
filename = remove_special_chars(remove_diacritics(filename.replace(" ","_")))
if filename=="":
self.write (dict(status=1, msg=u"Nome do arquivo inválido."))
return
if filename[0]=="_":
self.write (dict(status=1, msg=u"Nome do arquivo não pode iniciar com sublinhado (_)."))
return
if "." not in filename or filename.split(".")[-1].lower() not in ["gif", "jpg", "jpeg", "png"]:
self.write (dict(status=1, msg=u"Utilize somente arquivos com extensão: gif, jpg, jpeg ou png."))
return
if registry_id in core.database.REGISTRY:
if not isUserOrMember(user, registry_id):
self.write (dict(status=1, MSG=u"Você não tem permissão para carregar arquivos aqui."))
return
# A chave _id do documento no couchdb é nome/arquivo
file_id = '/'.join([registry_id,filename])
self._file = model.Studio().retrieve(file_id)
if self._file:
self.write (dict(status=1, MSG=u"Já existe um arquivo com este mesmo nome (%s). Remova-o antes de subir com uma nova versão." % file_id))
return
else:
self._file = model.Studio(file_id=file_id)
if self.get_argument("type","")=="":
self.write (dict(status=1, MSG=u"Escolha a fase onde a imagem deve ser armazenada."))
return
self._file.type = int(self.get_argument("type",""))
self._file.description = self.get_argument("description","")
self._file.url = self.get_argument("url","")
self._file.tags = splitTags(self.get_argument("tags",""))
self._file.owner = self._file.alterado_por = user
self._file.registry_id = registry_id
self._file.data_upload = self._file.data_alt = str(datetime.now())
self._file.filename = filename
if not self._file.saveFile(file_id, self.request.files):
self.write (dict(status=1, MSG=u"Erro na leitura do arquivo de imagem. (%s)" %file_id))
return
log.model.log(user, u'criou o arquivo', objeto=file_id, tipo="file")
self.write (dict(status=0, redirect="/studio/%s" % (registry_id)))
else:
self.write (dict(status=1, msg=u"Usuário ou comunidade inexistentes."))
else:
self.write (dict(status=1, msg=u"Erro: Arquivo inexistente!"))
def post(self, registry_id):
msg = ""
user = self.get_current_user()
folder = self.get_argument("parent_folder","")
if folder:
folder_id = registry_id+"/"+folder
self._pai = model.Wiki().retrieve(folder_id)
parent_name = self._pai.nomepag
else:
parent_name = registry_id+"/"
nomepag = self.get_argument("nomepag","")
if nomepag=="":
msg += u"* Nome da página não preenchido<br/>"
nomepag_id = remove_special_chars(remove_diacritics(nomepag.replace(" ","_")))
if nomepag_id=="":
msg += u"* Nome da página inválido<br/>"
doc_id = '/'.join([registry_id,nomepag_id])
if model.Wiki.nomepagExists(registry_id, nomepag) or model.Wiki().retrieve(doc_id):
msg += u"* Já existe uma página ou pasta com este nome<br/>"
self._wiki = model.Wiki()
conteudo = self.get_argument("conteudo","")
if conteudo=="": msg += u"* Conteúdo não preenchido<br/>"
historico = dict(
conteudo=conteudo,
data_alt=str(datetime.now()),
alterado_por = user
)
self._wiki.historico.append(historico)
self._wiki.tags = splitTags(self.get_argument("tags",""))
self._wiki.parent_folder = self.get_argument("parent_folder","")
if self._wiki.parent_folder!="":
parent_id = '/'.join([registry_id,self._wiki.parent_folder])
test_parent_folder = model.Wiki().retrieve(parent_id)
if not test_parent_folder:
msg += u"* Impossível criar página dentro de uma pasta inexistente (%s)<br/>" % parent_id
elif not isAllowedToWriteObject(user, "wiki", registry_id, self._wiki.parent_folder):
msg += u"* Você não tem permissão para criar páginas nesta pasta."
if msg:
self.write (dict(status=1, msg=msg))
else:
self._wiki.nomepag = nomepag
self._wiki.nomepag_id = nomepag_id
self._wiki.user = user
self._wiki.owner = user
self._wiki.registry_id = registry_id
self._wiki.data_cri = self._wiki.historico[-1]["data_alt"]
self._wiki.saveWiki(id=doc_id)
# inclui a página recem criada na lista de filhos do parent_folder
if self._wiki.parent_folder:
parent = model.Wiki().retrieve(registry_id+"/"+self._wiki.parent_folder)
parent.addItemToParent(user, self._wiki.nomepag_id)
log.model.log(user, u'criou a página', objeto=doc_id, tipo="wiki")
self.redirect("/wiki/%s" % doc_id)
