public async Task <ResponseApi> Handle(UpdateListLanguagesCommand request, CancellationToken cancellationToken)
{
try
{
int invalidQty = 0;
foreach (var language in request.Languages)
{
language.Validate();
if (language.Invalid)
{
invalidQty += 1;
}
if (invalidQty > 0)
{
return(new ResponseApi(false, "Something is wrong...", language.Notifications));
}
}
List <LanguageViewModel> result = new List <LanguageViewModel>();
for (int i = 0; i < request.Languages.Count; i++)
{
Language language = _mapper.Map <Language>(await _languageRepository.Get(request.Languages[i].Id));
language.UpdateFields(_mapper.Map <Language>(request.Languages[i]));
await _languageRepository.Update(language);
var updateResult = new LanguageViewModel
{
Id = language.Id,
LanguageName = language.LanguageName,
LanguageUnderstanding = language.LanguageUnderstanding,
LanguageWriting = language.LanguageWriting,
LanguageSpeaking = language.LanguageSpeaking,
Active = language.Active,
Excluded = language.Excluded,
CreationDate = language.CreationDate,
LastUpdate = language.LastUpdate,
IdUser = language.IdUser
};
result.Add(updateResult);
}
return(new ResponseApi(true, "Competences updated sucessfuly", result));
}
catch (Exception e)
{
return(new ResponseApi(false, "Error...", e));
}
}
public void Can_Perform_Add_On_DictionaryRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
ILanguageRepository languageRepository = GetRequiredService <ILanguageRepository>();
IDictionaryRepository repository = CreateRepository();
ILanguage language = languageRepository.Get(1);
var read = new DictionaryItem("Read");
var translations = new List <IDictionaryTranslation>
{
new DictionaryTranslation(language, "Read")
};
read.Translations = translations;
// Act
repository.Save(read);
bool exists = repository.Exists(read.Id);
// Assert
Assert.That(read.HasIdentity, Is.True);
Assert.That(exists, Is.True);
}
}
/// <summary>
/// Gets a <see cref="Language"/> by its id
/// </summary>
/// <param name="id">Id of the <see cref="Language"/></param>
/// <returns><see cref="Language"/></returns>
public ILanguage GetLanguageById(int id)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
{
return(_languageRepository.Get(id));
}
}
protected override IDictionaryItem PerformGet(int id)
{
var sql = GetBaseQuery(false)
.Where(GetBaseWhereClause(), new { Id = id })
.OrderBy <DictionaryDto>(x => x.UniqueId);
var dto = Database.Fetch <DictionaryDto, LanguageTextDto, DictionaryDto>(new DictionaryLanguageTextRelator().Map, sql).FirstOrDefault();
if (dto == null)
{
return(null);
}
var factory = new DictionaryItemFactory();
var entity = factory.BuildEntity(dto);
var list = new List <IDictionaryTranslation>();
foreach (var textDto in dto.LanguageTextDtos)
{
var language = _languageRepository.Get(textDto.LanguageId);
var translationFactory = new DictionaryTranslationFactory(dto.UniqueId, language);
list.Add(translationFactory.BuildEntity(textDto));
}
entity.Translations = list;
((ICanBeDirty)entity).ResetDirtyProperties();
return(entity);
}
public async Task <IActionResult> ExecuteAsync(int languageId, SaveLanguage saveLanguage, CancellationToken cancellationToken)
{
var language = await _languageRepository.Get(languageId, cancellationToken);
if (language == null)
{
return(new NotFoundResult());
}
_saveLanguageToLanguageMapper.Map(saveLanguage, language);
//// 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;
//language.ModifiedBy = userId;
//// end created by
language = await _languageRepository.Update(language, cancellationToken);
var languageViewModel = _languageToLanguageMapper.Map(language);
return(new OkObjectResult(languageViewModel));
}
public ActionResult Change(string code)
{
if (HttpContext.Session != null)
{
var lang = _LanguageRepository.Get(code);
if (lang == null)
{
lang = _LanguageRepository.Get("en");
}
CultureInfo ci = new CultureInfo(lang.Code);
Session["Culture"] = ci;
Thread.CurrentThread.CurrentUICulture = ci;
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(ci.Name);
}
return(RedirectToAction("Index", "Blog"));
}
public async Task <IActionResult> ExecuteAsync(int languageId, CancellationToken cancellationToken)
{
var language = await _languageRepository.Get(languageId, cancellationToken);
if (language == null)
{
return(new NotFoundResult());
}
var httpContext = _actionContextAccessor.ActionContext.HttpContext;
if (httpContext.Request.Headers.TryGetValue(HeaderNames.IfModifiedSince, out var stringValues))
{
if (DateTimeOffset.TryParse(stringValues, out var modifiedSince) &&
(modifiedSince >= language.ModifiedAt))
{
return(new StatusCodeResult(StatusCodes.Status304NotModified));
}
}
var languageViewModel = _languageMapper.Map(language);
httpContext.Response.Headers.Add(HeaderNames.LastModified, language.ModifiedAt.ToString());
return(new OkObjectResult(languageViewModel));
}
public async Task <IResult> Handle(DeleteLanguageCommand request, CancellationToken cancellationToken)
{
var languageToDelete = _languageRepository.Get(p => p.Id == request.Id);
_languageRepository.Delete(languageToDelete);
await _languageRepository.SaveChangesAsync();
return(new SuccessResult(Messages.Deleted));
}
public LanguageForm(int ID)
{
InitializeComponent();
_langRepo = new LanguageRepository();
Language lang = _langRepo.Get(ID);
InitializeWindow(lang);
}
public bool Add(LocalizationCreateModel entity)
{
var language = _languageRepository.Get(entity.LanguageId);
if (language == null)
{
throw new Exception(LOCALIZATION_LOCALIZATIONCLASS_NOT_FOUND);
}
Localization localization = new Localization
{
LocalizationKey = entity.LocalizationKey,
LocalizationValue = entity.LocalizationValue,
Language = language,
CountryId = entity.CountryId
};
return(_repository.Add(localization));
}
public IActionResult Update(int id)
{
var result = new ResultModel <Language>();
try
{
var model = _ILanguage.Get(id);
if (model == null)
{
result.status = false;
result.mess = "Không tìm thấy đối tượng";
return(Json(result));
}
else
{
return(PartialView("_LanguageUpdate", model));
}
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> ExecuteAsync(
int languageId,
JsonPatchDocument <SaveLanguage> patch,
CancellationToken cancellationToken)
{
var language = await _languageRepository.Get(languageId, cancellationToken);
if (language == null)
{
return(new NotFoundResult());
}
var saveLanguage = _languageToSaveLanguageMapper.Map(language);
//// 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;
//language.ModifiedBy = userId;
//// end created by
var modelState = _actionContextAccessor.ActionContext.ModelState;
patch.ApplyTo(saveLanguage, modelState);
_objectModelValidator.Validate(
_actionContextAccessor.ActionContext,
validationState: null,
prefix: null,
model: saveLanguage);
if (!modelState.IsValid)
{
return(new BadRequestObjectResult(modelState));
}
_saveLanguageToLanguageMapper.Map(saveLanguage, language);
await _languageRepository.Update(language, cancellationToken);
var languageViewModel = _languageToLanguageMapper.Map(language);
return(new OkObjectResult(languageViewModel));
}
public Language GetLanguageById(int Id)
{
return(_languageRepository.Get(Id));
}
public IDataResult <LanguageDto> GetLanguageByCode(string languageCode)
{
var language = _languageRepository.Get(x => x.LanguageCode == languageCode);
return(new SuccessDataResult <LanguageDto>(Messages.SuccessOperation, _mapper.Map <LanguageDto>(language)));
}
public IEnumerable <Language> Get()
{
return(_repository.Get().Select(c => c.ToClient()));
}
public IActionResult Get()
{
return(Ok(_repository.Get()));
}
public async Task <RLanguage[]> Get()
{
return(await _languageRepository.Get());
}
public Language Get(int entityId)
{
return(_languageRepository.Get(entityId));
}
