private void CreateCultureHierarchy(IDatabaseStaticTextContext dbContext, Culture culture)
        {
            var cultureHierarchyDao = new CultureHierarchyDao(dbContext.CultureHierarchy);
            var cultureDao          = new CultureDao(dbContext.Culture);

            cultureHierarchyDao.MakeCultureSelfReferencing(culture);

            var defaultCultureName = m_configuration.DefaultCulture.Name;
            var defaultCulture     = cultureDao.FindByName(defaultCultureName);

            var cultureInfo = new CultureInfo(culture.Name);

            if (cultureInfo.IsNeutralCulture) //Just reference to default culture
            {
                cultureHierarchyDao.MakeCultureReference(culture, defaultCulture, 1);
            }
            else
            {
                var parentCultureName = cultureInfo.Parent.Name;
                var parentCulture     = cultureDao.FindByName(parentCultureName);
                if (parentCulture == null)
                {
                    cultureHierarchyDao.MakeCultureReference(culture, defaultCulture, 1);
                }
                else
                {
                    cultureHierarchyDao.MakeCultureReference(culture, parentCulture, 1);
                    cultureHierarchyDao.MakeCultureReference(culture, defaultCulture, 2);
                }
            }
        }
        private DictionaryScope CreateDictionaryScope(IDatabaseStaticTextContext dbContext, string dictionaryScopeName)
        {
            var dsDao = new DictionaryScopeDao(dbContext.DictionaryScope);

            return(dsDao.Create(new DictionaryScope()
            {
                Name = dictionaryScopeName
            }));
        }
        private Culture CreateCulture(IDatabaseStaticTextContext dbContext, string cultureName)
        {
            var cultureDao = new CultureDao(dbContext.Culture);

            return(cultureDao.Create(new Culture()
            {
                Id = 0, Name = cultureName
            }));
        }
        /// <summary>
        /// Executes an action on default culture text if it does not exist. Actions include - nothing, create empty string, copy current culture text
        /// </summary>
        /// <param name="actionForDefaultCulture">Specific action</param>
        /// <param name="dynamicText">Current dynamic text entity</param>
        /// <param name="currentCulture">Current culture entity</param>
        /// <param name="dictionaryScope">Current dictionary scope entity</param>
        /// <param name="dbContext">Database context</param>
        /// <param name="dao">DAO of static text entity</param>
        private void ExecuteDefaultCultureAction(IfDefaultNotExistAction actionForDefaultCulture,
                                                 DynamicText dynamicText, Culture currentCulture,
                                                 DictionaryScope dictionaryScope, IDatabaseStaticTextContext dbContext, StaticTextDao dao)
        {
            var defaultCulture = GetDefaultCulture(dbContext);

            if (currentCulture == defaultCulture)
            {
                return;
            }

            var defaultText = dao.FindByNameAndCultureAndScope(
                dynamicText.Name, defaultCulture, dictionaryScope, dbContext.CultureHierarchy
                );

            if (defaultText != null)
            {
                return;
            }

            defaultText = new StaticText
            {
                Format           = dynamicText.Format,
                ModificationTime = DateTime.UtcNow,
                ModificationUser = dynamicText.ModificationUser,
                Name             = dynamicText.Name,
                Culture          = defaultCulture,
                DictionaryScope  = dictionaryScope,
            };

            switch (actionForDefaultCulture)
            {
            case IfDefaultNotExistAction.DoNothing:
                return;

            case IfDefaultNotExistAction.CreateEmpty:
                defaultText.Text = string.Empty;
                dao.Create(defaultText);
                break;

            case IfDefaultNotExistAction.CreateTextCopy:
                defaultText.Text = dynamicText.Text;
                dao.Create(defaultText);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(actionForDefaultCulture), actionForDefaultCulture,
                                                      "Invalid default language save action");
            }
        }
        protected Culture GetDefaultCulture(IDatabaseStaticTextContext dbContext)
        {
            var cultureDao = new CultureDao(dbContext.Culture);

            var resultCulture = cultureDao.FindByName(m_configuration.DefaultCulture.Name);

            if (resultCulture == null)
            {
                if (m_logger.IsErrorEnabled())
                {
                    m_logger.LogError("Default culture from library configuration is not in database.");
                }
            }

            return(resultCulture);
        }
        protected DictionaryScope GetDictionaryScope(IDatabaseStaticTextContext dbContext, string scopeName)
        {
            var dictionaryScopeDao = new DictionaryScopeDao(dbContext.DictionaryScope);

            var resultDictionaryScope = dictionaryScopeDao.FindByName(scopeName);

            if (resultDictionaryScope == null)
            {
                resultDictionaryScope = dictionaryScopeDao.FindByName(m_configuration.DefaultScope);
            }
            if (resultDictionaryScope == null)
            {
                if (m_logger.IsErrorEnabled())
                {
                    m_logger.LogError(@"Default dictionary scope ""{0}"" from library configuration is not in database.", m_configuration.DefaultScope);
                }
            }

            return(resultDictionaryScope);
        }