def get (self, registry_id):
user = self.get_current_user()
folder = self.get_argument("folder","")
items = self.request.arguments["items"]
desc_list = []
for item in items:
doc_id = '/'.join([registry_id, item])
self._wiki = model.Wiki().retrieve(doc_id)
desc = self._wiki.getDescendentsList()
if desc:
desc_list.extend(desc)
select_folders = [ f for f in model.Wiki.listWikiFolders(registry_id) if f not in desc_list]
if folder:
doc_id = '/'.join([registry_id, folder])
self._folder = model.Wiki().retrieve(doc_id)
if self._folder:
self.write (dict(status=0, result=dict(path=self._folder.getPagePath(links=False),
e_usuario=isAUser(registry_id), e_owner=isOwner(user, registry_id),
items=items, folder=folder, folders=select_folders)))
else:
self.write (dict(status=0, result=dict(path="/%s/"%registry_id,
e_usuario=isAUser(registry_id), e_owner=isOwner(user, registry_id),
items=items, folder=folder, folders=select_folders)))
def email_notify(cls, user, sujeito, assunto, message="", link="", sendToMyself=False):
# user -> quem deve ser avisado
# sujeito -> quem realizou a ação
# sendToMyself=True indica que a mensagem deve ser enviada para mim, mesmo que eu tenha realizado a ação. Ex: troca de senha.
if (sendToMyself or user!=sujeito) and isAUser(sujeito):
if isAUser(user):
# usuário a ser avisado
to_user_data = model._EMPTYMEMBER()
to_user_data.update(database.REGISTRY[user])
email = to_user_data["email"]
notify = to_user_data["notify"]
nome_destinatario = to_user_data["name"]
# usuário que realizou a ação
from_user_data = database.REGISTRY[sujeito]
nome_completo = from_user_data["name"] + " " + from_user_data["lastname"]
assunto = sendToMyself and assunto or nome_completo + " " + assunto
if notify == "2":
# envia e-mail imediatamente
if not Notify.enviaEmail (email, assunto, nome_destinatario, message, link):
# erro no envio do e-mail: guarda mensagem em NOTIFICATIONERROR
notify_data = _EMPTYNOTIFICATIONERROR()
if user in log.database.NOTIFICATIONERROR:
notify_data.update(log.database.NOTIFICATIONERROR[user])
reg = dict(
sujeito= sujeito,
subject= assunto,
message= message,
data_inclusao= str(datetime.now())
)
notify_data["registros"].append(reg)
log.database.NOTIFICATIONERROR[user] = notify_data
#print "Erro no envio do email. Msg salva em NOTIFICATIONERROR"
else:
#print "Email enviado com sucesso para "+email
pass
elif notify == "1":
# guarda mensagem no banco para depois enviar resumo semanal
notify_data = _EMPTYNOTIFICATION()
if user in log.database.NOTIFICATION:
notify_data.update(log.database.NOTIFICATION[user])
reg = dict(
sujeito= sujeito,
subject= assunto,
message= message,
data_inclusao= str(datetime.now())
)
notify_data["registros"].append(reg)
log.database.NOTIFICATION[user] = notify_data
#print "Email salvo em NOTIFICATION"
else:
#print "Usuário não deseja ser notificado"
pass
elif isACommunity(user):
for participante in database.REGISTRY[user]["participantes"]:
Notify.email_notify(participante, sujeito, assunto, message, link)
def email_notify_old(cls, user, sujeito, assunto, message="", link=""):
if user!=sujeito and isAUser(user) and isAUser(sujeito):
# usuário a ser avisado
to_user_data = model._EMPTYMEMBER()
to_user_data.update(database.REGISTRY[user])
email = to_user_data["email"]
notify = to_user_data["notify"]
nome_destinatario = to_user_data["name"]
# usuário que realizou a ação
from_user_data = database.REGISTRY[sujeito]
nome_completo = from_user_data["name"] + " " + from_user_data["lastname"]
assunto = nome_completo + " " + assunto
if notify == "2":
# envia e-mail imediatamente
if not Notify.enviaEmail (email, assunto, nome_destinatario, message, link):
# erro no envio do e-mail: guarda mensagem em NOTIFICATIONERROR
notify_data = _EMPTYNOTIFICATIONERROR()
if user in log.database.NOTIFICATIONERROR:
notify_data.update(log.database.NOTIFICATIONERROR[user])
reg = dict(
sujeito= sujeito,
subject= assunto,
message= message,
data_inclusao= str(datetime.now())
)
notify_data["registros"].append(reg)
log.database.NOTIFICATIONERROR[user] = notify_data
#print "Erro no envio do email. Msg salva em NOTIFICATIONERROR"
else:
#print "Email enviado com sucesso para "+email
pass
elif notify == "1":
# guarda mensagem no banco para depois enviar resumo semanal
notify_data = _EMPTYNOTIFICATION()
if user in log.database.NOTIFICATION:
notify_data.update(log.database.NOTIFICATION[user])
reg = dict(
sujeito= sujeito,
subject= assunto,
message= message,
data_inclusao= str(datetime.now())
)
notify_data["registros"].append(reg)
log.database.NOTIFICATION[user] = notify_data
#print "Email salvo em NOTIFICATION"
else:
#print "Usuário não deseja ser notificado"
pass
def replyTo (user, user_to, user_from):
reply_to = ""
if isAUser(user_to):
if isFriend(user, user_from):
reply_to = user_from
else:
if isMember(user, user_to):
reply_to = user_to
return reply_to
def get (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:
self.write (dict(status=0, result=dict(path=self._wiki.getPagePath(links=False), pagina=pagina,
e_usuario=isAUser(registry_id), e_owner=isOwner(user, registry_id))))
else:
self.write (dict(status=1, msg=u"Documento não encontrado."))
def get(self, registry_id, image):
msg = ""
user = self.get_current_user()
if not (isAUser(registry_id) and registry_id == user):
msg = u"Você não tem permissão para editar este desenho."
self.render("home.html", MSG=msg,NOMEPAG='desenhos', REGISTRY_ID=registry_id)
return
self.render("modules/paint/svg-editor.html", REGISTRY_ID=registry_id,
NOMEPAG='agenda',NEW_PICTURE=image, EDIT_PICTURE ="")
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):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
(sel_multipla, pags) = prepareFolderPages(user, model.Wiki.listFolderPages(user, registry_id, "", page, NUM_MAX_WIKIPAGES, True), getType(registry_id)[0])
pag_count = model.Wiki.countRemovedPages(registry_id)
links = []
if isUserOrOwner(user, registry_id):
links.append((u"Listar páginas", "/static/imagens/icones/wiki32.png", "/wiki/"+registry_id))
self.write (dict(status=0, result=dict(pag_count=pag_count, paginas=pags, page=page, pagesize=NUM_MAX_WIKIPAGES,
e_usuario=isAUser(registry_id) )))
def get(self, registry_id):
msg = ""
user = self.get_current_user()
permissao = False
if (isAUser(registry_id) and registry_id == user):
permissao = True
desenho_data = _EMPTYDESENHO()
desenhos = []
if registry_id in model.DESENHO:
desenho_data.update(model.DESENHO[registry_id])
desenhos = desenho_data['desenhos'].items()
self.render("modules/paint/desenhos.html", NOMEPAG='desenhos', \
REGISTRY_ID=registry_id, DESENHOS = desenhos, MSG="", PERMISSAO = permissao)
def usersAllowedToRead(servico, registry_id, nomeobj=""):
""" retorna lista de usuário autorizados a ler um serviço/objeto dentre os amigos/participantes de registry_id,
mesmo que a permissão seja acesso_activ ou acesso_externo.
"""
usuarios = []
if isAUser(registry_id):
for u in core.database.REGISTRY[registry_id]["amigos"]:
if isAllowedToReadObject(u, servico, registry_id, nomeobj):
usuarios.append(u)
else:
for u in core.database.REGISTRY[registry_id]["participantes"]:
if isAllowedToReadObject(u, servico, registry_id, nomeobj):
usuarios.append(u)
return usuarios
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":
wiki_data = prepareWikiPage(user, self._wiki.getWikiPage(user, versao=int(versao)))
links = []
if user:
links.append(("Ver perfil de "+registry_id, "/static/imagens/icones/profile32.png", "/profile/"+registry_id))
if isFriend(user, registry_id):
#links.append(("Enviar recado", "/static/imagens/icones/scrap32.png", "/scrap/"+registry_id))
if isOnline(registry_id):
links.append((u"Iniciar Chat com "+registry_id, "/static/imagens/icones/talk32.png", "/chat/"+registry_id))
else:
links.append((registry_id+u" não está online. Deixe uma mensagem.", "/static/imagens/icones/nottalk32.png", "/chat/"+registry_id))
elif isAUser(registry_id) and user != registry_id:
self._reg = core.model.Member().retrieve(registry_id)
if user in self._reg.amigos_pendentes:
links.append((u"Já convidado. Aguardando resposta.", "/static/imagens/icones/invited_friend32.png", ""))
elif user in self._reg.amigos_convidados:
links.append(("Aceite convite de "+registry_id, "/static/imagens/icones/add_friend32.png", "/invites"))
else:
links.append(("Adicionar amigo", "/static/imagens/icones/add_friend32.png", "/newfriend?friend="+registry_id))
self._reg_user = core.model.Registry().retrieve(user)
if self._reg_user and "bookmarks" in self._reg_user.getServices:
links.append(bookmarks.model.Bookmarks.createBookmarkLink(user, "http://"+PLATAFORMA_URL+self.request.path))
if isUserOrOwner(user, registry_id):
links.append((u"Ver histórico de versões", "/static/imagens/icones/versions32.png", "/wiki/history/"+doc_id))
if isAllowedToWriteObject(user, "wiki", registry_id, pagina):
links.append((u"Alterar esta página", "/static/imagens/icones/edit32.png", "/wiki/edit/"+doc_id))
if isAllowedToDeleteObject(user, wiki_data["owner"],doc_id, wiki="S"):
links.append((u"Alterar permissões desta página", "/static/imagens/icones/permissions32.png", "/permission/wiki/"+doc_id))
links.append((u"Apagar esta página", "/static/imagens/icones/delete32.png", "/wiki/delete/"+doc_id,\
"return confirm('Deseja realmente apagar esta página?');"))
indice_links = []
if wiki_data["alterar"]:
indice_links.append((u"Editar índice", "/static/imagens/icones/edit16.png", "/wiki/edit/"+registry_id+"/indice"))
self.write (dict(status=0, result=dict(path=self._wiki.getPagePath(), pagina=pagina,
wikidata=wiki_data )))
else:
self.write (dict(status=1, msg=u"Página não encontrada."))
def get (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:
if isAllowedToWriteObject(user, "wiki", registry_id, pagina):
folders = [f for f in model.Wiki.listWikiFolders(registry_id) if f not in self._wiki.getDescendentsList()]
self.write (dict(status=0, result=dict(pagina=pagina, path=self._wiki.getPagePath(links=False),
e_usuario=isAUser(registry_id), e_owner=isOwner(user, registry_id),folders=folders)))
else:
self.write (dict(status=1, msg=u"Você não tem permissão para alterar esta página."))
else:
self.write (dict(status=1, msg=u"Documento não encontrado."))
def post(self, registry_id):
user = self.get_current_user()
if not (isAUser(registry_id) and registry_id == user):
msg = u"Você não tem permissão para editar este desenho."
self.render("home.html", MSG=msg,NOMEPAG='desenhos', REGISTRY_ID=registry_id)
return
imagem = "nenhum"
if 'templates' in self.request.arguments:
for value in self.request.arguments['templates']:
imagem = value
url = "/paint/new/" + registry_id + "/" + imagem
self.redirect(url)
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 get(self, registry_id):
user = self.get_current_user()
if isAUser(registry_id):
page = int(self.get_argument("page","1"))
group = self.get_argument("group","")
self._user = core.model.Member().retrieve(registry_id)
# Se o grupo não existe, mostra todos os amigos do usuário.
# Este caso acontece qdo o grupo acabou de ser removido.
# Impede a visualização de um grupo de outra pessoa.
if group not in self._user.groups or user!=registry_id:
group = ""
(friends_count, amigos) = self._user.getFriendsList(group, page, NUM_MAX_FRIENDS, user=user)
links=[]
if group:
links.append(("Remover este grupo", "/static/imagens/icones/delete32.png", "/groups/delete/"+registry_id+"?group="+group, "return confirm('Deseja realmente remover este grupo? Os participantes não sairão da sua lista de amigos.','');"))
links.append(("Gerenciar participantes deste grupo", "/static/imagens/icones/group32.png", "/groups/"+registry_id+"?group="+group, "", "", True))
if user==registry_id:
links.append(("Procurar amigos", "/static/imagens/icones/search32.png", "/friends/search"))
links.append(("Responder convites", "/static/imagens/icones/invite32.png", "/invites"))
elif user not in self._user.amigos:
links.append(("Adicionar "+registry_id+" como amigo", "/static/imagens/icones/add_friend32.png", "/newfriend?friend="+registry_id))
if group:
msg = u"Este grupo ainda não possui nenhum amigo."
else:
msg = u"Este usuário ainda não possui nenhum amigo."
log.model.log(user, u'acessou a lista de amigos de', objeto=registry_id, tipo="user", news=False)
self.render("modules/friends/friend-list.html", NOMEPAG='amigos', \
REGISTRY_ID=registry_id, \
FRIENDS=amigos, \
FRIENDS_COUNT=friends_count, \
PAGE=page, PAGESIZE=NUM_MAX_FRIENDS, \
THIS_GROUP=group, GROUPS=self._user.groups.keys(), \
MSG=msg, \
LINKS=links)
else:
# se o registry_id for de uma comunidade
raise HTTPError(404)
def listPosts(self, user, registry_id, page, page_size, myself=False, myposts=0):
# Lista os posts de registry_id. Se user = registry_id, myself=True
lista_posts = []
if myself and myposts!=1:
# Estou vendo meu próprio mblog: vejo mensagens que me interessam.
for row in database.MBLOG.view('mblog/by_followers',startkey=[registry_id, {}],endkey=[registry_id], \
descending="true", skip=(page-1)*page_size , limit=page_size):
mblog_data = dict()
mblog_data.update(row.value)
mblog_data["apagar"] = (row.value["owner"] == user)
mblog_data["data_nofmt"] = row.value["data_cri"]
mblog_data["data_cri"] = human_date(row.value["data_cri"])
if "data_original" in row.value:
mblog_data["data_original"] = human_date(row.value["data_original"])
lista_posts.append(mblog_data)
else:
# Estou vendo o mblog de outra pessoa ou de uma comunidade:
# só vejo mensagens postadas por ela.
for row in database.MBLOG.view('mblog/by_owners',startkey=[registry_id, {}],endkey=[registry_id], \
descending="true", skip=(page-1)*page_size , limit=page_size):
mblog_data = dict()
mblog_data.update(row.value)
mblog_data["apagar"] = (row.value["owner"] == user)
mblog_data["data_nofmt"] = row.value["data_cri"]
mblog_data["data_cri"] = human_date(row.value["data_cri"])
if "data_original" in row.value:
mblog_data["data_original"] = human_date(row.value["data_original"])
if isAUser(registry_id):
community_id = ""
if registry_id != mblog_data["registry_id"]:
community_id = mblog_data["registry_id"]
if (not community_id) or \
(community_id in core.database.REGISTRY and \
core.database.REGISTRY[community_id]["privacidade"]!="Privada"):
lista_posts.append(mblog_data)
else:
lista_posts.append(mblog_data)
return lista_posts
def get (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:
_revision = self._wiki.rev
form = dict(
action="",
nomepag=dict(type="@hidden",value=self._wiki.nomepag),
revision=dict(type="@hidden",value=self._wiki.rev),
tags=dict(type="@text",value=self._wiki.tags),
e_usuario=dict(type="@text",value=isAUser(registry_id)),
e_owner=dict(type="@text",value=isOwner(user, registry_id)),
conteudo=dict(type="@textarea", value=self._wiki.historico[-1]["conteudo"])
)
self.write (dict(status=0, result=form))
else:
self.write (dict(status=1, msg=u"Documento não encontrado."))
def post(self, registry_id, image):
msg = ""
user = self.get_current_user()
if not (isAUser(registry_id) and registry_id == user):
msg = u"Você não tem permissão para editar este desenho."
self.render("home.html", MSG=msg,NOMEPAG='desenhos', REGISTRY_ID=registry_id)
return
nomeDesenho = self.get_argument("nomeDesenho", "").replace(" ", "_")
desenho = self.get_argument("desenho", "")
desenho_data = _EMPTYDESENHO()
if registry_id in model.DESENHO:
desenho_data.update(model.DESENHO[registry_id])
desenho_data['desenhos'][nomeDesenho] = desenho
try:
model.DESENHO[registry_id] = desenho_data
except:
self.render("home.html", MSG=u"Erro: %s" % detail, NOMEPAG='desenhos')
return
def get (self, registry_id):
user = self.get_current_user()
parent_folder = self.get_argument("folder","")
if parent_folder:
parent_id = registry_id+"/"+parent_folder
self._pai = model.Wiki().retrieve(parent_id)
parent_name = self._pai.nomepag
if not isAllowedToWriteObject(user, "wiki", registry_id, parent_folder):
self.write (dict(status=1, msg=u"Você não tem permissão para criar pastas nesta pasta."))
return
else:
parent_name = registry_id+"/"
self._wiki = model.Wiki(nomepag="Nova Pasta", nomepag_id="NovaPasta", parent_folder=parent_folder)
form = dict(
action="",
nomepag=dict(type="@text",value=""),
parent_name=dict(type="@text",value=parent_name),
e_ususario=dict(type="@text", value=isAUser(registry_id))
)
self.write (dict(status=0, result=form))
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 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 get(self, registry_id):
user = self.get_current_user()
if isACommunity(registry_id):
if isUserOrOwner(user, registry_id):
part = self.get_argument("part","")
group = self.get_argument("group","")
user_data = _EMPTYCOMMUNITY()
user_data.update(core.database.REGISTRY[registry_id])
if part:
groups = [(group, part in user_data["groups"][group]) for group in user_data["groups"].keys()]
self.render("modules/community/update-groups.html", NOMEPAG='comunidades', \
PART=part, GROUPS=groups, \
REGISTRY_ID=registry_id, MSG="")
elif group:
parts = [(part, part in user_data["groups"][group]) for part in user_data["participantes"] if isAUser(part)]
self.render("modules/community/update-parts.html", NOMEPAG='comunidades', \
PARTS=parts, GROUP=group, \
REGISTRY_ID=registry_id, MSG="")
else:
self.render("home.html", MSG=u"Chamada inválida.", NOMEPAG='comunidades')
else:
self.render("home.html", MSG=u"Somente administradores da comunidade podem agrupar participantes.", NOMEPAG='comunidades')
else:
if isUserOrOwner(user, registry_id):
part = self.get_argument("part","")
group = self.get_argument("group","")
user_data = _EMPTYMEMBER()
user_data.update(core.database.REGISTRY[registry_id])
if part:
groups = [(group, part in user_data["groups"][group]) for group in user_data["groups"].keys()]
self.render("modules/community/update-groups.html", NOMEPAG='amigos', \
PART=part, GROUPS=groups, \
REGISTRY_ID=registry_id, MSG="")
elif group:
parts = [(part, part in user_data["groups"][group]) for part in user_data["amigos"]]
self.render("modules/community/update-parts.html", NOMEPAG='amigos', \
PARTS=parts, GROUP=group, \
REGISTRY_ID=registry_id, MSG="")
else:
self.render("home.html", MSG=u"Chamada inválida.", NOMEPAG='amigos')
else:
self.render("home.html", MSG=u"Somente o próprio usuário pode agrupar seus amigos.", NOMEPAG='amigos')