glossary_term = self.get_argument("term","") page = int(self.get_argument("page","1")) glossary = model.Glossary.searchGlossaryByItemId(user, glossary_item_id, page, NUM_MAX_ITENS_GLOSSARIO) glossary_count = model.Glossary.countGlossaryByItemId(glossary_item_id) tags_list = model.Glossary.listAllTags(user) self.render("modules/glossary/glossary-list.html", NOMEPAG=NOME_PAG_CLOSSARIO, \ REGISTRY_ID=user, CRIAR=False, \ TAG=None, LINKS=[], \ TAGS_LIST=tags_list, \ FOTO=True, \ GLOSSARY=glossary, GLOSSARY_COUNT=glossary_count, \ PAGE=page, PAGESIZE=NUM_MAX_ITENS_GLOSSARIO, \ TITLE=u"Usuários que definiram o termo %s" % glossary_term, \ MSG="") URL_TO_PAGETITLE.update ({ "glossary": "Glossário" }) HANDLERS.extend([ (r"/glossary/new/%s" % (NOMEUSERS), GlossaryNewItemHandler), (r"/glossary/view/%s/%s" % (NOMEUSERS, PAGENAMECHARS), GlossaryViewItemHandler), # registry_id/glossary_item_id> (r"/glossary/term", GlossaryTermHandler), # ?item_id=<glossary_item_id> (r"/glossary/%s" % (NOMEUSERS), GlossaryListHandler), (r"/glossary/delete/%s" % (NOMEUSERS), GlossaryDeleteItemHandler), # ?item_id=<glossary_item_id> (r"/glossary/edit/%s" % (NOMEUSERS), GlossaryEditItemHandler), # ?Item_id=<glossary_item_id> (r"/glossary/%s/%s" % (NOMEUSERS, PAGENAMECHARS), GlossaryListUserTagHandler) ])
def post(self, app_name, registry_id, key): # armazena <key>:<value> no storage if registry_id == "current_user": registry_id = self.get_current_user() value = self.get_argument("value","") self._storage = model.Storage().retrieve(app_name) if self._storage: self._storage.setValue(registry_id, key, value) self._storage.save() else: self._storage = model.Storage() self._storage.setValue(registry_id, key, value) self._storage.save(id=app_name) self.write (dict(status=0, msg=u"Valor armazenado.")) URL_TO_PAGETITLE.update ({ "storage": u"Storage" }) HANDLERS.extend([ (r"/storage/%s" % (NOMEUSERS), StorageStartAppHandler), # GET /storage/<app_name> (r"/storage/%s/%s/%s" % (NOMEUSERS, NOMEUSERS, PAGENAMECHARS), StorageItemHandler), # GET /storage/<app_name>/<registry_id>/<key> # GET /storage/<app_name>/current_user/<key> # POST /storage/<app_name>/<registry_id>/<key> # POST /storage/<app_name>/current_user/<key> ])
from plugins.api import model as model GAMEPAGE = "modules/plugins/game/game.html" CRITERIA = ["state", "marker", "house", "xpos", "ypos", "time"] HEADINGS = ["Tipo", "Marcador", "Casa", "Coluna", "Linha", "Tempo"] class GameHandler(MethodDispatcher): """ Trilha Topológica """ @libs.methoddispatcher.authenticated def index(self, init="1"): self.title = "Trilha Topológica" sessionid = self.get_current_gamesession() if init == "1": self._trainz = model.API_GAME().retrieve(sessionid) self._trainz.next(newgame="trilha", newlevel=1, criteria=CRITERIA, headings=HEADINGS) self.render( GAMEPAGE, TITLE=self.title, BEADS={}, HAND=[], CRITERIA=CRITERIA, SESSIONID=sessionid, RESULT=model.RESULT ) URL_TO_PAGETITLE.update({"game": "Trilha Topológica"}) HANDLERS.extend([(r"/game/.*", GameHandler)])
def open(self): print "WebSocket opened" def on_message(self, message): self.write_message(u"You said: " + message) def on_close(self): print "WebSocket closed" class TestWebSocket(BaseHandler): @tornado.web.authenticated def get(self): self.render("modules/chat/websocket-test.html", NOMEPAG="Chat") URL_TO_PAGETITLE.update ({ "chat": "Chat" }) HANDLERS.extend([ (r"/chat", MyChatHandler), (r"/chat/%s" % (NOMEUSERS), ChatHandler), (r"/chat/%s/new" % (NOMEUSERS), MessageNewHandler), (r"/chat/%s/updates" % (NOMEUSERS), MessageUpdatesHandler), (r"/chat/%s/messages" % (NOMEUSERS), MessagesHandler), (r"/chat/%s/clear" % (NOMEUSERS), NotificationsClearHandler), (r"/chat/%s/notifications" % (NOMEUSERS), NumNotificationsHandler), (r"/websocket", EchoWebSocket), (r"/websocket/test", TestWebSocket) ])
self.write (dict(status=1, msg=u"Você não tem permissão para acessar esta página.")) class EvaluationResultHandler(BaseHandler): ''' Permite que o dono de uma comunidade veja resultados parciais de uma avaliação ''' @tornado.web.authenticated @core.model.serviceEnabled('evaluation') def get(self, registry_id, aval): user = self.get_current_user() if isOwner(user, registry_id): aval_id = '/'.join([registry_id,unquote(aval).decode("UTF-8")]) self._aval = model.Evaluation().retrieve(aval_id) if self._aval: aval_data = prepareResults(self._aval.calcResultAvaliacao()) log.model.log(user, u'acessou o resultado da avaliação', objeto=aval_id, tipo="evaluation", news=False) self.write (dict(status=0, result=aval_data)) else: self.write (dict(status=1, msg=u"Avaliação inexistente.")) else: self.write (dict(status=1, msg=u"Você não tem permissão para acessar esta página.")) HANDLERS.extend([ (r"/rest/evaluation/result/%s" % (NOMEUSERS), CommunityResultsHandler), (r"/rest/evaluation/result/%s/%s" % (NOMEUSERS,PAGENAMECHARS), EvaluationResultHandler) ])
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) URL_TO_PAGETITLE.update ({ "newfriend": "Amigos", "friends": "Amigos", "searchfriends": "Amigos", "sugestfriends": "Sugestões", "acceptfriend": "Convites", "rejectfriend": "Convites", "sugestcontent": "Sugestões" }) HANDLERS.extend([ (r"/newfriend", NewFriendHandler), (r"/friends/search", SearchFriendsHandler), (r"/friends/%s" % NOMEUSERS, ListFriendsHandler), (r"/sugestfriends/%s" % NOMEUSERS, SugestFriendsHandler), (r"/sugestcontent/%s" % NOMEUSERS, SugestContentHandler), (r"/acceptfriend/%s" % (NOMEUSERS), AcceptFriendHandler), (r"/rejectfriend/%s" % (NOMEUSERS), RejectFriendHandler) ])
self._registry = core.model.Registry().retrieve(registry_id) self._registry.conta_google = email_google self._registry.save() self.redirect("/google/" + registry_id) class GoogleLogoffHandler(BaseHandler): ''' Desloga google de um usuário/comunidade ''' @tornado.web.authenticated def get (self): # Esta página google-logout possui 2 frames com 2 urls diferentes que desconectam do google. # São usadas 2 urls diferentes para caso de erro em uma delas self.render("modules/google/google-logout.html", NOMEPAG="agenda") URL_TO_PAGETITLE.update ({ "google": "Agenda Google" }) HANDLERS.extend([ (r"/google/logoff", GoogleLogoffHandler), (r"/google/init/%s" % NOMEUSERS, GoogleInitHandler), (r"/google/%s" % NOMEUSERS, GoogleCalendarHandler) ])
# remove o post try: tags = self._mblog.tags self._mblog.delete() for tag in tags: removeTag(remove_diacritics(tag.lower()), "mblog", mblog_id) except Exception as detail: self.render("home.html", MSG=u"Erro: %s" % detail, REGISTRY_ID=registry_id, NOMEPAG="microblog") return log.model.log(user, u'removeu uma mensagem do mblog de', objeto=registry_id, tipo="none") self.redirect("/mblog/%s" % registry_id) URL_TO_PAGETITLE.update ({ "mblog": "Microblog" }) HANDLERS.extend([ (r"/mblog/new/%s" % (NOMEUSERS), NewMblogHandler), (r"/mblog/mentions/%s" % (NOMEUSERS), MentionsMblogHandler), (r"/mblog/talk", ListTalkMblogHandler), (r"/mblog/reply", ReplyMblogHandler), (r"/mblog/share", ShareMblogHandler), (r"/mblog/delete", DeleteMblogHandler), (r"/mblog/post", ShowMblogPostHandler), (r"/mblog/support", SuporteActivHandler), (r"/mblog/%s" % (NOMEUSERS), MblogHandler) ])
self._rating.user = user self._rating.tipo = tipo self._rating.escopo = escopo self._rating.objeto = objeto self._rating.rating = rating self._rating.data_cri = str(datetime.now()) self._rating.save() if tipo=="question": log.model.log(user, u'avaliou uma questão de', objeto=escopo, tipo=tipo, link="/question/%s?id=%s"%(escopo,objeto)) else: log.model.log(user, u'avaliou', objeto=escopo+"/"+objeto, tipo=tipo) (mean_rating, num_ratings) = model.Rating.getRatingsFromObject(tipo, escopo, objeto) self.write("%.1f %i" % (mean_rating, num_ratings)) else: raise HTTPError(400) else: raise HTTPError(400) URL_TO_PAGETITLE.update ({ "rating": u"Avaliação e Recomendação" }) HANDLERS.extend([ (r"/rating/%s/%s" % (NOMEUSERS, PAGENAMECHARS), ListEvaluationsHandler), (r"/rating/new/%s/%s" % (NOMEUSERS, PAGENAMECHARS), NewEvaluationHandler) ])
file_id = '/'.join([registry_id,filename]) self._file = model.Studio().retrieve(file_id) if self._file != None: if not user and self._file.acesso_publico!="S": self.redirect ("/?next=/file/"+file_id) return # Header content-disposition deve ser inline ou attachment disposition = self.get_argument("disp", "inline") attachname = "img%s.png" % size if '_attachments' not in self._file or attachname not in self._file["_attachments"]: self.redirect("/file/info/%s/%s" % (registry_id, filename)) self.set_header("Content-Disposition", "%s; filename=%s" % (disposition, attachname)) self.set_header("Content-Type", self._file["_attachments"][attachname]['content_type']) self.set_header("Content-Length", self._file["_attachments"][attachname]['length']) if DB_VERSAO_010: self.write(database.STUDIO.get_attachment(file_id, attachname, default="Object not found!")) else: self.write(database.STUDIO.get_attachment(file_id, attachname, default="Object not found!").read()) #log.model.log(user, u'acessou o arquivo', objeto=file_id, tipo="file") else: self.write (dict(status=1, msg=u"Arquivo não encontrado.")) HANDLERS.extend([ (r"/rest/studio/%s" % (NOMEUSERS), StudioListHandler), (r"/rest/studio/%s/%s" % (NOMEUSERS, FILENAMECHARS), StudioViewHandler) ])
@tornado.web.authenticated def get (self, service, index_tutorial, index_tela): user = self.get_current_user() if service in TUTORIAL and \ int(index_tutorial) < len(TUTORIAL[service]["tutoriais"]) and \ "telas" in TUTORIAL[service]["tutoriais"][int(index_tutorial)] and \ int(index_tela) < len(TUTORIAL[service]["tutoriais"][int(index_tutorial)]["telas"]): log.model.log(user, u'acessou uma tela do tutorial ', objeto=service+"/"+index_tutorial, tipo="tutorial", news=False) self.render("modules/tutorial/tutorial.html", \ TUTORIAL=TUTORIAL[service]["tutoriais"][int(index_tutorial)], \ VOLTAR=len(TUTORIAL[service]["tutoriais"])>1, \ SERVICE=service, INDEX_TUTORIAL=int(index_tutorial), INDEX_TELA=int(index_tela)) else: raise HTTPError(404) URL_TO_PAGETITLE.update ({ "tutorial": u"Tutorial" }) HANDLERS.extend([ (r"/tutorial/change_status", TutorialChangeStatusHandler), (r"/tutorial/%s" % (PAGENAMECHARS), TutorialIndexHandler), (r"/tutorial/%s/%s" % (PAGENAMECHARS,NUMERO), TutorialHandler), (r"/tutorial/%s/%s/%s" % (PAGENAMECHARS,NUMERO,NUMERO), TutorialScreenHandler) ])
habilidades_mapeadas.remove(item) else: habilidades_mapeadas = [] dict_habilidades["usuarios"].append(row.id) habilidades_mapeadas.append(dict_habilidades) dict_habilidades = {} habilidades_mapeadas.sort(key=lambda x: (len(x["usuarios"])), reverse=True) self.render("modules/admin/list-skills.html", REGISTRY_ID=PRIV_GLOBAL_ADMIN, \ MSG="", HABILIDADES=habilidades_mapeadas,\ NOMEPAG="cadastro") URL_TO_PAGETITLE.update ({ "admin": u"Administração" }) HANDLERS.extend([ (r"/admin/listusers", ListUsersHandler), (r"/admin/onlineusers", OnlineUsersHandler), (r"/admin/listcommunities", ListCommunitiesActHandler), (r"/admin/uploadquota/%s" % NOMEUSERS, FileQuotaHandler), (r"/admin/totalusers", TotalUsersHandler), (r"/admin/apps/%s" % NOMEUSERS, AppsHandler), (r"/admin/myapps", MyAppsHandler), (r"/admin/skillstats", SkillStatsHandler), (r"/admin/skillstats/user/%s"% NOMEUSERS, UserSkillsHandler), (r"/admin/skillstats/skills", SkillUsersHandler) ])
bookm_count = model.Bookmarks.countBookmarksByUrl(url) bookmarks = model.Bookmarks.searchBookmarksByUrl(user, page, NUM_MAX_FAVORITOS, url) tags_list = model.Bookmarks.listAllTags(user) self.render("modules/bookmarks/bookmarks-list.html", NOMEPAG='favoritos', \ REGISTRY_ID=user, CRIAR=False, \ TAG=None, LINKS=[], \ TAGS=tags_list, \ FOTO=True, \ BOOKMARKS=bookmarks, BOOKM_COUNT=bookm_count, \ PAGE=page, PAGESIZE=NUM_MAX_FAVORITOS, \ TITLE=u"Usuários que marcaram %s"%url, \ MSG="") URL_TO_PAGETITLE.update ({ "bookmarks": "Favoritos" }) HANDLERS.extend([ (r"/bookmarks/new/%s" % (NOMEUSERS), BookmarkNewHandler), (r"/bookmarks/popup/%s" % (NOMEUSERS), BookmarkNewPopUpHandler), (r"/bookmarks/url", BookmarkUrlHandler), # ?url=<url> (r"/bookmarks/comment/%s" % (NOMEUSERS), BookmarkCommentHandler), # ?id=<bookmark_id> (r"/bookmarks/comment/%s/delete" % (NOMEUSERS), BookmarkDeleteCommentHandler), (r"/bookmarks/delete/%s" % (NOMEUSERS), BookmarkDeleteHandler), # ?id=<bookmark_id> (r"/bookmarks/edit/%s" % (NOMEUSERS), BookmarkEditHandler), # ?id=<bookmark_id> (r"/bookmarks/%s" % (NOMEUSERS), BookmarkListHandler), (r"/bookmarks/%s/%s" % (NOMEUSERS, PAGENAMECHARS), BookmarkUserTagHandler) ])
return for community_id in comunidades: aval_id = "%s/%s" % (community_id, aval_data["nome"]) if aval_id not in model.EVALUATION: model.EVALUATION[aval_id] = aval_data log.model.log(user, u'criou a avaliação', objeto=aval_id, tipo="evaluation") msg += u"* Criada avaliação %s.<br/>" % aval_id else: msg += u"* Já existe uma avaliação %s.<br/>" % aval_id self.render("home.html", MSG=msg, REGISTRY_ID=user, \ NOMEPAG=u"Avaliações") """ URL_TO_PAGETITLE.update ({ "evaluation": u"Avaliação" }) HANDLERS.extend([ #(r"/evaluation/new", NewMultipleEvaluationHandler), (r"/evaluation/new/%s/(wiki|member)" % (NOMEUSERS), NewEvaluationHandler), (r"/evaluation/%s" % (NOMEUSERS), ListEvaluationHandler), (r"/evaluation/result/%s" % (NOMEUSERS), CommunityResultsHandler), (r"/evaluation/result/%s/%s" % (NOMEUSERS,PAGENAMECHARS), EvaluationResultHandler), (r"/evaluation/%s/%s" % (NOMEUSERS,PAGENAMECHARS), EvaluationHandler), (r"/evaluation/delete/%s/%s" % (NOMEUSERS,PAGENAMECHARS), EvaluationDeleteHandler), (r"/evaluation/edit/%s/%s" % (NOMEUSERS,PAGENAMECHARS), EvaluationEditHandler), ])
log.model.log(user, u'removeu uma resposta de um tópico do forum', objeto=_reply.registry_id, tipo="forum") # busca o tópico para recuperar o name_id e poder redirecionar para a página do tópico _topic = model.Topic().retrieve(_reply.group_id) if _topic: self.redirect("/forum/%s/%s" % (_reply.registry_id, _topic.name_id)) else: self.redirect("/forum/%s" % _reply.registry_id) else: raise HTTPError(403) #============================================================================== URL_TO_PAGETITLE.update ({ "forum": "Forum" }) HANDLERS.extend([ (r"/forum/%s" % NOMEUSERS, ForumHandler), (r"/forum/newtopic/%s" % NOMEUSERS, NewTopicHandler), (r"/forum/%s/%s" % (NOMEUSERS, PAGENAMECHARS), TopicHandler), (r"/forum/edit/%s/%s" % (NOMEUSERS, PAGENAMECHARS), EditTopicHandler), (r"/forum/delete/%s/%s" % (NOMEUSERS, PAGENAMECHARS), DeleteTopicHandler), (r"/forum/reply/edit/%s" % NOMEUSERS, EditReplyHandler), # ?id=xxxxxxxx (r"/forum/reply/delete/%s" % NOMEUSERS, DeleteReplyHandler), # ?id=xxxxxxxx (r"/forum/reply/%s/%s" % (NOMEUSERS, PAGENAMECHARS), ReplyHandler), ])
''' Retorna Json com lista de pessoas sugeridas para um autocomplete ''' @tornado.web.authenticated def get(self): user = self.get_current_user() ret = dict() for row in core.database.REGISTRY.view('users/partial_data'): ret[row.key] = row.value["nome_completo"] self.write (ret) class FindCommunityHandler(BaseHandler): ''' Retorna Json com lista de comunidades sugeridas para um autocomplete ''' @tornado.web.authenticated def get(self): user = self.get_current_user() ret = dict() for row in core.database.REGISTRY.view('communities/partial_data'): ret[row.key] = row.value["description"] self.write (ret) class FindTagHandler(BaseHandler): ''' Retorna Json com lista de tags sugeridas para um autocomplete ''' @tornado.web.authenticated def get(self): self.write (cloudTag()) HANDLERS.extend([ (r"/ajax/finduser", FindUserHandler), (r"/ajax/findcommunity", FindCommunityHandler), (r"/ajax/findtag", FindTagHandler) ])
################################################ Plataforma ActivUFRJ ################################################ :Author: *Núcleo de Computação Eletrônica (NCE/UFRJ)* :Contact: [email protected] :Date: $Date: 2009-2010 $ :Status: This is a "work in progress" :Revision: $Revision: 0.01 $ :Home: `LABASE `__ :Copyright: ©2009, `GPL """ from core.dispatcher import BaseHandler, HANDLERS, URL_TO_PAGETITLE from tornado.web import HTTPError """ Atenção: este módulo deve ser o último controlador a ser importado no main.py """ class ErrorHandler(BaseHandler): """ Alternativa para gerar erro 404 quando a url não é atendida por nenhum outro controlador """ def get(self, x): raise HTTPError(404) URL_TO_PAGETITLE.update({"Error": "error"}) HANDLERS.extend([(r"/(.*)", ErrorHandler)])
self._file = model.Studio().retrieve(file_id) if self._file: self._file.deleteFileComment(comentario) log.model.log(user, u'removeu um comentário da imagem no studio de games', objeto=file_id, tipo="studio") self.redirect("/studio/info/%s#comment" % file_id) else: msg = u"Arquivo não encontrado." self.render("home.html", MSG=msg, REGISTRY_ID=registry_id, NOMEPAG=u'Estúdio') else: msg = u"Você não tem permissão para apagar este comentário." self.render("home.html", MSG=msg, REGISTRY_ID=registry_id, NOMEPAG=u'Estúdio') URL_TO_PAGETITLE.update ({ "studio": u"Estúdio" }) HANDLERS.extend([ (r"/studio/upload2/%s" % (NOMEUSERS), MultipleStudioUploadHandler), (r"/studio/upload/%s" % (NOMEUSERS), StudioUploadHandler), (r"/studio/info/%s/%s" % (NOMEUSERS, FILENAMECHARS), StudioInfoHandler), (r"/studio/comment/%s/%s" % (NOMEUSERS, FILENAMECHARS), StudioCommentHandler), (r"/studio/comment/delete/%s/%s" % (NOMEUSERS, FILENAMECHARS), StudioDeleteCommentHandler), (r"/studio/delete/%s/%s" % (NOMEUSERS, FILENAMECHARS), StudioDeleteHandler), (r"/studio/%s" % (NOMEUSERS), StudioListHandler), (r"/studio/%s/%s" % (NOMEUSERS, FILENAMECHARS), StudioViewHandler), (r"/studio/edit/%s/%s" % (NOMEUSERS, FILENAMECHARS), StudioEditHandler) ])
URL_TO_PAGETITLE.update ({ "communities": "Comunidades", "community": "Comunidades", "members": "Participantes", "invite": "Comunidades", "accept": "Convites", "reject": "Convites" }) HANDLERS.extend([ (r"/communities/search", CommunitySearchHandler), (r"/communities/%s" % NOMEUSERS, UserCommunitiesHandler), (r"/community/%s" % NOMEUSERS, CommunityHandler), (r"/community/owners/%s" % NOMEUSERS, CommunityOwnersHandler), (r"/community/join/%s" % NOMEUSERS, CommunityJoinHandler), (r"/community/leave/%s" % NOMEUSERS, CommunityLeaveHandler), (r"/community/delete/%s" % NOMEUSERS, DeleteCommunityHandler), (r"/members/%s" % NOMEUSERS, ListMembersHandler), (r"/invite/%s" % NOMEUSERS, InviteUserHandler), (r"/accept/%s" % NOMEUSERS, AcceptCommunityHandler), (r"/reject/%s" % NOMEUSERS, RejectCommunityHandler), (r"/members/admin/%s" % NOMEUSERS, MembersAdminHandler), (r"/members/delete/%s" % NOMEUSERS, DeleteMembersHandler), (r"/members/search/%s" % NOMEUSERS, SearchMembersHandler), (r"/members/searchgroup/%s" % NOMEUSERS, SearchGroupHandler), (r"/members/invitegroup/%s" % NOMEUSERS, InviteGroupHandler), (r"/members/callgroup/%s" % NOMEUSERS, CallGroupHandler) ])
table=[dict(house=pin, marker=self._bead, result=result, state=self._next, time=str(datetime.now()))]) return hand def _move(self,sessionid,pin): self._tol = API_GAME().retrieve(sessionid) self.title = "Torre de Londres" # self._tol.save() hand = [BEAD_COLOR[hand] for hand in self._move_bead(pin)] self.render(TOLPAGE, TITLE = self.title, BEADS = self._show(), HAND = hand, LEVEL=self._tol.level,\ CRITERIA=CRITERIA, SESSIONID=sessionid, RESULT=RESULT) @libs.methoddispatcher.authenticated def big(self,sessionid,y=0,x=0, **kargs): self._move(sessionid,'b') @libs.methoddispatcher.authenticated def mid(self,sessionid,y=0,x=0, **kargs): self._move(sessionid,'m') @libs.methoddispatcher.authenticated def lit(self,sessionid,y=0,x=0, **kargs): self._move(sessionid,'l') URL_TO_PAGETITLE.update ({ "tol": "Torre de Londres" }) HANDLERS.extend([ (r"/tol/.*", TolHandler), ])
#@tornado.web.authenticated @core.model.allowedToAccess @core.model.serviceEnabled('videoaula') @libs.permissions.hasReadPermission ("videoaula") 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] self.render("modules/videoaula/videoaula-play.html", NOMEPAG="videoaulas", VIDEODATA=_va, \ SORTEDKEYS=sortedKeys, MIME_TYPE=mime_types[ext], \ REGISTRY_ID=registry_id, MSG="") else: raise HTTPError(404) URL_TO_PAGETITLE.update ({ "videoaula": "Videoaulas" }) HANDLERS.extend([ (r"/videoaula/%s" % (NOMEUSERS), VideoAulaListHandler), (r"/videoaula/tag/%s/%s" % (NOMEUSERS, PAGENAMECHARS), VideoAulaTagHandler), (r"/videoaula/new/%s" % (NOMEUSERS), NewVideoAulaHandler), (r"/videoaula/edit/%s/%s" % (NOMEUSERS, PAGENAMECHARS), EditVideoAulaHandler), (r"/videoaula/sync/%s/%s" % (NOMEUSERS, PAGENAMECHARS), VideoAulaSyncHandler), (r"/videoaula/delsync/%s/%s" % (NOMEUSERS, PAGENAMECHARS), VideoAulaDelSyncHandler), (r"/videoaula/delete/%s/%s" % (NOMEUSERS, PAGENAMECHARS), VideoAulaDeleteHandler), (r"/videoaula/%s/%s" % (NOMEUSERS, PAGENAMECHARS), VideoAulaPlayHandler) ])
if msg: tabs = [] tabs.append(("Nº de Acessos por Usuário", "/stats/"+registry_id)) tabs.append(("Nº de Acessos por Objeto", "")) self.render("modules/log/plot-objects-data.html", NOMEPAG=u"estatísticas", \ NOMECOMUNIDADE=registry_id, REGISTRY_ID=registry_id, \ TABS=tabs, MSG=msg) else: if periodo_estatistica == "diario": self.render("modules/log/stats-render.html", NOMEPAG=u"estatísticas", LISTADEDADOS = listaDeDados, LISTADEUSUARIOS = listaDeObjetos, \ REGISTRY_ID=registry_id, TAMANHO_EIXO=tamanho_eixo, TITLE=u"Uso de objetos ao longo do tempo") elif periodo_estatistica == "total": self.render("modules/log/stats-render-bar-chart.html", NOMEPAG=u"estatísticas", LISTADEDADOS = listaDeDados, LISTADEUSUARIOS = listaDeObjetos, \ REGISTRY_ID=registry_id, TAMANHO_EIXO=tamanho_eixo, TITLE=u"Uso de objetos ao longo do tempo", ALTURA = (len(listaDeDados)*45)) URL_TO_PAGETITLE.update ({ "news": "Novidades", "stats": u"Estatísticas" }) HANDLERS.extend([ (r"/news", ListMyNewsHandler), (r"/news/%s" % NOMEUSERS, ListNewsHandler), (r"/stats", PlotSystemStats), (r"/stats/users", PlotSystemUserStats), (r"/stats/%s" % NOMEUSERS, PlotStats), (r"/stats/object/%s" % NOMEUSERS, PlotObjectStats) ])
TRAINZPAGE ="modules/plugins/trainz/trainz.html" CRITERIA = ['marker','house','state','score','time'] HEADINGS = ['Marcador', 'Casa', 'Movimento', 'Pontos', 'Tempo'] class TrainzHandler(MethodDispatcher): """ Manobrando o Trem no Desvio """ @libs.methoddispatcher.authenticated def index(self, init="1"): self.title = "Manobrando o Trem" sessionid = self.get_current_gamesession() if init=="1": self._trainz = model.API_GAME().retrieve(sessionid) self._trainz.next(newgame="trainz", newlevel=1, criteria=CRITERIA, headings=HEADINGS) self.render(TRAINZPAGE, TITLE=self.title, BEADS={}, HAND=[], CRITERIA=CRITERIA, \ SESSIONID=sessionid, RESULT=model.RESULT) URL_TO_PAGETITLE.update ({ "trainz": "Manobrando o Trem", }) HANDLERS.extend([ (r"/trainz/.*", TrainzHandler), ])
''' Retorna XML com as noticias de uma comunidade, utilizado para o pop-up de notícias. ''' @tornado.web.authenticated @core.model.allowedToAccessPrivNoticias @core.model.serviceEnabled('noticia') def get (self, registry_id): # Classe noticias noticias = Noticias(registry_id) lista = noticias.get_obj_lista_noticias(popup="S") self.set_header("Content-Type", "application/xml") self.render("modules/noticia/noticias.xml", NOMEPAG=u'Notícias', \ LISTA=lista, NOW=str(datetime.now())[0:11], \ CHANGE_NAVIGATION=False, \ REGISTRY_ID=registry_id) #============================================================================== URL_TO_PAGETITLE.update ({ "noticia": "Noticia" }) HANDLERS.extend([ (r"/noticia/%s" % NOMEUSERS, ListaHandler), (r"/noticia/%s/new" % NOMEUSERS, NewHandler), (r"/noticia/xml/%s" % NOMEUSERS, XMLHandler), (r"/noticia/%s/%s" % (NOMEUSERS,NOMEUSERS), NoticiaHandler) ])
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) URL_TO_PAGETITLE.update ({ "scrap": "Recados" }) HANDLERS.extend([ (r"/scrap/%s" % (NOMEUSERS), ListScrapbookHandler), (r"/new/scrap", NewScrapHandler), (r"/delete/scrap", DeleteScrapHandler) ])
criteria = criteria and json_decode(criteria.replace("'",'"')) table = self._compute_score(score, criteria) sessionid = self.get_current_gamesession() self._apidoc = model.API_GAME().retrieve(sessionid) self._apidoc.next(newtrial=True, table=table) return ('{"result":true}') @libs.methoddispatcher.authenticated def showscore(self, sessionid=None, game=-1, goal=-1): ''' Exibe tabela com os movimentos de uma fase de um jogo ''' if not sessionid: sessionid = self.get_current_gamesession() self._apidoc = model.API_GAME().retrieve(sessionid) score_table = self._apidoc.show_score(int(game), int(goal)) self.title = score_table[TITLE] self.render(SCOREPAGE, TITLE=self.title, GAME=game, GOAL=goal, BEADS={}, ROW=score_table[HEAD], BODY=score_table[BODY]) URL_TO_PAGETITLE.update ({ "newsession": u"Cadastro de Sessão", "next": u"Próxima Fase", "quit": u"Fim de Jogo", "showscore": u"Resultados do Jogo" }) HANDLERS.extend([ (r"/api/.*", APIHandler), ])
#Se os acertos consecutivos chegarem a 10, troca a categoria if acertosConsecutivos == 10: acertosConsecutivos = 0 categoria += 1 houses = {"indiceCartaAtual": indiceCartaAtual, "categoria": categoria, "acertosConsecutivos": acertosConsecutivos, "outrosConsecutivos": outrosConsecutivos, "wteste": None } self._wisc.next(houses=houses, table=table) # Termina o teste se esgotar as categorias ou fim das cartas respostas. if ((categoria >= len(wcst.listaCategorias)) or (indiceCartaAtual >= len(wcst.listaCartasResposta)-1)): resultadoTeste = "Fim do Jogo" self.redirect('/wisconsin/play?'+urllib.urlencode({"result":resultadoTeste.encode("UTF-8")})) URL_TO_PAGETITLE.update ({ "wisconsin": "Wisconsin" }) HANDLERS.extend([ (r"/wisconsin/.*", WisconsinHandler) ])
CHECK = self._cancel.markers, \ HAND = [0,3], CRITERIA=CRITERIA, \ SESSIONID=sessionid, RESULT=model.RESULT) @libs.methoddispatcher.authenticated def click(self,sessionid,y=0,x=0, shape='(0,0,0)',**kargs): shape = [int(it) for it in shape[1:-1].split(',')] clicked_shape = shape[0] shape[0] = (0,1)[shape[0] in [0,3]] shape.append(str(datetime.now())) shape.append(clicked_shape) self._cancel = model.API_GAME().retrieve(sessionid) markers = self._cancel.markers markers.append(shape) self._cancel.next(markers=markers) self.render(CANCELPAGE, SHAPES = self._show(), CHECK = self._cancel.markers, \ HAND = [0,3], CRITERIA=CRITERIA,\ SESSIONID=sessionid, RESULT=model.RESULT) URL_TO_PAGETITLE.update ({ "can": "Teste de Cancelamento" }) HANDLERS.extend([ (r"/can/.*", CancelHandler) ])
totais = [len(resultados_busca[key]) for key in resultados_busca] self.render("modules/search/user-results.html", REGISTRY_ID=registry_id, \ NOMEPAG='busca', \ RESULTADOS=resultados_busca, LEGENDA=URL_TO_PAGETITLE, \ NUM_RESULT=sum(totais), \ TAGS_PROCURADAS=tags_procuradas) class TagCloudHandler(BaseHandler): ''' Exibe tagcloud de um usuário ou comunidade ''' @tornado.web.authenticated @core.model.allowedToAccess def get(self, registry_id): self.render("modules/search/tagcloud.html", NOMEPAG="perfil", \ REGISTRY_ID = registry_id, MSG=u"", \ TAGCLOUD = cloudTag(registry_id)) URL_TO_PAGETITLE.update ({ "search": "Busca" }) HANDLERS.extend([ (r"/search", SearchTagHandler), (r"/search/%s"%NOMEUSERS, SearchUserTagHandler), (r"/tagcloud/%s"%NOMEUSERS, TagCloudHandler) ])
self.render("modules/quiz/quiz-result-survey.html", NOMEPAG="Quiz", \ REGISTRY_ID=registry_id, TITLE=u"Quiz de %s" % registry_id, \ ANSWERS=_answers, QUIZ=_quiz, QUESTIONS= _questions, \ IMGLIST=["resp_a.gif", "resp_b.gif", "resp_c.gif", "resp_d.gif", "resp_e.gif"], \ LINKS=[] ) else: raise HTTPError(404) URL_TO_PAGETITLE.update ({ "quiz": u"Quiz" }) HANDLERS.extend([ (r"/quiz/new/%s" % (NOMEUSERS), NewQuizHandler), (r"/quiz/%s" % (NOMEUSERS), QuizListHandler), (r"/quiz/%s/%s" % (NOMEUSERS, NOMEUSERS), QuizAnswerHandler), (r"/quiz/edit/%s/%s" % (NOMEUSERS, NOMEUSERS), QuizEditHandler), (r"/quiz/delete/%s/%s" % (NOMEUSERS, NOMEUSERS), QuizDeleteHandler), (r"/quiz/answerkey/%s/%s" % (NOMEUSERS, NOMEUSERS), QuizAnswerKeyHandler), (r"/quiz/result/%s/%s" % (NOMEUSERS, NOMEUSERS), QuizResultHandler) ])