def test_json(self):
t = self.topology_model.objects.first()
n = t._create_node(
label='test node',
addresses=['192.168.0.1', '10.0.0.1'],
properties={"gateway": True},
)
self.assertEqual(
dict(n.json(dict=True)),
{
'id': '192.168.0.1',
'label': 'test node',
'local_addresses': ['10.0.0.1'],
'properties': {
'gateway': True,
'created': JSONEncoder().default(n.created),
'modified': JSONEncoder().default(n.modified),
},
},
)
self.assertIsInstance(n.json(), str)
with self.subTest('testing original=True'):
netjson = n.json(dict=True, original=True)
self.assertNotIn('created', netjson['properties'])
self.assertNotIn('modified', netjson['properties'])
def json(self, dict=False, original=False, **kwargs):
"""
Returns a NetJSON NetworkGraph Node object.
If ``original`` is passed, the data will be returned
as it has been collected from the network (used when
doing the comparison).
"""
netjson = OrderedDict({'id': self.netjson_id})
label = self.get_name()
if label:
netjson['label'] = label
for attr in ['local_addresses', 'properties']:
value = getattr(self, attr)
if value or attr == 'properties':
netjson[attr] = deepcopy(value)
if not original:
netjson['properties'].update(deepcopy(self.user_properties))
netjson['properties']['created'] = JSONEncoder().default(
self.created)
netjson['properties']['modified'] = JSONEncoder().default(
self.modified)
if dict:
return netjson
return json.dumps(netjson, cls=JSONEncoder, **kwargs)
def json(self, dict=False, **kwargs):
"""
returns a NetJSON NetworkGraph Node object
"""
netjson = OrderedDict({'id': self.netjson_id})
for attr in ['label', 'local_addresses', 'properties']:
value = getattr(self, attr)
if value or attr == 'properties':
netjson[attr] = value
netjson['properties']['created'] = JSONEncoder().default(self.created)
netjson['properties']['modified'] = JSONEncoder().default(
self.modified)
if dict:
return netjson
return json.dumps(netjson, cls=JSONEncoder, **kwargs)
def render(
self,
data: Any,
accepted_media_type: Optional[str] = None,
renderer_context: Any = None,
) -> bytes:
"""
Render `data` into JSON, returning a bytestring.
"""
if data is None:
return b""
renderer_context = renderer_context or {}
ret = orjson.dumps(
data,
option=orjson.OPT_NON_STR_KEYS,
default=JSONEncoder().default,
)
# We always fully escape \u2028 and \u2029 to ensure we output JSON
# that is a strict javascript subset.
# See: http://timelessrepo.com/json-isnt-a-javascript-subset
ret = ret.replace(b"\u2028", b"\\u2028").replace(b"\u2029", b"\\u2029")
return ret
def perform_update(self, serializer):
existing_customer = self.get_object()
updated_customer = serializer.save()
json_encoder = JSONEncoder()
existing_customer_data = json_encoder.encode(
self.serializer_class(existing_customer).data
)
updated_customer_data = json_encoder.encode(serializer.data)
if existing_customer_data != updated_customer_data:
adapter = get_adapter(self.request)
context = {
"customer": updated_customer,
}
managers_emails = updated_customer.customer_users.managers(
).values_list("user__email", flat=True)
adapter.send_mail(
"astrosat_users/email/update_customer",
managers_emails,
context,
fail_silently=True,
)
return updated_customer
def _serialize_datetime(cls, dt): # pylint: disable=invalid-name
""" Serializes datetime values using Django REST Framework's encoder.
Use this to simplify equality assertions.
"""
if dt:
return JSONEncoder().default(dt)
return None
def _serialize_course_mode(course_mode):
""" Serialize a CourseMode to a dict. """
# encode the datetime (if nonempty) using DRF's encoder, simplifying
# equality assertions.
expires = course_mode.expiration_datetime
if expires is not None:
expires = JSONEncoder().default(expires)
return {
u'name': course_mode.mode_slug,
u'currency': course_mode.currency.lower(),
u'price': course_mode.min_price,
u'sku': course_mode.sku,
u'expires': expires,
}
def perform_update(self, serializer):
existing_customer_user = self.get_object()
updated_customer_user = serializer.save()
json_encoder = JSONEncoder()
existing_customer_user_user_data = json_encoder.encode(
self.serializer_class(existing_customer_user).data["user"]
)
updated_customer_user_user_data = json_encoder.encode(
serializer.data["user"]
)
adapter = get_adapter(self.request)
context = {
"user": updated_customer_user.user,
"customer": updated_customer_user.customer,
}
if existing_customer_user_user_data != updated_customer_user_user_data:
template_prefix = "astrosat_users/email/update_user"
adapter.send_mail(
template_prefix, updated_customer_user.user.email, context, fail_silently=True,
)
if existing_customer_user.customer_user_type != updated_customer_user.customer_user_type:
if updated_customer_user.customer_user_type == CustomerUserType.MANAGER:
# customer_user was something else, now it's a MANAGER
template_prefix = "astrosat_users/email/admin_assign"
elif existing_customer_user.customer_user_type == CustomerUserType.MANAGER:
# customer_user was a MANAGER, now it's something else
template_prefix = "astrosat_users/email/admin_revoke"
adapter.send_mail(
template_prefix, updated_customer_user.user.email, context, fail_silently=True,
)
return updated_customer_user
def setUp(self):
self.antenna = AntennaFactory()
self.encoder = JSONEncoder()
self.station = StationFactory.create(antennas=[self.antenna])
def setUp(self):
self.encoder = JSONEncoder()
