def test_clear_cache(self): config = Configuration.objects.all().first() get_configuration(code=config.code, edition=config.edition) cache_key = '{}_{}_{}'.format(config.code, config.edition, get_language()) self.assertIsNotNone(cache.get(cache_key)) request = MagicMock() request.user.is_superuser = True # Missing messages-framework will raise a type error. with contextlib.suppress(TypeError): delete_caches(request) self.assertIsNone(cache.get(cache_key))
def test_clear_cache(self): config = Configuration.objects.all().first() get_configuration(code=config.code, edition=config.edition) cache_key = '{}_{}_{}'.format( config.code, config.edition, get_language()) self.assertIsNotNone(cache.get(cache_key)) request = MagicMock() request.user.is_superuser = True # Missing messages-framework will raise a type error. with contextlib.suppress(TypeError): delete_caches(request) self.assertIsNone(cache.get(cache_key))
def __init__(self, instance=None, data=empty, **kwargs): """ Keyword Args: config: configuration.QuestionnaireConfiguration Setup the correct config. If no config is passed, use the questionnaires default config. The config is required for some fields that can only be accessed on the actual configuration object. If a model instance is serialized, the 'instance' kwarg is passed. If an elasticsearch result is deserialized, the 'data' kwarg is passed. """ if instance: self.config = instance.configuration_object elif data != empty and data.get('serializer_config'): # Restore object from json data. Make sure the serializer_config # is valid / exists in the db. self.config = get_configuration(code=data['serializer_config'], edition=data['serializer_edition']) else: raise ValueError( _(u"Can't serialize questionnaire without a valid " u"configuration.")) super().__init__(instance=instance, data=data, **kwargs)
def get_choices_from_questiongroups( questionnaire_data: dict, questiongroups: list, configuration_code: str, configuration_edition: str) -> list: """ Return a list of valid choices based on the presence of certain questiongroups within a questionnaire data JSON. Args: questionnaire_data: The questionnaire data dict questiongroups: A list of questiongroup keywords (basically a list of all possible choices) configuration: QuestionnaireConfiguration Returns: A list of possible choices [(keyword, label)] """ choices = [] configuration = get_configuration( code=configuration_code, edition=configuration_edition) for questiongroup in questiongroups: if questiongroup in questionnaire_data: questiongroup_object = configuration.get_questiongroup_by_keyword( questiongroup) choices.append((questiongroup, questiongroup_object.label)) return choices
def get_choices_from_questiongroups(questionnaire_data: dict, questiongroups: list, configuration_code: str, configuration_edition: str) -> list: """ Return a list of valid choices based on the presence of certain questiongroups within a questionnaire data JSON. Args: questionnaire_data: The questionnaire data dict questiongroups: A list of questiongroup keywords (basically a list of all possible choices) configuration: QuestionnaireConfiguration Returns: A list of possible choices [(keyword, label)] """ choices = [] configuration = get_configuration(code=configuration_code, edition=configuration_edition) for questiongroup in questiongroups: if questiongroup in questionnaire_data: questiongroup_object = configuration.get_questiongroup_by_keyword( questiongroup) choices.append((questiongroup, questiongroup_object.label)) return choices
def setUp(self): super().setUp() self.config = get_configuration(code='approaches', edition='2015') self.questionnaire = Questionnaire.objects.get(id=2) self.data = get_questionnaire_data_in_single_language( self.questionnaire.data, 'en') self.parser = Approach2015Parser(config=self.config, n_a='', questionnaire=self.questionnaire, summary_type='full', **self.data)
def handle(self, **options): pre_save.disconnect(prevent_updates_on_published_items, sender=Questionnaire) configuration_code = 'unccd' config = get_configuration(configuration_code, edition='2015') questionnaires = Questionnaire.objects.filter( code__startswith=configuration_code) self.find_int_values(questionnaires, config) pre_save.connect(prevent_updates_on_published_items, sender=Questionnaire)
def setUp(self): super().setUp() self.config = get_configuration(code='approaches', edition='2015') self.questionnaire = Questionnaire.objects.get(id=2) self.data = get_questionnaire_data_in_single_language( self.questionnaire.data, 'en' ) self.parser = Approach2015Parser( config=self.config, n_a='', questionnaire=self.questionnaire, summary_type='full', **self.data )
def handle(self, **options): pre_save.disconnect( prevent_updates_on_published_items, sender=Questionnaire ) configuration_code = 'unccd' config = get_configuration(configuration_code, edition='2015') questionnaires = Questionnaire.objects.filter( code__startswith=configuration_code) self.find_int_values(questionnaires, config) pre_save.connect( prevent_updates_on_published_items, sender=Questionnaire )
def __init__(self, code: str, edition: str, flat: bool = False): self.structure = [] self.error = None try: configuration = get_configuration(code=code, edition=edition) except Configuration.DoesNotExist: self.error = 'No configuration found for this code and edition.' return for section in configuration.sections: for category in section.categories: if flat: self.build_flat_structure(category) else: self.structure.append(self.get_nested_structure(category))
def links_property(self): """ Collect all info about linked questionnaire and structure it according to language. This follows a often used pattern of questionnaire data. Returns: list """ links = [] current_language = get_language() for link in self.links.filter(status=settings.QUESTIONNAIRE_PUBLIC): link_configuration = get_configuration( code=link.configuration.code, edition=link.configuration.edition) name_data = link_configuration.get_questionnaire_name(link.data) try: original_language = link.questionnairetranslation_set.first( ).language except AttributeError: original_language = settings.LANGUAGES[0][0] # 'en' names = {} urls = {} for code, language in settings.LANGUAGES: activate(code) names[code] = name_data.get(code, name_data.get(original_language)) urls[code] = link.get_absolute_url() if code == original_language: names['default'] = names[code] urls['default'] = urls[code] links.append({ 'code': link.code, 'configuration': link_configuration.keyword, 'name': names, 'url': urls, }) activate(current_language) return links
def handle(self, **options): """ Loop over all active configurations, get the mappings and create the elasticsearch-indexes. Args: **options: None """ configurations = Configuration.objects.all() for language in dict(settings.LANGUAGES).keys(): activate(language) for configuration in configurations: questionnaire_configuration = get_configuration( code=configuration.code, edition=configuration.edition) mappings = get_mappings() create_or_update_index( configuration=questionnaire_configuration, mappings=mappings)
def links_property(self): """ Collect all info about linked questionnaire and structure it according to language. This follows a often used pattern of questionnaire data. Returns: list """ links = [] current_language = get_language() for link in self.links.filter(status=settings.QUESTIONNAIRE_PUBLIC): link_configuration = get_configuration( code=link.configuration.code, edition=link.configuration.edition) name_data = link_configuration.get_questionnaire_name(link.data) try: original_language = link.questionnairetranslation_set.first().language except AttributeError: original_language = settings.LANGUAGES[0][0] # 'en' names = {} urls = {} for code, language in settings.LANGUAGES: activate(code) names[code] = name_data.get(code, name_data.get(original_language)) urls[code] = link.get_absolute_url() if code == original_language: names['default'] = names[code] urls['default'] = urls[code] links.append({ 'code': link.code, 'configuration': link_configuration.keyword, 'name': names, 'url': urls, }) activate(current_language) return links
def index(request, configuration, edition): """ Create or update the mapping of an index. Args: ``request`` (django.http.HttpRequest): The request object. ``configuration`` (str): The code of the Questionnaire configuration. ``edition`` (str): The edition of the Questionnaire configuration. Returns: ``HttpResponse``. A rendered Http Response (redirected to the search admin home page). """ if request.user.is_superuser is not True: raise PermissionDenied() questionnaire_configuration = get_configuration( code=configuration, edition=edition ) if questionnaire_configuration.get_configuration_errors() is not None: return HttpResponseBadRequest( questionnaire_configuration.configuration_error) mappings = get_mappings() success, logs, error_msg = create_or_update_index( configuration=questionnaire_configuration, mappings=mappings ) if success is not True: messages.error(request, 'The following error(s) occured: {}'.format( error_msg)) else: messages.success( request, 'Index "{}" was created or updated.'.format( configuration)) return redirect('search:admin')
def handle(self, **options): """ Loop over all active configurations, get the mappings and create the elasticsearch-indexes. Args: **options: None """ configurations = Configuration.objects.all() for language in dict(settings.LANGUAGES).keys(): activate(language) for configuration in configurations: questionnaire_configuration = get_configuration( code=configuration.code, edition=configuration.edition ) mappings = get_mappings() create_or_update_index( configuration=questionnaire_configuration, mappings=mappings )
def create_temp_indices(configuration_list: list): """ For each index, create the index and update it with the questionnaires of the corresponding configuration as found in the database. Make sure to override the settings and use a custom prefix for the indices. Args: ``configuration_list`` (list): A list of tuples containing the configurations for which a ES index shall be created and consisting of - [0]: code of the configuration - [1]: edition of the configuration """ for code, edition in configuration_list: mappings = get_mappings() create_or_update_index(get_configuration(code=code, edition=edition), mappings) put_questionnaire_data(Questionnaire.with_status.public().filter( configuration__code=code))
def create_temp_indices(configuration_list: list): """ For each index, create the index and update it with the questionnaires of the corresponding configuration as found in the database. Make sure to override the settings and use a custom prefix for the indices. Args: ``configuration_list`` (list): A list of tuples containing the configurations for which a ES index shall be created and consisting of - [0]: code of the configuration - [1]: edition of the configuration """ for code, edition in configuration_list: mappings = get_mappings() create_or_update_index( get_configuration(code=code, edition=edition), mappings) put_questionnaire_data( Questionnaire.with_status.public().filter(configuration__code=code) )
def test_does_not_set_cache_if_found(self, mock_cache): mock_cache.get.return_value = 'bar' get_configuration('foo', 'edition_2015') self.assertEqual(mock_cache.set.call_count, 0)
def test_returns_cache_if_found(self, mock_cache): mock_cache.get.return_value = 'bar' ret = get_configuration('foo', 'edition_2015') self.assertEqual(ret, 'bar')
def post(self, request, *args, **kwargs): if not request.data: # No data passed. return Response({'detail': 'No questionnaire data.'}, status=status.HTTP_400_BAD_REQUEST) # Parse the configuration code and edition request_code = kwargs['configuration'] request_edition = kwargs['edition'] # Validate configuration exists for code and edition structure_obj = ConfigurationStructure( code=request_code, edition=request_edition, ) if structure_obj.error: # No configuration found for this code and edition. return Response( { 'detail': 'No configuration found for this code and edition.' }, status=status.HTTP_404_NOT_FOUND) # Fetch a new configuration request_config = get_configuration(code=request_code, edition=request_edition) # Questionnaires can only be created for the latest edition if request_config.has_new_edition: # Newer edition found for this code return Response( { 'detail': 'A newer edition exists for {}. Questionnaires can be ' 'published only for the latest edition.'.format( request_code) }, status=status.HTTP_400_BAD_REQUEST) # Questionnaire data is validated cleaned_data, config_errors = validate_questionnaire_data( request.data, request_config) if config_errors: # Questionnaire data does not fit configuration structure. return Response({'detail': config_errors}, status=status.HTTP_400_BAD_REQUEST) # Validate the questionnaire data using the serializer serializer = self.get_serializer(data={'data': cleaned_data}) if serializer.is_valid(): # Create a new Questionnaire and save new_questionnaire = Questionnaire.create_new( configuration_code=request_code, data=cleaned_data, user=request.user, created=timezone.now(), updated=timezone.now()) new_questionnaire.save() return Response({ 'success': "true", 'code': new_questionnaire.code }, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs): """ Get a Questionnaire by its identifier for API v2. Returns the questiongroup keywords and its values ``configuration``: The code of the configuration (e.g. "technologies"). ``edition``: The edition of the configuration (e.g. "2018"). ``identifier``: The identifier / code of the questionnaire (e.g. technologies_0123). """ # Parse the configuration code, edition and identifier request_code = kwargs['configuration'] request_edition = kwargs['edition'] request_identifier = kwargs['identifier'] # Validate configuration exists for code and edition structure_obj = ConfigurationStructure( code=request_code, edition=request_edition, ) if structure_obj.error: # No configuration found for this code and edition. return Response( { 'detail': 'No configuration found for this configuration code and edition.' }, status=status.HTTP_400_BAD_REQUEST) # Fetch all questionnaire versions for the identifier questionnaire_all = get_list_or_404( Questionnaire.with_status.not_deleted(), code=request_identifier) # questionnaire = Questionnaire.with_status.not_deleted().filter(code=request_identifier).latest('version') # Use the latest version of the questionnaire if more than one version exists questionnaire = sorted(questionnaire_all, key=lambda x: x.version, reverse=True)[0] if questionnaire is None: # No questionnaire exists or is deleted # - this is a redundant check... raise Http404() # Check configuration matches if not questionnaire.configuration_object == get_configuration( code=request_code, edition=request_edition): # Configuration mismatch return Response( { 'detail': 'Questionnaire does not match configuration code and edition.' }, status=status.HTTP_400_BAD_REQUEST) # Get request user's role in this questionnaire request_user_role = '' for user_role, user in questionnaire.get_users(): if user == request.user: request_user_role = user_role break if not request_user_role: # User has no role on this questionnaire return Response({'detail': 'Unauthorized.'}, status=status.HTTP_401_UNAUTHORIZED) # Check the questionnaire status, allow access only when DRAFT/PUBLIC if questionnaire.status not in (settings.QUESTIONNAIRE_DRAFT, settings.QUESTIONNAIRE_PUBLIC): # Questionnaire is not editable return Response({'detail': 'Not editable.'}, status=status.HTTP_405_METHOD_NOT_ALLOWED) # Check if the questionnaire has any locks if not questionnaire.can_edit(user=request.user): # Questionnaire is currently locked for editing blocked_msg = questionnaire.get_blocked_message( user=request.user)[1] return Response({'detail': blocked_msg}, status=status.HTTP_409_CONFLICT) # Handle the EditRequests table entry # - This request could also be to just view the data, nonetheless we record it as an Edit Request # - Check if the same user has an active EditRequest for this Questionnaire # - if Yes, access timestamp and questionnaire version are updated # - if No, Create a new EditRequest if APIEditRequests.with_status.is_active(code=request_identifier, for_user=request.user): # Found an active request from the user, updating APIEditRequests.objects.filter( questionnaire_code=request_identifier, user=request.user, is_edit_complete=False).update( access=timezone.now(), questionnaire_version=questionnaire.version) else: # No active request from the user, creating APIEditRequests.objects.create( questionnaire_code=request_identifier, questionnaire_version=questionnaire.version, user=request.user) # Finally, deserialize the questionnaire data serializer = QuestionnaireInputSerializer(questionnaire) return Response( { 'status': questionnaire.status_property[0], 'data': serializer.data['data'] }, status=status.HTTP_200_OK)
def handle(self, *args, **options): self.only_on_develop() # Pull latest translations from transifex - unless specified otherwise. if not options.get('do_create_only'): print('Pulling latest from transifex') subprocess.call('tx pull --mode=developer{}'.format( ' -f' if options.get('do_force_pull') else ' ' ), shell=True) print('Compiling latest po files') call_command('compilemessages') configuration_helper_file = os.path.join( 'apps', 'configuration', 'configuration_translations.py' ) # Get a list of all used Translations by all configurations. This can # then be used to remove unused translations. used_translation_ids = [] for configuration in Configuration.objects.all(): questionnaire_configuration = get_configuration( code=configuration.code, edition=configuration.edition) used_translation_ids.extend( questionnaire_configuration.get_translation_ids()) # Remove duplicates used_translation_ids = set(used_translation_ids) # It is not enough to check for new 'Translation' rows as new # configuration editions can update only the translation for the new # edition which creates a new entry in the existing 'Translation' data # json. # Instead, first get all existing content of TranslationContent, group # it by configuration and keyword. Then extract all entries in the # 'Translation' table and see if they are already available in the # 'TranslationContent' table. If not, create them later. existing_translation_content = {} for existing in TranslationContent.objects.all(): (existing_translation_content .setdefault(existing.configuration, {}) .setdefault(existing.keyword, []) .append(existing.text)) unused_translation_ids = [] for translation in Translation.objects.all(): if translation.id not in used_translation_ids: unused_translation_ids.append(translation.id) continue for configuration, contents in translation.data.items(): for keyword, translated_items in contents.items(): # Only English texts are expected. If 'en' is not available, # this must raise an exception. translation_string = translated_items['en'] if translation_string in existing_translation_content.get( configuration, {}).get(keyword, []): # String already in TranslationContent, do nothing. continue # Add new strings to TranslationContent TranslationContent( translation=translation, configuration=configuration, keyword=keyword, text=translation_string ).save() if len(translated_items.keys()) != 1: print(u'Warning: More than one translation in the' u'fixtures. Only the English text is used.') if unused_translation_ids: print( 'The following translations are not needed anymore. They will ' 'be deleted. You should also remove these from the fixtures, ' 'along with the keys/values/categories they belong to (if they ' 'still exist). \n%s' % '\n'.join([str(i) for i in sorted(unused_translation_ids)])) TranslationContent.objects.filter( translation__id__in=unused_translation_ids).delete() Translation.objects.filter(id__in=unused_translation_ids).delete() # All translations must be written to the file again. # By using pgettext and contextual markers, one separate # translation per configuration and keyword is ensured. all_translations = TranslationContent.objects.exclude( text='' ).filter( Q(translation__category__isnull=False) | Q(translation__questiongroup__isnull=False) | Q(translation__key__isnull=False) | Q(translation__value__isnull=False) ).order_by( 'translation__id', 'id' ) with open(configuration_helper_file, 'w') as f: line_number = 1 for translation in all_translations: while line_number < translation.translation.id: f.write('\n') line_number += 1 f.write('pgettext("{0} {1}", {2!r})\n'.format( translation.configuration, translation.keyword, translation.text.replace('\r', '').replace('%', '%%') )) line_number += 1 self.call_parent_makemessages(*args, **options) # Remove temporary file. os.unlink(configuration_helper_file) do_upload_to_transifex = input('Do you want to push the new ' 'translations to transifex? (y/n)') if do_upload_to_transifex == 'y': subprocess.call('tx push -s -t', shell=True)
def post(self, request, *args, **kwargs): """ Update a Questionnaire by its identifier for API v2. Returns the identifier of the updated Questionnaire. The POST data must only contain questiongroup keywords and its values ``configuration``: The code of the configuration (e.g. "technologies"). ``edition``: The edition of the configuration (e.g. "2018"). ``identifier``: The identifier / code of the questionnaire (e.g. technologies_0123). """ if not request.data: # No data passed. return Response({'detail': 'No questionnaire data.'}, status=status.HTTP_400_BAD_REQUEST) # Parse the configuration code, edition and idenfiier request_code = kwargs['configuration'] request_edition = kwargs['edition'] request_identifier = kwargs['identifier'] # Validate configuration exists for code and edition structure_obj = ConfigurationStructure( code=request_code, edition=request_edition, ) if structure_obj.error: # No configuration found for this code and edition. return Response( { 'detail': 'No configuration found for this configuration code and edition.' }, status=status.HTTP_400_BAD_REQUEST) # APIEditRequest corresponding to POST, when the user made the GET, must exist if not APIEditRequests.with_status.is_active(code=request_identifier, for_user=request.user): # No matching edit request, edit is rejected return Response( { 'detail': 'Must fetch questionnaire data before submitting edits.' }, status=status.HTTP_405_METHOD_NOT_ALLOWED) # Fetch all questionnaire versions for the identifier questionnaire_all = get_list_or_404( Questionnaire.with_status.not_deleted(), code=request_identifier) # questionnaire = Questionnaire.with_status.not_deleted().filter(code=request_identifier).latest('version') # Use the latest version of the questionnaire if more than one version exists questionnaire = sorted(questionnaire_all, key=lambda x: x.version, reverse=True)[0] if questionnaire is None: # No questionnaire exists or is deleted # - this is a redundant check... raise Http404() # Fetch a the configuration request_config = get_configuration(code=request_code, edition=request_edition) # Questionnaires can only be created for the latest edition if request_config.has_new_edition: # Newer edition found for this code err = str( 'A newer edition exists for {}. Questionnaires can be published only for the latest edition.' .format(request_code)) return Response({'detail': err}, status=status.HTTP_406_NOT_ACCEPTABLE) # Check configuration matches if questionnaire.configuration_object != request_config: # Configuration mismatch return Response( { 'detail': 'Questionnaire does not match configuration code and edition.' }, status=status.HTTP_400_BAD_REQUEST) # Get request user's role in this questionnaire request_user_role = '' for user_role, user in questionnaire.get_users(): if user == request.user: request_user_role = user_role break if not request_user_role: # User has no role on this questionnaire return Response({'detail': 'Unauthorized.'}, status=status.HTTP_401_UNAUTHORIZED) # Check the questionnaire status, allow access only when DRAFT/PUBLIC if questionnaire.status not in (settings.QUESTIONNAIRE_DRAFT, settings.QUESTIONNAIRE_PUBLIC): # Questionnaire is not editable return Response({'detail': 'Not editable.'}, status=status.HTTP_405_METHOD_NOT_ALLOWED) # Get the EditRequest created for the GET request questionnaire_edit_request = get_object_or_404( APIEditRequests.with_status.is_active(code=request_identifier, for_user=request.user)) # An active request found from the user # - Validate the version and timestamps if not questionnaire_edit_request.questionnaire_version == questionnaire.version: # Newer questionnaire version exists, user has to GET again return Response( {'detail': 'Newer Questionnaire version available.'}, status=status.HTTP_405_METHOD_NOT_ALLOWED) if not questionnaire_edit_request.access > questionnaire.updated: # Questionnaire updated, user has to GET again return Response( {'detail': 'Questionnaire updated since edit started.'}, status=status.HTTP_405_METHOD_NOT_ALLOWED) # Validate the questionnaire edit data cleaned_data, config_errors = validate_questionnaire_data( request.data, request_config) if config_errors: # Questionnaire data does not fit configuration structure. return Response({'detail': config_errors}, status=status.HTTP_400_BAD_REQUEST) if not compare_questionnaire_data(cleaned_data, questionnaire.data): # No changes to Questionnaire data return Response({'detail': "No changes detected."}, status=status.HTTP_400_BAD_REQUEST) # Validate the questionnaire edit data using the serializer serializer = self.get_serializer(data={'data': cleaned_data}) if serializer.is_valid(): # Edit Request is set to complete questionnaire_edit_request.close_request(is_edit_complete=True) # If the questionnaire status is public, we create a new draft version if questionnaire.status == settings.QUESTIONNAIRE_PUBLIC: new_questionnaire = Questionnaire.create_new( configuration_code=questionnaire.configuration.code, data=questionnaire.data, user=self.request.user, previous_version=questionnaire) # Also add previous links to new questionnaire. for linked_questionnaire in questionnaire.links.all(): new_questionnaire.add_link(linked_questionnaire) # 'Draft' Questionnaire data is updated new_questionnaire.update_data( serializer.data['data'], timezone.now(), new_questionnaire.configuration.code) return Response( { 'success': "true", 'code': new_questionnaire.code }, status=status.HTTP_200_OK) # If the questionnaire is a draft version, we accept the edits if questionnaire.status == settings.QUESTIONNAIRE_DRAFT: # Questionnaire data is updated questionnaire.update_data(serializer.data['data'], timezone.now(), questionnaire.configuration.code) return Response({ 'success': "true", 'code': questionnaire.code }, status=status.HTTP_200_OK) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_does_not_set_cache_if_found(self, mock_cache): mock_cache.get.return_value = 'bar' get_configuration('foo', 'edition_2015') self.assertEqual(mock_cache.set.call_count, 0)
def configuration_object(self): return get_configuration(code=self.configuration.code, edition=self.configuration.edition)
def configuration_object(self): return get_configuration( code=self.configuration.code, edition=self.configuration.edition )
def handle(self, **options): languages = dict(settings.LANGUAGES).keys() for configuration in Configuration.objects.all(): for language in languages: activate(language) get_configuration(configuration.code, configuration.edition)
def handle(self, *args, **options): self.only_on_develop() # Pull latest translations from transifex - unless specified otherwise. if not options.get('do_create_only'): print('Pulling latest from transifex') subprocess.call('tx pull --mode=developer{}'.format( ' -f' if options.get('do_force_pull') else ' '), shell=True) print('Compiling latest po files') call_command('compilemessages') configuration_helper_file = os.path.join( 'apps', 'configuration', 'configuration_translations.py') # Get a list of all used Translations by all configurations. This can # then be used to remove unused translations. used_translation_ids = [] for configuration in Configuration.objects.all(): questionnaire_configuration = get_configuration( code=configuration.code, edition=configuration.edition) used_translation_ids.extend( questionnaire_configuration.get_translation_ids()) # Remove duplicates used_translation_ids = set(used_translation_ids) # It is not enough to check for new 'Translation' rows as new # configuration editions can update only the translation for the new # edition which creates a new entry in the existing 'Translation' data # json. # Instead, first get all existing content of TranslationContent, group # it by configuration and keyword. Then extract all entries in the # 'Translation' table and see if they are already available in the # 'TranslationContent' table. If not, create them later. existing_translation_content = {} for existing in TranslationContent.objects.all(): (existing_translation_content.setdefault( existing.configuration, {}).setdefault(existing.keyword, []).append(existing.text)) unused_translation_ids = [] for translation in Translation.objects.all(): if translation.id not in used_translation_ids: unused_translation_ids.append(translation.id) continue for configuration, contents in translation.data.items(): for keyword, translated_items in contents.items(): # Only English texts are expected. If 'en' is not available, # this must raise an exception. translation_string = translated_items['en'] if translation_string in existing_translation_content.get( configuration, {}).get(keyword, []): # String already in TranslationContent, do nothing. continue # Add new strings to TranslationContent TranslationContent(translation=translation, configuration=configuration, keyword=keyword, text=translation_string).save() if len(translated_items.keys()) != 1: print(u'Warning: More than one translation in the' u'fixtures. Only the English text is used.') if unused_translation_ids: print( 'The following translations are not needed anymore. They will ' 'be deleted. You should also remove these from the fixtures, ' 'along with the keys/values/categories they belong to (if they ' 'still exist). \n%s' % '\n'.join([str(i) for i in sorted(unused_translation_ids)])) TranslationContent.objects.filter( translation__id__in=unused_translation_ids).delete() Translation.objects.filter(id__in=unused_translation_ids).delete() # All translations must be written to the file again. # By using pgettext and contextual markers, one separate # translation per configuration and keyword is ensured. all_translations = TranslationContent.objects.exclude(text='').filter( Q(translation__category__isnull=False) | Q(translation__questiongroup__isnull=False) | Q(translation__key__isnull=False) | Q(translation__value__isnull=False)).order_by( 'translation__id', 'id') with open(configuration_helper_file, 'w') as f: line_number = 1 for translation in all_translations: while line_number < translation.translation.id: f.write('\n') line_number += 1 f.write('pgettext("{0} {1}", {2!r})\n'.format( translation.configuration, translation.keyword, translation.text.replace('\r', '').replace('%', '%%'))) line_number += 1 self.call_parent_makemessages(*args, **options) # Remove temporary file. os.unlink(configuration_helper_file) do_upload_to_transifex = input('Do you want to push the new ' 'translations to transifex? (y/n)') if do_upload_to_transifex == 'y': subprocess.call('tx push -s -t', shell=True)
def test_returns_cache_if_found(self, mock_cache): mock_cache.get.return_value = 'bar' ret = get_configuration('foo', 'edition_2015') self.assertEqual(ret, 'bar')