private async Task GetLanguageForEditSuccessed(GetLanguageForEditOutput output)
        {
            Flags         = new ObservableCollection <ComboboxItemDto>(output.Flags);
            LanguageNames = new ObservableCollection <ComboboxItemDto>(output.LanguageNames);

            if (output.Language != null)
            {
                language.Id   = output.Language.Id;
                language.Name = output.Language.Name;
                language.Icon = output.Language.Icon;
                IsEnabled     = output.Language.IsEnabled;

                var f = Flags.FirstOrDefault(t => t.Value.Equals(language.Icon));
                if (f != null)
                {
                    SelectedFlag = f;
                }

                var l = LanguageNames.FirstOrDefault(t => t.Value.Equals(language.Name));
                if (l != null)
                {
                    SelectedLanguage = l;
                }
            }
            else
            {
                SelectedFlag     = Flags.First();
                SelectedLanguage = LanguageNames.First();
            }

            await Task.CompletedTask;
        }
        public async Task <GetLanguageForEditOutput> GetLanguageForEdit(NullableIdDto input)
        {
            ApplicationLanguage language = null;

            if (input.Id.HasValue)
            {
                language = await _languageRepository.GetAsync(input.Id.Value);
            }

            var output = new GetLanguageForEditOutput();

            //Language
            output.Language = language != null?ObjectMapper.Map <LanguageEditDto>(language) : new LanguageEditDto();

            //Language names
            output.LanguageNames = CultureHelper
                                   .Cultures
                                   .Select(c => new ComboboxItemDto(c.Name, $"{c.EnglishName} ({c.Name})")
            {
                IsSelected = output.Language.Name == c.Name
            })
                                   .ToList();

            //Flags
            output.Flags = FlagsHelper.GetFlags(output.Language?.Icon);


            return(output);
        }
        public async Task Create_Language()
        {
            //Act
            GetLanguageForEditOutput output = await _languageAppService.GetLanguageForEdit(new NullableIdDto(null));

            //Assert
            output.Language.Id.ShouldBeNull();
            output.LanguageNames.Count.ShouldBeGreaterThan(0);
            output.Flags.Count.ShouldBeGreaterThan(0);

            //Arrange
            System.Collections.Generic.IReadOnlyList <ApplicationLanguage> currentLanguages = await _languageManager.GetLanguagesAsync(AbpSession.TenantId);

            System.Collections.Generic.List <ComboboxItemDto> nonRegisteredLanguages = output.LanguageNames.Where(l => currentLanguages.All(cl => cl.Name != l.Value)).ToList();

            //Act
            string newLanguageName = nonRegisteredLanguages[RandomHelper.GetRandom(nonRegisteredLanguages.Count)].Value;
            await _languageAppService.CreateOrUpdateLanguage(
                new CreateOrUpdateLanguageInput
            {
                Language = new ApplicationLanguageEditDto
                {
                    Icon = output.Flags[RandomHelper.GetRandom(output.Flags.Count)].Value,
                    Name = newLanguageName
                }
            });

            //Assert
            currentLanguages = await _languageManager.GetLanguagesAsync(AbpSession.TenantId);

            currentLanguages.Count(l => l.Name == newLanguageName).ShouldBe(1);
        }
        public async Task SetLanguageIsDisabled()
        {
            //Arrange
            System.Collections.Generic.IEnumerable <ApplicationLanguage> currentEnabledLanguages =
                (await _languageManager.GetLanguagesAsync(AbpSession.TenantId)).Where(l => !l.IsDisabled);
            ApplicationLanguage randomEnabledLanguage = RandomHelper.GetRandomOf(currentEnabledLanguages.ToArray());

            //Act
            GetLanguageForEditOutput output = await _languageAppService.GetLanguageForEdit(new NullableIdDto(null));

            //Act
            await _languageAppService.CreateOrUpdateLanguage(
                new CreateOrUpdateLanguageInput
            {
                Language = new ApplicationLanguageEditDto
                {
                    Id        = randomEnabledLanguage.Id,
                    IsEnabled = false,
                    Name      = randomEnabledLanguage.Name,
                    Icon      = output.Flags[RandomHelper.GetRandom(output.Flags.Count)].Value
                }
            });

            //Assert
            System.Collections.Generic.IReadOnlyList <ApplicationLanguage> currentLanguages = await _languageManager.GetLanguagesAsync(AbpSession.TenantId);

            currentLanguages.FirstOrDefault(l => l.Name == randomEnabledLanguage.Name).IsDisabled.ShouldBeTrue();
        }
Exemple #5
0
        public async Task <PartialViewResult> CreateOrEditModal(int?id)
        {
            ILanguageAppService languageAppService = this._languageAppService;
            NullableIdInput     nullableIdInput    = new NullableIdInput()
            {
                Id = id
            };
            GetLanguageForEditOutput languageForEdit = await languageAppService.GetLanguageForEdit(nullableIdInput);

            return(this.PartialView("_CreateOrEditModal", new CreateOrEditLanguageModalViewModel(languageForEdit)));
        }
        public async Task <GetLanguageForEditOutput> GetLanguageForEdit(NullableIdDto input)
        {
            ApplicationLanguage language = null;

            if (input.Id.HasValue)
            {
                language = await _languageRepository.GetAsync(input.Id.Value);
            }

            var output = new GetLanguageForEditOutput();

            //Language
            output.Language = language != null
                ? language.MapTo <ApplicationLanguageEditDto>()
                : new ApplicationLanguageEditDto();

            //Language names
            output.LanguageNames = CultureInfo
                                   .GetCultures(CultureTypes.AllCultures)
                                   .OrderBy(c => c.DisplayName)
                                   .Select(c => new ComboboxItemDto(c.Name, c.DisplayName + " (" + c.Name + ")")
            {
                IsSelected = output.Language.Name == c.Name
            })
                                   .ToList();

            //Flags
            output.Flags = FamFamFamFlagsHelper
                           .FlagClassNames
                           .OrderBy(f => f)
                           .Select(f => new ComboboxItemDto(f, FamFamFamFlagsHelper.GetCountryCode(f))
            {
                IsSelected = output.Language.Icon == f
            })
                           .ToList();

            return(output);
        }
Exemple #7
0
        public async Task <GetLanguageForEditOutput> GetLanguageForEdit(NullableIdInput input)
        {
            ApplicationLanguageEditDto applicationLanguageEditDto;
            ApplicationLanguage        async = null;

            if (input.Id.HasValue)
            {
                IRepository <ApplicationLanguage> repository = this._languageRepository;
                async = await repository.GetAsync(input.Id.Value);
            }
            GetLanguageForEditOutput getLanguageForEditOutput  = new GetLanguageForEditOutput();
            GetLanguageForEditOutput getLanguageForEditOutput1 = getLanguageForEditOutput;

            applicationLanguageEditDto         = (async != null ? async.MapTo <ApplicationLanguageEditDto>() : new ApplicationLanguageEditDto());
            getLanguageForEditOutput1.Language = applicationLanguageEditDto;
            GetLanguageForEditOutput list = getLanguageForEditOutput;

            CultureInfo[] cultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
            list.LanguageNames = (
                from c in (IEnumerable <CultureInfo>) cultures
                orderby c.DisplayName
                select new ComboboxItemDto(c.Name, string.Concat(c.DisplayName, " (", c.Name, ")"))
            {
                IsSelected = getLanguageForEditOutput.Language.Name == c.Name
            }).ToList <ComboboxItemDto>();
            GetLanguageForEditOutput list1          = getLanguageForEditOutput;
            List <string>            flagClassNames = FamFamFamFlagsHelper.FlagClassNames;

            list1.Flags = (
                from f in flagClassNames
                orderby f
                select new ComboboxItemDto(f, FamFamFamFlagsHelper.GetCountryCode(f))
            {
                IsSelected = getLanguageForEditOutput.Language.Icon == f
            }).ToList <ComboboxItemDto>();
            return(getLanguageForEditOutput);
        }
 public CreateOrEditLanguageModalViewModel(GetLanguageForEditOutput output)
 {
     output.MapTo(this);
 }