private async Task GetOverrideKeysInternal(
            object settings,
            object model,
            int storeId,
            bool isRootModel,
            Func <string, string> propertyNameMapper,
            int?localeIndex)
        {
            if (storeId <= 0)
            {
                // Single store mode -> there are no overrides.
                return;
            }

            var data                = Data ?? new StoreDependingSettingData();
            var settingType         = settings.GetType();
            var modelType           = model.GetType();
            var settingName         = settingType.Name;
            var modelProperties     = modelType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            var localizedModelLocal = model as ILocalizedLocaleModel;

            foreach (var prop in modelProperties)
            {
                var name = propertyNameMapper?.Invoke(prop.Name) ?? prop.Name;

                var settingProperty = settingType.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);

                if (settingProperty == null)
                {
                    // Setting is not configurable or missing or whatever... however we don't need the override info.
                    continue;
                }

                string key = null;

                if (localizedModelLocal == null)
                {
                    key = settingName + "." + name;
                    if (await _settingService.GetSettingByKeyAsync <string>(key, storeId: storeId) == null)
                    {
                        key = null;
                    }
                }
                else if (localeIndex.HasValue)
                {
                    var value = await _leService.GetLocalizedValueAsync(localizedModelLocal.LanguageId, storeId, settingName, name);

                    if (!string.IsNullOrEmpty(value))
                    {
                        key = settingName + "." + "Locales[" + localeIndex.ToString() + "]." + name;
                    }
                }

                if (key != null)
                {
                    data.OverrideSettingKeys.Add(key);
                }
            }

            if (isRootModel)
            {
                data.ActiveStoreScopeConfiguration = storeId;
                data.RootSettingClass = settingName;

                _viewData[ViewDataKey] = data;
            }

            if (model is ILocalizedModel)
            {
                var localesProperty = modelType.GetProperty("Locales", BindingFlags.Public | BindingFlags.Instance);
                if (localesProperty != null)
                {
                    if (localesProperty.GetValue(model) is IEnumerable <ILocalizedLocaleModel> locales)
                    {
                        int i = 0;
                        foreach (var locale in locales)
                        {
                            await GetOverrideKeysInternal(settings, locale, storeId, false, propertyNameMapper, i);

                            i++;
                        }
                    }
                }
            }
        }
示例#2
0
        /// <summary>
        /// Get localized property of an entity
        /// </summary>
        /// <typeparam name="TEntity">Entity type</typeparam>
        /// <typeparam name="TPropType">Property type</typeparam>
        /// <param name="entity">Entity</param>
        /// <param name="keySelector">Key selector</param>
        /// <param name="languageId">Language identifier; pass null to use the current working language; pass 0 to get standard language value</param>
        /// <param name="returnDefaultValue">A value indicating whether to return default value (if localized is not found)</param>
        /// <param name="ensureTwoPublishedLanguages">A value indicating whether to ensure that we have at least two published languages; otherwise, load only default value</param>
        /// <returns>
        /// A task that represents the asynchronous operation
        /// The task result contains the localized property
        /// </returns>
        public virtual async Task <TPropType> GetLocalizedAsync <TEntity, TPropType>(TEntity entity, Expression <Func <TEntity, TPropType> > keySelector,
                                                                                     int?languageId = null, bool returnDefaultValue = true, bool ensureTwoPublishedLanguages = true)
            where TEntity : BaseEntity, ILocalizedEntity
        {
            if (entity == null)
            {
                throw new ArgumentNullException(nameof(entity));
            }

            if (keySelector.Body is not MemberExpression member)
            {
                throw new ArgumentException($"Expression '{keySelector}' refers to a method, not a property.");
            }

            if (member.Member is not PropertyInfo propInfo)
            {
                throw new ArgumentException($"Expression '{keySelector}' refers to a field, not a property.");
            }

            var result    = default(TPropType);
            var resultStr = string.Empty;

            var localeKeyGroup = entity.GetType().Name;
            var localeKey      = propInfo.Name;

            var workingLanguage = await _workContext.GetWorkingLanguageAsync();

            if (!languageId.HasValue)
            {
                languageId = workingLanguage.Id;
            }

            if (languageId > 0)
            {
                //ensure that we have at least two published languages
                var loadLocalizedValue = true;
                if (ensureTwoPublishedLanguages)
                {
                    var totalPublishedLanguages = (await _languageService.GetAllLanguagesAsync()).Count;
                    loadLocalizedValue = totalPublishedLanguages >= 2;
                }

                //localized value
                if (loadLocalizedValue)
                {
                    resultStr = await _localizedEntityService
                                .GetLocalizedValueAsync(languageId.Value, entity.Id, localeKeyGroup, localeKey);

                    if (!string.IsNullOrEmpty(resultStr))
                    {
                        result = CommonHelper.To <TPropType>(resultStr);
                    }
                }
            }

            //set default value if required
            if (!string.IsNullOrEmpty(resultStr) || !returnDefaultValue)
            {
                return(result);
            }
            var localizer = keySelector.Compile();

            result = localizer(entity);

            return(result);
        }