private async Task <string> GetResorces(LanguageAndCulture languageAndCulture)
        {
            var path = AuthorizeManager.AuthorizeActionOnPath(Config.ResourcesSourceCodePath, ActionKey.ReadFromDisk) + languageAndCulture.Language + ".js";


            if (await _fileSystemManager.FileExistAsync(path))
            {
                return(await _fileSystemManager.ReadAsync(path));
            }

            return("");
        }
        private void UpdateWebConfigSetting(LanguageAndCulture languageAndCulture, ActionKey action)
        {
            if ((Config.LanguageAndCultures.Exists(ln => ln == languageAndCulture.Language) && action == ActionKey.Add) ||
                (!Config.LanguageAndCultures.Exists(ln => ln == languageAndCulture.Language) && action == ActionKey.Delete))
            {
                return;
            }
            else if (!Config.LanguageAndCultures.Exists(ln => ln == languageAndCulture.Language) && action == ActionKey.Add)
            {
                Config.LanguageAndCultures.Add(languageAndCulture.Language);
                var setting = new WebConfigSetting()
                {
                    Key   = ConfigKey.LanguageAndCultures.ToString(),
                    Value = string.Join(",", Config.LanguageAndCultures),
                    InjectToJavaScript             = false,
                    Description                    = "",
                    MasterDataKeyValueId           = 0,
                    MasterDataKeyValuePropertyName = ""
                };


                var option = JsonConvert.SerializeObject(setting);
                _webConfigManager.AddOrUpdateSetting(ConfigKey.LanguageAndCultures.ToString(), string.Join(",", Config.LanguageAndCultures), option);
            }
            else if (Config.LanguageAndCultures.Exists(ln => ln == languageAndCulture.Language) && action == ActionKey.Delete)
            {
                Config.LanguageAndCultures.Remove(languageAndCulture.Language);
                var setting = new WebConfigSetting()
                {
                    Key   = ConfigKey.LanguageAndCultures.ToString(),
                    Value = string.Join(",", Config.LanguageAndCultures),
                    InjectToJavaScript             = false,
                    Description                    = "",
                    MasterDataKeyValueId           = 0,
                    MasterDataKeyValuePropertyName = ""
                };


                var option = JsonConvert.SerializeObject(setting);
                _webConfigManager.AddOrUpdateSetting(ConfigKey.LanguageAndCultures.ToString(), string.Join(",", Config.LanguageAndCultures), option);
            }
        }
 private async Task <JObject> ConvertToJsonAsync(LanguageAndCulture languageAndCulture)
 {
     return(JObject.FromObject(new
     {
         Id = languageAndCulture.Id,
         IsDefaults = languageAndCulture.IsDefaults,
         IsRightToLeft = languageAndCulture.IsRightToLeft,
         Culture = languageAndCulture.Culture,
         Country = languageAndCulture.Country,
         Language = languageAndCulture.Language,
         ViewRoleId = languageAndCulture.ViewRoleId,
         ModifyRoleId = languageAndCulture.ModifyRoleId,
         AccessRoleId = languageAndCulture.AccessRoleId,
         FlagUrl = languageAndCulture.Flag.Url,
         FlagId = languageAndCulture.FlagId,
         Status = languageAndCulture.Status,
         RowVersion = languageAndCulture.RowVersion,
         JsCode = await GetResorces(languageAndCulture)
     }));
 }
        public async Task <LanguageAndCulture> Save(JObject data)
        {
            dynamic languageAndCultureDto = data;
            int?    languageAndCultureId  = languageAndCultureDto.Id;
            var     languageAndCulture    = new LanguageAndCulture()
            {
                Id = languageAndCultureId ?? 0
            };
            bool isNew   = languageAndCultureDto.isNew;
            bool publish = languageAndCultureDto.publish;
            var  currentLanguageAndCulture = await _contentManagementContext.LanguageAndCultures.AsNoTracking().SingleOrDefaultAsync(ln => ln.Id == languageAndCulture.Id);

            if (!isNew)
            {
                if (currentLanguageAndCulture == null)
                {
                    throw new KhodkarInvalidException(LanguageManager.ToAsErrorMessage(ExceptionKey.LanguageAndCultureNotFound));
                }


                languageAndCulture            = currentLanguageAndCulture;
                languageAndCulture.RowVersion = languageAndCultureDto.RowVersion;

                _contentManagementContext.LanguageAndCultures.Attach(languageAndCulture);
            }
            else
            {
                _contentManagementContext.LanguageAndCultures.Add(languageAndCulture);
            }

            languageAndCulture.Country       = languageAndCultureDto.Country;
            languageAndCulture.Culture       = languageAndCultureDto.Culture;
            languageAndCulture.Language      = languageAndCultureDto.Language;
            languageAndCulture.FlagId        = languageAndCultureDto.FlagId;
            languageAndCulture.IsDefaults    = languageAndCultureDto.IsDefaults;
            languageAndCulture.IsRightToLeft = languageAndCultureDto.IsRightToLeft;

            //for force update and change version for force client to get new versipn of language.js
            languageAndCulture.Version = (currentLanguageAndCulture?.Version ?? 0) + 1;

            languageAndCulture.Status = languageAndCultureDto.Status;

            if (currentLanguageAndCulture != null)
            {
                languageAndCulture.ViewRoleId   = currentLanguageAndCulture.ViewRoleId;
                languageAndCulture.ModifyRoleId = currentLanguageAndCulture.ModifyRoleId;
                languageAndCulture.AccessRoleId = currentLanguageAndCulture.AccessRoleId;
            }

            AuthorizeManager.SetAndCheckModifyAndAccessRole(languageAndCulture, languageAndCultureDto);

            await _contentManagementContext.SaveChangesAsync();

            await _contentManagementContext.LanguageAndCultures.Where(lc => lc.Language == languageAndCulture.Language && lc.Id != languageAndCulture.Id)
            .UpdateAsync(t => new LanguageAndCulture()
            {
                Version = languageAndCulture.Version
            });

            string jsCode = languageAndCultureDto.JsCode;

            if (!string.IsNullOrEmpty(jsCode))
            {
                await WriteFileAsync(Config.ResourcesSourceCodePath, languageAndCulture.Language, ".js", jsCode);

                if (!publish)
                {
                    return(languageAndCulture);
                }

                await WriteFileAsync(Config.ResourcesDistPath, languageAndCulture.Language, ".js", _compressManager.CompressJavaScript(jsCode, languageAndCulture.Country));
            }
            UpdateWebConfigSetting(languageAndCulture, ActionKey.Add);



            CacheManager.Remove(CacheManager.GetBrowsersCodeInfoKey(CacheKey.BrowsersCodeInfo.ToString(),
                                                                    "~/" + languageAndCulture.Language));


            //var bundleInfo =
            //    SourceControl.BrowsersCodeInfos.FirstOrDefault(bc => bc.BundleUrl == languageAndCulture.Language);

            //if(bundleInfo != null)
            //bundleInfo.Version
            //    = Helper.UrlEncode(System.Text.Encoding.UTF8.GetString(languageAndCulture.RowVersion));

            //SourceControl.BrowsersCodeInfos.Remove(
            //    SourceControl.BrowsersCodeInfos.Find(bc => bc.BundleUrl == languageAndCulture.Language));

            return(languageAndCulture);
        }