Granting module permissions to anonymous user #621

1 Answer(s)

• 

  0

  alper created 4 years ago

  Support Team Director

  Hi,

  Use the below service to fetch the texts, Now you can fetch without any permission.

  
   public class MyLanguageAppService : LanguageAppServiceBase, IApplicationService
      {
          protected ILanguageTextRepository LanguageTextRepository { get; }
          protected IStringLocalizerFactory LocalizerFactory { get; }
          protected AbpLocalizationOptions AbpLocalizationOptions { get; }
  
          public MyLanguageAppService(
              ILanguageTextRepository languageTextRepository,
              IOptions<AbpLocalizationOptions> abpLocalizationOptions,
              IStringLocalizerFactory localizerFactory)
          {
              LanguageTextRepository = languageTextRepository;
              LocalizerFactory = localizerFactory;
              AbpLocalizationOptions = abpLocalizationOptions.Value;
          }
  
          public Task<PagedResultDto<LanguageTextDto>> GetListAsync(GetLanguagesTextsInput input)
          {
              var languageTexts = new List<LanguageTextDto>();
  
              foreach (var resourceName in GetResourceNames(input))
              {
                  languageTexts.AddRange(GetLocalizationsFromResource(input, resourceName));
              }
  
              var filteredQuery = languageTexts
                  .AsQueryable()
                  .WhereIf(
                      !input.Filter.IsNullOrWhiteSpace(),
                      l =>
                          (l.Name != null && l.Name.IndexOf(input.Filter, StringComparison.OrdinalIgnoreCase) >= 0) ||
                          (l.BaseValue != null && l.BaseValue.IndexOf(input.Filter, StringComparison.OrdinalIgnoreCase) >= 0) ||
                          (!input.GetOnlyEmptyValues && l.Value != null && l.Value.IndexOf(input.Filter, StringComparison.InvariantCultureIgnoreCase) >= 0)
                  );
  
              var languagesTextDtos = filteredQuery
                  .OrderBy(input.Sorting ?? $"{nameof(LanguageTextDto.Name)} ASC")
                  .PageBy(input)
                  .ToList();
  
              return Task.FromResult(new PagedResultDto<LanguageTextDto>(
                  filteredQuery.Count(),
                  languagesTextDtos
              ));
          }
  
          protected List<string> GetResourceNames(GetLanguagesTextsInput input)
          {
              var resourceNames = new List<string>();
  
              if (string.IsNullOrWhiteSpace(input.ResourceName))
              {
                  resourceNames.AddRange(
                      AbpLocalizationOptions
                          .Resources
                          .Values
                          .Select(l => l.ResourceName)
                  );
              }
              else
              {
                  resourceNames.Add(input.ResourceName);
              }
  
              return resourceNames;
          }
  
          protected virtual List<LanguageTextDto> GetLocalizationsFromResource(
            GetLanguagesTextsInput input,
            string resourceName)
          {
              var localizer = GetLocalizer(resourceName);
  
              List<LocalizedString> baseLocalizedStrings;
              List<LocalizedString> targetLocalizedStrings;
  
              using (CultureHelper.Use(CultureInfo.GetCultureInfo(input.BaseCultureName)))
              {
                  baseLocalizedStrings = localizer
                      .GetAllStrings(includeParentCultures: true, includeBaseLocalizers: false)
                      .ToList();
              }
  
              using (CultureHelper.Use(CultureInfo.GetCultureInfo(input.TargetCultureName)))
              {
                  targetLocalizedStrings = localizer
                      .GetAllStrings(includeParentCultures: false, includeBaseLocalizers: false)
                      .ToList();
              }
  
              var languageTextDtos = new List<LanguageTextDto>();
  
              foreach (var baseLocalizedString in baseLocalizedStrings)
              {
                  var target = targetLocalizedStrings.FirstOrDefault(l => l.Name == baseLocalizedString.Name);
  
                  if (input.GetOnlyEmptyValues)
                  {
                      if (!string.IsNullOrEmpty(target?.Value))
                      {
                          continue;
                      }
                  }
  
                  languageTextDtos.Add(
                      new LanguageTextDto
                      {
                          BaseCultureName = input.BaseCultureName,
                          CultureName = input.TargetCultureName,
                          Name = baseLocalizedString.Name,
                          BaseValue = baseLocalizedString.Value,
                          ResourceName = resourceName,
                          Value = target?.Value ?? ""
                      }
                  );
              }
  
              return languageTextDtos;
          }
  
          protected IStringLocalizer GetLocalizer(LocalizationResource resource)
          {
              return LocalizerFactory.Create(resource.ResourceType);
          }
  
          protected IStringLocalizer GetLocalizer(string recourseName)
          {
              return GetLocalizer(GetLocalizationResource(recourseName));
          }
  
          protected LocalizationResource GetLocalizationResource(string resourceName)
          {
              var resource = AbpLocalizationOptions.Resources
                  .Values
                  .FirstOrDefault(r => r.ResourceName == resourceName);
  
              if (resource == null)
              {
                  throw new AbpException($"Resource not found: {resourceName}");
              }
  
              return resource;
          }
      }
  
  

  Save Cancel