def editBookmark(self, user, newtitle, newdesc, newtags): # preserva tags anteriores old_tags = self.tags self.title = newtitle self.description = newdesc self.tags = newtags self.alterado_por = user self.data_alt = str(datetime.now()) self.save() # compara as tags anteriores com as modificadas, atualizando a lista de tags no BD data_tag = str(datetime.now()) if self.title: nome = self.title else: url = self.url url = remove_special_chars(remove_diacritics(url.replace(" ","_"))) nome = url for tag in self.tags: if tag not in old_tags: addTag(tag, self.registry_id, user, "bookmarks", self.id, nome, data_tag) for tag in old_tags: if tag not in self.tags: removeTag(remove_diacritics(tag.lower()), "bookmarks", self.id)
def post(self): user = self.get_current_user() formdata = _EMPTYREQUESTINVITEFORM() erros = 0 msg = "" for key in _REQUESTINVITEFORM: if self.get_argument(key, "") != "" : formdata[key] = self.get_argument(key) else: erros += 1 if erros > 0: msg += u"Há %d campos obrigatórios não preenchidos!<br/>" % erros if formdata["titulo"]!="": formdata["nome"] = remove_special_chars(remove_diacritics(formdata["titulo"].replace(" ","_"))) if formdata["nome"]=="": msg += u"Título do formulário inválido.<br/>" if msg: self.render("modules/invites/create-form-invite.html", REGISTRY_ID=user, \ FORMDATA=formdata, \ MSG=msg,\ NOMEPAG="convites") else: formdata["owner"] = user formdata["data_cri"] = str(datetime.now()) formdata["data_alt"] = formdata["data_cri"] id = "%s/%s" % (user, formdata["nome"]) model.REQUESTINVITEFORM[id] = formdata showInvitesPage(self, user, "")
def deleteFile(self, user): #print "self.filename=", self.filename filename = self.filename filename = filename.replace("%20"," ") #Corrigindo problema de upload de arquivo com espaço em branco filesize = self.filesize(unquote(filename)) #print "self.filename=", self.filename #print "filesize=", filesize registry_id = self.registry_id parent = self.parent_folder filename_id = self.id.split("/")[1] try: tags = self.tags self.delete() # vai para o tags.model for tag in tags: removeTag(remove_diacritics(tag.lower()), "file", self.id) except Exception as detail: return (True, detail) # remove da lista de filhos do pai if parent: parent_obj = Files().retrieve(registry_id+"/"+parent) parent_obj.removeItemFromParent(user, filename_id) # atualiza o espaço ocupado por arquivos deste usuário/comunidade _reg = core.model.Registry().retrieve(self.registry_id) _reg.updateUploadSize(-filesize) return (False, None)
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 registry_id = self._mblog.registry_id owner = self._mblog.owner if user != owner: raise HTTPError(403) return # remove o post try: tags = self._mblog.tags self._mblog.delete() for tag in tags: removeTag(remove_diacritics(tag.lower()), "mblog", mblog_id) except Exception as detail: self.render("home.html", MSG=u"Erro: %s" % detail, REGISTRY_ID=registry_id, NOMEPAG="microblog") return log.model.log(user, u'removeu uma mensagem do mblog de', objeto=registry_id, tipo="none") self.redirect("/mblog/%s" % registry_id)
def post(self, registry_id, name_id): user = self.get_current_user() _va = model.Videoaula().retrieve_by_name_id(registry_id, name_id) if _va: old_tags = _va.tags _va.tags = splitTags(self.get_argument("tags","")) data_tag = str(datetime.now()) for tag in _va.tags: if tag not in old_tags: addTag(tag, registry_id, user, "videoaula", registry_id+"/"+name_id, str_limit(remove_html_tags(_va.titulo), 50), data_tag) for tag in old_tags: if tag not in _va.tags: removeTag(remove_diacritics(tag.lower()), "videoaula", id) _va.data_alt = str(datetime.now()) _va.alterado_por = user _va.save() log.model.log(user, u'alterou uma videoaula de', objeto=registry_id, tipo="videoaula") self.redirect(r"/videoaula/edit/%s/%s" % (registry_id, name_id)) else: raise HTTPError(404)
def deleteWiki(self, user, permanently=False): registry_id = self.registry_id nomepag_id = self.nomepag_id parent = self.parent_folder tags = self.tags if permanently or self.is_folder=="S": # se é um folder, remove-o self.delete() else: # se é uma página, cria entrada no histórico marcando a página como removida self.historico.append(dict( conteudo=_CONTEUDO_REMOVIDO, alterado_por=user, data_alt=str(datetime.now()) )) # toda página removida vai para a pasta raiz self.parent_folder = "" self.save() #remove as tags for tag in tags: removeTag(remove_diacritics(tag.lower()), "wiki", self.id) # remove da lista de filhos do pai if parent: parent_obj = Wiki().retrieve(registry_id+"/"+parent) parent_obj.removeItemFromParent(user, nomepag_id)
def get(self, registry_id): user = self.get_current_user() tags_procuradas = self.get_argument("tags","") tags = remove_diacritics(tags_procuradas.lower()) resultados_busca = {} for tag in list(set(tags.split(","))): temp_busca = userTag(registry_id, tag) for item in temp_busca: for tupla in temp_busca[item]: #if self.isAllowedToAccess(user, tupla[2], display_error=False) and \ if core.model.isAllowedToAccess(user, tupla[2])==0: if item not in resultados_busca: resultados_busca[item] = [tupla] elif tupla not in resultados_busca[item]: resultados_busca[item].append(tupla) for item in resultados_busca: # ordena pela data não formatada resultados_busca[item].sort(key=itemgetter(4), reverse=True) # limita o número de itens exibidos resultados_busca[item] = resultados_busca[item][:_MAX_RESULTADOS_POR_ITEM] totais = [len(resultados_busca[key]) for key in resultados_busca] self.render("modules/search/user-results.html", REGISTRY_ID=registry_id, \ NOMEPAG='busca', \ RESULTADOS=resultados_busca, LEGENDA=URL_TO_PAGETITLE, \ NUM_RESULT=sum(totais), \ TAGS_PROCURADAS=tags_procuradas)
def post(self, registry_id): user = self.get_current_user() type = self.get_argument("type","") _group = model.Group() msg = "" _group.titulo = self.get_argument("titulo","") if _group.titulo == "": msg += u"O nome do grupo não pode ser vazio.<br/>" else: _group.name_id = remove_special_chars(remove_diacritics(_group.titulo.replace(" ","_"))) if _group.name_id == "": msg += u"Nome do grupo inválido<br/>" if msg: self.render("modules/activity/newgroup-form.html", NOMEPAG=u"atividades", \ GRUPO=_group, \ REGISTRY_ID=registry_id, MSG=msg) return doc_id = uuid4().hex _group.data_cri = str(datetime.now()) _group.service="activity" _group.type="group" _group.registry_id = registry_id _group.owner = user _group.save(id=doc_id) log.model.log(user, u'criou um grupo de atividades em', objeto=registry_id, tipo="activity", link="/activity/%s"%registry_id) self.render("modules/activity/newgroup-form.html", NOMEPAG=u"atividades", \ GRUPO=model.Group(), \ REGISTRY_ID=registry_id, MSG="O grupo foi criado com sucesso")
def deletePost(self, user, permanently=False): registry_id = self.registry_id post_id = self.post_id tags = self.tags if permanently: # se permanentemente, deleta self.delete() #remove os comentários deste post for row in database.COMMENT.view('blog/all_comments',startkey=[self.id],endkey=[self.id, {}]): (doc_id, comment_id) = row.key _comment = BlogComment(comment_id) _comment.delete() else: # se não, cria entrada no histórico marcando a página como removida self.historico.append(dict( conteudo=_CONTEUDO_REMOVIDO, alterado_por=user, data_alt=str(datetime.now()) )) self.save() #remove as tags #TODO? Mover tags para historico for tag in tags: removeTag(remove_diacritics(tag.lower()), "blog", self.id)
def deleteBookmark(self): tags = self.tags self.delete() # atualiza tabela de tags # vai para o tags.model for tag in tags: removeTag(remove_diacritics(tag.lower()), "bookmarks", self.id)
def deleteGlossaryItem(self): tags = self.tags self.delete() # atualiza tabela de tags # vai para o tags.model for tag in tags: removeTag(remove_diacritics(tag.lower()), "glossary", self.id)
def deleteTopic(self): registry_id = self.registry_id name_id = self.name_id tags = self.tags self.delete() #remove as tags for tag in tags: removeTag(remove_diacritics(tag.lower()), "forum", registry_id+"/"+name_id)
def post(self, registry_id, post_id): user = self.get_current_user() doc_id = '/'.join([registry_id, post_id]) self._blog = model.Blog().retrieve(doc_id) if self._blog: msg = "" self._blog.titulo = self.get_argument("titulo","") if self._blog.titulo == "": msg += u"O título do Post não pode ser vazio.<br/>" old_tags = self._blog.tags self._blog.tags = splitTags(self.get_argument("tags","")) self._blog.conteudo = self.get_argument("conteudo","") if self._blog.conteudo == "": msg += u"O conteúdo do Post não pode ser vazio.<br/>" if msg: self.render("modules/blog/blog-form.html", NOMEPAG="blog", REGISTRY_ID=registry_id, BLOGDATA=self._blog, MSG=msg) return else: data_tag = str(datetime.now()) for tag in self._blog.tags: if tag not in old_tags: addTag(tag, registry_id, user, "blog", doc_id, self._blog.titulo, data_tag) for tag in old_tags: if tag not in self._blog.tags: removeTag(remove_diacritics(tag.lower()), "blog", doc_id) # registro da atualização self._blog.data_alt = str(datetime.now()) self._blog.alterado_por = user historico_inicial = dict() historico_inicial["data_alt"] = self._blog.data_alt historico_inicial["alterado_por"] = user historico_inicial["conteudo"] = self._blog.conteudo self._blog.historico.append(historico_inicial) # limita o número de versões no histórico em BLOG_HISTORY_SIZE history_len = len(self._blog.historico) if history_len > BLOG_HISTORY_SIZE: inicio = history_len - BLOG_HISTORY_SIZE self._blog.historico = self._blog.historico[inicio:history_len] self._blog.save() log.model.log(user, u'alterou o blog', objeto=doc_id, tipo="blog") self.redirect("/blog/%s" % doc_id) else: self.render("home.html", MSG=u"Post não encontrado: ele pode ter sido removido por outro usuário enquanto você editava-o", REGISTRY_ID=registry_id, NOMEPAG="blog") return
def post(self, registry_id): user = self.get_current_user() self._blog = model.Blog() msg = "" self._blog.titulo = self.get_argument("titulo","") if self._blog.titulo == "": msg += u"O título do Post não pode ser vazio.<br/>" else: self._blog.post_id = remove_special_chars(remove_diacritics(self._blog.titulo.replace(" ","_"))) if self._blog.post_id == "": msg += u"Título do Post inválido<br/>" self._blog.tags = splitTags(self.get_argument("tags","")) self._blog.conteudo = self.get_argument("conteudo","") if self._blog.conteudo == "": msg += u"O conteúdo do Post não pode ser vazio.<br/>" if msg: self.render("modules/blog/blog-form.html", NOMEPAG="blog", REGISTRY_ID=registry_id, BLOGDATA=self._blog, MSG=msg) return else: self._blog.data_cri = str(datetime.now()) self._blog.data_alt = self._blog.data_cri # A chave _id do documento no couchdb é nome/pagina doc_id = '/'.join([registry_id,self._blog.post_id]) self._blog.registry_id = registry_id self._blog.owner = user historico_inicial = dict() historico_inicial["data_alt"] = self._blog.data_alt historico_inicial["alterado_por"] = user historico_inicial["conteudo"] = self._blog.conteudo self._blog.historico.append(historico_inicial) try: self._blog.save(id=doc_id) except Exception as detail: self.render("modules/blog/blog-form.html", NOMEPAG="blog", REGISTRY_ID=registry_id, BLOGDATA=self._blog, \ MSG=u"Já existe um post com este título.") return data_tag = str(datetime.now()) for tag in self._blog.tags: addTag(tag, registry_id, user, "blog", doc_id, self._blog.titulo, data_tag) log.model.log(user, u'escreveu no blog', objeto=doc_id, tipo="blog") self.redirect("/blog/%s" % doc_id)
def post(self, registry_id): user = self.get_current_user() msg = "" _topic = model.Topic() _topic.titulo = self.get_argument("titulo","") if _topic.titulo == "": msg += u"O título do tópico não pode ser vazio.<br/>" else: _topic.name_id = remove_special_chars(remove_diacritics(_topic.titulo.replace(" ","_"))) if _topic.name_id == "": msg += u"Título do tópico inválido<br/>" if model.Topic.exists(registry_id, _topic.name_id): msg += u"Já existe um tópico com este nome" _topic.tags = splitTags(self.get_argument("tags","")) _topic.conteudo = self.get_argument("conteudo","") if _topic.conteudo == "": msg += u"O conteúdo do tópico não pode ser vazio.<br/>" if msg: self.render("modules/forum/forum-form.html", NOMEPAG="forum", REGISTRY_ID=registry_id, TOPICO=_topic, MSG=msg) return else: _topic.receber_email = self.get_argument("receber_email", "N") _topic.data_cri = str(datetime.now()) _topic.data_alt = _topic.data_cri _topic.service = "forum" _topic.type = "topic" doc_id = uuid4().hex _topic.registry_id = registry_id _topic.owner = user _topic.alterado_por = user try: _topic.save(id=doc_id) except Exception as detail: self.render("modules/forum/forum-form.html", NOMEPAG="forum", REGISTRY_ID=registry_id, TOPICO=_topic, \ MSG=u"Já existe um tópico neste forum com este título.") return data_tag = str(datetime.now()) for tag in _topic.tags: addTag(tag, registry_id, user, "forum", registry_id+"/"+_topic.name_id, _topic.titulo, data_tag) log.model.log(user, u'criou um tópico no forum', objeto=registry_id, tipo="forum") self.redirect("/forum/%s" % registry_id)
def saveBookmark(self, id=None): self.save(id=id) # atualiza tabela de tags # vai para o tags.model data_tag = str(datetime.now()) for tag in self.tags: if self.title: nome = self.title else: url = self.url url = remove_special_chars(remove_diacritics(url.replace(" ","_"))) nome = url addTag(tag, self.registry_id, self.owner, "bookmarks", self.id, nome, data_tag)
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 saveTopic(self, id=None, old_tags=None): if id==None: self.save() else: self.save(id=id) # compara as tags anteriores com as modificadas, atualizando a lista de tags no BD data_tag = str(datetime.now()) for tag in self.tags: if old_tags==None or tag not in old_tags: addTag(tag, self.registry_id, self.owner, "forum", self.registry_id+"/"+self.name_id, self.titulo, data_tag) if old_tags != None: for tag in old_tags: if tag not in self.tags: removeTag(remove_diacritics(tag.lower()), "forum", registry_id+"/"+name_id)
def post(self, registry_id): user = self.get_current_user() _va = model.Videoaula() msg = "" _va.titulo = self.get_argument("name","") if _va.titulo == "": msg += u"Nome da videoaula não preenchido.<br/>" _va.arqvideo = self.get_argument("arqvideo","") if _va.arqvideo == "": msg += u"Arquivo de vídeo não preenchido.<br/>" _va.tags = splitTags(self.get_argument("tags","")) _va.service = "videoaula" _va.type = "videoaula" _va.registry_id = registry_id _va.name_id = remove_special_chars(remove_diacritics(_va.titulo.replace(" ","_"))) if model.Videoaula.exists(_va.registry_id, _va.name_id): msg += u"Já existe uma videoaula com este nome" if msg: self.render("modules/videoaula/videoaula-form.html", NOMEPAG="videoaulas", VIDEODATA=_va, \ FOLDERS = files.model.Files.listFolders(user, registry_id, "files/all_data"), \ REGISTRY_ID=registry_id, MSG=msg) return else: doc_id = uuid4().hex _va.owner = user #_va.alterado_por = user _va.data_cri = str(datetime.now()) _va.data_alt = _va.data_cri _va.save(id=doc_id) # Adiciona tags da videoaula ao banco de tags. data_tag = str(datetime.now()) for tag in _va.tags: addTag(tag, registry_id, user, "videoaula", registry_id+"/"+_va.name_id, str_limit(remove_html_tags(_va.titulo), 50), data_tag) log.model.log(user, u'criou videoaula em', objeto=registry_id, tipo="videoaula",link="/videoaula/%s/%s"%(registry_id,_va.name_id)) self.redirect("/videoaula/edit/%s/%s" % (registry_id,_va.name_id))
def saveWiki(self, id=None, old_tags=None): if id==None: self.save() else: self.save(id=id) # folders não possuem tags if self.is_folder!="S": # compara as tags anteriores com as modificadas, atualizando a lista de tags no BD data_tag = str(datetime.now()) for tag in self.tags: if old_tags==None or tag not in old_tags: addTag(tag, self.registry_id, self.owner, "wiki", self.id, self.nomepag, data_tag) if old_tags != None: for tag in old_tags: if tag not in self.tags: removeTag(remove_diacritics(tag.lower()), "wiki", self.id)
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 editGlossaryItem(self, user, newdef, newtags): # preserva tags anteriores old_tags = self.tags self.definition = newdef self.tags = newtags self.alterado_por = user self.data_alt = str(datetime.now()) self.save() # compara as tags anteriores com as modificadas, atualizando a lista de tags no BD data_tag = str(datetime.now()) for tag in self.tags: if tag not in old_tags: addTag(tag, self.registry_id, user, "glossary", self.id, self.term, data_tag) for tag in old_tags: if tag not in self.tags: removeTag(remove_diacritics(tag.lower()), "glossary", self.id)
def editFile(self, user, newdesc, newtags): # preserva tags anteriores old_tags = self.tags self.description = newdesc self.tags = newtags self.alterado_por = user self.data_alt = str(datetime.now()) self.save() # compara as tags anteriores com as modificadas, atualizando a lista de tags no BD data_tag = str(datetime.now()) nome = self.description if self.description else self.filename for tag in self.tags: if tag not in old_tags: addTag(tag, self.registry_id, user, "file", self.id, nome, data_tag) for tag in old_tags: if tag not in self.tags: removeTag(remove_diacritics(tag.lower()), "file", self.id)
def deleteFile(self): #filename = self.filename #filename = filename.replace("%20"," ") #Corrigindo problema de upload de arquivo com espaço em branco #filesize = self.filesize(unquote(filename)) registry_id = self.registry_id try: tags = self.tags self.delete() # vai para o tags.model for tag in tags: removeTag(remove_diacritics(tag.lower()), "studio", self.id) except Exception as detail: return (True, detail) # atualiza o espaço ocupado por arquivos deste usuário/comunidade #_reg = core.model.Registry().retrieve(self.registry_id) #_reg.updateUploadSize(-filesize) return (False, None)
def post(self, registry_id): user = self.get_current_user() if not isUserOrMember(user, registry_id): self.render("home.html", MSG=u"Você não tem permissão para criar termos neste glossário.", \ NOMEPAG=NOME_PAG_CLOSSARIO, REGISTRY_ID=registry_id) return MSG = "" glossary_term = self.get_argument("term","") if not glossary_term: MSG += u"Termo não pode ser vazio." glossary_definition = self.get_argument("definition","") if not glossary_definition: MSG += u"%sA definição do termo não pode estar vazia." % ("" if not MSG else "<br/>") if not MSG: glossary_item_id = remove_special_chars(remove_diacritics(glossary_term.replace(" ","_"))) if model.Glossary.searchItemByRegistryIdAndItemId(user, registry_id, glossary_item_id, False): MSG += u"Termo já definido neste glossário." if MSG: self.render("modules/glossary/new_glossary_item-form.html", \ NOMEPAG=NOME_PAG_CLOSSARIO, DEFINITION=glossary_definition, REGISTRY_ID=registry_id, MSG=MSG) return else: self._glossary = model.Glossary() self._glossary.id = '/'.join([registry_id,glossary_item_id]) self._glossary.registry_id = registry_id self._glossary.owner = user self._glossary.item_id = glossary_item_id self._glossary.term = self.get_argument("term","") self._glossary.definition = glossary_definition self._glossary.tags = splitTags(self.get_argument("tags","")) self._glossary.data_cri = self._glossary.data_alt = str(datetime.now()) self._glossary.alterado_por = user self._glossary.saveGlossaryItem(glossary_item_id) log.model.log(user, u'criou um termo no glossário de', objeto=registry_id, tipo="glossary") self.redirect("/glossary/%s" % registry_id)
def post(self, registry_id): user = self.get_current_user() if self.request.files: # este split é para resolver o problema do IE, que manda o caminho completo. filename = self.request.files["arquivo"][0]["filename"].split("\\")[-1] filename = remove_diacritics(filename) filename = filename.replace(" ", "_") if "." not in filename or filename.split(".")[-1].lower() not in ["gif", "jpg", "jpeg", "png"]: self.render("home.html", MSG=u"Utilize somente arquivos com extensão: gif, jpg, jpeg ou png.", \ NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id) return tipo = "" if registry_id in core.database.REGISTRY: if not isUserOrMember(user, registry_id): self.render("home.html", MSG=u"Você não tem permissão para carregar arquivos aqui.", \ NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id) return #if len(self.request.files["arquivo"][0]["body"]) + core.database.REGISTRY[registry_id]["upload_size"] > core.database.REGISTRY[registry_id]["upload_quota"]: # self.render("home.html", MSG=u"Espaço para armazenamento de arquivos excedido.", \ # NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id) # return # A chave _id do documento no couchdb é nome/arquivo file_id = '/'.join([registry_id,filename]) self._file = model.Studio().retrieve(file_id) if self._file: self.render("home.html", MSG=u"Já existe um arquivo com este mesmo nome. Remova-o antes de subir com uma nova versão.", \ NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id) return else: self._file = model.Studio(file_id=file_id) if self.get_argument("type","")=="": self.render("home.html", MSG=u"Escolha a fase onde a imagem deve ser armazenada.", \ NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id) return self._file.type = int(self.get_argument("type","")) self._file.description = self.get_argument("description","") self._file.url = self.get_argument("url","") self._file.tags = splitTags(self.get_argument("tags","")) self._file.owner = self._file.alterado_por = user self._file.registry_id = registry_id self._file.data_upload = self._file.data_alt = str(datetime.now()) self._file.filename = filename if not self._file.saveFile(file_id, self.request.files): self.render("home.html", MSG=u"Erro na leitura do arquivo de imagem.", \ NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id) return log.model.log(user, u'criou imagem no studio de games', objeto=file_id, tipo="studio") self.redirect("/studio/%s" % registry_id) else: self.render("home.html", MSG=u"Usuário ou comunidade inexistentes.", \ NOMEPAG=u'Estúdio', REGISTRY_ID=user) else: self.render("home.html", MSG=u"Erro: Arquivo inexistente!", \ NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
def get(self, registry_id): user = self.get_current_user() if user != registry_id: raise HTTPError(403) else: self._user = core.model.Member().retrieve(user) tags = self._user.tags friends_list = self._user.getFriendsList()[1] friends = [ friend[0] for friend in friends_list ] tags_comuns = [] paginas = [] posts = [] perfis = [] comunidades = [] if tags: for tag in tags: resultado = findTag(remove_diacritics(tag.lower())) tags_comuns.append((tag,resultado)) for item in tags_comuns: # Páginas encontradas for pagina in item[1]['wiki']: registry_id_found = pagina[2] doc_id_found = pagina[3] if registry_id_found in database.REGISTRY and wiki.model.Wiki.nomepagExists(registry_id_found, doc_id_found.split("/")[1]): if database.REGISTRY[registry_id_found]["privacidade"] == u"Pública": if doc_id_found and registry_id_found != user: self.inclui (doc_id_found, item[0], paginas) else: if isAUser(registry_id_found): if doc_id_found and registry_id_found != user and \ registry_id_found in database.REGISTRY[user]["amigos"]: self.inclui (doc_id_found, item[0], paginas) else: if doc_id_found and registry_id_found in database.REGISTRY[user]["comunidades"]: self.inclui (doc_id_found, item[0], paginas) # Blogs encontrados for post in item[1]['blog']: registry_id_found = post[2] doc_id_found = post[3] if registry_id_found in database.REGISTRY and doc_id_found in blog.database.BLOG: if database.REGISTRY[registry_id_found]["privacidade"] == u"Pública": if doc_id_found and registry_id_found != user: self.inclui (doc_id_found, item[0], posts) else: if core.model.isFriendOrMember(user, registry_id_found): self.inclui (doc_id_found, item[0], posts) ''' if isAUser(post.split("/")[0]): if doc_id_found and registry_id_found != user and \ post.split("/")[0] in database.REGISTRY[user]["amigos"]: self.inclui (doc_id_found, item[0], posts) else: if doc_id_found and registry_id_found in database.REGISTRY[user]["comunidades"]: self.inclui (doc_id_found, item[0], posts) ''' # Usuários encontrados for perfil in item[1]['user']: registry_id_found = perfil[2] if registry_id_found and \ registry_id_found in database.REGISTRY and \ registry_id_found not in friends and \ registry_id_found != user and \ registry_id_found not in database.REGISTRY[user]["amigos_convidados"] and \ registry_id_found not in database.REGISTRY[user]["amigos_pendentes"] and \ database.REGISTRY[registry_id_found]["privacidade"] == u"Pública": self.inclui (registry_id_found, item[0], perfis) # Comunidades encontradas for comunidade in item[1]['community']: registry_id_found = comunidade[2] if registry_id_found and \ registry_id_found in database.REGISTRY and \ registry_id_found not in database.REGISTRY[user]["comunidades"] and \ database.REGISTRY[registry_id_found]["privacidade"] == u"Pública" and \ user not in database.REGISTRY[registry_id_found]["participantes"] and \ user not in database.REGISTRY[registry_id_found]["participantes_pendentes"] : self.inclui (registry_id_found, item[0], comunidades) paginas.reverse() posts.reverse() self.render("modules/friends/sugest-content.html", NOMEPAG="amigos", \ REGISTRY_ID=registry_id, PAGINAS=paginas[:20], POSTS=posts[:20], PERFIL=perfis, \ COMUNIDADES=comunidades)
def post(self, registry_id, tipo): user = self.get_current_user() msg = "" if isOwner(user, registry_id): self._aval = model.Evaluation() self._aval.nome = self.get_argument("nome","") if not self._aval.nome: msg += u"Nome da avaliação não informado.<br/>" else: self._aval.nome = remove_special_chars(remove_diacritics(self._aval.nome.replace(" ","_"))) if self._aval.nome == "": msg += u"Nome da avaliação inválido.<br/>" self._aval.descricao = self.get_argument("descricao", "") if tipo=="member": self._aval.tipo = "participantes" self._comu = core.model.Community().retrieve(registry_id) avaliados = self._comu.participantes grupos = self._comu.groups groupnames = {} for grupo in grupos: groupnames[grupo] = grupo else: # tipo =="wiki" self._aval.tipo = u"páginas" avaliados = [row.key[1].split("/")[1] for row in wiki.database.WIKI.view('wiki/partial_data',startkey=[registry_id],endkey=[registry_id, {}]) if row.value["is_folder"]!="S" and not row.value["removido"]] (grupos, groupnames) = wiki.model.Wiki.listWikiFolderItens(registry_id) # qdo colocamos as views passou a dar erro de encoding # avaliados = [x.encode("UTF-8") for x in avaliados] for item in avaliados: if self.get_argument(item,"") == "S": self._aval.avaliados.append(item) if not self._aval.avaliados: msg += u"Selecione pelo menos um item para ser avaliado.<br/>" pontuacao = self.get_argument("pontuacao","").strip() if pontuacao: self._aval.pontuacao = pontuacao.split(",") else: msg += u"O campo 'Pontuação' não foi preenchido.<br/>" self._aval.owner = user self._aval.data_cri = str(datetime.now()) self._aval.data_inicio = self.get_argument("data_start","") if not self._aval.data_inicio: msg += u"O campo 'Data/hora de início' não foi preenchido.<br/>" self._aval.data_encerramento = self.get_argument("data_end","") if not self._aval.data_encerramento: msg += u"O campo 'Data/hora de encerramento' não foi preenchido.<br/>" if msg: self.render("modules/evaluation/newevaluation-form.html", MSG=msg, EVALUATIONDATA=self._aval, \ AVALIADOS=avaliados, REGISTRY_ID=registry_id, \ GROUPS=grupos, \ GROUPNAMES=groupnames, \ NOMEPAG=u"Avaliações") else: aval_id = "%s/%s" % (registry_id, self._aval.nome) try: self._aval.save(id=aval_id) except Exception as detail: self.render("modules/evaluation/newevaluation-form.html", MSG=u"Já existe uma avaliação com este nome", EVALUATIONDATA=self._aval, \ AVALIADOS=avaliados, REGISTRY_ID=registry_id, \ GROUPS=grupos, \ GROUPNAMES=groupnames, \ NOMEPAG=u"Avaliações") return log.model.log(user, u'criou a avaliação', objeto=aval_id, tipo="evaluation") self.redirect("/evaluation/%s" % registry_id) else: self.render("home.html", MSG=u"Você não pode criar avaliação nesta comunidade.", REGISTRY_ID=ifExists(registry_id, user), \ NOMEPAG="comunidades")
def post(self): user = self.get_current_user() tipo = self.get_argument("tipo","") str_busca = self.get_argument("str_busca","") if str_busca: if tipo == "T": # busca por tags tags = remove_diacritics(str_busca.lower()) if tags: resultados_busca = {} for tag in list(set(tags.split(","))): temp_busca = findTag(tag.strip()) for item in temp_busca: for tupla in temp_busca[item]: registry_id = tupla[2] # se este item ainda não foi encontrado e ele # não faz parte de uma comunidade privada... #if self.isAllowedToAccess(user, registry_id, display_error=False) and \ if core.model.isAllowedToAccess(user, registry_id)==0: if item not in resultados_busca: resultados_busca[item] = [tupla] elif tupla not in resultados_busca[item]: resultados_busca[item].append(tupla) for item in resultados_busca: # ordena pela data não formatada resultados_busca[item].sort(key=itemgetter(4), reverse=True) # limita o número de itens exibidos resultados_busca[item] = resultados_busca[item][:_MAX_RESULTADOS_POR_ITEM] totais = [len(resultados_busca[key]) for key in resultados_busca] self.render("modules/search/search-results.html", REGISTRY_ID=user, \ NOMEPAG='busca', \ RESULTADOS=resultados_busca, LEGENDA=URL_TO_PAGETITLE, \ NUM_RESULT=sum(totais), \ TAGS_PROCURADAS=str_busca) return elif tipo == "P": # busca por usuários #registry_id = self.get_argument("registry_id","") registry_id = str_busca.split(":")[0] if isAUser(registry_id): self.redirect ("/user/%s"%registry_id) return else: #msg = u'Usuário não encontrado.' msg = 121 elif tipo == "C": # busca por comunidades #registry_id = self.get_argument("registry_id","") registry_id = str_busca.split(":")[0] if isACommunity(registry_id): self.redirect ("/community/%s"%registry_id) return else: #msg = u'Comunidade não encontrada.' msg = 122 else: #msg = u'Tipo de busca incorreto.' msg = 123 else: #msg = u'Termos de busca não preenchidos.' msg = 124 #self.render("popup_msg.html", MSG=msg) self.redirect ("/profile/%s?msg=%s" % (user,msg))
def post(self, registry_id): user = self.get_current_user() if self.request.files: # este split é para resolver o problema do IE, que manda o caminho completo. filename = self.request.files["arquivo"][0]["filename"].split("\\")[-1] #filename = remove_diacritics(filename) #filename = filename.replace(" ", "_") filename = remove_special_chars(remove_diacritics(filename.replace(" ","_"))) if filename=="": self.write (dict(status=1, msg=u"Nome do arquivo inválido.")) return if filename[0]=="_": self.write (dict(status=1, msg=u"Nome do arquivo não pode iniciar com sublinhado (_).")) return if "." not in filename or filename.split(".")[-1].lower() not in ["gif", "jpg", "jpeg", "png"]: self.write (dict(status=1, msg=u"Utilize somente arquivos com extensão: gif, jpg, jpeg ou png.")) return if registry_id in core.database.REGISTRY: if not isUserOrMember(user, registry_id): self.write (dict(status=1, MSG=u"Você não tem permissão para carregar arquivos aqui.")) return # A chave _id do documento no couchdb é nome/arquivo file_id = '/'.join([registry_id,filename]) self._file = model.Studio().retrieve(file_id) if self._file: self.write (dict(status=1, MSG=u"Já existe um arquivo com este mesmo nome (%s). Remova-o antes de subir com uma nova versão." % file_id)) return else: self._file = model.Studio(file_id=file_id) if self.get_argument("type","")=="": self.write (dict(status=1, MSG=u"Escolha a fase onde a imagem deve ser armazenada.")) return self._file.type = int(self.get_argument("type","")) self._file.description = self.get_argument("description","") self._file.url = self.get_argument("url","") self._file.tags = splitTags(self.get_argument("tags","")) self._file.owner = self._file.alterado_por = user self._file.registry_id = registry_id self._file.data_upload = self._file.data_alt = str(datetime.now()) self._file.filename = filename if not self._file.saveFile(file_id, self.request.files): self.write (dict(status=1, MSG=u"Erro na leitura do arquivo de imagem. (%s)" %file_id)) return log.model.log(user, u'criou o arquivo', objeto=file_id, tipo="file") self.write (dict(status=0, redirect="/studio/%s" % (registry_id))) else: self.write (dict(status=1, msg=u"Usuário ou comunidade inexistentes.")) else: self.write (dict(status=1, msg=u"Erro: Arquivo inexistente!"))