def get(self, registry_id, filename):
user = self.get_current_user()
filename = unquote(filename)
file_data = dict()
file_id = '/'.join([registry_id,filename])
self._file = model.Studio().retrieve(file_id)
if self._file != None:
file_data = self._file.getFileInfo(user, filename)
file_data["apagar"] = isAllowedToDeleteObject(user, file_data["owner"], file_id)
file_data["alterar"] = isAllowedToEditObject(user, file_data["owner"], file_id)
file_data["data_upload"] = short_datetime(file_data["data_upload"])
file_data["data_alt"] = short_datetime(file_data["data_alt"])
file_data["comentar"] = isAllowedToComment(user, file_id, file_data["owner"])
for comentario in file_data["comentarios"]:
comentario["comment"] = comentario["comment"].replace("\r\n", "<br/>")
comentario["apagar"] = isAllowedToDeleteComment(user, registry_id, comentario["owner"])
comentario["data_fmt"] = short_datetime(comentario["data_cri"])
links = []
links.append(("Ver", "/static/imagens/icones/view32.png", "/studio/"+file_id+"?disp=inline&size=G"))
links.append(("Baixar", "/static/imagens/icones/down32.png", "/studio/"+file_id+"?disp=attachment&size=G"))
if isAllowedToEditObject(user, file_data["owner"], file_id):
links.append(("Alterar este arquivo", "/static/imagens/icones/edit32.png", "/studio/edit/"+file_id))
if isAllowedToDeleteObject(user, file_data["owner"], file_id):
links.append(("Remover este arquivo", "/static/imagens/icones/delete32.png", "/studio/delete/"+file_id,
"return confirm('Deseja realmente remover este Arquivo?');"))
self.render("modules/studio/file-info.html", NOMEPAG=u'Estúdio', \
REGISTRY_ID=registry_id, \
LINKS=links, \
FILE=file_data, MSG="")
else:
self.render("home.html", MSG=u"Arquivo não encontrado.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
def searchGlossaryByItemId(self, user, item_id, page, page_size):
glossary = []
for row in database.GLOSSARY.view('glossary/by_item_id', startkey=[item_id], endkey=[item_id, {}], skip=(page-1)*page_size , limit=page_size):
(item_id, registry_id) = row.key
glossary_data = dict()
glossary_data["id"] = glossary_id = registry_id+"/"+item_id
glossary_data["registry_id"] = registry_id
glossary_data["owner"] = row.value["owner"]
glossary_data["item_id"] = item_id
glossary_data["term"] = row.value["term"]
glossary_data["definition"] = row.value["definition"]
glossary_data["tags"] = row.value["tags"]
glossary_data["alterar"] = isAllowedToWriteObject(user, "glossary", registry_id)
glossary_data["apagar"] = glossary_data["alterar"] and isAllowedToDeleteObject(user, row.value["owner"], glossary_id)
glossary_data["data_nofmt"] = row.value["data_alt"]
glossary_data["data_alt"] = short_datetime(row.value["data_alt"])
glossary_data["alterado_por"] = row.value["alterado_por"]
#term_count = _itemIdCount(glossary_data["item_id"])
glossary_data["term_count"] = ""
#if term_count > 1: glossary_data["term_count"] = u"%d usuários definiram este termo" % term_count
glossary.append(glossary_data)
glossary = sorted(glossary, key=itemgetter("data_nofmt"), reverse = True)
return glossary
def searchBookmarksByUrl(self, user, page, page_size, url):
bookmarks = []
# Obtem uma página de resultados no BD
# descending=true para listar os mais recentes primeiro
# como a árvore é percorrida em sentido inverso, endkey é o documento inicial e startkey é o final.
for row in database.BOOKMARKS.view('bookmarks/by_url' ,startkey=[url, {}, {}], endkey=[url], descending="true", skip=(page-1)*page_size , limit=page_size):
(url, data_alt, bookmark_id) = row.key
bookmark_data = dict()
bookmark_data["registry_id"] = row.value["registry_id"]
bookmark_data["owner"] = row.value["owner"]
bookmark_data["description"] = row.value["description"]
bookmark_data["title"] = row.value["title"]
bookmark_data["url"] = row.value["url"]
bookmark_data["tags"] = row.value["tags"]
bookmark_data["id"] = bookmark_id
bookmark_data["alterar"] = isAllowedToWriteObject(user, "bookmarks", row.value["registry_id"])
bookmark_data["apagar"] = bookmark_data["alterar"] and isAllowedToDeleteObject(user, row.value["owner"], row.value["registry_id"]+"/"+bookmark_id)
bookmark_data["data_nofmt"] = row.value["data_alt"]
bookmark_data["data_alt"] = short_datetime(row.value["data_alt"])
bookmark_data["alterado_por"] = row.value["alterado_por"]
bookmark_data["num_comments"] = _strListSize (len(row.value["comentarios"]), u"comentário")
#bookmark_data["url_count"] = _strListSize (_urlCount(bookmark_data["url"]), u"referência", genero='F')
#url_count = _urlCount(bookmark_data["url"])
bookmark_data["url_count"] = ""
#if url_count > 1: bookmark_data["url_count"] = u"%d usuários marcaram esta página" % url_count
bookmarks.append(bookmark_data)
bookmarks = sorted(bookmarks, key=itemgetter("data_nofmt"), reverse = True)
return bookmarks
def prepareTopicos(user, topicos):
prepared_topics = []
for t in topicos:
tmp = dict()
tmp["titulo"] = str_limit(remove_html_tags(t["titulo"]), 120)
tmp["owner"] = t["owner"]
tmp["name_id"] = t["name_id"]
# somente o dono do tópico ou o dono/admins da comunidade podem apagar um tópico
tmp["apagar"] = isAllowedToDeleteObject(user, t["owner"], t["registry_id"]+"/"+t["_id"])
# somente o dono do objeto pode alterar
tmp["alterar"] = (user == t["owner"])
# map/reduce para contar o número de replies do tópico
tmp["num_replies"] = model.Topic.countObjectsByGroup(t["_id"])
# datas formatadas
tmp["data_cri"] = t["data_cri"]
tmp["data_cri_fmt"] = short_datetime(t["data_cri"])
tmp["ultimo_reply"] = t["ultimo_reply"]
tmp["ultimo_reply_fmt"] = short_datetime(tmp["ultimo_reply"]) if tmp["ultimo_reply"] else "-"
prepared_topics.append(tmp)
return prepared_topics
def get (self, registry_id):
# Apagar resposta equivale a limpar sem remover
user = self.get_current_user()
id = self.get_argument("id","")
_reply = model.Reply().retrieve(id)
if not _reply or registry_id != _reply.registry_id:
# chamada inválida (id não existe ou reply não corresponde a um forum do registry_id)
raise HTTPError(404)
return
if isAllowedToDeleteObject(user, _reply.owner, registry_id+"/"+id):
_reply.titulo = "***** Mensagem Removida *****"
_reply.conteudo = ""
_reply.data_alt = str(datetime.now())
_reply.alterado_por = user
_reply.save()
log.model.log(user, u'removeu uma resposta de um tópico do forum', objeto=_reply.registry_id, tipo="forum")
# busca o tópico para recuperar o name_id e poder redirecionar para a página do tópico
_topic = model.Topic().retrieve(_reply.group_id)
if _topic:
self.redirect("/forum/%s/%s" % (_reply.registry_id, _topic.name_id))
else:
self.redirect("/forum/%s" % _reply.registry_id)
else:
raise HTTPError(403)
def prepareReplies(user, replies):
prepared_list = []
i = 0
for obj in replies:
tmp = dict()
tmp.update(obj)
# somente o dono da resposta ou o dono/admins da comunidade podem apagar
tmp["apagar"] = isAllowedToDeleteObject(user, obj["owner"], obj["registry_id"]+"/"+obj["_id"])
# somente o dono do objeto pode alterar
tmp["alterar"] = (user == obj["owner"])
# datas formatadas
tmp["data_cri_fmt"] = short_datetime(obj["data_cri"])
tmp["data_alt_fmt"] = short_datetime(obj["data_alt"])
if i==0:
prepared_list.append(tmp) # retorna primeiro o tópico
else:
prepared_list.insert(1, tmp) # e depois a lista de replies em ordem cronológica inversa
i = i + 1
return prepared_list
def get(self, registry_id, name_id):
user = self.get_current_user()
_va = model.Videoaula.retrieve_by_name_id(registry_id, name_id)
if _va:
va_owner = _va.owner
if not isAllowedToDeleteObject(user, va_owner, registry_id+"/"+name_id):
raise HTTPError(403)
return
va_name = str_limit(remove_html_tags(_va.titulo), 200)
_va.delete()
# notifica o dono da videoaula excluída
email_msg = "Videoaula removida: "+va_name+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(va_owner, user, u"removeu uma videoaula criada por você", \
message=email_msg, \
link="videoaula/"+registry_id)
log.model.log(user, u'removeu uma videoaula de', objeto=registry_id, tipo="videoaula")
self.redirect("/videoaula/%s" % registry_id)
else:
raise HTTPError(404)
def get(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:
bookmark_owner = self._bookmark.owner
if not isAllowedToDeleteObject(user, bookmark_owner, registry_id+"/"+bookmark_id):
raise HTTPError(403)
return
url = self._bookmark.url
self._bookmark.deleteBookmark()
# notifica o dono do arquivo excluído
email_msg = "Favorito removido: "+url+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(bookmark_owner, user, u"removeu um favorito criado por você", \
message=email_msg, \
link="bookmarks/"+registry_id)
log.model.log(user, u'removeu um link de favoritos de', objeto=registry_id, tipo="bookmarks")
self.redirect("/bookmarks/%s" % registry_id)
return
else:
raise HTTPError(404)
def get(self, registry_id):
user = self.get_current_user()
glossary_item_id = self.get_argument("item_id","")
glossary_id = registry_id+"/"+glossary_item_id
self._glossary = model.Glossary().retrieve(glossary_id)
if self._glossary != None:
glossary_owner = self._glossary.owner
if not isAllowedToDeleteObject(user, glossary_owner, glossary_id):
self.render("home.html", MSG=u"Você não tem permissão para remover este termo deste glossário.", \
NOMEPAG=NOME_PAG_CLOSSARIO, REGISTRY_ID=registry_id)
return
term = self._glossary.term
self._glossary.deleteGlossaryItem()
# notifica o dono do arquivo excluído
email_msg = u"Item de glossário removido: "+term+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(glossary_owner, user, u"removeu um termo de glossário criado por você", \
message=email_msg, \
link="glossary/"+registry_id)
log.model.log(user, u'removeu um termo do glossário de', objeto=registry_id, tipo="glossary")
self.redirect("/glossary/%s" % registry_id)
else:
raise HTTPError(404)
def prepareActivities(user, activities):
for a in activities:
a["value"]["titulo"] = str_limit(remove_html_tags(a["value"]["titulo"]), 120)
# somente o dono do tópico ou o dono/admins da comunidade podem apagar um tópico
a["value"]["apagar"] = isAllowedToDeleteObject(user, a["value"]["owner"], a["value"]["registry_id"]+"/"+a["value"]["_id"])
# somente o dono do objeto pode alterar
a["value"]["alterar"] = isAllowedToWriteObject(user, "activity", a["value"]["registry_id"])
return activities
def get(self, registry_id, pagina):
user = self.get_current_user()
versao = self.get_argument("versao","-1")
doc_id = '/'.join([registry_id, pagina])
self._wiki = model.Wiki().retrieve(doc_id, include_removed=True)
if self._wiki and self._wiki.is_folder!="S":
wiki_data = prepareWikiPage(user, self._wiki.getWikiPage(user, versao=int(versao)))
links = []
if user:
links.append(("Ver perfil de "+registry_id, "/static/imagens/icones/profile32.png", "/profile/"+registry_id))
if isFriend(user, registry_id):
#links.append(("Enviar recado", "/static/imagens/icones/scrap32.png", "/scrap/"+registry_id))
if isOnline(registry_id):
links.append((u"Iniciar Chat com "+registry_id, "/static/imagens/icones/talk32.png", "/chat/"+registry_id))
else:
links.append((registry_id+u" não está online. Deixe uma mensagem.", "/static/imagens/icones/nottalk32.png", "/chat/"+registry_id))
elif isAUser(registry_id) and user != registry_id:
self._reg = core.model.Member().retrieve(registry_id)
if user in self._reg.amigos_pendentes:
links.append((u"Já convidado. Aguardando resposta.", "/static/imagens/icones/invited_friend32.png", ""))
elif user in self._reg.amigos_convidados:
links.append(("Aceite convite de "+registry_id, "/static/imagens/icones/add_friend32.png", "/invites"))
else:
links.append(("Adicionar amigo", "/static/imagens/icones/add_friend32.png", "/newfriend?friend="+registry_id))
self._reg_user = core.model.Registry().retrieve(user)
if self._reg_user and "bookmarks" in self._reg_user.getServices:
links.append(bookmarks.model.Bookmarks.createBookmarkLink(user, "http://"+PLATAFORMA_URL+self.request.path))
if isUserOrOwner(user, registry_id):
links.append((u"Ver histórico de versões", "/static/imagens/icones/versions32.png", "/wiki/history/"+doc_id))
if isAllowedToWriteObject(user, "wiki", registry_id, pagina):
links.append((u"Alterar esta página", "/static/imagens/icones/edit32.png", "/wiki/edit/"+doc_id))
if isAllowedToDeleteObject(user, wiki_data["owner"],doc_id, wiki="S"):
links.append((u"Alterar permissões desta página", "/static/imagens/icones/permissions32.png", "/permission/wiki/"+doc_id))
links.append((u"Apagar esta página", "/static/imagens/icones/delete32.png", "/wiki/delete/"+doc_id,\
"return confirm('Deseja realmente apagar esta página?');"))
indice_links = []
if wiki_data["alterar"]:
indice_links.append((u"Editar índice", "/static/imagens/icones/edit16.png", "/wiki/edit/"+registry_id+"/indice"))
self.write (dict(status=0, result=dict(path=self._wiki.getPagePath(), pagina=pagina,
wikidata=wiki_data )))
else:
self.write (dict(status=1, msg=u"Página não encontrada."))
def prepareWikiPage(user, pagina):
# acrescenta permissões para o usuário user e datas formatadas
pagina["apagar"] = isAllowedToDeleteObject(user, pagina["owner"], pagina["pag"], wiki="S")
pagina["alterar"] = isAllowedToWriteObject(user, "wiki", pagina["registry_id"], nomeobj=pagina["nomepag_id"])
pagina["ler"] = isAllowedToReadObject(user, "wiki", pagina["registry_id"], nomeobj=pagina["nomepag_id"])
pagina["data_cri_fmt"] = short_datetime(pagina["data_cri"])
pagina["data_alt_fmt"] = short_datetime(pagina["data_alt"])
pagina["comentar"] = isAllowedToComment(user, pagina["pag"], pagina["owner"])
for comentario in pagina["comentarios"]:
comentario["comment"] = comentario["comment"].replace("\r\n", "<br/>")
comentario["apagar"] = isAllowedToDeleteComment(user, pagina["registry_id"], comentario["owner"])
comentario["data_fmt"] = short_datetime(comentario["data_cri"])
return pagina
def prepareBlogPosts(user, posts, include_removed=False):
for post in posts:
# permissões para remover e alterar um post
post["alterar"] = isAllowedToWriteObject(user, "blog", post["registry_id"])
post["apagar"] = post["alterar"] and isAllowedToDeleteObject(user, post["owner"], post["_id"])
# datas formatadas
post["data_fmt"] = short_datetime(post["data_cri"])
if "data_alt" in post and post["data_alt"]:
post["data_alt"] = short_datetime(post["data_alt"])
post["num_comments"] = model.Blog().retrieve(post["_id"], include_removed).getNumComments()
return sorted(posts, key=itemgetter("data_cri"), reverse=True)
def prepareVideoaulas(user, videoaulas):
for va in videoaulas:
va["titulo"] = str_limit(remove_html_tags(va["titulo"]), 200)
# permissões para remover e alterar uma videoaula
va["alterar"] = isAllowedToWriteObject(user, "videoaula", va["registry_id"], va["name_id"])
va["apagar"] = isAllowedToDeleteObject(user, va["owner"], va["registry_id"]+"/"+va["name_id"])
# datas formatadas
va["data_fmt"] = short_datetime(va["data_cri"])
if "data_alt" in va and va["data_alt"]:
va["data_alt"] = short_datetime(va["data_alt"])
#return sorted(videoaulas, key=itemgetter("data_cri"), reverse=True)
return videoaulas
def get (self, registry_id, name_id):
user = self.get_current_user()
# remove somente o tópico e todas as suas tags.
# todas as respostas ficam no activdb e poderão ser removidas posteriormente pelo dbclean.
_topic = model.Topic().retrieve_by_name_id(registry_id, name_id)
if isAllowedToDeleteObject(user, _topic.owner, registry_id+"/"+name_id):
_topic.deleteTopic()
log.model.log(user, u'removeu um tópico do forum', objeto=registry_id, tipo="forum")
self.redirect("/forum/" + registry_id)
else:
raise HTTPError(403)
def listBookmarks(self, user, registry_id, page, page_size, tag=None):
bookmarks = []
if tag:
view_name = 'bookmarks/by_registry_id_and_tag'
start_key = [registry_id, tag]
end_key = [registry_id, tag, {}, {}]
else:
view_name = 'bookmarks/by_registry_id'
start_key = [registry_id]
end_key = [registry_id, {}, {}]
# Obtem uma página de resultados no BD
# descending=true para listar os mais recentes primeiro
# como a árvore é percorrida em sentido inverso, endkey é o documento inicial e startkey é o final.
for row in database.BOOKMARKS.view(view_name, startkey=end_key,endkey=start_key, descending="true", skip=(page-1)*page_size , limit=page_size):
if tag:
(registry_id, tag_found, data_alt, bookmark_id) = row.key
else:
(registry_id, data_alt, bookmark_id) = row.key
bookmark_data = dict()
bookmark_data["registry_id"] = registry_id
bookmark_data["owner"] = row.value["owner"]
bookmark_data["description"] = row.value["description"]
bookmark_data["title"] = row.value["title"]
bookmark_data["url"] = row.value["url"]
bookmark_data["tags"] = row.value["tags"]
bookmark_data["id"] = bookmark_id
# _file = Files().retrieve(file_id)
bookmark_data["alterar"] = isAllowedToWriteObject(user, "bookmarks", registry_id)
bookmark_data["apagar"] = bookmark_data["alterar"] and isAllowedToDeleteObject(user, row.value["owner"], registry_id+"/"+bookmark_id)
bookmark_data["data_nofmt"] = row.value["data_alt"]
bookmark_data["data_alt"] = short_datetime(row.value["data_alt"])
bookmark_data["alterado_por"] = row.value["alterado_por"]
bookmark_data["num_comments"] = _strListSize (len(row.value["comentarios"]), u"comentário")
#bookmark_data["url_count"] = _strListSize (url_count, u"referência", genero='F')
url_count = _urlCount(bookmark_data["url"])
bookmark_data["url_count"] = ""
if url_count > 1: bookmark_data["url_count"] = u"%d usuários marcaram esta página" % url_count
bookmarks.append(bookmark_data)
return bookmarks
def listGlossary(self, user, registry_id, page, page_size, tag=None):
glossary = []
if tag:
view_name = 'glossary/by_registry_id_and_tag'
start_key = [registry_id, tag]
end_key = [registry_id, tag, {}]
else:
view_name = 'glossary/by_registry_id'
start_key = [registry_id]
end_key = [registry_id, {}]
# Obtem uma página de resultados no BD
for row in database.GLOSSARY.view(view_name, startkey=start_key, endkey=end_key, skip=(page-1)*page_size , limit=page_size):
if tag:
(registry_id, tag_found, glossary_item_id) = row.key
else:
(registry_id, glossary_item_id) = row.key
glossary_data = dict()
glossary_data["id"] = glossary_id = registry_id+"/"+glossary_item_id
glossary_data["registry_id"] = registry_id
glossary_data["owner"] = row.value["owner"]
glossary_data["item_id"] = glossary_item_id
glossary_term = glossary_data["term"] = row.value["term"]
glossary_data["key_to_compare"] = remove_diacritics(" ".join(glossary_term.lower().split()))
glossary_data["definition"] = row.value["definition"]
glossary_data["tags"] = row.value["tags"]
# _file = Files().retrieve(file_id)
glossary_data["alterar"] = isAllowedToWriteObject(user, "glossary", registry_id)
glossary_data["apagar"] = glossary_data["alterar"] and isAllowedToDeleteObject(user, row.value["owner"], glossary_id)
glossary_data["data_nofmt"] = row.value["data_alt"]
glossary_data["data_alt"] = short_datetime(row.value["data_alt"])
glossary_data["alterado_por"] = row.value["alterado_por"]
#glossary_data["term_count"] = _strListSize (term_count, u"referência", genero='F')
term_count = _itemIdCount(glossary_data["item_id"])
glossary_data["term_count"] = ""
if term_count > 1: glossary_data["term_count"] = u"%d usuários definiram este termo" % term_count
glossary.append(glossary_data)
glossary = sorted(glossary, key=itemgetter("key_to_compare"), reverse = False)
return glossary
def get (self, registry_id, name_id):
user = self.get_current_user()
_va = model.Videoaula().retrieve_by_name_id(registry_id, name_id)
if _va:
ext = _va.arqvideo.split(".")[-1]
links = []
if isUserOrOwner(user, registry_id) or user == objectOwnerFromService("videoaula", registry_id, name_id):
links.append((u"Alterar permissões desta videoaula", "/static/imagens/icones/permissions32.png", "/permission/videoaula/"+registry_id+"/"+name_id, "", "", True))
if isAllowedToDeleteObject(user, _va.owner, registry_id+"/"+name_id):
links.append(("Remover esta videoaula", "/static/imagens/icones/delete32.png", "/videoaula/delete/"+registry_id+"/"+name_id,
"return confirm('Deseja realmente remover esta videoaula?');"))
self.render("modules/videoaula/videoaula-edit.html", NOMEPAG="videoaulas", VIDEODATA=_va, \
FOLDERS = files.model.Files.listFolders(user, registry_id, "files/all_data"), \
SORTEDKEYS=sortedKeys, MIME_TYPE=mime_types[ext],
LINKS=links, \
REGISTRY_ID=registry_id, MSG="")
else:
raise HTTPError(404)
def prepareFolderPages(user, paginas, registry_type, privacidade):
# chamadas:
# only_removed = False
# /wiki/%s -> lista pastas e páginas não removidas do registry_id
# only_removed = True
# /wiki/deleted/%s -> lista todas as páginas removidas
sel_multipla = False
for pagina in paginas:
pagina["data_nofmt"] = pagina["data_alt"]
pagina["data_alt"] = short_datetime(pagina["data_nofmt"], include_year=True)
pagina["apagar"] = isAllowedToDeleteObject(user, pagina["owner"], pagina["doc_id"], wiki="S")
pagina["alterar"] = isAllowedToWriteObject(user, "wiki", pagina["registry_id"], nomeobj=pagina["nomepag_id"])
pagina["ler"] = isAllowedToReadObject(user, "wiki", pagina["registry_id"], nomeobj=pagina["nomepag_id"])
parent_id = pagina["registry_id"]+"/"+pagina["parent_folder"]
parent = model.Wiki().retrieve(parent_id)
# Vc só pode mover um item para uma pasta se:
# vc pode apagar o item e o dono da pasta permite que vc crie items nela.
pagina["mover"] = pagina["apagar"]
if parent:
pagina["mover"] = pagina["mover"] and isAllowedToWriteObject(user, "wiki", pagina["registry_id"], pagina["parent_folder"])
# se houver pelo menos um checkbox, ativa seleção múltipla
if pagina["alterar"] and pagina["mover"] and pagina["nomepag_id"] not in ["home", "indice"]:
sel_multipla = True
# obtem permissões da página
_perm = permission.model.Permission().retrieve("wiki/"+pagina["doc_id"])
if _perm:
pagina["escrita"] = _perm.escrita
pagina["leitura"] = _perm.leitura
else:
pagina["escrita"] = permission.model.default_permission("W", "wiki", registry_type, privacidade)
pagina["leitura"] = permission.model.default_permission("R", "wiki", registry_type, privacidade)
#paginas = sorted(paginas, key=itemgetter("data_nofmt"), reverse = True)
return (sel_multipla, paginas)
def get(self, registry_id, id):
user = self.get_current_user()
_object = model.Activity().retrieve(id)
if _object :
_object_owner = _object.owner
if not isAllowedToDeleteObject(user, _object_owner, registry_id+"/"+id):
raise HTTPError(403)
elif _object.type == "activity" :
_object.delete()
log.model.log(user, u'removeu uma atividade de', objeto=registry_id, tipo="activity", link="/activity/%s"%registry_id)
self.redirect("/activity/%s" % registry_id)
return
elif _object.type == "group" and not model.Group().countObjectsByGroup(id):
_object.delete()
log.model.log(user, u'removeu um grupo de atividades de', objeto=registry_id, tipo="activity", link="/activity/%s"%registry_id)
self.redirect("/activity/%s" % registry_id)
else:
raise HTTPError(404)
def get(self, registry_id, pagina):
user = self.get_current_user()
if pagina in ["home", "indice"]:
self.write (dict(status=1, msg=u"Esta página não pode ser removida."))
else:
doc_id = '/'.join([registry_id, pagina])
self._wiki = model.Wiki().retrieve(doc_id)
if self._wiki:
# salva variáveis para poder ter acesso a elas depois de remover do banco
nomepag = self._wiki.nomepag
owner = self._wiki.owner
is_folder = self._wiki.is_folder
legenda = "pasta" if self._wiki.is_folder=="S" else u"página"
if isAllowedToDeleteObject(user, self._wiki.owner, doc_id, wiki="S"):
if self._wiki.is_folder=="S" and self._wiki.folder_items!=[]:
self.write (dict(status=1, msg=u"Você não pode apagar uma pasta que não esteja vazia."))
return
parent_folder = self._wiki.parent_folder
self._wiki.deleteWiki(user)
# notifica o dono da página excluída
email_msg = legenda + u" removida: "+doc_id+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(owner, user, u"removeu uma %s criada por você"%legenda, \
message=email_msg, \
link="wiki/"+registry_id)
if is_folder=="S":
log.model.log(user, u'removeu a pasta', objeto=registry_id+"/"+nomepag, tipo="none")
else:
log.model.log(user, u'removeu a página', objeto=doc_id, tipo="none")
self.redirect("/wiki/%s?folder=%s" % (registry_id, parent_folder) )
else:
self.write (dict(status=1, msg=u"Você não tem permissão para remover esta %s."%legenda))
else:
self.write (dict(status=1, msg=u"Pasta/página não encontrada."))
def post(self, registry_id):
user = self.get_current_user()
items = self.request.arguments["items"] # items é uma lista
folder = self.get_argument("folder", "")
for item in items:
if item in ["home", "indice"]:
continue
doc_id = '/'.join([registry_id, item])
self._wiki = model.Wiki().retrieve(doc_id)
if self._wiki:
# salva variáveis para poder ter acesso a elas depois de remover do banco
nomepag = self._wiki.nomepag
owner = self._wiki.owner
is_folder = self._wiki.is_folder
legenda = "pasta" if self._wiki.is_folder=="S" else u"página"
if isAllowedToDeleteObject(user, self._wiki.owner, doc_id, wiki="S"):
if self._wiki.is_folder=="S" and self._wiki.folder_items!=[]:
# Você não pode apagar uma pasta que não esteja vazia.
continue
parent_folder = self._wiki.parent_folder
self._wiki.deleteWiki(user)
# notifica o dono da página excluída
email_msg = legenda + u" removida: "+doc_id+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(owner, user, u"removeu uma %s criada por você"%legenda, \
message=email_msg, \
link="wiki/"+registry_id)
#log.model.log(user, u'removeu a '+legenda, objeto=doc_id, tipo="none")
if is_folder=="S":
log.model.log(user, u'removeu a pasta', objeto=registry_id+"/"+nomepag, tipo="none")
else:
log.model.log(user, u'removeu a página', objeto=doc_id, tipo="none")
self.redirect("/wiki/%s?folder=%s" % (registry_id, folder) )
def get(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 != None:
if registry_id in core.database.REGISTRY:
file_owner = self._file.owner
if not isAllowedToDeleteObject(user, file_owner, file_id):
self.render("home.html", MSG=u"Você não tem permissão para remover este arquivo.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
return
(error, detail) = self._file.deleteFile()
if error:
self.render("home.html", MSG=u"Erro: %s" % detail, \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
return
# notifica o dono do arquivo excluído
email_msg = "Arquivo removido: "+file_id+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(file_owner, user, u"removeu uma imagem na studio de games", \
message=email_msg, \
link="studio/"+registry_id)
log.model.log(user, u'removeu a imagem no studio de games', objeto=file_id, tipo="none")
self.redirect("/studio/%s" % registry_id)
return
else:
msg = u"Usuário ou comunidade inexistentes."
self.render("home.html", MSG=msg, \
NOMEPAG=u'Estúdio', REGISTRY_ID=user)
else:
self.render("home.html", MSG=u"Arquivo não encontrado.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
def searchItemByRegistryIdAndItemId(self, user, registry_id, item_id, pode_modificar=False):
glossary = []
view_name = 'glossary/by_registry_id_and_item_id'
start_key = [registry_id, item_id]
end_key = [registry_id, item_id, {}]
for row in database.GLOSSARY.view(view_name,startkey=start_key,endkey=end_key):
(registry_id, glossary_item_id) = row.key
glossary_data = dict()
glossary_data["id"] = glossary_id = registry_id+"/"+glossary_item_id
glossary_data["registry_id"] = registry_id
glossary_data["owner"] = row.value["owner"]
glossary_data["item_id"] = glossary_item_id
glossary_data["term"] = row.value["term"]
glossary_data["definition"] = row.value["definition"]
glossary_data["tags"] = row.value["tags"]
# _file = Files().retrieve(file_id)
if pode_modificar:
glossary_data["alterar"] = isAllowedToWriteObject(user, "glossary", registry_id)
glossary_data["apagar"] = glossary_data["alterar"] and isAllowedToDeleteObject(user, row.value["owner"], glossary_id)
else:
glossary_data["apagar"] = glossary_data["alterar"] = False
glossary_data["data_nofmt"] = row.value["data_alt"]
glossary_data["data_alt"] = short_datetime(row.value["data_alt"])
glossary_data["alterado_por"] = row.value["alterado_por"]
#glossary_data["term_count"] = _strListSize (term_count, u"referência", genero='F')
term_count = _itemIdCount(glossary_data["item_id"])
glossary_data["term_count"] = ""
if term_count > 1: glossary_data["term_count"] = u"%d usuários definiram este termo" % term_count
glossary.append(glossary_data)
return glossary
def get (self, registry_id, post_id):
user = self.get_current_user()
doc_id = "/".join([registry_id, post_id])
versao = self.get_argument("versao","-1")
self._blog = model.Blog().retrieve(doc_id, include_removed=True)
if self._blog:
post_data = prepareBlogPost(user, self._blog.getBlogPost(user, versao=int(versao)))
links = []
links.append(("Blog de "+registry_id, "/static/imagens/icones/back32.png", "/blog/"+registry_id))
if user:
reg = core.model.Registry().retrieve(user)
if reg and "bookmarks" in reg.getServices:
links.append(bookmarks.model.Bookmarks.createBookmarkLink(user, "http://"+PLATAFORMA_URL+self.request.path))
if isAllowedToWriteObject(user, "blog", registry_id):
links.append(("Alterar este post", "/static/imagens/icones/edit32.png", "/blog/edit/"+doc_id))
if isUserOrOwner(user, registry_id):
links.append(("Ver histórico de versões", "/static/imagens/icones/versions32.png", "/blog/history/"+doc_id))
if isAllowedToDeleteObject(user, post_data["owner"], doc_id) and versao == "-1":
links.append(("Remover este post", "/static/imagens/icones/delete32.png", "/blog/delete/"+doc_id,
"return confirm('Deseja realmente remover este Post?');"))
log.model.log(user, u'acessou o post', objeto=post_id, tipo="blog", news=False)
self.render("modules/blog/post.html", NOMEPAG="blog", POST_DATE=full_week_date(post_data["data_cri_nofmt"]), \
REGISTRY_ID=registry_id, \
ARCHIVE=model.Blog.get_blog_archive(registry_id), \
SORTEDKEYS=sortedKeys, MESES=_meses, \
POST=post_data, \
LINKS=links)
else:
raise HTTPError(404)
def listStudioFiles(self, user, registry_id, type):
def _strListSize(values_list, str):
plural = lambda x: 's' if x!=1 else ''
if values_list:
return u"%d %s%s" % (len(values_list), str, plural(len(values_list)))
else:
return u"nenhum %s" % str
files = []
i = 0
for row in database.STUDIO.view('studio/all_data',startkey=[registry_id],endkey=[registry_id, {}]):
if row.value["type"] == type:
(registry_id, file_id) = row.key
file_data = dict()
file_data["registry_id"] = registry_id
file_data["owner"] = row.value["owner"]
file_data["acesso_publico"] = row.value["acesso_publico"]
file_data["description"] = row.value["description"]
file_data["url"] = row.value["url"]
#file_data["tags"] = row.value["tags"]
file_data["file_id"] = file_id
# _file = Studio().retrieve(file_id)
file_data["apagar"] = isAllowedToDeleteObject(user, row.value["owner"], file_id)
file_data["alterar"] = isAllowedToEditObject(user, row.value["owner"], file_id)
file_data["data_nofmt"] = row.value["data_alt"]
file_data["data_alt"] = short_datetime(row.value["data_alt"])
file_data["alterado_por"] = row.value["alterado_por"]
file_data["num_comments"] = _strListSize (row.value["comentarios"], u"comentário")
file_data["i"] = i
i = i + 1
files.append(file_data)
files = sorted(files, key=itemgetter("data_nofmt"), reverse = True)
return files
def get(self, registry_id, id):
user = self.get_current_user()
_quiz = model.Quiz().retrieve(id)
if _quiz != None:
quiz_owner = _quiz.owner
if not isAllowedToDeleteObject(user, quiz_owner, registry_id+"/"+id):
raise HTTPError(403)
if _quiz.deleteQuiz():
log.model.log(user, u'removeu um quiz de', objeto=registry_id, tipo="quiz")
self.redirect("/quiz/%s" % registry_id)
return
else:
self.render("home.html", MSG=u"Este quiz não pode ser apagado pois ele já foi respondido.", \
NOMEPAG=u'Quiz', REGISTRY_ID=registry_id)
else:
self.redirect("/quiz/%s" % registry_id)
def get(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:
if isAllowedToDeleteObject(user, self._blog.owner, doc_id):
try:
tags = self._blog.tags
self._blog.deletePost(user)
#for tag in tags:
# removeTag(remove_diacritics(tag.lower()), "blog", doc_id)
except Exception as detail:
self.render("home.html", MSG=u"Erro: %s" % detail, REGISTRY_ID=registry_id, NOMEPAG="blog")
return
log.model.log(user, u'removeu o post', objeto=doc_id, tipo="none")
self.redirect("/blog/%s" %registry_id)
else:
raise HTTPError(403)
else:
raise HTTPError(404)