/// <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); }