def channel_page(request, channel, allow_edit=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)
json_renderer = JSONRenderer()
return render(request, 'channel_edit.html', {"allow_edit":allow_edit,
"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,
"current_user" : json_renderer.render(CurrentUserSerializer(request.user).data),
"preferences" : request.user.preferences,
})
def test_create_object(self):
jr = JSONRenderer()
for name, model in models.generated_models.models.items():
serializer = models.generated_models.model_serializer(name)
obj = G(model)
pk = model._meta.pk.name
# PUT
data = serializer(N(model)).data
if pk in data:
del data[pk]
url = reverse(self.view_name, kwargs={'model': name, 'pk': obj.id})
response = self.client.put(url, jr.render(data), content_type='application/json')
response_data = response.data
if pk in response_data:
del response_data[pk]
self.assertDictEqual(data, response_data)
# PATCH
orig_data = serializer(obj).data
patch_data = {}
for key, val in orig_data.items():
if key != pk and val != data.get(key):
patch_data = {
key: val
}
data[key] = val
break
response = self.client.patch(url, jr.render(patch_data), content_type='application/json')
response_data = response.data
if pk in response_data:
del response_data[pk]
self.assertDictEqual(data, response_data)
def channel(request, channel_id):
channel = get_object_or_404(Channel, id=channel_id, deleted=False)
channel_serializer = ChannelSerializer(channel)
accessible_channel_list = Channel.objects.filter( Q(deleted=False, public=True) | Q(deleted=False, editors__email__contains= request.user.email))
accessible_channel_list = ChannelListSerializer.setup_eager_loading(accessible_channel_list)
accessible_channel_list_serializer = ChannelListSerializer(accessible_channel_list, many=True)
channel_list = accessible_channel_list.filter(editors__email__contains= request.user.email).exclude(id=channel_id).values("id", "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)
channel_tags = ContentTag.objects.filter(channel = channel)
channel_tags_serializer = TagSerializer(channel_tags, many=True)
json_renderer = JSONRenderer()
return render(request, 'channel_edit.html', {"channel" : json_renderer.render(channel_serializer.data),
"channel_id" : channel_id,
"channel_name": channel.name,
"accessible_channels" : json_renderer.render(accessible_channel_list_serializer.data),
"channel_list" : channel_list,
"fileformat_list" : fileformats,
"license_list" : licenses,
"fpreset_list" : formatpresets,
"ckinds_list" : contentkinds,
"ctags": json_renderer.render(channel_tags_serializer.data),
"current_user" : json_renderer.render(CurrentUserSerializer(request.user).data)})
def get_context_data(self, **kwargs):
# Add some serialized json for bootstrapping the client-side app
renderer = JSONRenderer()
kwargs['project_json'] = renderer.render(serializers.ProjectSerializer(self.get_project()).data)
kwargs['scheme_json'] = renderer.render(serializers.SchemeSerializer(self.object).data)
kwargs['user_json'] = renderer.render(serializers.UserSerializer(self.request.user).data)
return super(SchemeEditorView, self).get_context_data(**kwargs)
def get(self, request):
budget = Budget.objects.order_by("-updated_time")[:1][0]
categories = budget.categories.all();
budget_serializer = BudgetSerializer(budget)
categories_serializer = CategorySerializer(categories, many=True)
json_renderer = JSONRenderer();
budget_json_data = json_renderer.render(budget_serializer.data)
categories_json_data = json_renderer.render(categories_serializer.data)
return TemplateResponse(request, 'budget_ui/index.html', {"budget_data": budget_json_data, "categories_data": categories_json_data})
def test_float_strictness(self):
renderer = JSONRenderer()
# Default to strict
for value in [float('inf'), float('-inf'), float('nan')]:
with pytest.raises(ValueError):
renderer.render(value)
renderer.strict = False
assert renderer.render(float('inf')) == b'Infinity'
assert renderer.render(float('-inf')) == b'-Infinity'
assert renderer.render(float('nan')) == b'NaN'
def get_context_data(self, map_slug, *args, **kwargs):
renderer = JSONRenderer()
context = super(PublicView, self).get_context_data(
*args, **kwargs)
if self._has_access():
projectJSON = ProjectDetailSerializer(
self.map.project, context={'request': {}}).data
mapJSON = MapSerializerDetail(
self.map, context={'request': {}}).data
context.update({
'project': renderer.render(projectJSON),
'map': renderer.render(mapJSON)
})
return context
def _send_hook_request(self, obj, method):
url = self._build_hook_url(obj)
if method in ('POST', 'PUT'):
serializer = self.get_serializer(obj)
renderer = JSONRenderer()
context = {'request': self.request}
body = renderer.render(serializer.data, renderer_context=context)
else:
body = None
headers = {
'context-type': 'application/json',
'X-Signature': self._build_hook_signarute(method, url, body)
}
try:
print('Enviando peticion a :' + url + ' con metodo '+ method)
response = requests.request(method, url, data=body, timeout=0.5, headers=headers)
response.raise_for_status()
print('Peticion enviada...')
except requests.exceptions.ConnectionError:
print('Error de conexion')
# concexion rechazada
pass
except requests.exceptions.Timeout:
print('Error de timeout')
# timeout
pass
except requests.exceptions.RequestException, e:
print('Error de 400 o 500', e.message)
# error 4XX o 5XX
pass
def _send_hook_request(self, obj, method):
url = self._build_hook_url(obj)
if method in ('post', 'put'):
# Build body
serializer = self.get_serializer(obj)
renderer = JSONRenderer()
context = {'request': self.request}
body = renderer.render(serializer.data, renderer_context=context)
else:
body = None
headers = {
'content-type': 'application/json',
'X-Signature': self._build_hook_signature(method, url, body),
}
try:
response = requests.request(method, url,
timeout=0.5, headers=headers)
response.raise_for_status()
except requests.exceptions.ConnectionError:
"""Host cannot be resolved or connection refused"""
pass
except requests.exceptions.Timeout:
"""Request timed out"""
pass
except requests.exceptions.RequestException:
"""Server response of 4XX or 5XX"""
pass
def get_context_data(self, **kwargs):
context = super(ToolDetailBaseView, self).get_context_data(**kwargs)
state = {}
renderer = JSONRenderer()
try:
state_id = self.kwargs.get('state')
state = serializers.State(models.State.objects.get(id=state_id), context={'request': self.request}).data
except models.State.DoesNotExist:
pass
context['tool_json'] = renderer.render(serializers.Tool(self.object, context={'request': self.request}).data)
context['state_json'] = renderer.render(state)
return context
def _send_hook_request(self, obj, method):
url = self._build_hook_url(obj)
if method in ('POST', 'PUT'):
# Build the body
serializer = self.get_serializer(obj)
renderer = JSONRenderer()
context = {'request': self.request}
body = renderer.render(serializer.data, renderer_context=context)
else:
body = None
headers = {
'content-type': 'application/json',
'X-Signature': self._build_hook_signature(method, url, body)
}
try:
response = requests.request(method, url, data=body,
timeout=0.5, headers=headers)
response.raise_for_status()
except requests.exceptions.ConnectionError:
# Host could not be resolved or connection refused
pass
except requests.exceptions.Timeout:
# Request timed out
pass
except requests.exceptions.RequestException:
# Server responded with 4XX or 5XX status code
pass
def perform_create(self, serializer): serializer.save(owner=self.request.user) # add push notification task for the created question renderer = JSONRenderer() question_data = renderer.render(data=serializer.data) tasks.push_question.delay(question_data)
def _send_hook_request(self, obj, method):
url = self._build_hook_url(obj)
if method in ('POST', 'PUT'):
#compõe o corpo
serializer = self.get_serializer(obj)
rendererer = JSONRenderer()
context = {'request': self.request}
body = rendererer.render(serializer.data, renderer_context=context)
else:
body = None
headers = {
'content-type': 'application/json',
'X-Signature': self._build_hook_signature(method, url, body)
}
try:
s = requests.Session()
requisicao = requests.Request(method, url, data=body, headers=headers)
prepared = requisicao.prepare()
response = s.send(prepared, timeout=0.5)
response.raise_for_status()
except requests.exceptions.ConnectionError:
# Host não pôde ser resolvido ou a conexão foi recusada
pass
except requests.exceptions.Timeout:
# Solicitação expirou
pass
except requests.exceptions.RequestException:
# Servidor respondeu com código de status 4XX ou 5XX
pass
def process_response(self, request, response):
if 'HTTP_ACCEPT' in request.META.keys() and 'text/html' in request.META['HTTP_ACCEPT']:
try:
path = resolve(request.path)
except Resolver404:
pass
else:
if hasattr(path.func, 'cls') and hasattr(path.func.cls, 'crud_model'):
request._request = request
if not hasattr(response, 'data'):
content = {"Error": response.content}
else:
renderer = JSONRenderer()
renderer_context = {'indent': 4}
content = renderer.render(response.data, "application/json", renderer_context)
renderer_context = {
'content': content,
'request': request,
'response': response,
'args': {},
'kwargs': {}
}
return TemplateResponse(request, "api.html", renderer_context).render()
return response
def test_with_content_type_args(self):
"""
Test JSON rendering with additional content type arguments supplied.
"""
obj = {'foo': ['bar', 'baz']}
renderer = JSONRenderer()
content = renderer.render(obj, 'application/json; indent=2')
self.assertEqual(strip_trailing_whitespace(content.decode('utf-8')), _indented_repr)
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,
"channel_last_published":
channel.last_published,
"channel_has_editors":
len(channel_serializer.data.get("editors")) > 1,
"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 test_proper_encoding(self):
obj = {'countries': ['United Kingdom', 'France', 'España']}
renderer = JSONRenderer()
content = renderer.render(obj, 'application/json')
self.assertEqual(
content,
'{"countries":["United Kingdom","France","España"]}'.encode(
'utf-8'))
def emit_hedwig_serializer_data(action, module_name, serializer_name, serializer):
if not bool(hedwig_rest_framework_settings.SERIALIZER_SIGNALS):
return
routing_key = '.'.join([project_name, module_name, 'serializer', serializer_name, action,
str(serializer.instance.pk)])
json_renderer = JSONRenderer()
hedwig_emitter.emit(routing_key, json_renderer.render(serializer.data))
def test_with_content_type_args(self):
"""
Test JSON rendering with additional content type arguments supplied.
"""
obj = {'foo': ['bar', 'baz']}
renderer = JSONRenderer()
content = renderer.render(obj, 'application/json; indent=2')
self.assertEqual(strip_trailing_whitespace(content.decode('utf-8')), _indented_repr)
def _handle_error(status_code):
info = {
'status': status_code
}
renderer = JSONRenderer()
content_type = '{media}; charset={charset}'.format(media=renderer.media_type, charset=renderer.charset)
return HttpResponse(renderer.render(info), content_type=content_type, status=status_code)
def test_with_content_type_args(self):
"""
Test JSON rendering with additional content type arguments supplied.
"""
obj = {"foo": ["bar", "baz"]}
renderer = JSONRenderer()
content = renderer.render(obj, "application/json; indent=2")
self.assertEqual(strip_trailing_whitespace(content.decode("utf-8")), _indented_repr)
def car(request):
car = Car.objects.get(id=1)
#print(vars(car.drivers.all()))
#return HttpResponse('')
serializer_car = CarSerializer(car)
json_renderer = JSONRenderer()
json_car = json_renderer.render(serializer_car.data)
return HttpResponse(json_car, 200)
def test_compact(self):
renderer = JSONRenderer()
data = OrderedDict([('a', 1), ('b', 2)])
context = {'indent': 4}
assert (
renderer.render(data, renderer_context=context) ==
b'{\n "a": 1,\n "b": 2\n}'
)
def test_u2028_u2029(self):
# The \u2028 and \u2029 characters should be escaped,
# even when the non-escaping unicode representation is used.
# Regression test for #2169
obj = {'should_escape': '\u2028\u2029'}
renderer = JSONRenderer()
content = renderer.render(obj, 'application/json')
self.assertEqual(content, '{"should_escape":"\\u2028\\u2029"}'.encode('utf-8'))
def _handle_error(status_code):
info = {'status': status_code}
renderer = JSONRenderer()
content_type = f'{renderer.media_type}; charset={renderer.charset}'
return HttpResponse(renderer.render(info),
content_type=content_type,
status=status_code)
def test_u2028_u2029(self):
# The \u2028 and \u2029 characters should be escaped,
# even when the non-escaping unicode representation is used.
# Regression test for #2169
obj = {'should_escape': '\u2028\u2029'}
renderer = JSONRenderer()
content = renderer.render(obj, 'application/json')
self.assertEqual(content, '{"should_escape":"\\u2028\\u2029"}'.encode())
def test_compact(self):
renderer = JSONRenderer()
data = OrderedDict([('a', 1), ('b', 2)])
context = {'indent': 4}
assert (
renderer.render(data, renderer_context=context) ==
b'{\n "a": 1,\n "b": 2\n}'
)
def test_without_content_type_args(self):
"""
Test basic JSON rendering.
"""
obj = {'foo': ['bar', 'baz']}
renderer = JSONRenderer()
content = renderer.render(obj, 'application/json')
# Fix failing test case which depends on version of JSON library.
self.assertEqual(content.decode('utf-8'), _flat_repr)
def get(self, request, format=None):
params = request.query_params
page = int(params.get("page", 1)) # default page number is 1
per_page = int(params.get("per_page", 10)) # default per page is 10
filter = params.get("filter", None)
sort = params.get("sort", "desc") # default is descending
sort = '-time' if sort == "desc" else 'time'
if filter == "group":
try:
membership = Memberships.objects.get(user_id=request.user.id)
group = membership.group_id
results = Memberships.objects.filter(group_id=group)
users = []
for m in results:
users.append(m.user_id)
activities = Activity.objects.filter(
user__in=users).order_by(sort)
except ObjectDoesNotExist as error:
return Response(data={"detail": "User not in group."},
status=status.HTTP_400_BAD_REQUEST)
elif filter is None:
activities = Activity.objects.all().order_by(sort)
else:
all_activities = Activity.objects.select_related(
'workout').order_by(sort)
activities = list()
for a in all_activities:
if a.workout.category == filter:
activities.append(a)
paginator = Paginator(activities,
per_page,
allow_empty_first_page=True)
try:
# Get requested page
requested_page = paginator.page(page)
except InvalidPage:
raise Http404("Invalid Page")
# Serialize requested page and return
serializer = ActivityFullSerializer(data=requested_page, many=True)
#serializer = ActivitySummarySerializer(data=requested_page, many=True)
serializer.is_valid()
renderer = JSONRenderer()
activity_list = renderer.render(serializer.data).decode('utf-8')
data = {}
data["activities"] = json.loads(activity_list)
data["next"] = requested_page.next_page_number(
) if requested_page.has_next() else None
return JsonResponse(data, status=status.HTTP_200_OK, safe=False)
def test_without_content_type_args(self):
"""
Test basic JSON rendering.
"""
obj = {'foo': ['bar', 'baz']}
renderer = JSONRenderer()
content = renderer.render(obj, 'application/json')
# Fix failing test case which depends on version of JSON library.
self.assertEqual(content.decode('utf-8'), _flat_repr)
def test_without_content_type_args(self):
"""
Test basic JSON rendering.
"""
obj = {"foo": ["bar", "baz"]}
renderer = JSONRenderer()
content = renderer.render(obj, "application/json")
# Fix failing test case which depends on version of JSON library.
self.assertEqual(content.decode("utf-8"), _flat_repr)
def channel_page(request, channel, allow_edit=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,
"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":
request.user.preferences,
})
def upload_recap_json(self, pk):
"""Make a JSON object for a RECAP docket and upload it to IA"""
# This is a pretty highly optimized query that uses only 13 hits to the DB
# when generating a docket JSON rendering, regardless of how many related
# objects the docket has such as docket entries, parties, etc.
ds = Docket.objects.filter(pk=pk).select_related(
'originating_court_information',
).prefetch_related(
'panel',
'parties__attorneys__roles',
'parties__party_types__criminal_complaints',
'parties__party_types__criminal_counts',
# Django appears to have a bug where you can't defer a field on a
# queryset where you prefetch the values. If you try to, it crashes.
# We should be able to just do the prefetch below like the ones above
# and then do the defer statement at the end, but that throws an error.
Prefetch('docket_entries__recap_documents',
queryset=RECAPDocument.objects.all().defer('plain_text')))
d = ds[0]
renderer = JSONRenderer()
json_str = renderer.render(
IADocketSerializer(d).data,
accepted_media_type='application/json; indent=2',
)
file_name = get_docket_filename(d.court_id, d.pacer_case_id, 'json')
bucket_name = get_bucket_name(d.court_id, d.pacer_case_id)
responses = upload_to_ia(
self,
identifier=bucket_name,
files={file_name: StringIO(json_str)},
title=best_case_name(d),
collection=settings.IA_COLLECTIONS,
court_id=d.court_id,
source_url='https://www.courtlistener.com%s' % d.get_absolute_url(),
media_type='texts',
description="This item represents a case in PACER, the U.S. "
"Government's website for federal case data. This "
"information is uploaded quarterly. To see our most "
"recent version please use the source url parameter, "
"linked below. To see the canonical source for this data, "
"please consult PACER directly.",
)
if responses is None:
increment_failure_count(d)
return
if all(r.ok for r in responses):
d.ia_upload_failure_count = None
d.ia_date_first_changed = None
d.filepath_ia_json = "https://archive.org/download/%s/%s" % (
bucket_name, file_name)
mark_ia_upload_needed(d)
d.save()
else:
increment_failure_count(d)
def get_context_data(self, **kwargs):
ctx = super(AttendancePersonal, self).get_context_data(**kwargs)
listJSONRenderer = JSONRenderer()
user = self.request.user
trainee = trainee_from_user(user)
if not trainee:
trainee = Trainee.objects.filter(groups__name='attendance_monitors').first()
ctx['actual_user'] = listJSONRenderer.render(TraineeForAttendanceSerializer(self.request.user).data)
ctx.update(react_attendance_context(trainee))
return ctx
def render(self, data=None, accepted_media_type=None, renderer_context=None):
if isinstance(data, bytes):
return data
else:
jr = JSONRenderer()
self.media_type = jr.media_type
self.format = jr.format
self.charset = jr.charset
self.render_style = jr.render_style
return jr.render(data, accepted_media_type=accepted_media_type, renderer_context=renderer_context)
def form_valid(self, form):
self.object = form.save()
serializer = PictureSerializer(self.object)
renderer = JSONRenderer()
renderer.charset = "utf-8"
json = renderer.render(serializer.data).decode("utf-8")
change_object = Change.objects.create(model="Photo",
type_of_change="create",
content=json)
return HttpResponseRedirect(self.get_success_url())
def __init__(self, data, **kwargs):
request = data.pop('request')
mime = request.META.get('HTTP_ACCEPT')
if mime == 'application/json':
kwargs['content_type'] = 'application/json'
data['error'] = data.pop('detail')
renderer = JSONRenderer()
content = renderer.render(data)
else:
kwargs['content_type'] = 'application/vnd.collection+json'
self.exception = True
renderer_context = {
'request': request,
'view': None,
'response': self
}
renderer = CollectionJsonRenderer()
content = renderer.render(data, renderer_context=renderer_context)
super(RenderedResponse, self).__init__(content, **kwargs)
def add_to_queue(self, obj):
if getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_ENABLE_PROXY', False):
connection = StrictRedis(**private_settings.WS4REDIS_CONNECTION)
r = JSONRenderer()
json_data = r.render({'number': obj.from_phone})
channel = getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_DISPATCHER_CHANNEL', '__un_twilio_dispatcher')
connection.publish(channel, RedisMessage(json_data))
else:
self.send(obj.message)
obj.message.save()
def topics_json(request):
"""
Generates a JSON response containing topic data.
"""
queryset = Topic.objects.all()
serializer = TopicSerializer(queryset, many=True)
renderer = JSONRenderer()
response_data = renderer.render(serializer.data,
'application/json; indent=4')
return HttpResponse(response_data, content_type="application/json")
def handle(self, *args, **options):
connection = StrictRedis(**private_settings.WS4REDIS_CONNECTION)
numbers = PhonePendingMessages.objects.all().values_list(
"from_phone", flat=True).distinct()
for n in numbers:
r = JSONRenderer()
json_data = r.render({"number": n})
channel = getattr(
settings, "UNIVERSAL_NOTIFICATIONS_TWILIO_DISPATCHER_CHANNEL",
"__un_twilio_dispatcher")
connection.publish(channel, RedisMessage(json_data))
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
success_url = self.get_success_url()
serializer = SpeakerSerializer(self.object)
renderer = JSONRenderer()
renderer.charset = "utf-8"
json = renderer.render(serializer.data).decode("utf-8")
change_object = Change.objects.create(model="Speaker",
type_of_change="delete",
content=json)
self.object.delete()
return HttpResponseRedirect(success_url)
def authenticate(self, request):
if not self.auth_detected(request):
return None
user = request.resolver_match.kwargs.get('project') or request.query_params['user']
project_credentials = OAuthCredentials.get_credentials(user)
if not project_credentials:
raise exceptions.ValidationError(
'project {0} has no OAuth credentials'.format(user)
)
parameters = OAuthCredentials.get_parameters(request.query_params)
oauth_consumer_key = parameters['oauth_consumer_key']
if oauth_consumer_key != project_credentials['consumer_key']:
raise exceptions.AuthenticationFailed(
'oauth_consumer_key does not match credentials for project {0}'.format(user)
)
uri = '{0}://{1}{2}'.format(
settings.TREEHERDER_REQUEST_PROTOCOL,
request.get_host(),
request.path
)
# Construct the OAuth request based on the django request object
json_renderer = JSONRenderer()
req_obj = oauth.Request(
method=request.method,
url=uri,
parameters=parameters,
body=json_renderer.render(request.data),
)
server = oauth.Server()
token = oauth.Token(key='', secret='')
# Get the consumer object
cons_obj = oauth.Consumer(
oauth_consumer_key,
project_credentials['consumer_secret']
)
# Set the signature method
server.add_signature_method(oauth.SignatureMethod_HMAC_SHA1())
try:
# verify oauth django request and consumer object match
server.verify_request(req_obj, cons_obj, token)
except oauth.Error:
raise exceptions.AuthenticationFailed(
'Client authentication failed for project {0}'.format(user)
)
request.legacy_oauth_authenticated = True
return (DummyUser(), None)
def render(self, data, media_type=None, renderer_context=None):
# Return data, squeezing time dimension as this only works with 3D data
if not data["time_request"]:
self.render_style = 'binary'
data["data"].data = np.squeeze(data["data"].data, axis=(0,))
else:
# This appears to contain time data. Error out
renderer_context["response"].status_code = 400
renderer_context["accepted_media_type"] = 'application/json'
self.media_type = 'application/json'
self.format = 'json'
err_msg = {"status": 400, "message": "The cutout service JPEG interface does not support 4D cutouts",
"code": 2005}
jr = JSONRenderer()
return jr.render(err_msg, 'application/json', renderer_context)
if renderer_context['view'].bit_depth != 8:
# This renderer only works on uint8 data
renderer_context["response"].status_code = 400
renderer_context["accepted_media_type"] = 'application/json'
self.media_type = 'application/json'
self.format = 'json'
err_msg = {"status": 400, "message": "The cutout service JPEG interface only supports uint8 image data",
"code": 2001}
jr = JSONRenderer()
return jr.render(err_msg, 'application/json', renderer_context)
# Reshape matrix
d_shape = data["data"].data.shape
data["data"].data = np.reshape(data["data"].data, (d_shape[0] * d_shape[1], d_shape[2]), order="C")
# Save to Image
jpeg_image = Image.fromarray(data["data"].data)
img_file = io.BytesIO()
jpeg_image.save(img_file, "JPEG", quality=85)
# Send file
img_file.seek(0)
return img_file.read()
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 ActionCreate(request):
if request.method == 'POST':
Json_Data = request.body
stream = io.BytesIO(Json_Data)
pythondata = JSONParser().parse(stream)
serializer = ActionSerializer(data=pythondata)
if serializer.is_valid():
serializer.save()
res = {'msg': 'Data Created'}
Json_Data = JSONRenderer().render(res)
return HttpResponse(Json_Data, content_type='application/json')
Json_Data = JSONRenderer.render(serializer.errors)
return HttpResponse(json_data, content_type='application/json')
def get_context_data(self, **kwargs):
listJSONRenderer = JSONRenderer()
ctx = super(LeaveSlipUpdate, self).get_context_data(**kwargs)
trainee = self.get_object().get_trainee_requester()
kwargs['period'] = self.get_object().periods[0]
ctx.update(react_attendance_context(trainee, request_params=kwargs))
ctx['Today'] = self.get_object().get_date().strftime('%m/%d/%Y')
ctx['SelectedEvents'] = listJSONRenderer.render(
AttendanceEventWithDateSerializer(self.get_object().events,
many=True).data)
ctx['default_transfer_ta'] = self.request.user.TA or self.get_object(
).TA
return ctx
def assert_drf_json_equal(obj1, obj2):
"""
Asserts that two objects are equal after a round trip through JSON serialization/deserialization.
Particularly helpful when testing DRF serializers where you may get back OrderedDict and other such objects.
Args:
obj1 (object): the first object
obj2 (object): the second object
"""
json_renderer = JSONRenderer()
converted1 = json.loads(json_renderer.render(obj1))
converted2 = json.loads(json_renderer.render(obj2))
assert converted1 == converted2
def student_create(request):
if request.method == "POST":
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
serializer = StudentSerializer(data=python_data)
if serializer.is_valid():
serializer.save()
res = {"msg": "data inserted successfully"}
json_data = JSONRenderer.render(data=res)
return HttpResponse(json_data, content_type='application/json')
else:
json_data = JSONRenderer().render(serializer.errors)
return HttpResponse(json_data, content_type='application/json')
def get_context_data(self, **kwargs):
context = super(ToolDetailView, self).get_context_data(**kwargs)
user = self.request.user
renderer = JSONRenderer()
user_object = {}
# add logged in user
if user.is_authenticated():
user_object = AccountMin(user).data
context['user_json'] = renderer.render(user_object)
return context
def finalize(request):
if not request.method == 'POST':
return HttpResponseBadRequest('Request must use POST method')
data = json.loads(request.body)
trainee = get_object_or_404(Trainee, id=data['trainee']['id'])
submitter = get_object_or_404(Trainee, id=data['submitter']['id'])
period_start = dateutil.parser.parse(data['weekStart'])
period_end = dateutil.parser.parse(data['weekEnd'])
rolls_this_week = trainee.rolls.filter(date__gte=period_start,
date__lte=period_end)
if rolls_this_week.exists():
rolls_this_week.update(finalized=True)
else:
# we need some way to differentiate between those who have finalized and who haven't if they have no rolls
# add a dummy finalized present roll for this case
event = trainee.events[0] if trainee.events else (
Event.objects.first() if Event.objects else None)
if not event:
return HttpResponseServerError('No events found')
roll = Roll(date=period_start,
trainee=trainee,
status='P',
event=event,
finalized=True,
submitted_by=submitter)
roll.save()
listJSONRenderer = JSONRenderer()
if trainee.self_attendance:
rolls = listJSONRenderer.render(
RollSerializer(Roll.objects.filter(submitted_by=trainee),
many=True).data)
else:
rolls = listJSONRenderer.render(
RollSerializer(Roll.objects.filter(trainee=trainee),
many=True).data)
return JsonResponse({'rolls': json.loads(rolls)})
def get_context_data(self, project_id, *args, **kwargs):
from localground.apps.site.api.serializers import \
ProjectDetailSerializer
from rest_framework.renderers import JSONRenderer
context = super(MainView, self).get_context_data(*args, **kwargs)
project = Project.objects.get(id=project_id)
serializer = ProjectDetailSerializer(project, context={'request': {}})
renderer = JSONRenderer()
context.update({
'project': renderer.render(serializer.data),
'project_name': project.name
})
return context
def discussion(request, pk):
""" View an individual discussion. """
if 'login_prefix' in request.session:
del request.session['login_prefix']
topic = get_object_or_404(Topic, pk=pk)
r = JSONRenderer()
comments = r.render([CommentSerializer(c).data
for c in topic.comments.all()])
users = r.render([TopicUserSerializer(u).data for u in topic.users.all()])
groups = r.render([GroupSerializer(g).data for g in topic.groups.all()])
topic_user = None
if request.user.is_authenticated():
topic_user = request.user.topic_user(topic)
return render(request, "discussion.html",
{"topic": topic,
"comments": comments,
"users": users,
"groups": groups,
"total_users": User.objects.all().count(),
"topic_user": topic_user,
"active_users": Profile.objects.filter(active=True).count()}
)
def student_update(request):
if request.method == 'PUT':
json_data = request.body
stream = io.BytesIO(json_data)
pydata = JSONParser().parse(stream)
id = pydata.get('id')
stu = Student.objects.get(id=id)
serializer = StudentSerializer(stu, data=pydata, partial=True)
if serializer.is_valid():
serializer.save()
response = {'msg': 'Data Updates'}
json_data = JSONRenderer().render(response)
return HttpResponse(json_data, content_type='application/json')
else:
json_data = JSONRenderer.render(serializer.errors)
return HttpResponse(json_data, content_type='application/json')
def get_context_data(self, project_id, *args, **kwargs):
from localground.apps.site.api.serializers import \
ProjectDetailSerializer
from rest_framework.renderers import JSONRenderer
context = super(MainView, self).get_context_data(
*args, **kwargs)
project = Project.objects.get(id=project_id)
serializer = ProjectDetailSerializer(
project,
context={'request': {}}
)
renderer = JSONRenderer()
context.update({'project': renderer.render(serializer.data)})
return context
def notifications(request):
if not request.user.is_authenticated():
return {"notifications": []}
r = JSONRenderer()
def clean_unicode(p):
p["image"] = smart_text(p["image"])
p["short"] = smart_text(p["short"])
p["html"] = smart_text(p["html"])
return p
rr = [
clean_unicode(NotificationSerializer(n).data)
for n in request.user.notifications.all()
]
return {"notifications": r.render(rr)}
def put(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
_id = python_data.get("id")
stu = Student.objects.get(id=_id)
serialize = StudentSerializer(stu, data=python_data, partial=True)
# partial is set to True when we are updating only partial data
if serialize.is_valid():
serialize.save()
res = {"status": "Data updated !"}
return JsonResponse(res, safe=False)
json_response = JSONRenderer.render(serialize.errors)
return HttpResponse(json_response, content_type="application/json")
def on_message(cls, websocket, message):
print(message)
pid = websocket.session.get("profile-id")
profile = Profile.objects.get(id=pid)
try:
damp = json.loads(message)
except json.JSONDecodeError:
damp = {}
print("error Decoding JSON")
# registering to a room
# adding a user to a room
if not hasattr(websocket, "room"):
room = damp.get("room")
if room is None:
websocket.send("{'error': 'Not Yet regiesterd in a room'}")
websocket.close()
return
setattr(websocket, "room", room)
if cls.rooms.get(room) is None:
cls.rooms[room] = Game(room=room)
cls.rooms[room].save()
game = cls.rooms[room]
if game.isStarted:
websocket.send("{'error':'a game is in progress in that socket'}")
websocket.close()
return
user_str = JSONRenderer().render(ProfileSerializer(profile).data)
game.publish("{\"add_user\":"+user_str.decode("utf-8")+"}")
game.add_user(profile)
game.save()
users_str = JSONRenderer().render(ProfileSerializer(game.users.all(), many=True).data).decode("utf-8")
websocket.send("{\"users\": "+users_str+",\"room\":\""+room+"\"}")
elif damp.get("ready_set") is not None:
size = damp.get("ready_set")
game = cls.rooms.get(websocket.room)
if 3 <= size <= 8:
game.dimen = size
game.save()
game.start_game()
game.publish("{\"ready_set\":\"{}\"}".format(JSONRenderer.render(GameSerializer(game).data)))
return
def wrapper(*args, **kwargs):
"""Return a JSON response if a 403 found.
Executes the custom renderer if no 403 status code found.
Args:
Returns:
(BaseRenderer)
"""
# renderer_context is the 4th argument if not specified by keyword.
if len(args) < 4 and kwargs is None:
return fcn(*args, **kwargs)
renderer_context = None
if len(args) >= 4:
renderer_context = args[3]
elif kwargs is not None and 'renderer_context' in kwargs:
renderer_context = kwargs['renderer_context']
if renderer_context is None:
return fcn(*args, **kwargs)
# Check for presense of a Response object.
if 'response' not in renderer_context:
return fcn(*args, **kwargs)
# Have a response, check for 403.
if renderer_context['response'].status_code == 403:
renderer_context['response']['Content-Type'] = 'application/json'
obj = args[0]
obj.media_type = 'application/json'
obj.format = 'json'
err_msg = {"status": 403, "message": "Access denied, are you logged in?",
"code": ErrorCodes.ACCESS_DENIED_UNKNOWN}
jr = JSONRenderer()
return jr.render(err_msg, 'application/json', renderer_context)
return fcn(*args, **kwargs)
def test_long_form(self):
renderer = JSONRenderer()
renderer.compact = False
data = OrderedDict([('a', 1), ('b', 2)])
assert renderer.render(data) == b'{"a": 1, "b": 2}'
