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!"))
