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})
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 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()})