def prepareQuiz(user, quiz_list):
for quiz in quiz_list:
#quiz["titulo"] = str_limit(remove_html_tags(quiz["titulo"]), 200)
#quiz["descricao"] = str_limit(remove_html_tags(quiz["descricao"]), 200)
quiz["descricao"] = quiz["descricao"].replace("\n", "<br/>")
# permissões para remover e alterar um quiz
quiz["apagar"] = isAllowedToWriteObject(user, "quiz", quiz["registry_id"], quiz["_id"]) and not model.Quiz.quizIsAnswered(quiz["_id"])
quiz["alterar"] = isAllowedToWriteObject(user, "quiz", quiz["registry_id"], quiz["_id"])
# tipo do quiz em extenso
quiz["tipo"] = TIPO_QUIZ[quiz["subtype"]]
# datas formatadas
quiz["data_fmt"] = short_datetime(quiz["data_cri"])
if "data_alt" in quiz and quiz["data_alt"]:
quiz["data_alt"] = short_datetime(quiz["data_alt"])
# condição para permitir que o quiz seja respondido
dentro_do_periodo = verificaIntervaloDMY(quiz["data_inicio"], quiz["data_fim"]) == 0
ja_respondeu = model.Quiz.getQuizAnswers(quiz["_id"], user)
quiz["nao_pode_responder"] = (ja_respondeu and ja_respondeu["finalizado"]=="S") or \
not dentro_do_periodo or \
not isAllowedToReadObject(user, "quiz", quiz["registry_id"])
return sorted(quiz_list, key=itemgetter("data_cri"), reverse=True)
def get (self, registry_id):
user = self.get_current_user()
folder = self.get_argument("folder","")
if folder:
folder_id = registry_id+"/"+folder
self._pai = model.Wiki().retrieve(folder_id)
parent_name = self._pai.nomepag
if not isAllowedToWriteObject(user, "wiki", registry_id, folder):
self.write (dict(status=1, msg=u"Você não tem permissão para criar páginas nesta pasta."))
return
else:
parent_name = registry_id+"/"
self._wiki = model.Wiki(parent_folder=folder)
form = dict(
action="",
nomepag=dict(type="@text",value=""),
tags=dict(type="@text",value=""),
parent_name=dict(type="@text",value=registry_id+"/"),
conteudo=dict(type="@textarea", value="")
)
self.write (dict(status=0, result=form))
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 get(self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
letra = self.get_argument("letra","")
glossary = model.Glossary.listGlossary(user, registry_id, page, NUM_MAX_ITENS_GLOSSARIO)
glossary_count = model.Glossary.countGlossaryByRegistryId(registry_id)
tags_list = model.Glossary.listAllTags(registry_id)
links = []
if isAllowedToWriteObject(user, "glossary", registry_id):
links.append((u"Criar novo termo", "/static/imagens/icones/new32.png", "/glossary/new/"+registry_id))
if isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões deste Glossário", "/static/imagens/icones/permissions32.png", "/permission/glossary/"+registry_id, "", "", True))
log.model.log(user, u'acessou o glossário de', objeto=registry_id, tipo="glossary", news=False)
self.render("modules/glossary/glossary-list.html", NOMEPAG=NOME_PAG_CLOSSARIO, \
REGISTRY_ID=registry_id, CRIAR=isUserOrMember(user,registry_id), \
TAG=None, LINKS=links, \
FOTO=False, \
GLOSSARY=glossary, GLOSSARY_COUNT=glossary_count, \
TAGS_LIST = tags_list , \
PAGE=page, PAGESIZE=NUM_MAX_ITENS_GLOSSARIO, \
TITLE=u"Glossário de %s"%registry_id, \
MSG="")
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 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 get(self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
bookm_count = model.Bookmarks.countBookmarksByRegistryId(registry_id)
# Se forem todas as tags da página mostrada
#(bookmarks, tags_list) = model.Bookmarks.listBookmarks(user, registry_id, page, NUM_MAX_FAVORITOS, all_tags=False)
# Se forem todas as tags
bookmarks = model.Bookmarks.listBookmarks(user, registry_id, page, NUM_MAX_FAVORITOS)
tags_list = model.Bookmarks.listAllTags(registry_id)
links = []
if isAllowedToWriteObject(user, "bookmarks", registry_id):
links.append((u"Criar novo favorito", "/static/imagens/icones/new32.png", "/bookmarks/new/"+registry_id))
if isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões dos Favoritos", "/static/imagens/icones/permissions32.png", "/permission/bookmarks/"+registry_id, "", "", True))
log.model.log(user, u'acessou os favoritos de', objeto=registry_id, tipo="bookmarks", news=False)
self.render("modules/bookmarks/bookmarks-list.html", NOMEPAG='favoritos', \
REGISTRY_ID=registry_id, CRIAR=isUserOrMember(user,registry_id), \
TAG=None, LINKS=links, \
FOTO=False, \
BOOKMARKS=bookmarks, BOOKM_COUNT=bookm_count, \
TAGS = tags_list, \
PAGE=page, PAGESIZE=NUM_MAX_FAVORITOS, \
TITLE="Favoritos de %s"%registry_id, \
MSG="")
def get (self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
ordem = self.get_argument("ordem","0")
tag = self.get_argument("tag","")
if tag:
topics_count = model.Topic.countObjectsByRegistryIdTags(registry_id, tag)
topics_list = prepareTopicos(user, model.Topic.listForumTopics(registry_id, page, NUM_MAX_TOPICOS, ordem, tag))
else:
topics_count = model.Topic.countObjectsByRegistryId(registry_id)
topics_list = prepareTopicos(user, model.Topic.listForumTopics(registry_id, page, NUM_MAX_TOPICOS, ordem))
tags_list = model.Topic.listAllTags(registry_id)
links = []
if isAllowedToWriteObject(user, 'forum', registry_id):
links.append((u"Novo tópico", "/static/imagens/icones/new32.png", "/forum/newtopic/"+registry_id))
if isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões deste forum", "/static/imagens/icones/permissions32.png", "/permission/forum/"+registry_id, "", "", True))
if ordem == "1":
links.append(("Exibir mais recentes primeiro", "/static/imagens/icones/descending32.png", "/forum/"+registry_id+"?ordem=0"))
else:
links.append(("Exibir mais antigos primeiro", "/static/imagens/icones/ascending32.png", "/forum/"+registry_id+"?ordem=1"))
log.model.log(user, u'acessou o forum', objeto=registry_id, tipo="forum", news=False)
self.render("modules/forum/forum-list.html", NOMEPAG='forum', \
REGISTRY_ID=registry_id, \
TOPICOS=topics_list, TOPICOS_COUNT=topics_count, \
PAGE=page, PAGESIZE=NUM_MAX_TOPICOS, \
ORDEM=ordem, \
TITULO=u"Forum de %s" % registry_id if not tag else u"Forum de %s com a tag %s" % (registry_id, tag), \
TAGS = tags_list, \
LINKS=links)
def get (self, registry_id):
user = self.get_current_user()
mes = self.get_argument("mes","")
ano = self.get_argument("ano","")
events_data = {}
if registry_id in database.AGENDA:
if mes:
if not ano:
ano = date.today().year
ano_mes = "%04d%02d" % (int(ano), int(mes))
if ano_mes in database.AGENDA[registry_id]["events"]:
events_data[ano_mes] = database.AGENDA[registry_id]["events"][ano_mes]
else:
if ano:
for item in database.AGENDA[registry_id]["events"]:
if item[0:4] == ano:
events_data[item] = database.AGENDA[registry_id]["events"][item]
else:
events_data = database.AGENDA[registry_id]["events"]
links = []
if core.model.isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões desta agenda", "/static/imagens/icones/permissions32.png", "/permission/agenda/"+registry_id, "", "", True))
log.model.log(user, u'acessou a agenda de', objeto=registry_id, tipo="agenda", news=False)
self.render("modules/agenda/events.html", REGISTRY_ID=registry_id, EVENTS=events_data, MSG="", NOMEPAG='agenda', \
LINKS=links, \
ALTERAR=isAllowedToWriteObject(user, "agenda", registry_id))
def get (self, registry_id):
#hora_inicio = datetime.now()
#print "inicio=", hora_inicio
user = self.get_current_user()
_atividades = prepareActivities(user, model.Activity().listActivities(registry_id))
#print "prepareActivities=", datetime.now()
groupIsfilled = model.Group().GroupIsFilled(registry_id)
#print "GroupIsFilled=", datetime.now()
links = []
if isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões", "/static/imagens/icones/permissions32.png", "/permission/activity/"+registry_id, "", "", True))
if user == registry_id:
links.append((u"Atividades pendentes de "+registry_id, "/static/imagens/icones/pendent_activity32.png", "/activity/pendent/"+registry_id, "", "", False))
log.model.log(user, u'acessou as atividades de', objeto=registry_id, tipo="activity", link="/activity/%s"%registry_id, news=False)
#print "links=", datetime.now()
self.render("modules/activity/activity-list.html", NOMEPAG=u"atividades", \
GROUPISFILLED = groupIsfilled, \
ADMIN = isAllowedToWriteObject(user, "activity", registry_id) , \
LINKS=links, \
ATIVIDADES=_atividades, REGISTRY_ID=registry_id, MSG="")
def get (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 == None:
raise HTTPError(404)
return
lista = prepareReplies(user, model.Topic.listObjectByGroup(registry_id, _topic.id))
links=[]
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))
#links.append((u"Retornar aos tópicos", "/static/imagens/icones/back32.png", "/forum/"+registry_id))
if isAllowedToWriteObject(user, 'forum', registry_id):
links.append(("Responder", "/static/imagens/icones/reply32.png", "/forum/reply/"+doc_id))
log.model.log(user, u'acessou um tópico do forum', objeto=doc_id, tipo="forum", news=False)
self.render("modules/forum/topic.html", NOMEPAG='forum', \
REGISTRY_ID=registry_id, USER=user, \
LINKS=links, \
LISTA=lista, TOPIC_ID=topic_id)
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 post(self, registry_id):
msg = ""
user = self.get_current_user()
nomepag = self.get_argument("nomepag","")
if nomepag=="":
msg += u"* Nome de pasta não preenchido<br/>"
elif model.Wiki.nomepagExists(registry_id, nomepag):
msg += u"* Já existe uma página ou pasta com este nome<br/>"
self._wiki = model.Wiki(nomepag=nomepag)
self._wiki.is_folder = "S"
parent_folder = self.get_argument("parent_folder","")
if parent_folder!="":
parent_id = '/'.join([registry_id,parent_folder])
test_parent_folder = model.Wiki().retrieve(parent_id)
if not test_parent_folder:
msg += u"* Impossível criar pasta em baixo de uma pasta inexistente (%s)<br/>" % parent_id
elif not isAllowedToWriteObject(user, "wiki", registry_id, parent_folder):
msg += u"* Você não tem permissão para criar páginas nesta pasta."
self._wiki.parent_folder = parent_folder
#self._wiki.tags = splitTags(self.get_argument("tags",""))
if msg:
if parent_folder:
self._pai = model.Wiki().retrieve(registry_id+"/"+parent_folder)
parent_name = self._pai.nomepag
else:
parent_name = registry_id+"/"
self.write (dict(status=1, msg=msg))
else:
nomepag_id = uuid4().hex
doc_id = '/'.join([registry_id,nomepag_id])
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 = str(datetime.now())
self._wiki.alterado_por = user
self._wiki.data_alt = self._wiki.data_cri
self._wiki.saveWiki(id=doc_id)
# inclui a pasta recem criada na lista de filhos do pai
if parent_folder:
parent = model.Wiki().retrieve(registry_id+"/"+parent_folder)
parent.addItemToParent(user, self._wiki.nomepag_id)
log.model.log(user, u'criou a pasta', objeto=registry_id+"/"+self._wiki.nomepag, link="/wiki/%s?folder=%s"%(registry_id,nomepag_id), tipo="wiki")
self.redirect("/wiki/%s?folder=%s" % (registry_id, parent_folder))
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, 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 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 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 get (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:
if isAllowedToWriteObject(user, "wiki", registry_id, pagina):
folders = [f for f in model.Wiki.listWikiFolders(registry_id) if f not in self._wiki.getDescendentsList()]
self.write (dict(status=0, result=dict(pagina=pagina, path=self._wiki.getPagePath(links=False),
e_usuario=isAUser(registry_id), e_owner=isOwner(user, registry_id),folders=folders)))
else:
self.write (dict(status=1, msg=u"Você não tem permissão para alterar esta página."))
else:
self.write (dict(status=1, msg=u"Documento não encontrado."))
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):
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.render("modules/bookmarks/bookmark-edit.html", \
NOMEPAG='favoritos', REGISTRY_ID=registry_id, \
BOOKMARK=self._bookmark, MSG="")
else:
raise HTTPError(403)
else:
raise HTTPError(404)
def get (self, registry_id):
user = self.get_current_user()
_atividades = prepareActivities(user, model.Activity().listfinalizedByRegistry_id(registry_id))
groupIsfilled = model.Group().GroupIsFilled(registry_id, True)
if _atividades:
log.model.log(user, u'acessou as atividades finalizadas de', objeto=registry_id, tipo="activity", link="/activity/%s"%registry_id, news=False)
self.render("modules/activity/activity-finalized.html", NOMEPAG=u"atividades", \
ADMIN = isAllowedToWriteObject(user, "activity", registry_id) , \
GROUPISFILLED = groupIsfilled, \
ATIVIDADES=_atividades, REGISTRY_ID=registry_id, MSG="")
else:
raise HTTPError(404)
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 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:
#if isAllowedToEditObject(user, self._glossary.owner, glossary_id):
if isAllowedToWriteObject(user, "glossary", registry_id):
self.render("modules/glossary/glossary_item-edit.html", \
NOMEPAG=NOME_PAG_CLOSSARIO, REGISTRY_ID=registry_id, \
GLOSSARY=self._glossary, MSG="")
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):
user = self.get_current_user()
old_parent = self.get_argument("folder","")
items = self.request.arguments["items"]
new_parent = self.get_argument("destino","")
if new_parent!="":
parent_id = '/'.join([registry_id,new_parent])
test_parent_folder = model.Wiki().retrieve(parent_id)
if not test_parent_folder:
msg = u"Impossível mover objetos para pasta inexistente (%s)<br/>" % test_parent_folder.nomepag
self.write (dict(status=1, msg=msg))
return
elif not isAllowedToWriteObject(user, "wiki", registry_id, new_parent):
msg = u"Você não tem permissão para mover objetos para esta pasta."
self.write (dict(status=1, msg=msg))
return
for item in items:
doc_id = registry_id+"/"+item
self._wiki = model.Wiki().retrieve(doc_id)
old_path = self._wiki.getPagePath(links=False, includefolder=False)
self._wiki.moveWiki (registry_id, user, old_parent, new_parent)
new_path = self._wiki.getPagePath(links=False, includefolder=False)
legenda = "pasta" if self._wiki.is_folder=="S" else u"página"
# notifica o dono da página movida
email_msg = legenda+u" movida: "+self._wiki.nomepag+"\n"+\
u"De: " + old_path + " Para: " + new_path + "\n" +\
Notify.assinatura(user, registry_id, self._wiki.data_alt if self._wiki.is_folder=="S" else self._wiki.historico[-1]["data_alt"])+"\n\n"
Notify.email_notify(self._wiki.owner, user, u"moveu uma "+legenda+u" criada por você", \
message=email_msg, \
link="/wiki/%s?folder=%s"%(registry_id, item) if legenda=="pasta" else "wiki/"+doc_id)
#log.model.log(user, u'moveu a '+legenda, objeto=doc_id, tipo="wiki")
if self._wiki.is_folder=="S":
log.model.log(user, u'moveu a pasta', objeto=registry_id+"/"+self._wiki.nomepag, link="/wiki/%s?folder=%s"%(registry_id, item), tipo="wiki")
else:
log.model.log(user, u'moveu a página', objeto=doc_id, tipo="wiki")
self.write (dict(status=0, msg=u"Páginas/Pastas movidas com sucesso."))
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):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
quiz_count = model.Quiz.countObjectsByRegistryId(registry_id)
lista_quiz = prepareQuiz(user, model.Quiz.listObjects(registry_id, page, NUM_MAX_QUIZ))
links = []
if isAllowedToReadObject(user, "question", registry_id):
links.append((u"Banco de questões", "/static/imagens/icones/question32.png", "/question/"+registry_id))
if isAllowedToWriteObject(user, "quiz", registry_id):
links.append((u"Novo teste de múltipla escolha", "/static/imagens/icones/add_test32.png", "/quiz/new/%s?subtype=Teste"%registry_id))
links.append ((u"Nova pesquisa de opinião", "/static/imagens/icones/add_survey32.png", "/quiz/new/%s?subtype=Survey"%registry_id))
log.model.log(user, u'acessou a lista de quizes de', objeto=registry_id, tipo="quiz", news=False)
self.render("modules/quiz/quiz-list.html", NOMEPAG="Quiz", REGISTRY_ID=registry_id, \
IS_ADMIN=isUserOrOwner(user, registry_id), \
QUIZ=lista_quiz, QUIZ_COUNT=quiz_count, \
PAGE=page, PAGESIZE=NUM_MAX_QUIZ, \
LINKS=links)
def get (self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
posts_count = model.Blog.countPostsByRegistryId(registry_id)
lista_posts = prepareBlogPosts(user, model.Blog.listBlogPosts(registry_id, page, NUM_MAX_POSTS))
links = []
if isAllowedToWriteObject(user, "blog", registry_id):
links.append(("Novo post", "/static/imagens/icones/new32.png", "/blog/new/"+registry_id))
if isUserOrOwner(user, registry_id):
links.append((u"Ver lixeira", "/static/imagens/icones/recycle32.png", "/blog/deleted/"+registry_id))
links.append((u"Alterar permissões deste blog", "/static/imagens/icones/permissions32.png", "/permission/blog/"+registry_id, "", "", True))
log.model.log(user, u'acessou o blog de', objeto=registry_id, tipo="blog", news=False)
self.render("modules/blog/blog.html", NOMEPAG="blog", REGISTRY_ID=registry_id, \
ARCHIVE=model.Blog.get_blog_archive(registry_id), \
SORTEDKEYS=sortedKeys, MESES=_meses, \
POSTS=lista_posts, POSTS_COUNT=posts_count, \
PAGE=page, PAGESIZE=NUM_MAX_POSTS, \
LINKS=links)
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 get (self, registry_id):
user = self.get_current_user()
parent_folder = self.get_argument("folder","")
if parent_folder:
parent_id = registry_id+"/"+parent_folder
self._pai = model.Wiki().retrieve(parent_id)
parent_name = self._pai.nomepag
if not isAllowedToWriteObject(user, "wiki", registry_id, parent_folder):
self.write (dict(status=1, msg=u"Você não tem permissão para criar pastas nesta pasta."))
return
else:
parent_name = registry_id+"/"
self._wiki = model.Wiki(nomepag="Nova Pasta", nomepag_id="NovaPasta", parent_folder=parent_folder)
form = dict(
action="",
nomepag=dict(type="@text",value=""),
parent_name=dict(type="@text",value=parent_name),
e_ususario=dict(type="@text", value=isAUser(registry_id))
)
self.write (dict(status=0, result=form))
def get (self, registry_id, id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
#id = self.get_argument("id","")
links = []
_quiz= model.Quiz().retrieve(id)
if _quiz:
_questions = _quiz.listQuestionsInQuiz()
if isAllowedToWriteObject(user, "quiz", registry_id):
links.append(("Alterar este quiz", "/static/imagens/icones/edit32.png", "/quiz/edit/%s/%s"%(registry_id,id)))
self.render("modules/quiz/quiz-answerkey.html", NOMEPAG="Quiz", \
REGISTRY_ID=registry_id, \
QUIZ=_quiz, TITLE=u"Quiz de %s" % registry_id, \
QUESTIONS=_questions, \
IMGLIST=["resp_a.gif", "resp_b.gif", "resp_c.gif", "resp_d.gif", "resp_e.gif"], \
LINKS=links)
else:
raise HTTPError(404)
