/// <summary>
/// Deletes a <see cref="ILanguage" /> by removing it (but not its usages) from the db
/// </summary>
/// <param name="language"><see cref="ILanguage" /> to delete</param>
/// <param name="userId">Optional id of the user deleting the language</param>
public void Delete(ILanguage language, int userId = Constants.Security.SuperUserId)
{
using (ICoreScope scope = ScopeProvider.CreateCoreScope())
{
// write-lock languages to guard against race conds when dealing with default language
scope.WriteLock(Constants.Locks.Languages);
EventMessages eventMessages = EventMessagesFactory.Get();
var deletingLanguageNotification = new LanguageDeletingNotification(language, eventMessages);
if (scope.Notifications.PublishCancelable(deletingLanguageNotification))
{
scope.Complete();
return;
}
// NOTE: Other than the fall-back language, there aren't any other constraints in the db, so possible references aren't deleted
_languageRepository.Delete(language);
scope.Notifications.Publish(
new LanguageDeletedNotification(language, eventMessages).WithStateFrom(deletingLanguageNotification));
Audit(AuditType.Delete, "Delete Language", userId, language.Id, UmbracoObjectTypes.Language.GetName());
scope.Complete();
}
}
/// <summary>
/// Deletes a language
/// </summary>
/// <param name="language">Language</param>
public virtual void DeleteLanguage(Language language)
{
if (language == null)
{
throw new ArgumentNullException("language");
}
LocalizationSettings _localizationSettings = _settingService.LoadSetting <LocalizationSettings>(_storeContext.CurrentStore.Id);
//update default admin area language (if required)
if (_localizationSettings.DefaultAdminLanguageId == language.Id)
{
foreach (var activeLanguage in GetAllLanguages())
{
if (activeLanguage.Id != language.Id)
{
_localizationSettings.DefaultAdminLanguageId = activeLanguage.Id;
_settingService.SaveSetting(_localizationSettings);
break;
}
}
}
_languageRepository.Delete(language);
//cache
_cacheManager.GetCache(CACHE_NAME_LANUAGE).Clear();
//event notification
// _eventPublisher.EntityDeleted(language);
}
public async Task <LanguageDeleteResponse> DeleteLanguage(LanguageDeleteRequest request)
{
var response = new LanguageDeleteResponse();
var currentUser = _cacheManager.GetCachedUser(request.CurrentUserId);
if (!currentUser.IsSuperAdmin)
{
response.SetInvalid();
return(response);
}
var language = await _languageRepository.Select(x => x.Uid == request.LanguageUid);
if (language.IsNotExist())
{
response.SetInvalidBecauseEntityNotFound();
return(response);
}
var result = await _languageRepository.Delete(request.CurrentUserId, language.Id);
if (result)
{
response.Status = ResponseStatus.Success;
return(response);
}
response.SetFailed();
return(response);
}
public ActionResult DeleteConfirmed(int id)
{
Language language = _languageRepository.GetById(id);
_languageRepository.Delete(language);
_languageRepository.SaveChanges();
return(RedirectToAction("Index"));
}
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));
}
/// <summary>
/// Remove the language from the system
/// </summary>
/// <param name="languageId"></param>
public void RemoveLanguage(int languageId)
{
var languageViewModel = new LanguageViewModel {
LanguageId = languageId
};
var language = languageViewModel.ConvertToLanguageModel();
_languageRepository.Delete(language);
_languageRepository.SaveChanges();
}
/// <summary>
/// Deletes the given model.
/// </summary>
/// <param name="model">The model</param>
public async Task DeleteAsync(Language model)
{
// Call hooks & delete
App.Hooks.OnBeforeDelete(model);
await _repo.Delete(model.Id).ConfigureAwait(false);
App.Hooks.OnAfterDelete(model);
// Clear cache
_cache?.Remove(CacheKey);
}
public IActionResult DeleteLanguage(long id)
{
Language a = Lang_repo.Find(id);
if (a == null)
{
return(NotFound());
}
Lang_repo.Delete(a);
return(Ok());
}
public ActionResult DeleteConform(int id)
{
try
{
Language language = _languageRepository.GetId(id);
_languageRepository.Delete(id);
_languageRepository.Save();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <ResponseApi> Handle(DeleteLanguageCommand request, CancellationToken cancellationToken)
{
try
{
Language language = _mapper.Map <Language>(await _languageRepository.Get(request.IdLanguage));
await _languageRepository.Delete(language);
return(new ResponseApi(true, "Language deleted sucessfuly", null));
}
catch (Exception e)
{
return(new ResponseApi(false, "Error...", e));
}
}
public DeleteLanguageResponse DeleteLnaguage(DeleteLanguageRequest request)
{
DeleteLanguageResponse response = new DeleteLanguageResponse();
try
{
_languageRepository.Delete(request.LanguageId);
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public ActionResult Delete(int id, string icon)
{
try
{
FileInfo fi = new FileInfo(Server.MapPath("~/Content/Products/Sayfa/" + icon));
if (fi.Exists)
{
fi.Delete();
}
_languageRepository.Delete(id);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public bool Delete(Guid id, Guid countryId)
{
try
{
if (_repository.Count(countryId) > NUMBER_OF_LANGUAGES_REQUIRED_PER_COUNTRY)
{
_repository.Delete(id);
}
else
{
_logger.LogError(LOCALIZATION_LANGUAGE_LAST);
throw new Exception(LOCALIZATION_LANGUAGE_LAST);
}
}
catch (Exception ex)
{
_logger.LogError("Exception while deleting language : {0} - {1} ", ex.StackTrace, ex.Message);
return(false);
}
return(true);
}
public IActionResult Delete(int id)
{
var language = _languageRepository.GetById(id);
if (language == null)
{
return(RedirectToAction("Index"));
}
try
{
_languageRepository.Delete(language);
_languageRepository.Save();
TempData["Message"] = "The language has been deleted successfully.";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ViewBag.Message = ex.ToString();
}
return(RedirectToAction("Index"));
}
protected async override void Delete(object sender, RoutedEventArgs e)
{
try
{
Language ToBeDeleted = ((FrameworkElement)sender).DataContext as Language;
string messageboxTitle = String.Format(LangResource.MBTitleDeleteObj, ToBeDeleted.LocalName);
string messageboxContent = String.Format(LangResource.MBContentDeleteObj, LangResource.TheLanguage.ToLower(), ToBeDeleted.LocalName);
MessageBoxManager.Yes = LangResource.Yes;
MessageBoxManager.No = LangResource.No;
MessageBoxManager.Register();
if (MessageBox.Show(messageboxContent,
messageboxTitle,
MessageBoxButton.YesNo,
MessageBoxImage.Warning)
== MessageBoxResult.Yes)
{
MessageBoxManager.Unregister();
_langRepo.Delete(ToBeDeleted);
LanguageList.Remove(ToBeDeleted);
await _langRepo.SaveChangesAsync();
BindData();
}
else
{
MessageBoxManager.Unregister();
}
}
catch (Exception)
{
throw;
}
}
public IActionResult DeleteLanguage([FromQuery] int langId)
{
var lang = Request.Headers["language"].ToString();
var errorMessages = new List <string>();
try
{
var l = _languageRepository.FindById(langId);
if (l == null)
{
return(NotFound());
}
var deletedLanguage = _languageRepository.Delete(langId);
return(Ok(new { deletedLanguageId = deletedLanguage.Id }));
}
catch
{
errorMessages.Add(_translator.GetTranslation("ERROR", lang));
return(BadRequest(new { errors = errorMessages }));
}
}
/// <summary>
/// Deletes a <see cref="ILanguage"/> by removing it (but not its usages) from the db
/// </summary>
/// <param name="language"><see cref="ILanguage"/> to delete</param>
/// <param name="userId">Optional id of the user deleting the language</param>
public void Delete(ILanguage language, int userId = 0)
{
using (var scope = ScopeProvider.CreateScope())
{
// write-lock languages to guard against race conds when dealing with default language
scope.WriteLock(Constants.Locks.Languages);
var deleteEventArgs = new DeleteEventArgs <ILanguage>(language);
if (scope.Events.DispatchCancelable(DeletingLanguage, this, deleteEventArgs))
{
scope.Complete();
return;
}
// NOTE: Other than the fall-back language, there aren't any other constraints in the db, so possible references aren't deleted
_languageRepository.Delete(language);
deleteEventArgs.CanCancel = false;
scope.Events.Dispatch(DeletedLanguage, this, deleteEventArgs);
Audit(AuditType.Delete, "Delete Language", userId, language.Id, ObjectTypes.GetName(UmbracoObjectTypes.Language));
scope.Complete();
}
}
public Language Delete(int _id)
{
return(_Repository.Delete(_id));
}
public async Task Delete(string languageKey)
{
await _languageRepository.Delete(languageKey);
_cache.Clear();
}
public void Delete(long id)
{
_languageRepository.Delete(id);
}
public void DeleteLanguage(int id)
{
_languageRepository.Delete(id);
}
public IActionResult Delete([FromBody] Language language)
{
_repository.Delete(language);
return(new JsonResult(new { delete = true }));
}
public void DeleteLanguage(long id)
{
languageRepository.Delete(x => x.Id == id);
}
public bool Delete(Language entity)
{
_languageRepository.Delete(entity);
return(true);
}
public void DeleteLanguage(Language language)
{
languageRepository.Delete(language);
}
