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