def channel(request, channel_id):
channel_error = ""
# Check if channel exists
try:
channel = Channel.objects.get(id=channel_id)
channel_id = channel.id
except Channel.DoesNotExist:
channel_error = "CHANNEL_EDIT_ERROR_CHANNEL_NOT_FOUND"
channel_id = ""
# Check if user has permission to view channel
if channel_id != "":
try:
request.user.can_view_channel(channel)
# If user can view channel, but it's deleted, then we show
# an option to restore the channel in the Administration page
if channel.deleted:
channel_error = 'CHANNEL_EDIT_ERROR_CHANNEL_DELETED'
except PermissionDenied:
channel_error = "CHANNEL_EDIT_ERROR_CHANNEL_NOT_FOUND"
return render(
request,
"channel_edit.html",
{
CHANNEL_EDIT_GLOBAL: json_for_parse_from_data(
{"channel_id": channel_id, "channel_error": channel_error}
),
CURRENT_USER: current_user_for_context(request.user),
PREFERENCES: json_for_parse_from_data(request.user.content_defaults),
MESSAGES: json_for_parse_from_data(get_messages()),
},
)
def channel_page(request, channel, allow_edit=False, staging=False):
channel_serializer = ChannelSerializer(channel)
channel_list = Channel.objects.select_related('main_tree').prefetch_related('editors').prefetch_related('viewers')\
.exclude(id=channel.pk).filter(Q(deleted=False) & (Q(editors=request.user) | Q(viewers=request.user)))\
.annotate(is_view_only=Case(When(editors=request.user, then=Value(0)), default=Value(1), output_field=IntegerField()))\
.distinct().values("id", "name", "is_view_only").order_by('name')
token = None
if channel.secret_tokens.filter(is_primary=True).exists():
token = channel.secret_tokens.filter(is_primary=True).first().token
token = token[:5] + "-" + token[5:]
json_renderer = JSONRenderer()
return render(request, 'channel_edit.html', {"allow_edit": allow_edit,
"staging": staging,
"is_public": channel.public,
"channel": json_renderer.render(channel_serializer.data),
"channel_id": channel.pk,
"channel_name": channel.name,
"ricecooker_version": channel.ricecooker_version,
"channel_list": channel_list,
"current_user": json_renderer.render(CurrentUserSerializer(request.user).data),
"preferences": json.dumps(channel.content_defaults),
"messages": get_messages(),
"primary_token": token or channel.pk,
"title": settings.DEFAULT_TITLE,
})
def channel_list(request):
languages = get_or_set_cached_constants(Language, LanguageSerializer)
fileformats = get_or_set_cached_constants(FileFormat, FileFormatSerializer)
licenses = get_or_set_cached_constants(License, LicenseSerializer)
formatpresets = get_or_set_cached_constants(FormatPreset,
FormatPresetSerializer)
contentkinds = get_or_set_cached_constants(ContentKind,
ContentKindSerializer)
languages = get_or_set_cached_constants(Language, LanguageSerializer)
return render(
request, 'channel_list.html', {
"channel_name":
False,
"current_user":
JSONRenderer().render(
UserChannelListSerializer(request.user).data),
"user_preferences":
json.dumps(request.user.content_defaults),
"langs_list":
languages,
"fileformat_list":
fileformats,
"license_list":
licenses,
"fpreset_list":
formatpresets,
"ckinds_list":
contentkinds,
"langs_list":
languages,
"messages":
get_messages(),
})
def administration(request):
return render(
request, 'administration.html', {
"current_user": current_user_for_context(request.user),
"default_sender": settings.DEFAULT_FROM_EMAIL,
"messages": json_for_parse_from_data(get_messages()),
})
def administration(request):
return render(request, 'administration.html', {
"current_user": JSONRenderer().render(CurrentUserSerializer(request.user).data),
"default_sender": settings.DEFAULT_FROM_EMAIL,
"placeholders": json.dumps(EMAIL_PLACEHOLDERS, ensure_ascii=False),
"messages": get_messages(),
})
def channel_list(request):
languages = get_or_set_cached_constants(Language, LanguageSerializer)
return render(request, 'channel_list.html', {"channel_name": False,
"current_user": JSONRenderer().render(UserChannelListSerializer(request.user).data),
"user_preferences": json.dumps(request.user.content_defaults),
"langs_list": languages,
"messages": get_messages(),
})
def accounts(request):
if not request.user.is_anonymous:
return redirect("channels")
return render(
request,
"accounts.html",
{
PREFERENCES: json_for_parse_from_data(DEFAULT_USER_PREFERENCES),
MESSAGES: json_for_parse_from_data(get_messages()),
},
)
def administration(request):
return render(
request, 'administration.html', {
"current_user":
JSONRenderer().render(CurrentUserSerializer(request.user).data),
"default_sender":
settings.DEFAULT_FROM_EMAIL,
"placeholders":
json.dumps(EMAIL_PLACEHOLDERS, ensure_ascii=False),
"messages":
get_messages(),
})
def channel_list(request):
if not check_supported_browsers(request.META.get('HTTP_USER_AGENT')):
return redirect(reverse_lazy('unsupported_browser'))
languages = get_or_set_cached_constants(Language, LanguageSerializer)
return render(request, 'channel_list.html', {"channel_name": False,
"current_user": JSONRenderer().render(UserChannelListSerializer(request.user).data),
"user_preferences": request.user.preferences,
"langs_list": languages,
"messages": get_messages(),
})
def channel_list(request):
return render(
request, 'channel_list.html', {
"channel_name":
False,
"current_user":
JSONRenderer().render(
UserChannelListSerializer(request.user).data),
"user_preferences":
json.dumps(request.user.content_defaults),
"messages":
get_messages(),
})
def channel_page(request, channel, allow_edit=False, staging=False):
channel_serializer = ChannelSerializer(channel)
channel_list = Channel.objects.select_related('main_tree').prefetch_related('editors').prefetch_related('viewers')\
.exclude(id=channel.pk).filter(Q(deleted=False) & (Q(editors=request.user) | Q(viewers=request.user)))\
.annotate(is_view_only=Case(When(editors=request.user, then=Value(0)), default=Value(1), output_field=IntegerField()))\
.distinct().values("id", "name", "is_view_only").order_by('name')
fileformats = get_or_set_cached_constants(FileFormat, FileFormatSerializer)
licenses = get_or_set_cached_constants(License, LicenseSerializer)
formatpresets = get_or_set_cached_constants(FormatPreset,
FormatPresetSerializer)
contentkinds = get_or_set_cached_constants(ContentKind,
ContentKindSerializer)
languages = get_or_set_cached_constants(Language, LanguageSerializer)
json_renderer = JSONRenderer()
return render(
request, 'channel_edit.html', {
"allow_edit":
allow_edit,
"staging":
staging,
"is_public":
channel.public,
"channel":
json_renderer.render(channel_serializer.data),
"channel_id":
channel.pk,
"channel_name":
channel.name,
"channel_list":
channel_list,
"fileformat_list":
fileformats,
"license_list":
licenses,
"fpreset_list":
formatpresets,
"ckinds_list":
contentkinds,
"langs_list":
languages,
"current_user":
json_renderer.render(CurrentUserSerializer(request.user).data),
"preferences":
channel.preferences,
"messages":
get_messages()
})
def settings(request):
current_user = current_user_for_context(request.user)
channel_query = request.user.editable_channels.filter(
deleted=False).annotate(editor_count=Count("editors"))
return render(
request,
'settings.html',
{
CURRENT_USER:
current_user,
MESSAGES:
json_for_parse_from_data(get_messages()),
"channels":
json_for_parse_from_serializer(
SettingsChannelSerializer(channel_query, many=True)),
},
)
def administration(request):
# Check if browser is supported
if not check_supported_browsers(request.META['HTTP_USER_AGENT']):
return redirect(reverse_lazy('unsupported_browser'))
if not request.user.is_admin:
return redirect(reverse_lazy('unauthorized'))
return render(
request, 'administration.html', {
"current_user":
JSONRenderer().render(CurrentUserSerializer(request.user).data),
"default_sender":
settings.DEFAULT_FROM_EMAIL,
"placeholders":
json.dumps(EMAIL_PLACEHOLDERS, ensure_ascii=False),
"messages":
get_messages(),
})
def channel_page(request, channel, allow_edit=False, staging=False):
channel_serializer = ChannelSerializer(channel)
channel_list = Channel.objects.select_related('main_tree').prefetch_related('editors').prefetch_related('viewers')\
.exclude(id=channel.pk).filter(Q(deleted=False) & (Q(editors=request.user) | Q(viewers=request.user)))\
.annotate(is_view_only=Case(When(editors=request.user, then=Value(0)), default=Value(1), output_field=IntegerField()))\
.distinct().values("id", "name", "is_view_only").order_by('name')
fileformats = get_or_set_cached_constants(FileFormat, FileFormatSerializer)
licenses = get_or_set_cached_constants(License, LicenseSerializer)
formatpresets = get_or_set_cached_constants(FormatPreset, FormatPresetSerializer)
contentkinds = get_or_set_cached_constants(ContentKind, ContentKindSerializer)
languages = get_or_set_cached_constants(Language, LanguageSerializer)
token = None
if channel.secret_tokens.filter(is_primary=True).exists():
token = channel.secret_tokens.filter(is_primary=True).first().token
token = token[:5] + "-" + token[5:]
json_renderer = JSONRenderer()
return render(request, 'channel_edit.html', {"allow_edit": allow_edit,
"staging": staging,
"is_public": channel.public,
"channel": json_renderer.render(channel_serializer.data),
"channel_id": channel.pk,
"channel_name": channel.name,
"channel_list": channel_list,
"fileformat_list": fileformats,
"license_list": licenses,
"fpreset_list": formatpresets,
"ckinds_list": contentkinds,
"langs_list": languages,
"roles": json.dumps([r[0] for r in roles.choices]),
"mastery": json.dumps([m[0] for m in exercises.MASTERY_MODELS if m[0] != exercises.SKILL_CHECK]),
"current_user": json_renderer.render(CurrentUserSerializer(request.user).data),
"preferences": json.dumps(channel.content_defaults),
"messages": get_messages(),
"primary_token": token or channel.pk,
"title": settings.DEFAULT_TITLE,
})
def channel_list(request):
anon = settings.LIBRARY_MODE or request.user.is_anonymous()
current_user = current_user_for_context(None if anon else request.user)
preferences = DEFAULT_USER_PREFERENCES if anon else request.user.content_defaults
public_channel_list = Channel.objects.filter(
public=True,
main_tree__published=True,
deleted=False,
).values_list('main_tree__tree_id', flat=True)
# Get public channel languages
public_lang_query = (Language.objects.filter(
channel_language__public=True,
channel_language__main_tree__published=True,
channel_language__deleted=False,
).values("lang_code").annotate(
count=Count("lang_code")).order_by("lang_code"))
languages = {
lang["lang_code"]: lang["count"]
for lang in public_lang_query
}
# Get public channel licenses
public_license_query = (License.objects.filter(
contentnode__tree_id__in=public_channel_list).values_list(
"id", flat=True).order_by('id').distinct())
licenses = list(public_license_query)
# Get public channel kinds
public_kind_query = (ContentKind.objects.filter(
contentnodes__tree_id__in=public_channel_list).values_list(
"kind", flat=True).order_by('kind').distinct())
kinds = list(public_kind_query)
# Get public channel sets
public_channelset_query = ChannelSet.objects.filter(public=True).annotate(
count=SQCountDistinct(
Channel.objects.filter(
secret_tokens=OuterRef("secret_token"),
public=True,
main_tree__published=True,
deleted=False,
).values_list("id", flat=True),
field="id",
))
return render(
request,
"channel_list.html",
{
CURRENT_USER:
current_user,
PREFERENCES:
json_for_parse_from_data(preferences),
MESSAGES:
json_for_parse_from_data(get_messages()),
"LIBRARY_MODE":
settings.LIBRARY_MODE,
"public_languages":
json_for_parse_from_data(languages),
"public_kinds":
json_for_parse_from_data(kinds),
"public_licenses":
json_for_parse_from_data(licenses),
"public_collections":
json_for_parse_from_serializer(
PublicChannelSetSerializer(public_channelset_query,
many=True)),
},
)
def updates(request):
return render(request, 'updates.html', {
"messages": get_messages(),
"title": settings.DEFAULT_TITLE,
})
