public async Task <IHttpActionResult> CreatePackLang(TranslatePackageModelRequest request)
        {
            var baseLangFile = HttpContext.Current.Server.MapPath("~/clientapp/languages/en-us.js");
            var folderFiles  = HttpContext.Current.Server.MapPath("~/clientapp/languages/");

            return(Ok(await _translateService.CreatePackagesLanguages(request, baseLangFile, folderFiles)));
        }
Esempio n. 2
0
        public async Task <TranslatedPackagesModel> CreatePackagesLanguages(TranslatePackageModelRequest model, string baseLangPath, string folderFile)
        {
            var languageAvailable = await _translationProvider.GetAvailableLanguagesAsync();

            TranslatedPackagesModel tranlatedPackages = new TranslatedPackagesModel();

            if (model.AllLanguages)
            {
                foreach (var language in languageAvailable.Where(x => x.Code != "en" && x.Code != "es"))
                {
                    model.Code = language.Code;
                    tranlatedPackages.translatedPackages.Add(await GenerateFile(model, baseLangPath, folderFile, language.Name));
                }
            }
            else
            {
                var languageName = languageAvailable.FirstOrDefault(x => x.Code == model.Code).Name;
                tranlatedPackages.translatedPackages.Add(await GenerateFile(model, baseLangPath, folderFile, languageName));
            }
            return(tranlatedPackages);
        }
Esempio n. 3
0
        private async Task <TranslatedPackageModel> GenerateFile(TranslatePackageModelRequest model, string baseLangPath, string folderFile, string languageName)
        {
            string langTraslated = string.Empty;
            bool   translateText = false;
            Dictionary <string, string> translateTextJson = new Dictionary <string, string>();

            var langFile = File.ReadLines(baseLangPath);

            var fileName = $"{model.Code}-{languageName}";

            foreach (var line in langFile)
            {
                if (line.Contains("Global level translations"))
                {
                    translateText = true;
                }

                if (line.Contains("});") || line.Contains("}]);"))
                {
                    translateText = false;
                }

                if (translateText)
                {
                    if (!line.Contains("//") && !line.Contains("/*") && !string.IsNullOrWhiteSpace(line))
                    {
                        try
                        {
                            string[] KeyValue = line.Split(':');
                            KeyValue[1] = CleanValue(KeyValue[1]);
                            KeyValue[0] = CleanValue(KeyValue[0]);

                            string translatedText = string.Empty;
                            string exist          = existKey(folderFile, model.Code, KeyValue[0]);
                            if (!string.IsNullOrEmpty(exist))
                            {
                                translatedText = exist;
                            }
                            else
                            {
                                var transRequest = new TranslateRequest
                                {
                                    FromLangCode    = "en",
                                    ToLangCode      = model.Code,
                                    TextToTranslate = KeyValue[1]
                                };
                                translatedText = await _translationProvider.TranslateAsync(transRequest);
                            }


                            //Type logic: True = Web format language package, False = Movile format language package
                            if (model.Type)
                            {
                                KeyValue[0] = '"' + KeyValue[0] + '"';
                                KeyValue[1] = '"' + translatedText + '"';
                                string KeyValueTranslated = string.Join(":", KeyValue);
                                langTraslated += $"{KeyValueTranslated}," + Environment.NewLine;
                            }
                            else
                            {
                                KeyValue[0] = KeyValue[0].Replace("'", "");
                                KeyValue[0] = KeyValue[0].Replace('"', ' ');
                                KeyValue[1] = translatedText.Replace('"', ' ');
                                KeyValue[1] = translatedText.Replace("\"", "");
                                KeyValue[1] = translatedText.Replace("'", "");
                                translateTextJson.Add(KeyValue[0], KeyValue[1]);
                            }
                        }
                        catch (Exception ex)
                        {
                            throw;
                        }
                    }
                }
                else
                {
                    var lang = line.Replace("en-us", fileName);
                    langTraslated += $"{lang}" + Environment.NewLine;
                }
            }
            if (!model.Type)
            {
                langTraslated = JsonConvert.SerializeObject(translateTextJson);
            }

            var response = new TranslatedPackageModel
            {
                FileName    = fileName,
                FileContent = langTraslated
            };

            return(response);
        }