public IActionResult UpdateLanguage([FromBody] Language language)
        {
            var lang          = Request.Headers["language"].ToString();
            var errorMessages = new List <string>();

            try
            {
                var l = _languageRepository.FindById(language.Id);
                if (l == null)
                {
                    return(NotFound());
                }

                l.Name_EN    = language.Name_EN;
                l.Name_FR    = !string.IsNullOrEmpty(language.Name_FR) ? language.Name_FR : language.Name_EN;
                l.LevelRead  = language.LevelRead;
                l.LevelWrite = language.LevelWrite;
                l.LevelSpeak = language.LevelSpeak;

                var updatedLanguage = _languageRepository.Update(l);

                return(Ok(new { updatedLanguage }));
            }
            catch
            {
                errorMessages.Add(_translator.GetTranslation("ERROR", lang));
                return(BadRequest(new { errors = errorMessages }));
            }
        }
        public async Task <LanguageResponse> GetByIdAsync(int id)
        {
            var existingLanguage = await _languageRepository.FindById(id);

            if (existingLanguage == null)
            {
                return(new LanguageResponse("Language not found"));
            }
            return(new LanguageResponse(existingLanguage));
        }
Example #3
0
 public Language FindById(Guid id)
 {
     return(_cache.GetItem(() =>
     {
         return _languageRepository.FindById(id);
     }, id.ToString()));
 }
Example #4
0
        private void AppendCapturedStylesForNestedLanguage(Capture regexCapture,
                                                           int offset,
                                                           string nestedLanguageId,
                                                           ICollection <Scope> capturedStyles)
        {
            ILanguage nestedLanguage = languageRepository.FindById(nestedLanguageId);

            if (nestedLanguage == null)
            {
                throw new InvalidOperationException("The nested language was not found in the language repository.");
            }
            else
            {
                CompiledLanguage nestedCompiledLanguage = languageCompiler.Compile(nestedLanguage);

                Match regexMatch = nestedCompiledLanguage.Regex.Match(regexCapture.Value, 0, regexCapture.Value.Length);

                if (!regexMatch.Success)
                {
                    return;
                }
                else
                {
                    while (regexMatch.Success)
                    {
                        List <Scope> capturedStylesForMatchedFragment = GetCapturedStyles(regexMatch,
                                                                                          0,
                                                                                          nestedCompiledLanguage);
                        List <Scope> capturedStyleTree = CreateCapturedStyleTree(capturedStylesForMatchedFragment);

                        foreach (var nestedCapturedStyle in capturedStyleTree)
                        {
                            IncreaseCapturedStyleIndicies(capturedStyleTree, offset);
                            capturedStyles.Add(nestedCapturedStyle);
                        }

                        regexMatch = regexMatch.NextMatch();
                    }
                }
            }
        }
 public Language FindById(Guid id)
 {
     return(_languageRepository.FindById(id));
 }
Example #6
0
 public Language FindById(int?id)
 {
     return(languageRepo.FindById(id));
 }