def isAllowedToWriteObject(user, servico, registry_id, nomeobj=""):
perm_id = "%s/%s/%s" % (servico, registry_id, nomeobj)
_perm = permission.model.Permission().retrieve(perm_id)
if not _perm:
if servico in ["evaluation", "videoaula", "quiz", "question"]:
# "acesso_privado"
return (isUserOrOwner(user, registry_id))
else:
# "acesso_comunidade"
return (isUserOrMember(user, registry_id))
if _perm.escopo_W == "acesso_privado":
return (user == _perm.owner or isUserOrOwner(user, registry_id))
if _perm.escopo_W == "acesso_grupos":
# permite acesso ao dono do objeto e ao dono/admin da comunidade
if (user == _perm.owner or isUserOrOwner(user, registry_id)):
return True
# permite acesso aos participantes dos grupos selecionados
_reg = core.model.Registry().retrieve(registry_id)
if not _reg:
return False
for group in _perm.grupos_W:
if user in _reg.getGroups[group]:
return True
return False
if _perm.escopo_W == "acesso_comunidade":
# aqui pode ser isUserorMember pois não deixamos amigos escreverem em objetos de amigos
return (isUserOrMember(user, registry_id))
return False
def get (self, registry_id):
#hora_inicio = datetime.now()
#print "inicio=", hora_inicio
user = self.get_current_user()
_atividades = prepareActivities(user, model.Activity().listActivities(registry_id))
#print "prepareActivities=", datetime.now()
groupIsfilled = model.Group().GroupIsFilled(registry_id)
#print "GroupIsFilled=", datetime.now()
links = []
if isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões", "/static/imagens/icones/permissions32.png", "/permission/activity/"+registry_id, "", "", True))
if user == registry_id:
links.append((u"Atividades pendentes de "+registry_id, "/static/imagens/icones/pendent_activity32.png", "/activity/pendent/"+registry_id, "", "", False))
log.model.log(user, u'acessou as atividades de', objeto=registry_id, tipo="activity", link="/activity/%s"%registry_id, news=False)
#print "links=", datetime.now()
self.render("modules/activity/activity-list.html", NOMEPAG=u"atividades", \
GROUPISFILLED = groupIsfilled, \
ADMIN = isAllowedToWriteObject(user, "activity", registry_id) , \
LINKS=links, \
ATIVIDADES=_atividades, REGISTRY_ID=registry_id, MSG="")
def get(self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
bookm_count = model.Bookmarks.countBookmarksByRegistryId(registry_id)
# Se forem todas as tags da página mostrada
#(bookmarks, tags_list) = model.Bookmarks.listBookmarks(user, registry_id, page, NUM_MAX_FAVORITOS, all_tags=False)
# Se forem todas as tags
bookmarks = model.Bookmarks.listBookmarks(user, registry_id, page, NUM_MAX_FAVORITOS)
tags_list = model.Bookmarks.listAllTags(registry_id)
links = []
if isAllowedToWriteObject(user, "bookmarks", registry_id):
links.append((u"Criar novo favorito", "/static/imagens/icones/new32.png", "/bookmarks/new/"+registry_id))
if isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões dos Favoritos", "/static/imagens/icones/permissions32.png", "/permission/bookmarks/"+registry_id, "", "", True))
log.model.log(user, u'acessou os favoritos de', objeto=registry_id, tipo="bookmarks", news=False)
self.render("modules/bookmarks/bookmarks-list.html", NOMEPAG='favoritos', \
REGISTRY_ID=registry_id, CRIAR=isUserOrMember(user,registry_id), \
TAG=None, LINKS=links, \
FOTO=False, \
BOOKMARKS=bookmarks, BOOKM_COUNT=bookm_count, \
TAGS = tags_list, \
PAGE=page, PAGESIZE=NUM_MAX_FAVORITOS, \
TITLE="Favoritos de %s"%registry_id, \
MSG="")
def _on_auth(self, user):
print "voltei"
if not user:
#raise tornado.web.HTTPError(500, "Google auth failed")
# caso o usuário recarregue a página do calendário com os parâmetros da query_string devolvidos pela autenticação do google,
# faz redirect para o calendar sem parâmetro nenhum.
print "redirect"
self.redirect("/google/%s" % self.registry_id)
return
print "mostrando"
#link para registrar conta google
links = []
if isUserOrOwner(self.get_current_user(), self.registry_id):
links.append(("Registrar conta Google no Activ", "/static/imagens/icones/google32.png", "/google/init/"+self.registry_id))
#links.append(("Realizar logoff do Google", "/static/imagens/icones/add_event32.png", "/google/logoff"))
# monta iframe do calendario
account_google = self._registry.conta_google
logged_email = user["email"]
logged_name = user["name"]
logged_firstname = user["first_name"]
self.render("modules/google/calendar.html", NOMEPAG="agenda", GOOGLE_ACCOUNT=account_google, \
LOGGED_EMAIL=logged_email, \
LOGGED_NAME=logged_name, \
LOGGED_FIRSTNAME=logged_firstname, \
LINKS=links, REGISTRY_ID=self.registry_id, LOGOUT="")
def get (self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
ordem = self.get_argument("ordem","0")
tag = self.get_argument("tag","")
if tag:
topics_count = model.Topic.countObjectsByRegistryIdTags(registry_id, tag)
topics_list = prepareTopicos(user, model.Topic.listForumTopics(registry_id, page, NUM_MAX_TOPICOS, ordem, tag))
else:
topics_count = model.Topic.countObjectsByRegistryId(registry_id)
topics_list = prepareTopicos(user, model.Topic.listForumTopics(registry_id, page, NUM_MAX_TOPICOS, ordem))
tags_list = model.Topic.listAllTags(registry_id)
links = []
if isAllowedToWriteObject(user, 'forum', registry_id):
links.append((u"Novo tópico", "/static/imagens/icones/new32.png", "/forum/newtopic/"+registry_id))
if isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões deste forum", "/static/imagens/icones/permissions32.png", "/permission/forum/"+registry_id, "", "", True))
if ordem == "1":
links.append(("Exibir mais recentes primeiro", "/static/imagens/icones/descending32.png", "/forum/"+registry_id+"?ordem=0"))
else:
links.append(("Exibir mais antigos primeiro", "/static/imagens/icones/ascending32.png", "/forum/"+registry_id+"?ordem=1"))
log.model.log(user, u'acessou o forum', objeto=registry_id, tipo="forum", news=False)
self.render("modules/forum/forum-list.html", NOMEPAG='forum', \
REGISTRY_ID=registry_id, \
TOPICOS=topics_list, TOPICOS_COUNT=topics_count, \
PAGE=page, PAGESIZE=NUM_MAX_TOPICOS, \
ORDEM=ordem, \
TITULO=u"Forum de %s" % registry_id if not tag else u"Forum de %s com a tag %s" % (registry_id, tag), \
TAGS = tags_list, \
LINKS=links)
def post(self, registry_id):
user = self.get_current_user()
msg = ""
if isUserOrOwner(user, registry_id):
grupo = self.get_argument("grupo","")
p = re.compile(VALID_LOGIN)
if not grupo:
msg = u"Grupo não preenchido."
elif not p.match(grupo):
msg = u"Nome inválido. Deve ter no mínimo 3 caracteres, começando e terminando com letras ou números e utilizando apenas letras, números, '_' e '.' em sua composição. Não utilize acentuação!<br/>"
else:
user_data = _EMPTYCOMMUNITY()
user_data.update(core.database.REGISTRY[registry_id])
if grupo not in user_data["groups"]:
user_data["groups"][grupo] = []
core.database.REGISTRY[registry_id] = user_data
msg = u"Grupo criado com sucesso."
else:
msg = u"Grupo já existente."
elif isACommunity(registry_id):
msg=u"Somente administradores da comunidade podem criar grupos."
else:
msg=u"Somente o próprio usuário pode criar grupos."
self.render("popup_msg.html", MSG=msg, REGISTRY_ID=registry_id)
def wrapper(self, *args, **kwargs):
user = self.get_current_user()
service = args[0]
registry_id = args[1]
if registry_id not in core.database.REGISTRY:
raise HTTPError(404)
if len(args)>2:
obj_name = args[2]
if not isUserOrOwner(user, registry_id) and user != objectOwnerFromService(service, registry_id, obj_name):
raise HTTPError(403)
else:
if not isUserOrOwner(user, registry_id):
raise HTTPError(403)
return method(self, *args, **kwargs)
def isAllowedToEditObject(user, owner, doc_id, edicao_publica="S"):
# só o dono da comunidade ou dono do objeto ou
# (qq membro se o objeto for de edição pública)
(registry_id, nomeobj) = doc_id.split("/")
return (user == owner or \
isUserOrOwner(user, registry_id) or \
(isMember(user, registry_id) and edicao_publica=="S") )
def get(self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
letra = self.get_argument("letra","")
glossary = model.Glossary.listGlossary(user, registry_id, page, NUM_MAX_ITENS_GLOSSARIO)
glossary_count = model.Glossary.countGlossaryByRegistryId(registry_id)
tags_list = model.Glossary.listAllTags(registry_id)
links = []
if isAllowedToWriteObject(user, "glossary", registry_id):
links.append((u"Criar novo termo", "/static/imagens/icones/new32.png", "/glossary/new/"+registry_id))
if isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões deste Glossário", "/static/imagens/icones/permissions32.png", "/permission/glossary/"+registry_id, "", "", True))
log.model.log(user, u'acessou o glossário de', objeto=registry_id, tipo="glossary", news=False)
self.render("modules/glossary/glossary-list.html", NOMEPAG=NOME_PAG_CLOSSARIO, \
REGISTRY_ID=registry_id, CRIAR=isUserOrMember(user,registry_id), \
TAG=None, LINKS=links, \
FOTO=False, \
GLOSSARY=glossary, GLOSSARY_COUNT=glossary_count, \
TAGS_LIST = tags_list , \
PAGE=page, PAGESIZE=NUM_MAX_ITENS_GLOSSARIO, \
TITLE=u"Glossário de %s"%registry_id, \
MSG="")
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')
def isAllowedToReadObject(user, servico, registry_id, nomeobj=""):
perm_id = "%s/%s/%s" % (servico, registry_id, nomeobj)
_perm = permission.model.Permission().retrieve(perm_id)
if not _perm:
if servico in ["evaluation", "quiz"]:
# "acesso_comunidade"
return (isUserOrMember(user, registry_id))
elif servico in ["question"]:
# "acesso_privado"
return (isUserOrOwner(user, registry_id))
else:
# "acesso_activ"
return (user!="" and user!=None)
if _perm.escopo_R == "acesso_privado":
return (user == _perm.owner or isUserOrOwner(user, registry_id))
if _perm.escopo_R == "acesso_grupos":
# permite acesso ao dono do objeto e ao dono/admin da comunidade
if (user == _perm.owner or isUserOrOwner(user, registry_id)):
return True
# permite acesso aos participantes dos grupos selecionados
_reg = core.model.Registry().retrieve(registry_id)
if not _reg:
return False
for group in _perm.grupos_R:
if user in _reg.getGroups[group]:
return True
return False
if _perm.escopo_R == "acesso_comunidade":
#return (isUserOrMember(user, registry_id))
return (isFriendOrMember(user, registry_id))
if _perm.escopo_R == "acesso_activ":
return (user!="" and user!=None)
if _perm.escopo_R == "acesso_publico":
return True
return False
def get (self, registry_id, id):
user = self.get_current_user()
_quiz= model.Quiz().retrieve(id)
links = []
if _quiz:
if isUserOrOwner(user, registry_id):
links.append((u"Alterar permissões deste quiz", "/static/imagens/icones/permissions32.png", "/permission/quiz/"+registry_id+"/"+id, "", "", True))
self.render("modules/quiz/quiz-edit.html", NOMEPAG=u"Quiz", LINKS=links, QUIZDATA=_quiz, REGISTRY_ID=registry_id, MSG="")
else:
raise HTTPError(404)
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):
user = self.get_current_user()
if isUserOrOwner(user, registry_id):
user_data = _EMPTYCOMMUNITY()
user_data.update(core.database.REGISTRY[registry_id])
groups = user_data["groups"].keys()
self.render("modules/community/create-group.html", NOMEPAG='comunidades', \
GROUPS=groups, \
REGISTRY_ID=registry_id, MSG="")
elif isACommunity(registry_id):
self.render("home.html", MSG=u"Somente administradores da comunidade podem criar grupos.", NOMEPAG='comunidades')
else:
self.render("home.html", MSG=u"Somente o próprio usuário pode criar grupos.", NOMEPAG='amigos')
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 post(self, registry_id):
user = self.get_current_user()
if isUserOrOwner(user, registry_id):
part = self.get_argument("part","")
group = self.get_argument("group","")
if isACommunity(registry_id):
user_data = _EMPTYCOMMUNITY()
else:
user_data = _EMPTYMEMBER()
user_data.update(core.database.REGISTRY[registry_id])
if part:
for group in user_data["groups"].keys():
checkbox_value = self.get_argument(group,"")
if checkbox_value=="S" and part not in user_data["groups"][group]:
user_data["groups"][group].append(part)
elif checkbox_value<>"S" and part in user_data["groups"][group]:
while part in user_data["groups"][group]:
user_data["groups"][group].remove(part)
core.database.REGISTRY[registry_id] = user_data
self.render("popup_msg.html", MSG=u"Grupos alterados com sucesso.", REGISTRY_ID=registry_id)
elif group:
pessoas = user_data["participantes"] if isACommunity(registry_id) else user_data["amigos"]
for part in pessoas:
checkbox_value = self.get_argument(part,"")
if checkbox_value=="S" and part not in user_data["groups"][group]:
user_data["groups"][group].append(part)
elif checkbox_value<>"S" and part in user_data["groups"][group]:
while part in user_data["groups"][group]:
user_data["groups"][group].remove(part)
core.database.REGISTRY[registry_id] = user_data
self.render("popup_msg.html", MSG=u"Participantes alterados com sucesso.", REGISTRY_ID=registry_id)
else:
self.render("popup_msg.html", MSG=u"Chamada inválida.")
else:
if isACommunity(registry_id):
self.render("popup_msg.html", MSG=u"Somente administradores da comunidade podem agrupar participantes.", REGISTRY_ID=registry_id)
else:
self.render("popup_msg.html", MSG=u"Somente o próprio usuário pode agrupar seus amigos.", REGISTRY_ID=registry_id)
def get(self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
lista_posts = prepareBlogPosts(user, model.Blog.listBlogPosts(registry_id, page, NUM_MAX_POSTS, control_panel=False, only_removed=True), include_removed=True)
page_count = model.Blog.countRemovedPosts(registry_id)
links = []
if isUserOrOwner(user, registry_id):
links.append((u"Listar posts", "/static/imagens/icones/blog32.png", "/blog/"+registry_id))
log.model.log(user, u'acessou a lixeira do blog de', objeto=registry_id, tipo="blog", news=False)
self.render("modules/blog/blog-listaremovidas.html", NOMEPAG='blog', \
REGISTRY_ID=registry_id, \
LINKS=links, \
LISTA_POSTS=lista_posts, PAG_COUNT=page_count, \
PAGE=page, PAGESIZE=NUM_MAX_POSTS, \
MSG="")
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:
ext = _va.arqvideo.split(".")[-1]
links = []
if isUserOrOwner(user, registry_id) or user == objectOwnerFromService("videoaula", registry_id, name_id):
links.append((u"Alterar permissões desta videoaula", "/static/imagens/icones/permissions32.png", "/permission/videoaula/"+registry_id+"/"+name_id, "", "", True))
if isAllowedToDeleteObject(user, _va.owner, registry_id+"/"+name_id):
links.append(("Remover esta videoaula", "/static/imagens/icones/delete32.png", "/videoaula/delete/"+registry_id+"/"+name_id,
"return confirm('Deseja realmente remover esta videoaula?');"))
self.render("modules/videoaula/videoaula-edit.html", NOMEPAG="videoaulas", VIDEODATA=_va, \
FOLDERS = files.model.Files.listFolders(user, registry_id, "files/all_data"), \
SORTEDKEYS=sortedKeys, MIME_TYPE=mime_types[ext],
LINKS=links, \
REGISTRY_ID=registry_id, MSG="")
else:
raise HTTPError(404)
def get(self):
user = self.get_current_user()
registry_id = self.get_argument("id","")
item = self.get_argument("item","")
if registry_id == "" or item == "":
raise HTTPError(404)
elif not isUserOrOwner(user, registry_id):
raise HTTPError(403)
else:
# remove o post
self._scrap = model.Scrapbook().retrieve(registry_id)
if self._scrap:
self._scrap.removeScrap(int(item))
log.model.log(user, u'removeu o recado de', objeto=registry_id, tipo="none", news=False)
self.redirect("/scrap/%s" % registry_id)
def get (self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
quiz_count = model.Quiz.countObjectsByRegistryId(registry_id)
lista_quiz = prepareQuiz(user, model.Quiz.listObjects(registry_id, page, NUM_MAX_QUIZ))
links = []
if isAllowedToReadObject(user, "question", registry_id):
links.append((u"Banco de questões", "/static/imagens/icones/question32.png", "/question/"+registry_id))
if isAllowedToWriteObject(user, "quiz", registry_id):
links.append((u"Novo teste de múltipla escolha", "/static/imagens/icones/add_test32.png", "/quiz/new/%s?subtype=Teste"%registry_id))
links.append ((u"Nova pesquisa de opinião", "/static/imagens/icones/add_survey32.png", "/quiz/new/%s?subtype=Survey"%registry_id))
log.model.log(user, u'acessou a lista de quizes de', objeto=registry_id, tipo="quiz", news=False)
self.render("modules/quiz/quiz-list.html", NOMEPAG="Quiz", REGISTRY_ID=registry_id, \
IS_ADMIN=isUserOrOwner(user, registry_id), \
QUIZ=lista_quiz, QUIZ_COUNT=quiz_count, \
PAGE=page, PAGESIZE=NUM_MAX_QUIZ, \
LINKS=links)
def get (self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
videoaulas_count = model.Videoaula.countObjectsByRegistryId(registry_id)
lista_videoaulas = prepareVideoaulas(user, model.Videoaula.listObjects(registry_id, page, NUM_MAX_VIDEOAULAS))
tags_list = model.Videoaula.listAllTags(registry_id)
links = []
if isUserOrOwner(user, registry_id):
links.append((u"Nova videoaula", "/static/imagens/icones/new32.png", "/videoaula/new/"+registry_id))
log.model.log(user, u'acessou as videoaulas de', objeto=registry_id, tipo="videoaula", news=False)
self.render("modules/videoaula/videoaula-list.html", NOMEPAG="videoaulas", REGISTRY_ID=registry_id, \
VIDEOAULAS=lista_videoaulas, VIDEOAULAS_COUNT=videoaulas_count, \
PAGE=page, PAGESIZE=NUM_MAX_VIDEOAULAS, \
TITLE=u"Videoaulas de %s" % registry_id, \
TAGS = tags_list, \
LINKS=links)
def get(self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
if isFriendOrMember(user, registry_id):
self._scrap = model.Scrapbook().retrieve(registry_id)
scrap_list = []
scraps_count = 0
if self._scrap!=None:
filter = not isUserOrMember(user, registry_id)
scrap_list = self._scrap.getScrapbookList(user, page=page, page_size=NUM_MAX_SCRAPS, \
filter=filter)
scraps_count = self._scrap.countScraps(user, filter=filter)
self.render("modules/scrapbook/scrap-list.html", REGISTRY_ID=registry_id, \
USER=user, NOMEPAG='recados', \
APAGAR=isUserOrOwner(user, registry_id), \
SCRAPDATA=scrap_list, SCRAPS_COUNT = scraps_count, \
PAGE=page, PAGESIZE=NUM_MAX_SCRAPS)
else:
raise HTTPError(403)
def get (self, registry_id):
user = self.get_current_user()
page = int(self.get_argument("page","1"))
posts_count = model.Blog.countPostsByRegistryId(registry_id)
lista_posts = prepareBlogPosts(user, model.Blog.listBlogPosts(registry_id, page, NUM_MAX_POSTS))
links = []
if isAllowedToWriteObject(user, "blog", registry_id):
links.append(("Novo post", "/static/imagens/icones/new32.png", "/blog/new/"+registry_id))
if isUserOrOwner(user, registry_id):
links.append((u"Ver lixeira", "/static/imagens/icones/recycle32.png", "/blog/deleted/"+registry_id))
links.append((u"Alterar permissões deste blog", "/static/imagens/icones/permissions32.png", "/permission/blog/"+registry_id, "", "", True))
log.model.log(user, u'acessou o blog de', objeto=registry_id, tipo="blog", news=False)
self.render("modules/blog/blog.html", NOMEPAG="blog", REGISTRY_ID=registry_id, \
ARCHIVE=model.Blog.get_blog_archive(registry_id), \
SORTEDKEYS=sortedKeys, MESES=_meses, \
POSTS=lista_posts, POSTS_COUNT=posts_count, \
PAGE=page, PAGESIZE=NUM_MAX_POSTS, \
LINKS=links)
def get(self, registry_id):
user = self.get_current_user()
grupo = self.get_argument("group","")
if isUserOrOwner(user, registry_id):
user_data = _EMPTYCOMMUNITY()
user_data.update(core.database.REGISTRY[registry_id])
if grupo in user_data["groups"]:
del user_data["groups"][grupo]
core.database.REGISTRY[registry_id] = user_data
if isACommunity(registry_id):
self.redirect ("/members/"+registry_id)
else:
self.redirect ("/friends/"+registry_id)
return
else:
msg = u"Grupo não existente."
elif isACommunity(registry_id):
msg = u"Somente administradores da comunidade podem excluir grupos."
else:
msg = u"Somente o próprio usuário pode excluir grupos."
self.render("popup_msg.html", MSG=msg, REGISTRY_ID=registry_id)
def get (self, registry_id, post_id):
user = self.get_current_user()
doc_id = "/".join([registry_id, post_id])
versao = self.get_argument("versao","-1")
self._blog = model.Blog().retrieve(doc_id, include_removed=True)
if self._blog:
post_data = prepareBlogPost(user, self._blog.getBlogPost(user, versao=int(versao)))
links = []
links.append(("Blog de "+registry_id, "/static/imagens/icones/back32.png", "/blog/"+registry_id))
if user:
reg = core.model.Registry().retrieve(user)
if reg and "bookmarks" in reg.getServices:
links.append(bookmarks.model.Bookmarks.createBookmarkLink(user, "http://"+PLATAFORMA_URL+self.request.path))
if isAllowedToWriteObject(user, "blog", registry_id):
links.append(("Alterar este post", "/static/imagens/icones/edit32.png", "/blog/edit/"+doc_id))
if isUserOrOwner(user, registry_id):
links.append(("Ver histórico de versões", "/static/imagens/icones/versions32.png", "/blog/history/"+doc_id))
if isAllowedToDeleteObject(user, post_data["owner"], doc_id) and versao == "-1":
links.append(("Remover este post", "/static/imagens/icones/delete32.png", "/blog/delete/"+doc_id,
"return confirm('Deseja realmente remover este Post?');"))
log.model.log(user, u'acessou o post', objeto=post_id, tipo="blog", news=False)
self.render("modules/blog/post.html", NOMEPAG="blog", POST_DATE=full_week_date(post_data["data_cri_nofmt"]), \
REGISTRY_ID=registry_id, \
ARCHIVE=model.Blog.get_blog_archive(registry_id), \
SORTEDKEYS=sortedKeys, MESES=_meses, \
POST=post_data, \
LINKS=links)
else:
raise HTTPError(404)
def get (self, registry_id):
self.registry_id = registry_id
print registry_id
self._registry = core.model.Registry().retrieve(self.registry_id)
if self._registry and self._registry.conta_google:
if self.get_argument("openid.mode", None):
print "vou no google"
#self.get_authenticated_user(self.async_callback(self._on_auth))
google_user = yield self.get_authenticated_user()
print "google_user="******"Você ainda não registrou sua conta no Google"
links = []
if isUserOrOwner(self.get_current_user(), self.registry_id):
links.append(("Registrar conta Google no Activ", "/static/imagens/icones/google32.png", "/google/init/"+self.registry_id))
self.render("modules/google/calendar.html", NOMEPAG="agenda", GOOGLE_ACCOUNT="", LINKS=links, \
REGISTRY_ID=self.registry_id, LOGOUT="")
def isAllowedToDeleteObject(user, owner, doc_id, wiki="N"):
# só o dono de um objeto ou o dono da comunidade podem apagá-lo
(registry_id, nomeobj) = doc_id.split("/")
return ((wiki=="N" or nomeobj not in ["home", "indice"]) and \
((user == owner) or \
isUserOrOwner(user, registry_id)))
def isAllowedToDeleteComment(user, registry_id, owner):
# user: usuário que está tentando o acesso
# registry_id: usuário/comunidade onde está o objeto
# owner: dono do comentário
# só o dono de um comentário ou o dono da comunidade podem apagá-lo
return ((owner == user) or isUserOrOwner(user, registry_id))
