def create_json(self, obj, obj_start, obj_end):
"""Runs specific serializer against an object and creates a JSON-structured dict.
Args:
object (obj): a RightsShell or RightsGranted object.
serializer_class (str): A serializer class (RightsShellSerializer or RightsGrantedSerializer)
obj_start (datetime); a datetime object representing the group of object's start date
obj_end (datetime); a datetime object representing the group of object's end date
Returns:
data (dict): a JSON structured dictionary based on the object passed.
"""
obj.start_date = obj_start
obj.end_date = obj_end
if obj.__class__ == RightsShell:
if obj.rights_basis == "copyright":
serializer = CopyrightSerializer(obj)
elif obj.rights_basis == "statute":
serializer = StatuteSerializer(obj)
elif obj.rights_basis == "license":
serializer = LicenseSerializer(obj)
else:
serializer = OtherSerializer(obj)
else:
serializer = RightsGrantedSerializer(obj)
bytes = JSONRenderer().render(serializer.data)
return json.loads(bytes.decode("utf-8"))
def send_notifications(snapshot_time):
positions = Position.objects.filter(snapshot_time=snapshot_time)
serializer = PositionSerializer(positions, many=True)
rendered = JSONRenderer().render(serializer.data)
Group('trams/positions').send({'text': rendered.decode()})
def get_top(self):
"""
:param n: nombre de films/saisons souhaité à retourner
:return: la liste des n films/saisons qui ont la tendance.
"""
qs = RatingFilms.objects.all()
df = pd.DataFrame.from_records(
qs.values("film__id_video", 'user__id', 'note')
).rename(
columns={
'film__id_video': 'film_id',
'user__id': 'user_id',
'note': 'note'
}
)
# matrice d'interaction user - item
user_movie_df = df.pivot_table(index=['user_id'], columns=['film_id'], values='note')
nb_ratings_df = self.nb_ratings_df(user_movie_df)
moy_ratings_df = self.moy_ratings_df(user_movie_df)
combine_df = pd.concat([nb_ratings_df, moy_ratings_df], axis=1)
combine_df['rating_tendance'] = combine_df['nb_ratings'] * combine_df['moyenne']
top_n_movies = combine_df.sort_values('rating_tendance', ascending=False).head(10)
l = [Films.objects.get(id_video=id_movie) for id_movie in top_n_movies.index]
liste = []
for i in l:
filmSerializer = FilmSerializer(i)
json_data = JSONRenderer().render(filmSerializer.data)
liste.append(json.loads(json_data.decode("utf-8")))
if settings.GS:
self._to_google(liste)
else:
self._to_local(liste)
def test_render_dict_abc_obj(self):
class Dict(MutableMapping):
def __init__(self):
self._dict = dict()
def __getitem__(self, key):
return self._dict.__getitem__(key)
def __setitem__(self, key, value):
return self._dict.__setitem__(key, value)
def __delitem__(self, key):
return self._dict.__delitem__(key)
def __iter__(self):
return self._dict.__iter__()
def __len__(self):
return self._dict.__len__()
def keys(self):
return self._dict.keys()
x = Dict()
x["key"] = "string value"
x[2] = 3
ret = JSONRenderer().render(x)
data = json.loads(ret.decode("utf-8"))
self.assertEquals(data, {"key": "string value", "2": 3})
def test_item_serialization_datetime_range(self):
sample = self.data_factory.create_item_sample(
collection=self.collection.model, sample='item-2')
# translate to Python native:
context = {
'request':
api_request_mocker.get(
f'{STAC_BASE_V}/collections/{self.collection["name"]}/items/{sample["name"]}'
)
}
serializer = ItemSerializer(sample.model, context=context)
python_native = serializer.data
logger.debug('python native:\n%s', pformat(python_native))
# translate to JSON:
json_string = JSONRenderer().render(python_native,
renderer_context={'indent': 2})
logger.debug('json string: %s', json_string.decode("utf-8"))
self.assertSetEqual(
set([
'stac_version', 'id', 'bbox', 'geometry', 'type', 'properties',
'links', 'assets'
]).difference(python_native.keys()),
set(),
msg="These required fields by the STAC API spec are missing")
self.check_stac_item(sample.json, python_native,
self.collection["name"])
def test_asset_serialization(self):
collection_name = self.collection["name"]
item_name = self.item["name"]
asset_name = self.asset["name"]
# mock a request needed for the serialization of links
request_mocker = api_request_mocker.get(
f'{STAC_BASE_V}/collections/{collection_name}/items/{item_name}/assets/{asset_name}'
)
# translate to Python native:
serializer = AssetSerializer(self.asset.model,
context={'request': request_mocker})
python_native = serializer.data
logger.debug('serialized fields:\n%s', pformat(serializer.fields))
logger.debug('python native:\n%s', pformat(python_native))
# translate to JSON:
json_string = JSONRenderer().render(python_native,
renderer_context={'indent': 2})
logger.debug('json string: %s', json_string.decode("utf-8"))
self.check_stac_asset(self.asset.json,
python_native,
collection_name,
item_name,
ignore=["item"])
def book_detail(request, pk):
book_obj = Book.objects.filter(id=pk).first()
serializer = BookSerializer(book_obj, context={"request": request})
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data.decode())
def test_render_dict_abc_obj(self):
class Dict(MutableMapping):
def __init__(self):
self._dict = dict()
def __getitem__(self, key):
return self._dict.__getitem__(key)
def __setitem__(self, key, value):
return self._dict.__setitem__(key, value)
def __delitem__(self, key):
return self._dict.__delitem__(key)
def __iter__(self):
return self._dict.__iter__()
def __len__(self):
return self._dict.__len__()
def keys(self):
return self._dict.keys()
x = Dict()
x['key'] = 'string value'
x[2] = 3
ret = JSONRenderer().render(x)
data = json.loads(ret.decode('utf-8'))
self.assertEquals(data, {'key': 'string value', '2': 3})
def test_render_dict_abc_obj(self):
class Dict(MutableMapping):
def __init__(self):
self._dict = dict()
def __getitem__(self, key):
return self._dict.__getitem__(key)
def __setitem__(self, key, value):
return self._dict.__setitem__(key, value)
def __delitem__(self, key):
return self._dict.__delitem__(key)
def __iter__(self):
return self._dict.__iter__()
def __len__(self):
return self._dict.__len__()
def keys(self):
return self._dict.keys()
x = Dict()
x['key'] = 'string value'
x[2] = 3
ret = JSONRenderer().render(x)
data = json.loads(ret.decode('utf-8'))
self.assertEquals(data, {'key': 'string value', '2': 3})
async def sub_election_list(self, event):
serializer = SubElectionSerializer(SubElection.objects.filter(
election__pk=self.election_id).order_by('pk'),
many=True)
data = JSONRenderer().render(serializer.data)
# send data to subscribers
await self.send(text_data=data.decode('utf-8'))
def perform_destroy(self, instance):
post = DatasetPutSerializer(instance)
post_json = JSONRenderer().render(post.data)
post = DatasetPutSerializer(data=json.loads(post_json.decode()))
post.is_valid()
post_keydataset = KeyDataset.objects.get(
code=post['keydataset'].value).__str__()
# extract list of read/write field
if post.Meta.fields == '__all__':
fields = ()
for field in post.get_fields():
if post.Meta.read_only_fields:
if field not in post.Meta.read_only_fields:
fields += (field,)
else:
fields += (field,)
else:
fields = ()
for field in post.get_fields():
if field in post.Meta.fields:
fields += (field)
subject = ("%s: deleted dataset from user '%s' for"
" keydataset [%s] and country [%s]" % (
MAIL_SUBJECT_PREFIX,
instance.changed_by.username,
post['keydataset'].value,
post['country'].value))
rows = []
# manage differences between pre and post changes
for field in fields:
if field in ["id", "review_date"]:
continue
if field == "keydataset":
post_value = post_keydataset
elif field == "country":
post_value = Country.objects.get(iso2=post[field].value).name
else:
post_value = post[field].value
rows.append(
{"is_list": (type(post_value) is list),
"name":
instance._meta.get_field(field).verbose_name,
"post": post_value})
for reviewer in Profile.objects.filter(user__groups__name='reviewer'):
mailer(reviewer.user.email, subject,
{"title": subject,
"owner": instance.changed_by.username,
"table_title": "Deleted dataset:",
"rows": rows},
None, 'delete_by_owner')
instance.delete()
def test_limited_serialization_should_not_serialize_code(self):
s = Submission.objects.create(language=self.python_language, challenge=self.challenge, author=self.auth_user,
code="BAGDAD")
serializer = LimitedSubmissionSerializer(s)
created_at_date = s.created_at.isoformat()[:-6] + 'Z'
expected_json = (f'{{"id":{s.id},"challenge":{self.challenge.id},"author":"{self.auth_user.username}",'
f'"result_score":0,"pending":true,"created_at":"{created_at_date}",'
f'"compiled":true,"compile_error_message":"","language":"Python","timed_out":false,'
f'"user_has_voted":false,"user_has_upvoted":false,"upvote_count":0,"downvote_count":0}}')
content = JSONRenderer().render(serializer.data)
self.assertEqual(content.decode('utf-8').replace('\\n', '\n'), expected_json)
def get(self, request):
#also attach group id and group name.
response = super().get(request)
response = JSONRenderer().render(response.data)
response = json.loads(response.decode("utf-8")) #dict of response
for i in response:
associated_group = WorkGroup.objects.get(periods__id=i['period'])
i['group_name'] = associated_group.name
i['group_id'] = associated_group.id
return Response(response)
def post(self, request, *args, **kwargs):
serializer = FileSerializer(data=request.FILES)
if serializer.is_valid():
data = JSONRenderer().render(serializer._validated_data)
task = handle_file_upload.delay(dump=data.decode('utf-8'))
response_dict = {
'task_id': task.task_id,
'message': 'Uploaded file being processed'
}
return Response(response_dict, status=status.HTTP_200_OK)
else:
return Response(serializer.data, status=status.HTTP_400_BAD_REQUEST)
def update(self, instance, validated_data):
for key in validated_data.keys():
setattr(instance, key, validated_data[key])
instance.save()
j = TextMessageSerializer(instance, context=self.context)
json = JSONRenderer().render(j.data)
message = RedisMessage(json.decode("utf-8"))
RedisPublisher(facility=instance.channel,
broadcast=True).publish_message(message)
return instance
def _serve(self):
self.id_users = self.get_id_user()
liste_object = []
for _id in self.id_users:
base_object = {}
user = User.objects.get(id=_id)
user_serializer = SpecificUserSerializer(user)
json_data_user = JSONRenderer().render(user_serializer.data)
base_object['user'] = json.loads(json_data_user.decode("utf-8"))
top_10 = self.get_top_10(_id)
liste_film = []
for data in top_10:
film_serializer = SpecificFilmSerializer(data)
json_data_film = JSONRenderer().render(film_serializer.data)
liste_film.append(json.loads(json_data_film.decode("utf-8")))
base_object['favoris_suggestion'] = liste_film
liste_object.append(base_object)
if settings.GS:
self._to_google(liste_object)
else:
self._to_local(liste_object)
return self.list_favoris_recommand
def delete(self, request, id, format=None):
if request.user:
group_to_delete = self.get(request, id)
group_to_delete = JSONRenderer().render(group_to_delete.data)
group_to_delete = json.loads(group_to_delete.decode("utf-8"))
#only an admin can delete the group
if group_to_delete['is_admin']:
super().delete(request, id)
return Response("Group successfully deleted.")
else:
return Response("Only a group admin can delete the group.")
def test_implicit_date_filters(self):
john = Person.objects.get(name="John")
# Mark was created at least one second after John.
# mark = Person.objects.get(name="Mark")
# Figure out what the date strings should look like based on the
# serializer output.
data = PersonSerializer(john).data
date_str = JSONRenderer().render(
data['date_joined']).decode('utf-8').strip('"')
# Adjust for imprecise rendering of time
offset = parse_datetime(
data['datetime_joined']) + datetime.timedelta(seconds=0.6)
datetime_str = JSONRenderer().render(offset)
datetime_str = datetime_str.decode('utf-8').strip('"')
# Adjust for imprecise rendering of time
offset = datetime.datetime.combine(today,
parse_time(data['time_joined']))
offset += datetime.timedelta(seconds=0.6)
time_str = JSONRenderer().render(
offset.time()).decode('utf-8').strip('"')
# DateField
GET = {
'date_joined__lte': date_str,
}
f = PersonFilter(GET, queryset=Person.objects.all())
self.assertEqual(len(list(f.qs)), 2)
p = list(f.qs)[0]
# DateTimeField
GET = {
'datetime_joined__lte': datetime_str,
}
f = PersonFilter(GET, queryset=Person.objects.all())
self.assertEqual(len(list(f.qs)), 1)
p = list(f.qs)[0]
self.assertEqual(p.name, "John")
# TimeField
GET = {
'time_joined__lte': time_str,
}
f = PersonFilter(GET, queryset=Person.objects.all())
self.assertEqual(len(list(f.qs)), 1)
p = list(f.qs)[0]
self.assertEqual(p.name, "John")
def handle(self, *args, **options):
quiz_id = options["id"]
filepath = options["filepath"]
try:
quiz = Quiz.objects.get(pk=quiz_id)
serializer = QuizSerializer(quiz)
json = JSONRenderer().render(serializer.data)
with open(filepath, "w") as file:
file.write(json.decode())
self.stdout.write(
self.style.SUCCESS("Downloaded quiz %d to %s" %
(quiz_id, filepath)))
except Quiz.DoesNotExist:
raise CommandError('Quiz "%s" does not exist' % quiz_id)
def create(self, validated_data):
jawn_user = JawnUser.objects.get(
base_user=self.context['request'].user)
c = ImageMessage.objects.create(channel=validated_data['channel'],
image_url=validated_data['image_url'],
jawn_user=jawn_user,
caption=validated_data['caption'])
j = ImageMessageSerializer(c, context=self.context)
json = JSONRenderer().render(j.data)
message = RedisMessage(json.decode("utf-8"))
RedisPublisher(facility=validated_data['channel'],
broadcast=True).publish_message(message)
return c
def data_from_object(self, obj):
serializer = self.serializer(obj, context={'request': self.request})
json_data = JSONRenderer().render(serializer.data)
serialized = json.loads(json_data.decode('utf-8'), object_pairs_hook=OrderedDict)
# All items' ES IDs will be the URLs. However, their PKs from the
# database will also be stored for convenience.
url = serialized['url']
data = {
'pk': obj.pk,
'url': url,
'serialized': serialized,
'display_title': obj.as_text()
}
return data
def test_item_serialization(self):
context = {
'request':
api_request_mocker.get(
f'{STAC_BASE_V}/collections/{self.collection["name"]}/items/{self.item["name"]}'
)
}
serializer = ItemSerializer(self.item.model, context=context)
python_native = serializer.data
logger.debug('python native:\n%s', pformat(python_native))
# translate to JSON:
json_string = JSONRenderer().render(python_native,
renderer_context={'indent': 2})
logger.debug('json string: %s', json_string.decode("utf-8"))
self.assertSetEqual(
set([
'stac_version', 'id', 'bbox', 'geometry', 'type', 'properties',
'links', 'assets'
]).difference(python_native.keys()),
set(),
msg="These required fields by the STAC API spec are missing")
collection_name = self.collection.model.name
item_name = self.item.model.name
expected_asset = self.asset.json
expected_asset.pop('id')
expected_asset.pop('item')
expected = self.item.json
expected.update({
'assets': {
self.asset['name']: expected_asset
},
'bbox': (5.644711, 46.775054, 7.602408, 49.014995),
'stac_extensions': [
'eo', 'proj', 'view',
'https://data.geo.admin.ch/stac/geoadmin-extension/1.0/schema.json'
],
'stac_version':
settings.STAC_VERSION,
'type':
'Feature'
})
self.check_stac_item(expected, python_native, collection_name)
def get(self, request, id, format=None):
response = super().get(request)
response = JSONRenderer().render(response.data)
response = json.loads(response.decode("utf-8"))
if request.user.id in [j['id'] for j in response['admins']]:
response['is_admin'] = True
else:
response['is_admin'] = False
for j in response['periods']:
if UserPreference.objects.filter(user__id=request.user.id,
period__id=j['id']).exists():
j['preference_submitted'] = True
else:
j['preference_submitted'] = False
return Response(response)
def all_restaurants(request):
all_restaurants_stack = []
if request.method == 'GET':
# Fail if there are no restaurants in the DB
num_entries = Restaurant.objects.all().count()
if num_entries == 0:
return HttpResponse(status=500)
all_restaurants = Restaurant.objects.all()
serializer = RestaurantSerializer(all_restaurants, many=True)
serialized_data = JSONRenderer().render(serializer.data)
all_restaurants = json.loads(serialized_data.decode('utf-8'))
return HttpResponse(json.dumps(all_restaurants,
sort_keys=True,
indent=4),
content_type="application/json")
else:
return HttpResponse(status=405)
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 get(self, request, format=None):
response = super().get(request)
response = JSONRenderer().render(response.data)
response = json.loads(response.decode("utf-8"))
for i in response:
#check if the user is admin, add is_admin to all results
if request.user.id in [j['id'] for j in i['admins']]:
i['is_admin'] = True
else:
i['is_admin'] = False
#check if the user has submitted preferences, add preference_submitted to all periods
for j in i['periods']:
if UserPreference.objects.filter(user__id=request.user.id,
period__id=j['id']).exists():
j['preference_submitted'] = True
else:
j['preference_submitted'] = False
return Response(response)
def view_commission(request, slug):
com = get_object_or_404(Commission, slug=slug)
events = com.events.all()
administrative_members = com.get_membres().filter(
role__isnull=False).order_by("identification__first_name")
members = com.get_membres().filter(
role__isnull=True).order_by("identification__first_name")
serialized = JSONRenderer().render(
CommissionSerializer(com, context={
"request": request
}).data)
support = User.objects.filter(support_member=com.organization_dependant)
return render(
request, "view_commission.html", {
'com':
com,
'membre_inside':
com.in_commission_membre(request),
'can_manage':
com.has_change_permission(request),
'events':
events,
'primary_member':
request.user in [com.president, com.treasurer, com.deputy],
"administrative_members":
administrative_members,
"members":
members,
"serialized_commission":
serialized.decode("utf8"),
"support":
support,
'view_commission_id':
com.id
})
def test_observed_property_serializer(self):
""" Test Observed Property Serialization"""
obj = ObservedProperty(
description="Acetate (CH3COO)",
observed_property_variable=self.observed_property_var,
sampling_medium=self.sampling_medium,
datasource=self.datasource)
# important if the serializer uses any query_params this won't work
# b/c the django test request does not return a django request
s = ObservedPropertySerializer(obj, context={'request': None})
json_obj = JSONRenderer().render(s.data)
self.assertEqual(
json.loads(json_obj.decode('utf-8')), {
"url": None,
"sampling_medium": "WATER",
"datasource": "Alpha",
"observed_property_variable": "ACT",
"description": "Acetate (CH3COO)"
})
def test_datetime_timezone_awareness(self):
# Issue #24 - coorectly handle datetime strings terminating in 'Z'.
# Figure out what the date strings should look like based on the serializer output
john = Person.objects.get(name="John")
data = PersonSerializer(john).data
offset = parse_datetime(
data['datetime_joined']) + datetime.timedelta(seconds=0.6)
datetime_str = JSONRenderer().render(offset)
datetime_str = datetime_str.decode('utf-8').strip('"')
# DRF appends a 'Z' to timezone aware UTC datetimes when rendering:
# https://github.com/tomchristie/django-rest-framework/blob/3.2.0/rest_framework/fields.py#L1002-L1006
self.assertTrue(datetime_str.endswith('Z'))
GET = {
'datetime_joined__lte': datetime_str,
}
f = PersonFilter(GET, queryset=Person.objects.all())
self.assertEqual(len(list(f.qs)), 1)
p = list(f.qs)[0]
self.assertEqual(p.name, "John")
def get_fumbles_players(url):
urls = get_urls(url)
for url in urls:
response = urlopen(url)
html = response.read()
soup = BeautifulSoup(html, "html.parser")
body = soup.find("tbody")
itens = body.findAll("tr")
players = []
for item in itens:
attributes = item.findAll("td")
attibutes_clean = []
for c in attributes:
attibutes_clean.append(c.get_text().strip("\n").strip(" ").replace("\n", ""))
players.append(attibutes_clean)
for player in players:
player_temp = Fumbles()
player_temp.year = 2020
player_temp.name = player[0]
player_temp.ff = player[1]
player_temp.fr = player[2]
player_temp.fr_td = player[3]
logger.info("salvando player: " + player_temp.name)
time.sleep(1)
#player_temp.save()
serializer = FumblesSerializer(player_temp)
content = JSONRenderer().render(serializer.data)
payload = content.decode("utf-8")
print(payload)
headers = {'content-type': 'application/json'}
r = requests.post("http://localhost:8080/fumble", data=payload, headers = headers)
def test_render_queryset_values_list(self):
o = DummyTestModel.objects.create(name='dummy')
qs = DummyTestModel.objects.values_list('id', 'name')
ret = JSONRenderer().render(qs)
data = json.loads(ret.decode('utf-8'))
self.assertEquals(data, [[o.id, o.name]])
def test_render_queryset_values_list(self):
o = DummyTestModel.objects.create(name='dummy')
qs = DummyTestModel.objects.values_list('id', 'name')
ret = JSONRenderer().render(qs)
data = json.loads(ret.decode('utf-8'))
self.assertEquals(data, [[o.id, o.name]])
def test_render_queryset_values_list(self):
o = DummyTestModel.objects.create(name="dummy")
qs = DummyTestModel.objects.values_list("id", "name")
ret = JSONRenderer().render(qs)
data = json.loads(ret.decode("utf-8"))
self.assertEquals(data, [[o.id, o.name]])
def my_ratings(request):
user = User.objects.get(id=request.session.get('user'))
serialized_data = RatingSerializer(user.ratings.all(), many=True).data
json = JSONRenderer().render(serialized_data)
return render(request, 'eval_record.html',
{'rating_count': user.ratings.all().count(), 'record': json.decode('utf8')})
def evaluate(request):
user = User.objects.get(id=request.session.get('user'))
eval_list = RECO_INTERFACE.get_eval_list(user, limit=200)
json = JSONRenderer().render(eval_list)
rating_count = user.ratings.all().count()
return render(request, 'evaluate.html', {'rating_count': rating_count, 'eval_list': json.decode('utf8')})
def test_serialize(self):
""" the Category should show all its subcategories """
expected_json = f'{{"id":{self.c1.id},"name":"Test","sub_categories":["Unit","Mock","Patch"]}}'
received_data = JSONRenderer().render(MainCategorySerializer(self.c1).data)
self.assertEqual(received_data.decode('utf-8'), expected_json)
def get_context_data(self, **kwargs):
contextData = super(ClientView, self).get_context_data(**kwargs)
# group serializer
try:
group = self.project.group
except:
group = get_object_or_404(Group, slug=kwargs['group_slug'])
groupSerializer = GroupSerializer(group,
projectId=str(self.project.pk),
projectType=kwargs['project_type'],
request=self.request)
groupData = deepcopy(groupSerializer.data)
# choose client by querystring paramenters
contextData['client_default'] = self.get_client_name()
# login_url
login_url = None
try:
login_url = resolve_url(settings.LOGIN_URL) + '?next={}'.format(
reverse('group-project-map',
kwargs={
'group_slug': kwargs['group_slug'],
'project_type': kwargs['project_type'],
'project_id': self.project.pk
}))
except:
pass
# logout_url
logout_url = None
try:
logout_url = reverse('logout') + '?next={}'.format(
reverse('group-project-map',
kwargs={
'group_slug': kwargs['group_slug'],
'project_type': kwargs['project_type'],
'project_id': self.project.pk
}))
except:
pass
# add user login data
u = self.request.user
# admin_url
change_grant_users = get_users_for_object(self.project,
"change_project",
with_group_users=True)
if u in change_grant_users or u.is_superuser:
admin_url = reverse('home')
else:
admin_url = None
user_data = {'i18n': get_language(), 'login_url': login_url}
if not u.is_anonymous:
user_data.update({
'id': u.pk,
'username': u.username,
'first_name': u.first_name,
'last_name': u.last_name,
'is_superuser': u.is_superuser,
'is_staff': u.is_staff,
'groups': [g.name for g in u.groups.all()],
'logout_url': logout_url
})
if admin_url:
user_data.update({'admin_url': admin_url})
user_data = JSONRenderer().render(user_data)
serializedGroup = JSONRenderer().render(groupData)
if six.PY3:
serializedGroup = str(serializedGroup, 'utf-8')
baseurl = "/{}".format(
settings.SITE_PREFIX_URL if settings.SITE_PREFIX_URL else '')
frontendurl = ',"frontendurl":"{}"'.format(
baseurl) if settings.FRONTEND else ''
generaldata = GeneralSuiteData.objects.get()
# add baseUrl property
contextData['group_config'] = 'var initConfig ={{ "i18n": {}, "staticurl":"{}", "client":"{}", ' \
'"mediaurl":"{}", "user":{}, "group":{}, "baseurl":"{}", "vectorurl":"{}", ' \
'"proxyurl": "{}", "rasterurl":"{}", "interfaceowsurl":"{}", "main_map_title":{}, ' \
'"g3wsuite_logo_img": "{}", "credits": "{}", ' \
'"version": "{}" {} }}'.\
format(json.dumps(settings.LANGUAGES),
settings.STATIC_URL,
"{}/".format(settings.CLIENT_DEFAULT),
settings.MEDIA_URL,
user_data.decode('UTF-8'),
serializedGroup, baseurl,
settings.VECTOR_URL,
reverse('interface-proxy'),
settings.RASTER_URL,
reverse('interface-ows'),
'"' + generaldata.main_map_title + '"' if generaldata.main_map_title else 'null',
settings.CLIENT_G3WSUITE_LOGO,
reverse('client-credits'),
get_version(),
frontendurl)
# project by type(app)
if not '{}-{}'.format(kwargs['project_type'], self.project.pk) in list(
groupSerializer.projects.keys()):
raise Http404('No project type and/or project id present in group')
# page title
contextData['page_title'] = '{} | {}'.format(
getattr(settings, 'G3WSUITE_CUSTOM_TITLE', 'g3w - client'),
self.project.title_ur
if self.project.title_ur else self.project.title)
# choosen skin by user main role
contextData['skin_class'] = get_adminlte_skin_by_user(
self.request.user)
return contextData
def tweet_save_callback(sender, instance, **kwargs):
TweetIndexer().index_instance(instance)
if kwargs['created']:
tweet_json = JSONRenderer().render(TweetSerializer(instance).data)
Group("tweets").send({"text": tweet_json.decode()})
