def get(self, registry_id, post_id):
user = self.get_current_user()
doc_id = '/'.join([registry_id, post_id])
self._blog = model.Blog().retrieve(doc_id, include_removed=True)
if self._blog:
# salva variáveis para poder ter acesso a elas depois de remover do banco
owner = self._blog.owner
# se é uma página e está na lixeira, remove-a
if self._blog.historico[-1]["conteudo"] == _CONTEUDO_REMOVIDO:
self._blog.deletePost(user, permanently=True)
# notifica o dono da página excluída
email_msg = u"Post removido da lixeira: "+doc_id+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(owner, user, u"removeu um post seu da lixeira", \
message=email_msg, \
link="blog/"+registry_id)
log.model.log(user, u'removeu da lixeira o post', objeto=doc_id, tipo="none")
self.redirect("/blog/deleted/%s" % registry_id )
else:
raise HTTPError(404)
def get(self, registry_id):
user = self.get_current_user()
bookmark_id = self.get_argument("id","")
self._bookmark = model.Bookmarks().retrieve(bookmark_id)
if self._bookmark != None:
bookmark_owner = self._bookmark.owner
if not isAllowedToDeleteObject(user, bookmark_owner, registry_id+"/"+bookmark_id):
raise HTTPError(403)
return
url = self._bookmark.url
self._bookmark.deleteBookmark()
# notifica o dono do arquivo excluído
email_msg = "Favorito removido: "+url+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(bookmark_owner, user, u"removeu um favorito criado por você", \
message=email_msg, \
link="bookmarks/"+registry_id)
log.model.log(user, u'removeu um link de favoritos de', objeto=registry_id, tipo="bookmarks")
self.redirect("/bookmarks/%s" % registry_id)
return
else:
raise HTTPError(404)
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:
if isAllowedToComment(user, doc_id, self._blog.owner):
comment_data = self._blog.addComment(user, str(datetime.now()), self.get_argument("comment",""))
if comment_data:
# notifica o dono do post comentado
email_msg = "Post: "+self._blog.titulo+"\n"+\
comment_data["comment"]+"\n"+\
Notify.assinatura(user, registry_id, comment_data["data_cri"])+"\n\n"
Notify.email_notify(self._blog.owner, user, "comentou seu post no Blog", \
message=email_msg, \
link="blog/"+doc_id)
log.model.log(user, u'comentou no blog', objeto=doc_id, tipo="blog")
self.redirect("/blog/%s" % doc_id)
else:
self.render("home.html", MSG=u"O comentário não pode ser vazio.", REGISTRY_ID=registry_id, NOMEPAG="blog")
else:
self.render("home.html", MSG=u"Somente amigos de um usuário ou membros de uma comunidade podem comentar.", REGISTRY_ID=registry_id, NOMEPAG="blog")
else:
raise HTTPError(404)
def get(self, registry_id, pagina):
user = self.get_current_user()
if pagina in ["home", "indice"]:
self.write (dict(status=1, msg=u"Esta página não pode ser removida."))
else:
doc_id = '/'.join([registry_id, pagina])
self._wiki = model.Wiki().retrieve(doc_id, include_removed=True)
if self._wiki:
# salva variáveis para poder ter acesso a elas depois de remover do banco
owner = self._wiki.owner
# se é uma página e está na lixeira, remove-a
if self._wiki.is_folder!="S" and self._wiki.historico[-1]["conteudo"] == _CONTEUDO_REMOVIDO:
self._wiki.deleteWiki(user, permanently=True)
# notifica o dono da página excluída
email_msg = u"Página removida da lixeira: "+doc_id+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(owner, user, u"removeu uma página sua da lixeira", \
message=email_msg, \
link="wiki/"+registry_id)
log.model.log(user, u'removeu da lixeira a página', objeto=doc_id, tipo="none")
self.redirect("/wiki/deleted/%s" % registry_id )
else:
self.write (dict(status=1, msg=u"Página não encontrada."))
def post(self, registry_id, pagina):
user = self.get_current_user()
doc_id = "/".join([registry_id, pagina])
self._wiki = model.Wiki().retrieve(doc_id)
if self._wiki:
comentario = dict()
comentario["comment"] = self.get_argument("comment","")
comentario["owner"] = user
comentario["data_cri"] = str(datetime.now())
if comentario["comment"]:
self._wiki.comentarios.append(comentario)
self._wiki.save()
# notifica o dono do post comentado
email_msg = u"Página: "+self._wiki.nomepag+"\n"+\
comentario["comment"]+"\n"+\
Notify.assinatura(user, registry_id, comentario["data_cri"])+"\n\n"
Notify.email_notify(self._wiki.owner, user, u"comentou sua página", \
message=email_msg, \
link="wiki/"+doc_id)
log.model.log(user, u'comentou a página', objeto=doc_id, tipo="wiki")
self.redirect("/wiki/%s" % doc_id)
else:
self.write (dict(status=1, msg=u"O comentário não pode ser vazio."))
else:
self.write (dict(status=1, msg=u"Página não encontrada."))
def incluirParticipantes(self, users):
msg = ""
users = users[0].split("\r\n")
for u in users:
user_id = u.strip(" ")
if user_id:
_member = core.model.Member().retrieve(user_id)
if _member and _member.isAUser():
if user_id not in self._comu.participantes:
self._comu.participantes.append(user_id)
if self._comu.id not in _member.comunidades:
_member.comunidades.append(self._comu.id)
_member.save()
# notifica o usuário incluído na comunidade
email_msg = "Comunidade: "+self._comu.description+" ("+self._comu.id+")\n"+\
u"Clique no botão abaixo para visitá-la.\n\n"+\
Notify.assinatura(self._user, self._comu.id, str(datetime.now()))+"\n\n"
Notify.email_notify(user_id, self._user, u"incluiu você como participante de uma comunidade", \
message=email_msg, \
link="community/"+self._comu.id)
else:
msg += user_id + " "
return "Usuário(s) não encontrado(s): " + msg if msg else "Todos os usuários foram incluídos."
def post(self, registry_id, filename):
user = self.get_current_user()
comentario = self.get_argument("comment","")
file_id = "/".join([registry_id, unquote(filename)])
self._file = model.Studio().retrieve(file_id)
if self._file:
if isAllowedToComment(user, file_id, self._file.owner):
if comentario:
self._file.newFileComment(user, comentario)
# notifica o dono do post comentado
email_msg = "Arquivo: "+file_id+"\n"+\
self._file.comentarios[-1]["comment"]+"\n"+\
Notify.assinatura(user, registry_id, self._file.comentarios[-1]["data_cri"])+"\n\n"
Notify.email_notify(self._file.owner, user, "comentou a imagem no studio de games", \
message=email_msg, \
link="studio/info/"+file_id)
log.model.log(user, u'comentou a imagem no studio de games', objeto=file_id, tipo="studio")
self.redirect("/studio/info/%s" % file_id)
else:
self.render("home.html", MSG=u"O comentário não pode ser vazio.", REGISTRY_ID=registry_id, NOMEPAG=u'Estúdio')
else:
self.render("home.html", MSG=u"Você não tem permissão para comentar este arquivo.", REGISTRY_ID=registry_id, NOMEPAG=u'Estúdio')
else:
self.render("home.html", MSG=u"Arquivo não encontrado.", REGISTRY_ID=registry_id, NOMEPAG=u'Estúdio')
def get(self, registry_id, name_id):
user = self.get_current_user()
_va = model.Videoaula.retrieve_by_name_id(registry_id, name_id)
if _va:
va_owner = _va.owner
if not isAllowedToDeleteObject(user, va_owner, registry_id+"/"+name_id):
raise HTTPError(403)
return
va_name = str_limit(remove_html_tags(_va.titulo), 200)
_va.delete()
# notifica o dono da videoaula excluída
email_msg = "Videoaula removida: "+va_name+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(va_owner, user, u"removeu uma videoaula criada por você", \
message=email_msg, \
link="videoaula/"+registry_id)
log.model.log(user, u'removeu uma videoaula de', objeto=registry_id, tipo="videoaula")
self.redirect("/videoaula/%s" % registry_id)
else:
raise HTTPError(404)
def get(self, registry_id):
user = self.get_current_user()
glossary_item_id = self.get_argument("item_id","")
glossary_id = registry_id+"/"+glossary_item_id
self._glossary = model.Glossary().retrieve(glossary_id)
if self._glossary != None:
glossary_owner = self._glossary.owner
if not isAllowedToDeleteObject(user, glossary_owner, glossary_id):
self.render("home.html", MSG=u"Você não tem permissão para remover este termo deste glossário.", \
NOMEPAG=NOME_PAG_CLOSSARIO, REGISTRY_ID=registry_id)
return
term = self._glossary.term
self._glossary.deleteGlossaryItem()
# notifica o dono do arquivo excluído
email_msg = u"Item de glossário removido: "+term+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(glossary_owner, user, u"removeu um termo de glossário criado por você", \
message=email_msg, \
link="glossary/"+registry_id)
log.model.log(user, u'removeu um termo do glossário de', objeto=registry_id, tipo="glossary")
self.redirect("/glossary/%s" % registry_id)
else:
raise HTTPError(404)
def post(self, registry_id):
user = self.get_current_user()
bookmark_id = self.get_argument("id","")
comentario = self.get_argument("comment","")
self._bookmark = model.Bookmarks().retrieve(bookmark_id)
if self._bookmark:
if isAllowedToComment(user, registry_id+"/"+bookmark_id, self._bookmark.owner):
if comentario:
self._bookmark.addBookmarkComment(user, comentario)
# notifica o dono do favorito comentado
email_msg = "Favorito: "+self._bookmark.url+"\n"+\
self._bookmark.comentarios[-1]["comment"]+"\n"+\
Notify.assinatura(user, registry_id, self._bookmark.comentarios[-1]["data_cri"])+"\n\n"
Notify.email_notify(self._bookmark.owner, user, "comentou seu favorito", \
message=email_msg, \
link="bookmarks/comment/%s?id=%s"%(registry_id, self._bookmark.id))
log.model.log(user, u'comentou um link favorito de', objeto=registry_id, tipo="bookmarks")
self.redirect("/bookmarks/comment/%s?id=%s" % (registry_id, self._bookmark.id))
else:
self.render("home.html", MSG=u"O comentário não pode ser vazio.", REGISTRY_ID=registry_id, NOMEPAG='favoritos')
else:
raise HTTPError(403)
else:
raise HTTPError(404)
def get(self, id_community):
user = self.get_current_user()
member = self.get_argument('member', "")
msg = ''
_comu = core.model.Community().retrieve(id_community)
if _comu:
if not _comu.isOwner(user) or not _comu.isMedianteConvite():
raise HTTPError(403)
return
elif not member:
msg = u'Usuário não especificado!'
else:
_member = core.model.Member().retrieve(member)
#print [item for item in _member]
if _member:
if member in _comu.participantes_pendentes:
msg = u'Usuário já convidado! Aguardando resposta...'
elif member in _comu.participantes:
msg = u'Usuário já está nesta comunidade!'
else:
_comu.participantes_pendentes.append(member)
_comu.save()
_member.comunidades_pendentes.append(id_community)
_member.save()
# notifica o usuário convidado
email_msg = u"Comunidade: "+_comu.description+" ("+id_community+")\n"+\
u"Para aceitar esta solicitação clique no botão abaixo ou acesse o seu Painel de Controle e clique em Convites.\n\n"+\
Notify.assinatura(user, id_community, str(datetime.now()))+"\n\n"
Notify.email_notify(member, user, u"convidou você para participar de uma comunidade", \
message=email_msg, \
link="invites")
log.model.log(user, u'convidou um participante para a comunidade', objeto=id_community, tipo="community", news=False)
msg = u'Convite para usuário enviado com sucesso!'
else:
msg = u'Usuário inexistente!'
else:
raise HTTPError(404)
return
#self.redirect("/profile/%s?msg=%d" % (id_community,err))
self.render("modules/community/invite-form.html", NOMEPAG='participantes', REGISTRY_ID=id_community, MSG=msg,\
TABS=self.setTabs(_comu))
def post(self, registry_id, name_id):
user = self.get_current_user()
msg = ""
_reply = model.Reply()
_reply.titulo = self.get_argument("titulo","")
_reply.conteudo = self.get_argument("conteudo","")
if _reply.conteudo == "":
msg += u"O conteúdo do tópico não pode ser vazio.<br/>"
self.render("modules/forum/reply-form.html", NOMEPAG="forum", REGISTRY_ID=registry_id, REPLY=_reply, MSG=msg)
return
else:
_reply.data_cri = str(datetime.now())
_reply.data_alt = _reply.data_cri
_reply.service = "forum"
_reply.type = "reply"
doc_id = uuid4().hex
_reply.registry_id = registry_id
_reply.owner = user
_reply.alterado_por = user
_topic = model.Topic().retrieve_by_name_id(registry_id, name_id)
_reply.group_id = _topic.id # inclui a referênca ao tópico no reply
_reply.save(id=doc_id)
_topic.ultimo_reply = _reply.data_cri # atualiza data do último reply no tópico
try:
_topic.save(id=_topic.id)
except ResourceConflict:
# ignora se houve conflito ao salvar o tópico
pass
if _topic.receber_email=="S":
# Notifica o dono do tópico respondido
assunto = u"respondeu um tópico que você criou no Fórum da comunidade %s" % registry_id
email_msg = u"Comunidade: "+registry_id+"\n" + \
u"Tópico: "+_topic.titulo+"\n\n" + \
_reply.titulo+"\n"+ \
_reply.conteudo+"\n\n"+ \
Notify.assinatura(_reply.owner,registry_id,_reply.data_cri)+"\n\n"
Notify.email_notify(_topic.owner, _reply.owner, assunto, \
message=email_msg, \
link="forum/"+registry_id)
log.model.log(user, u'respondeu um tópico do forum', objeto=registry_id, tipo="forum")
self.redirect("/forum/%s/%s" % (registry_id, name_id))
def post(self, registry_id, pagina):
user = self.get_current_user()
doc_id = '/'.join([registry_id, pagina])
self._wiki = model.Wiki().retrieve(doc_id)
if self._wiki:
msg = ""
conteudo_db = ''
tags_db = []
if self._wiki.rev != self.get_argument("revision",""):
# Document Update Conflict.
msg += u"Conflito ao salvar o documento. Enquanto você editava-o, ele foi alterado por outro usuário.<br/>"
msg += u"Compare as duas versões abaixo e refaça as alterações que ainda achar pertinentes.<br/>"
msg += u"Ao final envie novamente o formulário.<br/>"
# preserva os dados alterados pelo outro usuário
conteudo_db = self._wiki.historico[-1]["conteudo"]
tags_db = self._wiki.tags
if self.get_argument("conteudo","") != "" :
conteudo = self.get_argument("conteudo")
else:
msg += u"Conteúdo não preenchido<br/>"
conteudo = " "
old_tags = self._wiki.tags # preserva tags anteriores
self._wiki.tags = splitTags(self.get_argument("tags","")) # suas tags
if msg:
self.write (dict(status=1, msg=msg))
else:
# registro da atualização
self._wiki.historico.append(dict(
conteudo=conteudo,
data_alt = str(datetime.now()),
alterado_por = user
))
# salva o documento alterado
self._wiki.saveWiki(old_tags=old_tags)
# notifica o dono da página alterada
email_msg = u"Página alterada: "+doc_id+"\n"+\
Notify.assinatura(user, registry_id, self._wiki.historico[-1]["data_alt"])+"\n\n"
Notify.email_notify(self._wiki.owner, user, u"alterou uma página criada por você", \
message=email_msg, \
link="wiki/"+doc_id)
log.model.log(user, u'alterou a página', objeto=doc_id, tipo="wiki")
self.redirect("/wiki/%s" % doc_id)
else:
self.write (dict(status=1, msg=u"Documento não encontrado: provavelmente o mesmo foi removido enquanto você editava-o."))
def post(self, registry_id):
user = self.get_current_user()
id = self.get_argument("id","")
_reply = model.Reply().retrieve(id)
if not _reply or registry_id != _reply.registry_id:
# chamada inválida (id não existe ou reply não corresponde a um forum do registry_id)
raise HTTPError(404)
return
if user != _reply.owner:
# sem permissão
raise HTTPError(403)
return
_reply.titulo = self.get_argument("titulo","")
_reply.conteudo = self.get_argument("conteudo","")
if _reply.conteudo == "":
msg = u"O conteúdo do tópico não pode ser vazio.<br/>"
self.render("modules/forum/reply-form.html", NOMEPAG="forum", REGISTRY_ID=registry_id, REPLY=_reply, MSG=msg)
return
_reply.data_alt = str(datetime.now())
_reply.alterado_por = user
_reply.save()
_topic = model.Topic().retrieve(_reply.group_id)
_topic.ultimo_reply = _reply.data_alt # atualiza data do último reply no tópico
try:
_topic.save()
except ResourceConflict:
# ignora se houve conflito ao salvar o tópico
pass
if _topic.receber_email=="S":
# Notifica o dono do tópico respondido
assunto = u"alterou uma resposta de um tópico que você criou no Fórum da comunidade %s" % registry_id
email_msg = u"Comunidade: "+registry_id+"\n" + \
u"Tópico: "+_topic.titulo+"\n\n" + \
_reply.titulo+"\n"+ \
_reply.conteudo+"\n\n"+ \
Notify.assinatura(_reply.owner,registry_id,_reply.data_alt)+"\n\n"
Notify.email_notify(_topic.owner, _reply.owner, assunto, \
message=email_msg, \
link="forum/"+registry_id)
log.model.log(user, u'alterou uma resposta de um tópico do forum', objeto=registry_id, tipo="forum")
self.redirect("/forum/%s/%s" % (registry_id, _topic.name_id))
def batch_notify():
num = 0
data_inicio = str(datetime.now())
for user in database.NOTIFICATION_CHAT:
if "_design/" in user or user in ['_id', '_rev']:
continue
# usuário a ser avisado
assunto = u"Mensagens de chat para você"
msg = ""
_notification = NotificationChat().retrieve(user)
email = _notification.email
nome_destinatario = _notification.name
for reg in _notification.registros:
msg = msg + reg + "\n" + \
"----------------------------------------\n\n"
if Notify.enviaEmail (email, assunto, nome_destinatario, msg, "chat/"+user+"/messages"):
# print "Email enviado com sucesso para " + email
_notification.delete()
num = num + 1
#else:
#print "Erro no envio do email para " + email
if LOG_THREADS:
# se estiver rodando em localhost e ENVIAR_EMAIL_DE_LOCALHOST for False
# não envia o email apesar da mensagem do log dizer que enviou
text_file = open(DIR_RAIZ_ACTIV+LOG_THREADS_FILE, "a+")
text_file.write(u"[%s - %s] ChatNotifier: %d emails enviados.\n" % (data_inicio, str(datetime.now()), num))
text_file.close()
def notify():
for user in NOTIFICATION:
if user not in ['_id', '_rev']:
# usuário a ser avisado
to_user_data = REGISTRY[user]
email = to_user_data["email"]
nome_destinatario = to_user_data["name"]
assunto = u"Veja o que aconteceu recentemente por aqui"
msg = ""
for registro in NOTIFICATION[user]["registros"]:
msg = msg + registro["subject"] + "\n" +\
registro["message"] + "\n" +\
"\n----------------------------------------\n\n"
if Notify.enviaEmail (email, assunto, nome_destinatario, msg, "user/"+user):
print "Email enviado com sucesso para " + email
try:
del NOTIFICATION[user]
except:
print "Erro na exclusão de registro: " + user
else:
print "Erro no envio do email para " + email
def get(self):
user = self.get_current_user()
user_data = _EMPTYMEMBER()
user_data.update(database.REGISTRY[user])
msg = ''
friend = self.get_argument('friend', "")
if friend == user:
msg = u'Você não pode convidar a si mesmo como amigo.'
elif isAUser(friend):
if friend in user_data['amigos_convidados']:
msg = u'Você já convidou %s anteriormente. Aguardando resposta.' % friend
elif friend in user_data['amigos_pendentes']:
msg = u'%s já te convidou anteriormente. Aguardando sua resposta.' % friend
elif friend in user_data['amigos']:
msg = u'Você já é amigo de %s.' % friend
else:
user_data['amigos_convidados'].append(friend)
try:
database.REGISTRY[user] = user_data
except ResourceConflict as detail:
# se o registry está sendo usado ao mesmo tempo pela thread dá erro 503
raise HTTPError(503)
friend_data = _EMPTYMEMBER()
friend_data.update(database.REGISTRY[friend])
friend_data['amigos_pendentes'].append(user)
database.REGISTRY[friend] = friend_data
msg = u'Convite para %s enviado com sucesso.' % friend
# notifica o usuário convidado
email_msg = u"Para aceitar esta solicitação clique no botão abaixo ou acesse o seu Painel de Controle e clique em Convites.\n\n"
Notify.email_notify(friend, user, u"convidou você para amigo", \
message=email_msg, \
link="invites")
log.model.log(user, u'convidou um usuário para amigo', tipo="user", news=False)
else:
msg = u'Usuário não encontrado.'
self.render("modules/friends/friend-form.html", NOMEPAG="amigos", REGISTRY_ID=user, MSG=msg)
def post(self, registry_id):
user = self.get_current_user()
old_parent = self.get_argument("folder","")
items = self.request.arguments["items"]
new_parent = self.get_argument("destino","")
if new_parent!="":
parent_id = '/'.join([registry_id,new_parent])
test_parent_folder = model.Wiki().retrieve(parent_id)
if not test_parent_folder:
msg = u"Impossível mover objetos para pasta inexistente (%s)<br/>" % test_parent_folder.nomepag
self.write (dict(status=1, msg=msg))
return
elif not isAllowedToWriteObject(user, "wiki", registry_id, new_parent):
msg = u"Você não tem permissão para mover objetos para esta pasta."
self.write (dict(status=1, msg=msg))
return
for item in items:
doc_id = registry_id+"/"+item
self._wiki = model.Wiki().retrieve(doc_id)
old_path = self._wiki.getPagePath(links=False, includefolder=False)
self._wiki.moveWiki (registry_id, user, old_parent, new_parent)
new_path = self._wiki.getPagePath(links=False, includefolder=False)
legenda = "pasta" if self._wiki.is_folder=="S" else u"página"
# notifica o dono da página movida
email_msg = legenda+u" movida: "+self._wiki.nomepag+"\n"+\
u"De: " + old_path + " Para: " + new_path + "\n" +\
Notify.assinatura(user, registry_id, self._wiki.data_alt if self._wiki.is_folder=="S" else self._wiki.historico[-1]["data_alt"])+"\n\n"
Notify.email_notify(self._wiki.owner, user, u"moveu uma "+legenda+u" criada por você", \
message=email_msg, \
link="/wiki/%s?folder=%s"%(registry_id, item) if legenda=="pasta" else "wiki/"+doc_id)
#log.model.log(user, u'moveu a '+legenda, objeto=doc_id, tipo="wiki")
if self._wiki.is_folder=="S":
log.model.log(user, u'moveu a pasta', objeto=registry_id+"/"+self._wiki.nomepag, link="/wiki/%s?folder=%s"%(registry_id, item), tipo="wiki")
else:
log.model.log(user, u'moveu a página', objeto=doc_id, tipo="wiki")
self.write (dict(status=0, msg=u"Páginas/Pastas movidas com sucesso."))
def get(self, registry_id, pagina):
user = self.get_current_user()
versao = self.get_argument("versao","-1")
doc_id = '/'.join([registry_id, pagina])
self._wiki = model.Wiki().retrieve(doc_id, include_removed=True)
if self._wiki and self._wiki.is_folder!="S":
self._wiki.restoreVersion(int(versao))
# notifica o dono da página restaurada
email_msg = u"Página restaurada: "+doc_id+"\n"+\
u"Versão: " + versao + "\n" +\
Notify.assinatura(user, registry_id, self._wiki.historico[-1]["data_alt"])+"\n\n"
Notify.email_notify(self._wiki.owner, user, u"restaurou uma versão de uma página criada por você", \
message=email_msg, \
link="/wiki/%s/%s"%(registry_id, pagina))
log.model.log(user, u'restaurou a página', objeto=doc_id, tipo="wiki")
self.redirect("/wiki/history/%s/%s"%(registry_id,pagina))
def get(self, registry_id, post_id):
user = self.get_current_user()
versao = self.get_argument("versao","-1")
doc_id = '/'.join([registry_id, post_id])
self._blog = model.Blog().retrieve(doc_id, include_removed=True)
if self._blog:
self._blog.restoreVersion(int(versao))
# notifica o dono da página restaurada
email_msg = u"Post restaurado: "+doc_id+"\n"+\
u"Versão: " + versao + "\n" +\
Notify.assinatura(user, registry_id, self._blog.historico[-1]["data_alt"])+"\n\n"
Notify.email_notify(self._blog.owner, user, u"restaurou uma versão de um post criado por você", \
message=email_msg, \
link="/blog/%s/%s"%(registry_id, post_id))
log.model.log(user, u'restaurou o post', objeto=doc_id, tipo="blog")
self.redirect("/blog/history/%s/%s"%(registry_id,post_id))
def incluirParticipantes(self, users):
msg = ""
users = users[0].split("\r\n")
for user1 in users:
user_id = user1.strip(" ")
if user_id:
_member = core.model.Registry().retrieve(user_id)
if _member and _member.isAUser():
if user_id not in self._comu.participantes:
self._comu.participantes.append(user_id)
if self._comu.id not in _member.comunidades:
_member.comunidades.append(self._comu.id)
_member.save()
# notifica o usuário incluído na comunidade
email_msg = "Comunidade: "+self._comu.description+" ("+self._comu.id+")\n"+\
u"Clique no botão abaixo para visitá-la.\n\n"+\
Notify.assinatura(self._user, self._comu.id, str(datetime.now()))+"\n\n"
Notify.email_notify(user_id, self._user, u"incluiu você como participante de uma comunidade", \
message=email_msg, \
link="community/"+self._comu.id)
else:
msg += user_id + " "
self._comu.save()
if msg:
msg = "Usuários não encontrados: " + msg
else:
msg = "Todos os usuários foram incluídos."
# o dono da comunidade não vai na lista pois ele não pode ser removido
# o usuário logado também não pode ser removido
participantes = [x for x in self._comu.participantes if x != self._comu.owner and x != self._user]
self.render("modules/community/admin.html", REGISTRY_ID=self._comu.id, \
NOMEPAG='comunidades', \
PARTICIPANTES=participantes, \
PENDENTES=self._comu.participantes_pendentes, \
MSG=msg)
def _send_email(self, quem_convidou, convidado, comunidade):
assunto = "Convite para participar da comunidade %s na plataforma %s" % (comunidade, PLATAFORMA)
msg_txt = (u"Você foi convidado por %s para participar da comunidade %s no %s e seu email %s não consta entre os usuários cadastrados na plataforma.\n\n" + \
u"Caso você já seja usuário do %s e esteja cadastrado com outro email, avise %s para que ele possa lhe reenviar o convite para o email correto.\n\n" + \
u"Para se cadastrar no %s, acesse a intranet da UFRJ e clique em 'ActivUFRJ' na tela principal. \n\n") % \
(quem_convidou, comunidade, PLATAFORMA, convidado, PLATAFORMA, quem_convidou, PLATAFORMA)
if Notify.enviaEmail (convidado, assunto, convidado, msg_txt, ""):
return u"E-mail enviado com sucesso.<br/>"
else:
return u"Erro no envio do E-mail.<br/>"
def enviaConvite(self, user, convidado, key):
assunto = "Convite para a plataforma %s" % PLATAFORMA
msgTxt = (u"Você foi convidado por %s para a plataforma educacional %s.\n\n" + \
u"Clique no botão abaixo ou copie e cole o endereço " + \
u"http://%s/new/user?mkey=%s\n\n no seu navegador para se cadastrar. \n\n") % \
(user, PLATAFORMA, PLATAFORMA_URL, key)
if Notify.enviaEmail (convidado, assunto, convidado, msgTxt, "new/user?mkey=%s" % key):
return u"Convite enviado com sucesso.<br/>"
else:
return u"Erro no envio do E-mail. Clique em reenviar para tentar novamente.<br/>"
def post(self, registry_id, pagina):
user = self.get_current_user()
doc_id = '/'.join([registry_id, pagina])
self._wiki = model.Wiki().retrieve(doc_id)
if self._wiki:
old_name = self._wiki.nomepag
new_name = self.get_argument("nomepag_novo","")
if new_name:
if model.Wiki.nomepagExists(registry_id, new_name):
msg = u"Já existe uma página ou pasta com este nome<br/>"
self.write (dict(status=1, result=dict(path=self._wiki.getPagePath(links=False), pagina=pagina, newname=new_name, msg=msg,
e_usuario=isAUser(registry_id), e_owner=isOwner(user, registry_id))))
else:
# atualiza nome da pasta
self._wiki.nomepag = new_name
self._wiki.data_alt = str(datetime.now())
self._wiki.alterado_por = user
self._wiki.save()
# notifica o dono da página movida
email_msg = u"Pasta renomeada: "+doc_id+"\n"+\
u"De: " + old_name + " Para: " + new_name + "\n" +\
Notify.assinatura(user, registry_id, self._wiki.data_alt)+"\n\n"
Notify.email_notify(self._wiki.owner, user, u"renomeou uma pasta criada por você", \
message=email_msg, \
link="/wiki/%s?folder=%s"%(registry_id, pagina))
log.model.log(user, u'renomeou a pasta', objeto=registry_id+"/"+self._wiki.nomepag, link="/wiki/%s?folder=%s"%(registry_id, pagina), tipo="wiki")
self.write (dict(status=0, msg=u"Pasta renomeada com sucesso."))
else:
msg = u"Nome da pasta não preenchido."
self.write (dict(status=1, result=dict(path=self._wiki.getPagePath(links=False), pagina=pagina, newname=new_name, msg=msg,
e_usuario=isAUser(registry_id), e_owner=isOwner(user, registry_id))))
else:
self.write (dict(status=0, msg=u"Documento não encontrado: provavelmente o mesmo foi removido enquanto você editava-o."))
def get(self, registry_id, pagina):
user = self.get_current_user()
if pagina in ["home", "indice"]:
self.write (dict(status=1, msg=u"Esta página não pode ser removida."))
else:
doc_id = '/'.join([registry_id, pagina])
self._wiki = model.Wiki().retrieve(doc_id)
if self._wiki:
# salva variáveis para poder ter acesso a elas depois de remover do banco
nomepag = self._wiki.nomepag
owner = self._wiki.owner
is_folder = self._wiki.is_folder
legenda = "pasta" if self._wiki.is_folder=="S" else u"página"
if isAllowedToDeleteObject(user, self._wiki.owner, doc_id, wiki="S"):
if self._wiki.is_folder=="S" and self._wiki.folder_items!=[]:
self.write (dict(status=1, msg=u"Você não pode apagar uma pasta que não esteja vazia."))
return
parent_folder = self._wiki.parent_folder
self._wiki.deleteWiki(user)
# notifica o dono da página excluída
email_msg = legenda + u" removida: "+doc_id+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(owner, user, u"removeu uma %s criada por você"%legenda, \
message=email_msg, \
link="wiki/"+registry_id)
if is_folder=="S":
log.model.log(user, u'removeu a pasta', objeto=registry_id+"/"+nomepag, tipo="none")
else:
log.model.log(user, u'removeu a página', objeto=doc_id, tipo="none")
self.redirect("/wiki/%s?folder=%s" % (registry_id, parent_folder) )
else:
self.write (dict(status=1, msg=u"Você não tem permissão para remover esta %s."%legenda))
else:
self.write (dict(status=1, msg=u"Pasta/página não encontrada."))
def post(self, registry_id):
user = self.get_current_user()
items = self.request.arguments["items"] # items é uma lista
folder = self.get_argument("folder", "")
for item in items:
if item in ["home", "indice"]:
continue
doc_id = '/'.join([registry_id, item])
self._wiki = model.Wiki().retrieve(doc_id)
if self._wiki:
# salva variáveis para poder ter acesso a elas depois de remover do banco
nomepag = self._wiki.nomepag
owner = self._wiki.owner
is_folder = self._wiki.is_folder
legenda = "pasta" if self._wiki.is_folder=="S" else u"página"
if isAllowedToDeleteObject(user, self._wiki.owner, doc_id, wiki="S"):
if self._wiki.is_folder=="S" and self._wiki.folder_items!=[]:
# Você não pode apagar uma pasta que não esteja vazia.
continue
parent_folder = self._wiki.parent_folder
self._wiki.deleteWiki(user)
# notifica o dono da página excluída
email_msg = legenda + u" removida: "+doc_id+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(owner, user, u"removeu uma %s criada por você"%legenda, \
message=email_msg, \
link="wiki/"+registry_id)
#log.model.log(user, u'removeu a '+legenda, objeto=doc_id, tipo="none")
if is_folder=="S":
log.model.log(user, u'removeu a pasta', objeto=registry_id+"/"+nomepag, tipo="none")
else:
log.model.log(user, u'removeu a página', objeto=doc_id, tipo="none")
self.redirect("/wiki/%s?folder=%s" % (registry_id, folder) )
def get(self, registry_id, filename):
user = self.get_current_user()
file_id = '/'.join([registry_id,unquote(filename)])
self._file = model.Studio().retrieve(file_id)
if self._file != None:
if registry_id in core.database.REGISTRY:
file_owner = self._file.owner
if not isAllowedToDeleteObject(user, file_owner, file_id):
self.render("home.html", MSG=u"Você não tem permissão para remover este arquivo.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
return
(error, detail) = self._file.deleteFile()
if error:
self.render("home.html", MSG=u"Erro: %s" % detail, \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
return
# notifica o dono do arquivo excluído
email_msg = "Arquivo removido: "+file_id+"\n"+\
Notify.assinatura(user, registry_id, str(datetime.now()))+"\n\n"
Notify.email_notify(file_owner, user, u"removeu uma imagem na studio de games", \
message=email_msg, \
link="studio/"+registry_id)
log.model.log(user, u'removeu a imagem no studio de games', objeto=file_id, tipo="none")
self.redirect("/studio/%s" % registry_id)
return
else:
msg = u"Usuário ou comunidade inexistentes."
self.render("home.html", MSG=msg, \
NOMEPAG=u'Estúdio', REGISTRY_ID=user)
else:
self.render("home.html", MSG=u"Arquivo não encontrado.", \
NOMEPAG=u'Estúdio', REGISTRY_ID=registry_id)
def post(self):
user = self.get_current_user()
friend = self.get_argument('friend', "")
scrap = self.get_argument('scrap', "")
# trata injeção de tags html e acrescenta links nas urls
scrap = replace(scrap,"<","<")
scrap = replace(scrap,">",">")
scrap = processa_url(scrap)
if isFriendOrMember(user, friend):
msg = ''
if friend and getType(friend)[0] in ["member" , "community"]:
if scrap:
# saveScrap -----------------------------------------
self._scrap = model.Scrapbook().retrieve(friend)
if not self._scrap: self._scrap = model.Scrapbook(user_to=friend)
self._scrap.saveScrap(user_from=user, scrap=scrap)
# ---------------------------------------------------
# notifica quem recebeu o recado
email_msg = scrap+"\n"+\
Notify.assinatura (user, friend, self._scrap.recados[0].data)+"\n\n"
Notify.email_notify(friend, user, u"enviou um recado para %s" % friend, \
message=email_msg, link="scrap/"+friend)
log.model.log(user, u'enviou recado para', objeto=friend, tipo="user", news=False)
self.redirect ("/scrap/%s" % friend)
else:
self.render("home.html", MSG=u'Você não escreveu o seu recado.',\
NOMEPAG='recados', REGISTRY_ID=friend)
else:
raise HTTPError(404)
else:
raise HTTPError(403)
def post(self, id_community):
user = self.get_current_user()
_comu = core.model.Community().retrieve(id_community)
if _comu:
convidados = self.get_arguments("users")
emails = self.get_argument("emails", "")
for convidado in convidados:
_member = core.model.Member().retrieve(convidado)
if _comu.isMedianteConvite():
# convida usuário para a comunidade
if convidado not in _comu.participantes_pendentes and convidado not in _comu.participantes:
_comu.participantes_pendentes.append(convidado)
_comu.save()
_member.comunidades_pendentes.append(id_community)
_member.save()
# notifica o usuário convidado
email_msg = u"Comunidade: "+_comu.description+" ("+id_community+")\n"+\
u"Para aceitar esta solicitação clique no botão abaixo ou acesse o seu Painel de Controle e clique em Convites.\n\n"+\
Notify.assinatura(user, id_community, str(datetime.now()))+"\n\n"
Notify.email_notify(convidado, user, u"convidou você para participar de uma comunidade", \
message=email_msg, \
link="invites")
elif _comu.isObrigatoria(): # obrigatória
# inclui usuário na comunidade
if convidado not in _comu.participantes:
_comu.participantes.append(convidado)
_comu.save()
if _comu.id not in _member.comunidades:
_member.comunidades.append(_comu.id)
_member.save()
# notifica o usuário incluído na comunidade
email_msg = "Comunidade: "+_comu.description+" ("+_comu.id+")\n"+\
u"Clique no botão abaixo para visitá-la.\n\n"+\
Notify.assinatura(user, _comu.id, str(datetime.now()))+"\n\n"
Notify.email_notify(convidado, user, u"incluiu você como participante de uma comunidade", \
message=email_msg, \
link="community/"+_comu.id)
# POST /members/searchgroup/%s
# gera novamente a tela com os usuários
log.model.log(user, u'convidou um grupo de usuários para a comunidade', objeto=id_community, tipo="community", news=False)
self.render("modules/community/searchgroup-hidden-form.html", REGISTRY_ID=id_community, EMAILS=emails)
else:
raise HTTPError(404)
def post(self):
user = self.get_current_user()
mblog_id = self.get_argument("mblog_id","")
registry_id = self.get_argument("registry_id","")
self._registry = core.model.Registry().retrieve(registry_id)
if not self._registry:
raise HTTPError(404)
return
if not self._registry.isUserOrMember(user):
raise HTTPError(403)
return
self._mblog = model.Mblog().retrieve(mblog_id)
self._mblog_novo = model.Mblog()
self._mblog_novo.conteudo = self.get_argument("conteudo","")
if len (self._mblog_novo.conteudo) > MAX_CHR_MBLOG:
self._mblog_novo.conteudo = self._mblog_novo.conteudo[:MAX_CHR_MBLOG]
self._mblog_novo.registry_id = registry_id
self._mblog_novo.owner = user
self._mblog_novo.data_cri = str(datetime.now())
if self._mblog.conteudo_original:
# estou compartilhando uma msg já compartilhada
self._mblog_novo.conteudo_original = self._mblog.conteudo_original
self._mblog_novo.data_original = self._mblog.data_original
self._mblog_novo.registry_id_original = self._mblog.registry_id_original
self._mblog_novo.owner_original = self._mblog.owner_original
self._mblog_novo.mblog_id_original = self._mblog.mblog_id_original
else:
# estou compartilhando uma msg que ainda não foi compartilhada
self._mblog_novo.conteudo_original = self._mblog.conteudo
self._mblog_novo.data_original = self._mblog.data_cri
self._mblog_novo.registry_id_original = self._mblog.registry_id
self._mblog_novo.owner_original = self._mblog.owner
self._mblog_novo.mblog_id_original = mblog_id
mblog_id_original = self._mblog_novo.mblog_id_original
self._mblog_novo.tags = self._mblog.tags
# preenche a lista de interessados
self._mblog_novo.interessados = [registry_id]
type = self._registry.getType()
if type=="member":
self._mblog_novo.interessados.extend(self._registry.amigos)
elif type=="community":
self._mblog_novo.interessados.extend(self._registry.participantes)
# trata injeção de tags html e acrescenta links nas urls
self._mblog_novo.conteudo = replace(self._mblog_novo.conteudo,"<","<")
self._mblog_novo.conteudo = replace(self._mblog_novo.conteudo,">",">")
self._mblog_novo.conteudo = processa_url(self._mblog_novo.conteudo)
ret = processa_arroba(self._mblog_novo.conteudo)
self._mblog.mencionados = ret["lista_original"]
self._mblog_novo.interessados.extend(ret["lista_processada"])
self._mblog_novo.interessados = list(set(self._mblog_novo.interessados))
self._mblog_novo.conteudo = ret["conteudo"]
mblog_id_novo = uuid4().hex
try:
self._mblog_novo.save(id=mblog_id_novo)
self._mblog.save()
except Exception as detail:
self.render("home.html", MSG=u"Erro: %s" % detail, NOMEPAG="microblog")
return
# acrescenta esse post a lista de compartilhamentos da mensagem original
self._mblog_original = model.Mblog().retrieve(mblog_id_original)
if self._mblog_original:
self._mblog_original.share_list.append (mblog_id_novo)
self._mblog_original.save()
# se uma mensagem for compartilhada, notifica seu dono
email_msg = ret["conteudo_email"]+"\n"+\
self._mblog_novo.owner+" em "+short_datetime(self._mblog_novo.data_cri)+"\n\n"+\
self._mblog_original.conteudo+"\n"+\
Notify.assinatura (self._mblog_original.owner, self._mblog_original.registry_id, self._mblog_original.data_cri)+"\n\n"
Notify.email_notify(self._mblog_original.owner, \
user, u"compartilhou uma mensagem sua no Mblog", \
message=email_msg, \
link="mblog/"+self._mblog_original.owner)
log.model.log(user, u'compartilhou um mblog de', objeto=self._mblog_novo.registry_id_original, tipo="mblog", link="/mblog/post?id="+mblog_id_novo)
self.redirect("/mblog/%s" % registry_id)
