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