def test_router_pass_parameters_to_route(self):
router = Router(lookup_type='slug', lookup_field='title')
assert isinstance(router.lookup_field, defaultdict)
assert isinstance(router.lookup_type, defaultdict)
# Register route without override
route = router.register(lambda book: None)
assert isinstance(route.lookup_field, defaultdict)
assert isinstance(route.lookup_type, defaultdict)
print(router.lookup_field)
print(route.lookup_field)
assert route.lookup_field['book'] == 'title'
assert route.lookup_type['book'] == 'slug'
# Override field
route = router.register(lambda book: None, lookup_field='author')
assert route.lookup_field['book'] == 'author'
assert route.lookup_type['book'] == 'slug'
# Override type
route = router.register(lambda book: None, lookup_type='str')
assert route.lookup_field['book'] == 'title'
assert route.lookup_type['book'] == 'str'
# Override type with dict
route = router.register(lambda book: None, lookup_type={'book': 'str'})
assert route.lookup_field['book'] == 'title'
assert route.lookup_type['book'] == 'str'
from logging import getLogger
from django.http import HttpResponse, JsonResponse, Http404
from django.shortcuts import redirect
from boogie.router import Router
from ej_users.routes import login as ej_login
from . import forms
from .decorators import security_policy, requires_rc_perm
from .models import RCConfig, RCAccount
from .rocket import rocket
log = getLogger('ej')
app_name = 'ej_rocketchat'
urlpatterns = Router(template=['ej_rocketchat/{name}.jinja2'], )
@urlpatterns.route('', decorators=[requires_rc_perm, security_policy])
def iframe(request):
ask_password_form = None
ask_password = False
# Superuser must type the password since it is not stored in the database
if request.user.is_superuser:
ask_password = True
password, ask_password_form = ask_admin_password(request)
token = rocket.admin_token
username = rocket.admin_username
if password:
rocket.password_login(rocket.admin_username, password)
ask_password = False
from sidekick import import_later
from ej_conversations.models import Conversation
from ej_conversations.routes import conversation_url
from ej_conversations.utils import check_promoted
from ej_profiles.enums import Gender, Race, STATE_CHOICES
np = import_later("numpy")
wordcloud = import_later("wordcloud")
stop_words = import_later("stop_words")
pd = import_later("pandas")
log = getLogger("ej")
urlpatterns = Router(
base_path=conversation_url,
template="ej_dataviz/{name}.jinja2",
models={"conversation": Conversation},
login=True,
)
app_name = "ej_dataviz"
User = get_user_model()
#
# Scatter plot
#
@urlpatterns.route("scatter/")
def scatter(request, conversation, slug, check=check_promoted):
names = getattr(settings, "EJ_PROFILE_FIELD_NAMES", {})
return {
"gender_field": names.get("gender", _("Gender")),
"race_field": names.get("race", _("Race")),
from boogie.router import Router
from . import models, forms
from . import rules
from django.shortcuts import render
from ej_users.models import User
from ej.utils.perms import conversations
app_name = 'ej_conversations'
urlpatterns = Router(
template='ej_conversations/{name}.jinja2',
models={
'conversation': models.Conversation,
'comment': models.Comment,
'user': User
},
lookup_field={
'conversation': 'slug',
'comment': 'slug',
'user': '******',
},
lookup_type='slug',
object='conversation',
)
conversation_url = '<model:conversation>/'
base_url = 'conversations/'
user_url = '<model:user>/'
#
# Administrative views
#
from boogie.router import Router
from boogie.rules import proxy_seq
from ej_clusters.math import get_raw_votes, get_votes
from ej_conversations.models import Conversation
from ej_dataviz import render_dataframe
from ej_math import VoteStats
from hyperpython.components import html_table, hyperlink
from sklearn.decomposition import PCA
urlpatterns = Router(
template=['ej_reports/{name}.jinja2', 'generic.jinja2'],
perms=['ej_reports.can_view_report'],
object='conversation',
models={
'conversation': Conversation,
},
lookup_field='slug',
lookup_type='slug',
login=True,
)
app_name = 'ej_reports'
conversation_url = '<model:conversation>/reports/'
User = get_user_model()
@urlpatterns.route(conversation_url)
def index(request, conversation):
statistics = conversation.statistics()
votes = get_raw_votes(conversation)
comments = comments_table(conversation, votes)
import logging
from allauth.account import views as allauth
from boogie.router import Router
from django.contrib import auth
from django.contrib.auth import get_user_model
from django.urls import reverse_lazy
from django.utils.translation import ugettext_lazy as _
from . import forms
from . import models
User = get_user_model()
app_name = "ej_users"
urlpatterns = Router(template="account/{name}.jinja2", login=True)
log = logging.getLogger("ej")
#
# Account management
#
@urlpatterns.route("")
def index(request):
return {"user": request.user, "profile": getattr(request.user, "profile", None)}
@urlpatterns.route("logout/")
def logout(request):
if request.method == "POST":
auth.logout(request)
from django.shortcuts import redirect
from boogie.router import Router
from ej_clusters.forms import StereotypeForm
from ej_clusters.utils import check_stereotype
from .models import Stereotype
app_name = "ej_cluster"
urlpatterns = Router(
template="ej_clusters/stereotypes/{name}.jinja2",
models={"stereotype": Stereotype},
login=True,
)
@urlpatterns.route("")
def list(request):
qs = request.user.stereotypes.prefetch_related(
"clusters__clusterization__conversation")
stereotypes = []
for stereotype in qs:
stereotype.conversations = conversations = []
for cluster in stereotype.clusters.all():
conversations.append(cluster.clusterization.conversation)
stereotypes.append(stereotype)
return {"stereotypes": stereotypes}
@urlpatterns.route("add/")
def create(request):
form = StereotypeForm(request=request, owner=request.user)
import toolz
from boogie.router import Router
from django.apps import apps
from django.db.models import Q, Count
from django.shortcuts import redirect
from django.urls import reverse
from ej_conversations.models import Conversation, Comment
from . import forms
app_name = "ej_profiles"
urlpatterns = Router(template=["ej_profiles/{name}.jinja2", "generic.jinja2"],
login=True)
@urlpatterns.route("")
def detail(request):
user = request.user
return {
"profile":
user.get_profile(),
"n_conversations":
user.conversations.count(),
"n_boards":
user.boards.count(),
"n_favorites":
user.favorite_conversations.count(),
"n_comments":
user.comments.count(),
"n_votes":
user.votes.count(),
from pathlib import Path
from django.contrib.flatpages.models import FlatPage
from django.shortcuts import render
from django.utils.translation import ugettext_lazy as _
from boogie.router import Router
from ej_configurations import social_icons
app_name = 'ej_help'
urlpatterns = Router(template=['ej_help/{name}.jinja2', 'generic.jinja2'], )
REPO = Path(__file__).parent.parent.parent
LIB = REPO / 'lib/resources/pages/'
def flat_pages_route(slug):
def route(request):
try:
page = FlatPage.objects.get(url=f'/{slug}/')
except FlatPage.DoesNotExist:
page = fallback_page(slug)
return render(request, page.template_name, {'flatpage': page})
route.__name__ = route.__qualname__ = slug
return route
def fallback_page(slug):
md = LIB / f'{slug}.md'
html = LIB / f'{slug}.html'
from boogie.router import Router
from django.utils import timezone
from ej_conversations.models import Conversation
from ej_conversations.utils import check_promoted
from ej_gamification.models import endorse_comment
from ej_gamification.models.progress_base import get_participation, get_progress
app_name = "ej_gamification"
urlpatterns = Router(
template="ej_gamification/conversation/{name}.jinja2",
base_path="<model:conversation>/<slug:slug>/",
models={"conversation": Conversation},
login=True,
)
@urlpatterns.route("achievements/")
def achievements(request, conversation, slug, check=check_promoted):
check(conversation, request)
user = request.user
return {
"user": user,
"progress": get_participation(user, conversation),
"conversation_progress": get_progress(conversation),
}
@urlpatterns.route("endorse-comments/", perms=["ej.can_edit_conversation"])
def endorse(request, conversation, slug, check=check_promoted):
from django.db.models import Q
from django.http import JsonResponse
from django.shortcuts import render, redirect
from boogie.router import Router
from consultations.models.emergency_care import Triage, Call
urlpatterns = Router()
@urlpatterns.route()
def index(request):
"""
[...]
"""
if request.user.is_authenticated:
if hasattr(request.user, 'medic'):
response = redirect('/chamada-de-pacientes/')
elif hasattr(request.user, 'clerk'):
response = redirect('/registro-de-pacientes/')
elif request.user.is_superuser:
response = render(request, 'homepage.html')
else:
from django.shortcuts import redirect
from django.urls import reverse
from django.utils.translation import ugettext_lazy as _
from boogie.router import Router
from ej_conversations.proxy import conversations_with_moderation
from ej_conversations import forms
from ..models import Board, BoardSubscription
app_name = 'ej_boards'
urlpatterns = Router(
template=['ej_boards/{name}.jinja2', 'generic.jinja2'],
models={
'board': Board,
},
lookup_field='slug',
lookup_type='slug',
)
board_url = '<model:board>/conversations/'
@urlpatterns.route(board_url, template='ej_conversations/list.jinja2')
def conversation_list(request, board):
user = request.user
conversations = board.conversations.all()
tags = board.tags.all()
board_user = board.owner
boards = board_user.boards.all()
return {
'conversations': conversations_with_moderation(user, conversations),
from .forms import (
RasaConversationForm,
ConversationComponentForm,
ConversationComponent,
MailingToolForm,
MauticConversationForm,
)
from .models import RasaConversation, ConversationMautic
from .. import models
from ..tools.table import Tools
app_name = "ej_conversations_tools"
urlpatterns = Router(
template="ej_conversations_tools/{name}.jinja2",
models={
"conversation": models.Conversation,
"connection": RasaConversation,
"mautic_connection": ConversationMautic,
},
)
conversation_tools_url = f"<model:conversation>/<slug:slug>/tools"
@urlpatterns.route(conversation_tools_url)
def index(request, conversation, slug, npm=npm_version):
tools = Tools(conversation)
return {"tools": tools.list(), "conversation": conversation}
@urlpatterns.route(conversation_tools_url + "/mailing")
def mailing(request, conversation, slug):
from .mailing import TemplateGenerator
from django.http import Http404, JsonResponse
from django.http import HttpResponseServerError
from django.shortcuts import redirect
from django.template.loader import get_template
from django.utils.translation import ugettext_lazy as _
from rest_framework import status
from rest_framework.authtoken.models import Token
from boogie.router import Router
from ej_users import forms
from .socialbuttons import social_buttons
User = get_user_model()
app_name = 'ej_users'
urlpatterns = Router(template='ej_users/{name}.jinja2', )
log = logging.getLogger('ej')
@urlpatterns.route('register/')
def register(request):
form = forms.RegistrationForm.bind(request)
next = request.GET.get('next', '/')
if form.is_valid_post():
data = form.cleaned_data
name, email, password = data['name'], data['email'], data['password']
try:
user = User.objects.create_user(email, password, name=name)
log.info(f'user {user} ({email}) successfully created')
from ej_conversations.enums import Choice
from ej_conversations.models import Conversation, Comment
from ej_conversations.routes import conversation_url, check_promoted
from . import forms
from .models import Stereotype, Cluster
from .models import StereotypeVote
from .utils import cluster_shapes
log = getLogger("ej")
app_name = "ej_cluster"
urlpatterns = Router(
template="ej_clusters/{name}.jinja2",
login=True,
models={
"conversation": Conversation,
"stereotype": Stereotype,
"cluster": Cluster
},
)
stereotype_perms = {"perms": ["ej.can_manage_stereotypes:conversation"]}
#
# Cluster visualization
#
@urlpatterns.route(conversation_url + "clusters/")
def index(request, conversation, slug, check=check_promoted):
check(conversation, request)
user = request.user
clusterization = getattr(conversation, "clusterization", None)
from django.shortcuts import redirect
from django.urls import reverse
from django.utils.translation import ugettext_lazy as _
from hyperpython import a
from . import forms, models
from .models import Conversation
from .rules import next_comment
from .tour import TOUR
from .utils import check_promoted, conversation_admin_menu_links, handle_detail_post
log = getLogger("ej")
app_name = "ej_conversations"
urlpatterns = Router(
template="ej_conversations/{name}.jinja2",
models={"conversation": models.Conversation},
)
conversation_url = f"<model:conversation>/<slug:slug>/"
#
# Display conversations
#
@urlpatterns.route("", name="list")
def list_view(request,
queryset=Conversation.objects.filter(is_promoted=True),
context=None):
user = request.user
# Select the list of conversations: staff get to see hidden conversations while
# regular users cannot
from boogie.router import Router
from django.db.models import Count, Q
from django.http import Http404
from django.shortcuts import redirect
from django.urls import reverse
from django.utils.translation import ugettext_lazy as _
from ej_conversations.models import FavoriteConversation, Comment, Choice
from .forms import ProfileForm
app_name = 'ej_profiles'
urlpatterns = Router(
template=['ej_profiles/{name}.jinja2', 'generic.jinja2'],
login=True,
)
@urlpatterns.route('')
def detail(request):
user = request.user
# Select conversations and comments in an optimized query
favorites = (
FavoriteConversation.objects
.filter(user=user)
.select_related('conversation')
.prefetch_related('conversation__followers')
.prefetch_related('conversation__tags')
)
conversations = [fav.conversation for fav in favorites]
from ej_conversations import forms
from ej_conversations.models import Conversation
from ej_conversations.routes.conversations import conversation_detail_context
from .forms import BoardForm
from .models import Board
app_name = 'ej_boards'
#
# Board management
#
urlpatterns = Router(
template=['ej_boards/{name}.jinja2', 'generic.jinja2'],
models={
'board': Board,
'conversation': Conversation,
},
object='conversation',
lookup_field='slug',
lookup_type='slug',
)
@urlpatterns.route('profile/boards/', template='ej_boards/list.jinja2')
def list(request):
user = request.user
return {
'boards': user.boards.all(),
'can_add_board': user.has_perm('ej_boards.can_add_board'),
}
from boogie.router import Router
from ej_conversations import models
app_name = 'ej_conversations'
urlpatterns = Router(
template=['ej_conversations/{name}.jinja2', 'generic.jinja2'],
models={
'conversation': models.Conversation,
'comment': models.Comment,
},
lookup_field={
'conversation': 'slug',
'comment': 'slug',
},
lookup_type='slug',
object='conversation',
)
conversation_url = f'<model:conversation>/'
# Must import after urlpatterns
from .admin import create, edit, moderate
from .conversations import conversation_list, detail, info, leaderboard
from .comments import comment_list, comment_detail
from pprint import pformat
from boogie.router import Router
from django.conf import settings
from django.contrib.auth import get_user_model
from django.contrib.flatpages.models import FlatPage
from django.http import Http404
from django.shortcuts import render, redirect
from django.utils.translation import ugettext as _
from sidekick import import_later, Proxy
from ej.utils.flatpages import flat_page_route
conversations = import_later('ej_conversations.models:Conversation')
log = logging.getLogger("ej")
urlpatterns = Router(template="pages/{name}.jinja2")
#
# Views
#
@urlpatterns.route("")
def index(request):
if request.user.is_authenticated:
return redirect(settings.EJ_USER_HOME_PATH)
else:
return redirect(settings.EJ_ANONYMOUS_HOME_PATH)
@urlpatterns.route("start/")
def home(request):
from boogie.router import Router
from .models import Exhibit
# from users.models import Artwork
urlpatterns = Router(
template="core/exhibit.jinja2",
models={"exhibit": Exhibit},
lookup_field={"exhibit": "slug"},
)
@urlpatterns.route("<model:exhibit>/")
def exhibit(request, exhibit):
ctx = {'exhibit': exhibit, 'artworks': exhibit.artworks.all()}
return ctx
import logging
from django.conf import settings
from django.shortcuts import render, redirect
from boogie.router import Router
from ej_configurations import fragment, social_icons
from ej_conversations.proxy import conversations_with_moderation
log = logging.getLogger('ej')
urlpatterns = Router(template='pages/{name}.jinja2', )
#
# Views
#
@urlpatterns.route('')
def index(request):
if request.user.id:
return redirect(settings.EJ_USER_HOME_PATH)
else:
return redirect(settings.EJ_ANONYMOUS_HOME_PATH)
@urlpatterns.route('start/')
def start(request):
return {
'conversations': conversations_with_moderation(request.user),
'how_it_works_fragment': fragment('home.how-it-works', raises=False),
'start_now_fragment': fragment('home.start-now', raises=False),
'social_media_icons': social_icons(),
from django.shortcuts import redirect
from django.utils.translation import ugettext_lazy as _
from ej_boards.models import Board
from ej_boards.utils import check_board, register_route
from ej_clusters.models import Stereotype
from ej_conversations import routes as conversations
from ej_conversations.models import Conversation
from .forms import BoardForm
app_name = "ej_boards"
urlpatterns = Router(
template=["ej_boards/{name}.jinja2", "generic.jinja2"],
models={
"board": Board,
"conversation": Conversation,
"stereotype": Stereotype
},
lookup_field={"board": "slug"},
lookup_type={"board": "slug"},
)
# Constants
board_profile_admin_url = "profile/boards/"
board_base_url = "<model:board>/conversations/"
board_conversation_url = board_base_url + "<model:conversation>/<slug:slug>/"
reports_url = "<model:board>/conversations/<model:conversation>/reports/"
reports_kwargs = {"login": True}
#
# Board URLs
from rest_framework import status
from rest_framework.authtoken.models import Token
from boogie.router import Router
from ej_users import forms
from ej_conversations.models.conversation import Conversation
from ej_conversations import rules
from ej.utils.perms import conversations
User = get_user_model()
app_name = 'ej_users'
urlpatterns = Router(
template='ej_users/{name}.jinja2',
models={
'user': User,
},
lookup_field='username',
)
log = logging.getLogger('ej')
user_url = '<model:user>/'
@urlpatterns.route('register/')
def register(request):
form = forms.RegistrationForm()
if request.method == 'POST':
form = forms.RegistrationForm(request.POST)
if form.is_valid():
from logging import getLogger
from boogie.router import Router
from django.http import Http404
from django.urls import reverse
from django.utils.translation import ugettext_lazy as _
from . import models
from .enums import Choice
log = getLogger("ej")
app_name = "ej_conversations"
urlpatterns = Router(
template="ej_conversations/comments/{name}.jinja2",
models={"conversation": models.Conversation, "comment": models.Comment},
login=True,
)
conversation_url = f"<model:conversation>/<slug:slug>/"
#
# Display conversations
#
@urlpatterns.route("<model:comment>-<hex_hash>/")
def detail(request, comment, hex_hash):
if hex_hash != comment_url_hash(comment):
raise Http404
# We show an option for the user to vote, if it hasn't voted in the comment
# or has skip it.
from boogie.router import Router
from boogie.rules import proxy_seq
from ej_conversations.models import Conversation, Choice, Comment
from hyperpython import a, input_, label, Block
from hyperpython.components import html_list, html_table
from .models import Stereotype, Cluster, StereotypeVote, Clusterization
from ej_clusters.forms import StereotypeForm, StereotypeVoteFormSet
app_name = 'ej_cluster'
urlpatterns = Router(
template=['ej_clusters/{name}.jinja2', 'generic.jinja2'],
perms=['ej.can_edit_conversation'],
object='conversation',
login=True,
models={
'conversation': Conversation,
'stereotype': Stereotype,
'cluster': Cluster,
},
lookup_field={'conversation': 'slug'},
lookup_type={'conversation': 'slug'},
)
conversation_url = 'conversations/<model:conversation>/'
#
# Cluster info
#
@urlpatterns.route(conversation_url + 'clusters/')
def index(conversation):
clusters = proxy_seq(
from django.db.models import Model
from django.http import Http404
from django.urls import reverse
from django.utils.translation import ugettext_lazy as _
from hyperpython import html, a, span, div, h1
from hyperpython.components import html_list, html_map
from boogie.router import Router
from .utils import register_queryset
urlpatterns = Router(template="generic.jinja2")
@urlpatterns.route("")
def role_index():
data = []
classes = set()
# Collect all models and roles in the default render registry
for (cls, __) in html.registry:
if not issubclass(cls, Model) or cls in classes:
continue
classes.add(cls)
name = cls.__name__
href = reverse("role-model", kwargs={"model": name.lower()})
data.append((name, span([a(name, href=href), ": " + get_doc(cls)])))
# Now we collect the queryset renderers
classes = set()
for (cls, __) in register_queryset.registry:
classes.add(cls)
from django.utils.translation import ugettext_lazy as _
from boogie.router import Router
app_name = 'ej_notifications'
urlpatterns = Router(
login=True, template=['ej_notifications/{name}.jinja2', 'generic.jinja2'])
@urlpatterns.route()
def index(request):
user = request.user
return {
'content_title': _('List of notifications'),
'user': user,
'notifications': ['hello', 'world'],
# 'notifications': user.notifications.unseen(),
}
@urlpatterns.route('history/')
def clusters(request):
user = request.user
return {
'user': user,
# 'notifications': user.notifications.seen(),
}
from django.template.loader import get_template
from django.utils.translation import ugettext_lazy as _
from rest_framework import status
from rest_framework.authtoken.models import Token
from boogie.router import Router
from . import forms
from .models import PasswordResetToken, generate_token
from .socialbuttons import social_buttons
User = get_user_model()
app_name = 'ej_users'
urlpatterns = Router(template='ej_users/{name}.jinja2',
models={
'token': PasswordResetToken,
},
lookup_field={'token': 'url'})
log = logging.getLogger('ej')
@urlpatterns.route('register/')
def register(request):
form = forms.RegistrationForm.bind(request)
next_url = request.GET.get('next', '/')
if form.is_valid_post():
data = form.cleaned_data
name, email, password = data['name'], data['email'], data['password']
try:
from ej_gamification.models.progress import (
get_progress,
UserProgress,
ConversationProgress,
)
from .roles import (
profile_trophy,
participation_trophy,
host_trophy,
participate_conversation_trophy,
host_conversation_trophy,
)
app_name = "ej_gamification"
urlpatterns = Router(template="ej_gamification/{name}.jinja2", login=True)
sign = lambda x: 1 if x >= 0 else -1
@urlpatterns.route("achievements/")
def achievements(request):
user = request.user
progress = get_progress(user, sync=True)
participation = map(
participate_conversation_trophy, user.participation_progresses.all()
)
conversation_trophies = map(
host_conversation_trophy,
ConversationProgress.objects.filter(conversation__author=user),
)