public async Task <bool> GetLanguagesSupported()
{
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", GetTwitterAuthHeader(_config["TwitterService:Languages"]));
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/x-www-form-urlencoded");
var result = await httpClient.GetAsync(_config["TwitterService:Languages"]);
var response = await result.Content.ReadAsStringAsync();
if (result.StatusCode == HttpStatusCode.OK)
{
var languages = JsonConvert.DeserializeObject <IEnumerable <LanguageDTO> >(response);
foreach (var lang in languages)
{
var map = _mapper.Map <LanguageDTO, Language>(lang);
map.SetId(Guid.NewGuid());
if (_languageRepository.GetByCode(map.Code) == null)
{
_languageRepository.Add(map);
}
}
return(true);
}
}
return(false);
}
/// <summary>
/// Add a language to the system
/// </summary>
/// <param name="languageViewModel"></param>
public void CreateLanguage(LanguageViewModel languageViewModel)
{
var language = languageViewModel.ConvertToLanguageModel();
_languageRepository.Add(language);
_languageRepository.SaveChanges();
}
public IActionResult Add(Language data)
{
var result = new ResultModel <Language>();
try
{
_ILanguage.Add(data);
if (_ILanguage.Save() > 0)
{
result.listModel = loadData();
result.status = true;
result.mess = "Thành công";
return(PartialView("_LanguageTable", result));
}
else
{
result.status = false;
result.mess = "Thất bại";
}
return(Json(result));
}
catch (Exception ex)
{
result.status = false;
result.mess = ex.ToString();
return(Json(result));
}
}
/// <summary>
/// Loads language data to repository from CSV
/// </summary>
/// <param name="file"></param>
/// <param name="languageRepository"></param>
private void LoadLanguagesFromCSV(string file, ILanguageRepository languageRepository)
{
if (!File.Exists(file))
{
return;
}
List <Language> languages = new List <Language>();
using (StreamReader reader = new StreamReader(file))
{
Char delimiter = (Char)9;
int rowCount = 0;
while (!reader.EndOfStream)
{
rowCount++;
if (rowCount > 1) // Ignore header
{
string[] values = reader.ReadLine().Split(delimiter);
Language language = new Language()
{
Alpha3b = values[0].Trim().ToUpper(),
Alpha2 = values[1].Trim().ToUpper(),
Description = values[2].Trim()
};
languages.Add(language);
}
}
reader.Close();
}
// Save
languages.ForEach(language => languageRepository.Add(language));
}
public Language Update(Language language)
{
Language updatedLanguage = null;
updatedLanguage = language.Id == 0 ? _languageRepository.Add(language) : _languageRepository.Update(language);
return(updatedLanguage);
}
public ActionResult Create([Bind(Include = "LanguageId,Name,Communication,Presentation,Reading,Listening,Writing,PersonId")] Language language)
{
if (ModelState.IsValid)
{
_languageRepository.Add(language);
_languageRepository.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.PersonId = new SelectList(_personRepository.All, "PersonId", "Firstname", language.PersonId);
return(View(language));
}
private async Task <Language> GetOrCreateLanguageAsync(CreateBookCommand request, CancellationToken cancellationToken)
{
var language = request.LanguageName is not null
? await _languageRepository.FindByNameAsync(request.LanguageName) ??
_languageRepository.Add(new Language(request.LanguageName))
: null;
await _languageRepository.UnitOfWork.SaveChangesAsync(cancellationToken);
return(language);
}
/// <summary>
/// Add a new language
/// </summary>
/// <param name="language"></param>
/// <returns></returns>
public int AddLanguage(LanguageDomain language)
{
ValidateLanguageModel(language);
//Check if code exists
var languageWithProvidedCode = _languageRepository.GetByISOCode(language.IsoCode.SafeTrim());
if (languageWithProvidedCode != null)
{
throw new NsiArgumentException(MembershipMessages.LanguageISOCodeAlreadyExists, Common.Enumerations.SeverityEnum.Warning);
}
return(_languageRepository.Add(language));
}
public async Task <IActionResult> PostLanguage([FromBody] LanguageViewModel source)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (await _languageRepository.Exists(source.Name))
{
return(BadRequest(new { errors = "Already Exists" }));
}
var result = await _languageRepository.Add(new Language { Name = source.Name, IsActive = source.IsActive });
return(CreatedAtAction("getLanguage", new { id = result.LanguageId }, source));
}
public Language Add(Language language)
{
_logger.LogInfoCreateMethodStarted <Language>(LanguageRepositoryType, nameof(Add), new object[] { language });
if (language is null)
{
_logger.LogWarningCreateMethodNullData <Language>(LanguageRepositoryType, nameof(Add));
}
var result = _languageRepository.Add(language);
_logger.LogInfoCreateMethodEnded(LanguageRepositoryType, nameof(Add), result);
return(result);
}
public async Task <IActionResult> Create([FromBody] LanguageModel item)
{
if (item.LanguageId == 0)
{
await _repository.Add(item);
return(CreatedAtRoute("GetLanguage", new { Controller = "Language", id = item.LanguageId }, item));
}
else
{
if (item.LanguageId > 0)
{
await _repository.Update(item);
}
}
return(BadRequest());
}
public bool AddOrUpdate(Language entity)
{
try
{
if (entity.Id > 0)
{
_languageRepository.Update(entity);
}
else
{
_languageRepository.Add(entity);
}
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public async Task <IResult> Handle(CreateLanguageCommand request, CancellationToken cancellationToken)
{
var isThereLanguageRecord = _languageRepository.Query().Any(u => u.Name == request.Name);
if (isThereLanguageRecord)
{
return(new ErrorResult(Messages.NameAlreadyExist));
}
var addedLanguage = new Language
{
Name = request.Name,
Code = request.Code,
};
_languageRepository.Add(addedLanguage);
await _languageRepository.SaveChangesAsync();
return(new SuccessResult(Messages.Added));
}
/// <summary>
/// Saves the model
/// </summary>
/// <returns></returns>
private async Task SaveModel()
{
if (_updatingPage)
{
await _langRepo.UpdateAsync(LanguageModel);
await _langRepo.SaveChangesAsync();
TriggerSaveEvent();
}
else
{
_langRepo.Add(LanguageModel);
await _langRepo.SaveChangesAsync();
var window = (NavigationWindow)GetParentWindow();
window.ResetAllUserControls("ccLanguageOverview");
TriggerSaveEvent();
}
}
public async Task <IActionResult> ExecuteAsync(SaveLanguage saveLanguage, CancellationToken cancellationToken)
{
var listLanguage = await _languageRepository.GetAll(cancellationToken);
var count = listLanguage.SingleOrDefault(x => x.Code == saveLanguage.Code);
if (count != null)
{
return(new ConflictResult());
}
var language = _saveLanguageToLanguageMapper.Map(saveLanguage);
//// add created by
//var user = _httpContextAccessor.HttpContext.User;
//if (user == null)
// return new NotFoundResult();
//var claims = user.Claims.ToList();
//if (claims.Count < 1)
// return new NotFoundResult();
//var userId = claims.FirstOrDefault(claimRecord => claimRecord.Type == "sub").Value;
//if (language.CreatedBy == null)
// language.CreatedBy = userId;
//language.ModifiedBy = userId;
//// end created by
language = await _languageRepository.Add(language, cancellationToken);
if (language.IsDefault == true)
{
language = await _languageRepository.UpdateDefault(language, cancellationToken);
}
var languageViewModel = _languageToLanguageMapper.Map(language);
return(new CreatedAtRouteResult(LanguagesControllerRoute.GetLanguage, new { id = languageViewModel.Id },
languageViewModel));
}
public bool Add(LanguageCreateModel entity)
{
int cultureId;
int.TryParse(entity.CultureId, out cultureId);
if (cultureId > 0)
{
if (!Exists(cultureId, entity.CountryId))
{
try
{
CultureInfo cultureInfo = new CultureInfo(cultureId);
Language language = new Language
{
CultureId = cultureId,
LanguageName = cultureInfo.DisplayName,
LanguageShortName = cultureInfo.Name,
CountryId = entity.CountryId
};
return(_repository.Add(language));
}
catch (Exception ex)
{
throw ex;
}
}
else
{
throw new Exception(LOCALIZATION_LANGUAGE_ALREADY_ADDED);
}
}
else
{
throw new Exception(LOCALIZATION_LANGUAGE_CULTURE_MISSING);
}
}
public async Task Add(Language value)
{
await _languageRepository.Add(value);
_cache.Clear();
}
public void Add(Language language)
{
_languageRepository.Add(language);
}
public Language Add(Language model)
{
_languageRepository.Add(model);
return(model);
}
public void CreateLanguage(LanguageModel model)
{
_languageRepository.Add(model.ToEntity());
}
public void CreateLanguage(Domain.Entities.Language.Language language)
{
_languageRepository.Add(language);
}
public Language Add(Language _model)
{
return(_Repository.Add(_model));
}
public IActionResult AddLanguage([FromBody] Language model)
{
Lang_repo.Add(model);
return(new OkObjectResult(new { LanguageID = model.LanguageId }));
}
public void Create(Language language)
{
_languageRepository.Add(language);
}
public void AddLanguage(Models.LanguageModel model)
{
// Узнать как лучше проверять на подобность
_languageRepository.Add(model.ToEntity());
}
public async Task AddToDb(Language Language)
{
await _languageRepository.Add(Language);
}
