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 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 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 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 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 prepareBlogPost(user, post_data):
# acrescenta permissões para comentar um post e datas formatadas
post_data["comentar"] = isAllowedToComment(user, post_data["_id"], post_data["owner"])
post_data["data_cri_nofmt"] = post_data["data_cri"]
post_data["data_cri"] = short_datetime(post_data["data_cri"])
post_data["data_alt"] = short_datetime(post_data["data_alt"])
# acrescenta permissões de cada comentário
for comentario in post_data["comentarios"]:
comentario["comment"] = comentario["comment"].replace("\r\n", "<br/>")
comentario["apagar"] = isAllowedToDeleteComment(user, post_data["registry_id"], comentario["owner"])
comentario["data_fmt"] = short_datetime(comentario["data_cri"])
post_data["comentarios"] = sorted(post_data["comentarios"], key=itemgetter("data_cri"), reverse=True)
return post_data
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 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 listBlogPosts(self, registry_id, page, page_size, control_panel=False, only_removed=False):
lista_posts = []
if only_removed:
for row in database.BLOG.view('blog/removed_data',startkey=[registry_id, {}],endkey=[registry_id], \
descending="true", skip=(page-1)*page_size , limit=page_size):
(registry_id, data_alt, doc_id) = row.key
blog_data = dict()
blog_data.update(row.value)
blog_data["registry_id"] = registry_id
blog_data["doc_id"] = doc_id
lista_posts.append(blog_data)
else:
for row in database.BLOG.view('blog/all_data',startkey=[registry_id, {}], endkey=[registry_id], descending="true", skip=(page-1)*page_size , limit=page_size):
# (registry_id, post_id) = row.key
blog_data = dict()
blog_data.update(row.value)
if control_panel:
blog_data["conteudo"] = remove_html_tags(blog_data["conteudo"])
if len(blog_data["conteudo"]) > 100:
blog_data["conteudo"] = str_limit(blog_data["conteudo"], 100)
blog_data["data_fmt"] = short_datetime(blog_data["data_cri"])
lista_posts.append(blog_data)
return lista_posts
def listRatingsFromObject(self, tipo, escopo, objeto):
# retorna lista de tuplas com todas as avaliações de um objeto
result = []
for row in database.RATING.view("rating/partial_data",startkey=[tipo,escopo,objeto],endkey=[tipo,escopo,objeto, {}]):
user = row.key[3]
result.append([user, row.value["rating"], short_datetime(row.value["data_cri"], include_year=True)])
# result = sorted(paginas, key=itemgetter("data_nofmt"), reverse = True)
return result
def get_news_list(user_id, date_time=False):
# retorna lista de dicionários com novidades para um user_id
novidades = []
if user_id in database.NEWS and "avisos" in database.NEWS[user_id]:
novidades = database.NEWS[user_id]["avisos"]
for item in novidades:
item["data_inclusao"] = short_datetime(item["data_inclusao"], include_year=True) if date_time else short_date(item["data_inclusao"])
return novidades
def get_log_list(user_id, date_time=False, limit=300, news=True):
# retorna lista de dicionários com todas as ações realizadas por um user_id
novidades = []
view_name = news and 'log/log_list_news' or 'log/log_list'
for row in database.LOG.view(view_name,startkey=[user_id, {}], endkey=[user_id], descending="true", skip=0, limit=limit):
row.value["data_inclusao"] = short_datetime(row.value["data_inclusao"], include_year=True) if date_time else short_date(row.value["data_inclusao"])
novidades.append(row.value)
return novidades
def get_forum_list(self, registry_id):
forums = []
for obj in self.listForumTopics(registry_id):
num_comment = self.countObjectsByGroup(obj["_id"])
forums.append((obj["owner"], \
obj["titulo"], \
u"%d comentários." % num_comment, \
short_datetime(obj["ultimo_reply"]) if obj["ultimo_reply"] else ""))
return forums
def get (self):
user = self.get_current_user()
logados = []
for logado in core.model.USUARIOS_LOGADOS:
# usuários que acessaram nos últimos 15 minutoa
if isOnline(logado):
logados.append((logado, \
short_datetime(core.model.USUARIOS_LOGADOS[logado]), "green"))
# usuários que acessaram nos últimos 60 minutoa
if isOnline(logado, time_since_last_request=60*60) and not [item for item in logados if item[0] == logado]:
logados.append((logado, \
short_datetime(core.model.USUARIOS_LOGADOS[logado]), "yellow"))
#logados = [(logado, short_datetime(core.model.USUARIOS_LOGADOS[logado])) for logado in core.model.USUARIOS_LOGADOS if isOnline(logado, time_since_last_request=60*60)]
logados.sort(key=itemgetter(1), reverse=True)
self.render("modules/admin/online-users.html", REGISTRY_ID=PRIV_SUPORTE_ACTIV, MSG="",\
NOMEPAG="cadastro", LOGADOS=logados)
def prepareResults(aval_data):
(registry_id, nomeobj) = aval_data["_id"].split("/")
n_avaliacoes = 0
for item in aval_data["avaliacoes"]:
if "votos_dados" in aval_data["avaliacoes"][item] and aval_data["avaliacoes"][item]["votos_dados"]:
n_avaliacoes +=1
aval_data["n_avaliacoes"] = str(n_avaliacoes)
aval_data["n_avaliadores"] = str(len(usersAllowedToRead("evaluation", registry_id, nomeobj)))
aval_data["data_cri"] = short_datetime(aval_data["data_cri"])
return aval_data
def post(self, registry_id):
user = self.get_current_user()
_atividade = model.Activity()
msg = ""
_atividade.titulo = self.get_argument("titulo","")
if _atividade.titulo == "":
msg += u"O nome da atividade não pode ser vazio.<br/>"
else:
_atividade.name_id = remove_special_chars(remove_diacritics(_atividade.titulo.replace(" ","_")))
if _atividade.name_id == "":
msg += u"Título da atividade inválido<br/>"
_atividade.group_id = self.get_argument("id","")
if _atividade.group_id == "":
msg += u"O grupo da atividade não foi informado.<br/>"
if msg:
self.render("modules/activity/activity-form.html", NOMEPAG=u"atividades", \
ATIVIDADE=_atividade, \
GROUP=_atividade.group_id, \
REGISTRY_ID=registry_id, MSG=msg)
return
#verifica se o registry é usuário ou comunidade
if registry_id == user:
_atividade.subtype="user"
else:
_atividade.subtype="comunity"
doc_id = uuid4().hex
#_atividade.observacao = self.get_argument("observacao",'')
_atividade.data_cri = str(datetime.now())
_atividade.data_start = short_datetime(_atividade.data_cri, include_separator=" ")
_atividade.data_end = ""
_atividade.encarregados.append(user)
_atividade.prioritario = self.get_argument("prioritario",'N')
_atividade.status = u"pendente"
_atividade.service="activity"
_atividade.type="activity"
_atividade.registry_id = registry_id
_atividade.owner = user
log.model.log(user, u'criou uma atividade em', objeto=registry_id, tipo="activity",link="/activity/%s"%registry_id)
_atividade.save(id=doc_id)
self.render("modules/activity/activity-form.html", NOMEPAG=u"atividades", \
ATIVIDADE=model.Activity(), \
GROUP=_atividade.group_id, \
REGISTRY_ID=registry_id, MSG="A atividade foi criada com sucesso")
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 getWikiHistory(self):
# recupera dados no BD
wiki_data = dict(
registry_id = self.registry_id,
owner = self.owner,
nomepag = self.nomepag,
nomepag_id = self.nomepag_id,
historico = []
)
for i in range(len(self.historico)):
wiki_data["historico"].append(dict(
versao = str(i),
data_alt = short_datetime(self.historico[i]["data_alt"]),
alterado_por = self.historico[i]["alterado_por"]
))
wiki_data["historico"].reverse()
return wiki_data
def getBlogHistory(self):
# recupera dados no BD
blog_data = dict(
registry_id = self.registry_id,
owner = self.owner,
titulo = self.titulo,
post_id = self.post_id,
historico = []
)
for i in range(len(self.historico)):
blog_data["historico"].append(dict(
versao = str(i),
data_alt = short_datetime(self.historico[i]["data_alt"]),
alterado_por = self.historico[i]["alterado_por"]
))
blog_data["historico"].reverse()
return blog_data
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):
user = self.get_current_user()
mblog_id = self.get_argument("id","")
self._mblog = model.Mblog().retrieve(mblog_id)
if not self._mblog:
raise HTTPError(404)
return
self._mblog.data_cri = short_datetime(self._mblog.data_cri)
(permission, autocomplete) = autocomplete_mblog(user, user)
self.render("modules/mblog/share.html", NOMEPAG="microblog", \
POST=self._mblog, \
REGISTRY_ID=user, \
PERMISSION=permission, AUTOCOMPLETE_LIST=autocomplete, \
MAX_CHR_MBLOG=MAX_CHR_MBLOG, \
MBLOG_ID=mblog_id)
def listPortfolio(self, user, registry_id, page, page_size):
# chamadas:
# /wiki/portfolio/%s -> lista todas as páginas de todas as pastas
paginas = []
for row in database.WIKI.view('wiki/portfolio',startkey=[registry_id, {}],endkey=[registry_id], \
descending="true", skip=(page-1)*page_size, limit=page_size):
(registry_id, data_alt, doc_id) = row.key
if isAllowedToReadObject(user, "wiki", registry_id, doc_id):
# listagem das pastas e páginas não removidas
pagina_data = dict()
pagina_data.update(row.value)
pagina_data["registry_id"] = registry_id
pagina_data["doc_id"] = doc_id
pagina_data["data_alt"] = short_datetime(row.value["data_alt"], include_year=True)
pagina_data["data_nofmt"] = row.value["data_alt"]
paginas.append(pagina_data)
return paginas
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 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 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 msg_chat (user, msg):
d = str(datetime.now())
return "<div style='display:none'>%s</div><b>%s</b>: %s<div class='date'>%s</div>" % (d, user, msg, short_datetime(d, include_year=False))
def prepareCommentsToPrint(self, user):
for comment in self.comentarios:
comment["apagar"] = isAllowedToDeleteComment(user, self.registry_id, comment["owner"])
comment["data_fmt"] = short_datetime(comment["data_cri"])
comment["comment"] = comment["comment"].replace("\r\n", "<br/>")
self.comentarios = sorted(self.comentarios, key=itemgetter("data_cri"), reverse=True)
def getUserRatingFromObject(self, user, tipo, escopo, objeto):
# retorna uma tupla com a avaliação que um dado usuário fez de um objeto
result = []
for row in database.RATING.view("rating/partial_data",startkey=[tipo,escopo,objeto,user],endkey=[tipo,escopo,objeto,user, {}]):
result = [user, row.value["rating"], short_datetime(row.value["data_cri"], include_year=True)]
return result