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)
])
