def test_public_channel_list_filter_keyword(self):
response = self.client.get(
get_channel_lookup_url(baseurl="/", keyword="zzz"))
self.assertEqual(len(response.json()), 0)
response = self.client.get(
get_channel_lookup_url(baseurl="/", keyword="math"))
self.assertEqual(len(response.json()), 1)
self.assertEqual(response.json()[0]["id"], self.channel_id1)
def test_public_channel_list_filter_keyword_language(self):
response = self.client.get(
get_channel_lookup_url(baseurl="/", keyword="zzz", language="es"))
self.assertEqual(len(response.json()), 0)
response = self.client.get(
get_channel_lookup_url(baseurl="/",
keyword="science",
language="es"))
self.assertEqual(len(response.json()), 1)
self.assertEqual(response.json()[0]["id"], self.channel_id2)
def test_public_channel_list_filter_language(self):
response = self.client.get(
get_channel_lookup_url(baseurl="/", language="zu"))
self.assertEqual(len(response.json()), 0)
# filter based on contentnode languages
response = self.client.get(
get_channel_lookup_url(baseurl="/", language="en"))
self.assertEqual(len(response.json()), 2)
# filter based on root contentnode language
response = self.client.get(
get_channel_lookup_url(baseurl="/", language="es"))
self.assertEqual(len(response.json()), 1)
self.assertEqual(response.json()[0]["id"], self.channel_id2)
def channeldiffstats(self, request):
job_metadata = {}
channel_id = request.data.get("channel_id")
method = request.data.get("method")
drive_id = request.data.get("drive_id")
baseurl = request.data.get("baseurl")
# request validation and job metadata info
if not channel_id:
raise serializers.ValidationError("The channel_id field is required.")
if not method:
raise serializers.ValidationError("The method field is required.")
if method == "network":
baseurl = baseurl or conf.OPTIONS["Urls"]["CENTRAL_CONTENT_BASE_URL"]
job_metadata["baseurl"] = baseurl
# get channel version metadata
url = get_channel_lookup_url(baseurl=baseurl, identifier=channel_id)
resp = requests.get(url)
channel_metadata = resp.json()
job_metadata["new_channel_version"] = channel_metadata[0]["version"]
elif method == "disk":
if not drive_id:
raise serializers.ValidationError(
"The drive_id field is required when using 'disk' method."
)
job_metadata = _add_drive_info(job_metadata, request.data)
# get channel version metadata
drive = get_mounted_drive_by_id(drive_id)
channel_metadata = read_channel_metadata_from_db_file(
get_content_database_file_path(channel_id, drive.datafolder)
)
job_metadata["new_channel_version"] = channel_metadata.version
else:
raise serializers.ValidationError(
"'method' field should either be 'network' or 'disk'."
)
job_metadata.update(
{
"type": "CHANNELDIFFSTATS",
"started_by": request.user.pk,
"channel_id": channel_id,
}
)
job_id = priority_queue.enqueue(
diff_stats,
channel_id,
method,
drive_id=drive_id,
baseurl=baseurl,
extra_metadata=job_metadata,
track_progress=False,
cancellable=True,
)
resp = _job_to_response(priority_queue.fetch_job(job_id))
return Response(resp)
def test_public_filter_unlisted(self):
set_device_settings(allow_peer_unlisted_channel_import=False)
unlisted_channel_id = uuid.uuid4().hex
create_mini_channel(channel_name="math 2",
channel_id=unlisted_channel_id)
set_channel_metadata_fields(unlisted_channel_id, public=False)
response = self.client.get(get_channel_lookup_url(baseurl="/"))
data = response.json()
self.assertEqual(len(data), 2)
def lookup_channel_listing_status(channel_id, baseurl=None):
"""
Look up the listing status of the channel from the remote, this is surfaced as a
`public` boolean field.
"""
resp = requests.get(get_channel_lookup_url(identifier=channel_id, baseurl=baseurl))
if resp.status_code != 200:
return None
(channel_info,) = resp.json()
return channel_info.get("public", None)
def _make_channel_endpoint_request(
self, identifier=None, baseurl=None, keyword=None, language=None
):
url = get_channel_lookup_url(
identifier=identifier, baseurl=baseurl, keyword=keyword, language=language
)
resp = requests.get(url)
if resp.status_code == 404:
raise Http404(
_("The requested channel does not exist on the content server")
)
# map the channel list into the format the Kolibri client-side expects
channels = list(map(self._studio_response_to_kolibri_response, resp.json()))
return Response(channels)
def test_public_channel_lookup(self):
response = self.client.get(
get_channel_lookup_url(identifier=self.channel_id2), format="json")
data = response.json()
self.assertEqual(len(data), 1)
data = data[0]
expected = {
"id": self.channel_id2,
"name": "science",
"language": "es", # root node language
"description": "",
"total_resource_count":
2, # should account for nodes with duplicate content_ids
"version": 0,
"published_size": 20,
"last_published": None,
"icon_encoding": "",
"matching_tokens": [],
"public": True,
}
for key, value in iteritems(expected):
self.assertEqual(data[key], value)
# we don't care what order these elements are in
self.assertSetEqual(set(["en", "es"]), set(data["included_languages"]))
def test_public_channel_lookup_no_channel(self):
response = self.client.get(
get_channel_lookup_url(identifier=uuid.uuid4().hex))
self.assertEqual(response.status_code, 404)
def test_public_channel_list_no_version(self):
response = self.client.get(get_channel_lookup_url(version="100000"))
self.assertEqual(response.status_code, 404)
def test_public_channel_list(self):
response = self.client.get(get_channel_lookup_url(baseurl="/"))
data = response.json()
self.assertEqual(len(data), 2)
