public async Task <UpdateStatusEnum> UpdateItemAsync(UnifiedSetData unifiedSet) { UnifiedSetData origData = Auditing.Active ? await GetItemAsync(unifiedSet.UnifiedSetGuid) : null; unifiedSet.Updated = DateTime.UtcNow; if (unifiedSet.UnifiedMode == PageDefinition.UnifiedModeEnum.SkinDynamicContent) { unifiedSet.PageList = new List <string>(); } else { unifiedSet.PageSkin = new SkinDefinition(); } unifiedSet.PageGuids = await UpdatePageGuidsAsync(unifiedSet.UnifiedSetGuid, unifiedSet.PageList); UpdateStatusEnum status = await DataProvider.UpdateAsync(unifiedSet.UnifiedSetGuid, unifiedSet.UnifiedSetGuid, unifiedSet); if (status != UpdateStatusEnum.OK) { return(status); } await Auditing.AddAuditAsync($"{nameof(UnifiedSetDataProvider)}.{nameof(UpdateItemAsync)}", Dataset, Guid.Empty, $"Update UPS {unifiedSet.Name}", DataBefore : origData, DataAfter : unifiedSet ); return(status); }
public async Task <UpdateStatusEnum> UpdateItemAsync(string originalRole, RoleDefinition data) { if (data.RoleId == RoleDefinitionDataProvider.SuperUserId || data.Name == Globals.Role_Superuser) { throw new Error(this.__ResStr("cantUpdateSuper", "Can't update built-in superuser role")); } if (originalRole != data.Name && IsPredefinedRole(originalRole)) { throw new Error(this.__ResStr("cantUpdateUser", "The {0} role can't be updated", originalRole)); } if (YetaWF.Core.Support.Startup.MultiInstance) { throw new InternalError("Changing roles is not possible when distributed caching is enabled"); } RoleDefinition origRole = Auditing.Active ? await GetItemAsync(originalRole) : null; UpdateStatusEnum status = await DataProvider.UpdateAsync(originalRole, data.Name, data); if (status == UpdateStatusEnum.OK) { GetAllUserRoles(true); } await Auditing.AddAuditAsync($"{nameof(RoleDefinitionDataProvider)}.{nameof(UpdateItemAsync)}", originalRole, Guid.Empty, "Update Role", DataBefore : origRole, DataAfter : data, ExpensiveMultiInstance : true ); return(status); }
public async Task <bool> RemoveItemAsync(string role) { if (role == Globals.Role_Superuser) { throw new Error(this.__ResStr("cantRemoveSuper", "Can't remove built-in superuser role")); } if (IsPredefinedRole(role)) { throw new Error(this.__ResStr("cantRemoveUser", "The {0} role can't be removed", role)); } if (YetaWF.Core.Support.Startup.MultiInstance) { throw new InternalError("Removing roles is not possible when distributed caching is enabled"); } RoleDefinition origRole = Auditing.Active ? await GetItemAsync(role) : null; if (!await DataProvider.RemoveAsync(role)) { return(false); } GetAllUserRoles(true); await Auditing.AddAuditAsync($"{nameof(RoleDefinitionDataProvider)}.{nameof(RemoveItemAsync)}", role, Guid.Empty, "Remove Role", DataBefore : origRole, DataAfter : null, ExpensiveMultiInstance : true ); return(true); }
public async Task <bool> RemoveItemByIdentityAsync(int id) { VoiceMailData origData = Auditing.Active ? await GetItemByIdentityAsync(id) : null; if (!await DataProvider.RemoveByIdentityAsync(id)) { return(false); } await SetupClient(); try { if (YetaWFManager.IsSync()) { RecordingResource.Delete(pathSid: origData.RecordingSid); } else { await RecordingResource.DeleteAsync(pathSid : origData.RecordingSid); } } catch (Exception) { } await Auditing.AddAuditAsync($"{nameof(VoiceMailDataProvider)}.{nameof(RemoveItemByIdentityAsync)}", Dataset, Guid.Empty, $"Remove Voice Mail Entry {id}", DataBefore : origData, DataAfter : null ); return(true); }
public async Task <ActionResult> LocalizeConfig_Partial(Model model) { using (LocalizeConfigDataProvider dataProvider = new LocalizeConfigDataProvider()) { LocalizeConfigData origData = YetaWF.Core.Audit.Auditing.Active ? await dataProvider.GetItemAsync() : null; LocalizeConfigData data = await dataProvider.GetItemAsync();// get the original item if (!ModelState.IsValid) { return(PartialView(model)); } data = model.GetData(data); // merge new data into original model.SetData(data); // and all the data back into model for final display LocalizationSupport locSupport = new LocalizationSupport(); await locSupport.SetUseLocalizationResourcesAsync(model.UseLocalizationResources); await locSupport.SetAbortOnFailureAsync(model.AbortOnFailure); await dataProvider.UpdateConfigAsync(data); await Auditing.AddAuditAsync($"{nameof(LocalizeConfigModuleController)}.{nameof(LocalizeConfig)}", null, Guid.Empty, $"Localization", DataBefore : origData, DataAfter : data, RequiresRestart : true ); } return(FormProcessed(model, this.__ResStr("okSaved", "Localization settings saved - These settings won't take effect until the site is restarted"))); }
private async Task <PageDefinition> CreatePageDefinitionAsync(PageDefinition page) { using (ILockObject lockObject = await LockDesignedPagesAsync()) { PageDefinition.DesignedPage desPage = new PageDefinition.DesignedPage() { PageGuid = page.PageGuid, Url = page.Url, }; DesignedPagesDictionaryByUrl designedPagesByUrl = await GetDesignedPagesWithoutLockAsync(); if (designedPagesByUrl.ContainsKey(desPage.Url.ToLower())) { throw new Error(this.__ResStr("pageUrlErr", "A page with Url {0} already exists.", desPage.Url)); } if (!await DataProvider.AddAsync(page)) { throw new Error(this.__ResStr("pageGuidErr", "A page with Guid {0} already exists.", desPage.PageGuid)); } await SetCachedPageAsync(page); await AddDesignedPageAsync(designedPagesByUrl, page.Url.ToLower(), desPage); await lockObject.UnlockAsync(); } await Auditing.AddAuditAsync($"{nameof(PageDefinitionDataProvider)}.{nameof(CreatePageDefinitionAsync)}", page.Url, page.PageGuid, "Create Page", DataBefore : null, DataAfter : page, ExpensiveMultiInstance : true ); return(page); }
public async Task <bool> RemovePageDefinitionAsync(Guid pageGuid) { PageDefinition page; using (ILockObject lockObject = await LockDesignedPagesAsync()) { page = await LoadPageDefinitionAsync(pageGuid); if (page == null) { return(false); } await Manager.StaticPageManager.RemovePageAsync(page.Url); await DataProvider.RemoveAsync(pageGuid); await RemoveCachedPageAsync(pageGuid); DesignedPagesDictionaryByUrl designedPagesUrl = await GetDesignedPagesWithoutLockAsync(); await RemoveDesignedPageAsync(designedPagesUrl, page.Url); await lockObject.UnlockAsync(); } await Auditing.AddAuditAsync($"{nameof(PageDefinitionDataProvider)}.{nameof(RemovePageDefinitionAsync)}", page.Url, page.PageGuid, "Remove Page", DataBefore : page, DataAfter : null, ExpensiveMultiInstance : true ); return(true); }
public async Task <bool> AddItemAsync(UnifiedSetData unifiedSet) { unifiedSet.UnifiedSetGuid = Guid.NewGuid(); unifiedSet.Created = DateTime.UtcNow; if (unifiedSet.UnifiedMode == PageDefinition.UnifiedModeEnum.SkinDynamicContent) { unifiedSet.PageList = new List <string>(); } else { unifiedSet.PageSkin = new SkinDefinition(); } unifiedSet.PageGuids = await UpdatePageGuidsAsync(unifiedSet.UnifiedSetGuid, unifiedSet.PageList); if (!await DataProvider.AddAsync(unifiedSet)) { return(false); } await Auditing.AddAuditAsync($"{nameof(UnifiedSetDataProvider)}.{nameof(AddItemAsync)}", Dataset, Guid.Empty, $"Add UPS {unifiedSet.Name}", DataBefore : null, DataAfter : unifiedSet ); return(true); }
internal async Task RemoveSiteDefinitionAsync() { SiteDefinition site = Manager.CurrentSite; if (site.IsDefaultSite) { throw new Error(this.__ResStr("cantDeleteDefault", "The default site of a YetaWF instance cannot be removed")); } using (await lockObject.LockAsync()) { // protect SiteCache locally // remove all saved data SiteCache.Remove(site.SiteDomain.ToLower()); if (!string.IsNullOrWhiteSpace(site.StaticDomain)) { StaticSiteCache.Remove(site.StaticDomain.ToLower()); } if (!string.IsNullOrWhiteSpace(site.SiteTestDomain)) { TestSiteCache.Remove(site.SiteTestDomain.ToLower()); } await Package.RemoveSiteDataAsync(Manager.SiteFolder); await DataProvider.RemoveAsync(site.SiteDomain);// remove domain } await Auditing.AddAuditAsync($"{nameof(SiteDefinitionDataProvider)}.{nameof(SaveSiteDefinitionAsync)}", site.SiteDomain, Guid.Empty, "Remove Site", DataBefore : site, DataAfter : null, ExpensiveMultiInstance : true ); }
public async Task <bool> AddItemAsync(UserDefinition data) { CleanupRoles(data); if (!Manager.HasSuperUserRole) { int superuserRole = Resource.ResourceAccess.GetSuperuserRoleId(); if (data.RolesList.Contains(new Role { RoleId = superuserRole }, new RoleComparer())) { throw new Error(this.__ResStr("noSup", "Only a superuser can assign superuser status to another user")); } } if (data.UserId == SuperuserDefinitionDataProvider.SuperUserId || string.Compare(data.UserName, SuperuserDefinitionDataProvider.SuperUserName, true) == 0) { using (SuperuserDefinitionDataProvider superDP = new SuperuserDefinitionDataProvider()) { return(await superDP.AddItemAsync(data)); } } bool result = await DataProvider.AddAsync(data); await Auditing.AddAuditAsync($"{nameof(UserDefinitionDataProvider)}.{nameof(AddItemAsync)}", data.UserName, Guid.Empty, "Add User", DataBefore : null, DataAfter : data ); return(result); }
public async Task <UpdateStatusEnum> UpdateItemAsync(Authorization data) { Authorization origData = Auditing.Active ? await GetItemAsync(data.ResourceName) : null; CleanupUsersAndRoles(data); if (data.AllowedUsers.Count > Info.MAX_USERS_IN_RESOURCE) { throw new Error(this.__ResStr("maxUsers", "Only up to {0} users can be authorized for a resource. Consider creating a role instead, and add all users to that role. There is no limit to the number of users that can be added to a role.")); } UpdateStatusEnum status = await DataProvider.UpdateAsync(data.ResourceName, data.ResourceName, data); if (status == UpdateStatusEnum.RecordDeleted) { if (!await DataProvider.AddAsync(data)) { throw new Error(this.__ResStr("addFail", "Unexpected error adding new record - {0}", status)); } status = UpdateStatusEnum.OK; } if (status != UpdateStatusEnum.OK) { throw new Error(this.__ResStr("updFail", "Unexpected error updating record - {0}", status)); } await Auditing.AddAuditAsync($"{nameof(AuthorizationDataProvider)}.{nameof(UpdateItemAsync)}", data.ResourceName, Guid.Empty, "Add/Update Authorization", DataBefore : origData, DataAfter : data, ExpensiveMultiInstance : true ); return(status); }
public async Task ShutTheBackDoorAsync() { WebConfigHelper.SetValue <string>(AreaRegistration.CurrentPackage.AreaName, "BACKDOOR-IS-WIDE-OPEN", "0"); await WebConfigHelper.SaveAsync(); backDoor = false; await Auditing.AddAuditAsync($"{nameof(OwinEditModuleController)}.{nameof(ShutTheBackDoorAsync)}", "BACKDOOR-IS-WIDE-OPEN", Guid.Empty, $"{nameof(ShutTheBackDoorAsync)}", RequiresRestart : true ); }
// APPSETTINGS.JSON public async Task SetRunningAsync(bool running) { if (running != GetRunning()) { WebConfigHelper.SetValue <bool>(AreaRegistration.CurrentPackage.AreaName, "Running", running); await WebConfigHelper.SaveAsync(); await Auditing.AddAuditAsync($"{nameof(SchedulerDataProvider)}.{nameof(SetRunningAsync)}", "Scheduler", Guid.Empty, $"{nameof(SetRunningAsync)}({running})", RequiresRestart : true ); } }
protected async Task <bool> AddItemAsync(MenuInfo data) { bool result = await DataProvider.AddAsync(data); await Auditing.AddAuditAsync($"{nameof(MenuInfoDataProvider)}.{nameof(AddItemAsync)}", "Menu", data.ModuleGuid, "Add Menu", DataBefore : null, DataAfter : data, ExpensiveMultiInstance : true ); return(result); }
public async Task <UpdateStatusEnum> UpdateItemAsync(string originalName, UserDefinition data) { CleanupRoles(data); if (!Manager.HasSuperUserRole) { int superuserRole = Resource.ResourceAccess.GetSuperuserRoleId(); if (data.RolesList.Contains(new Role { RoleId = superuserRole }, new RoleComparer())) { // new data has super user role // get original to make sure superuser role isn't new UserDefinition origData = await GetItemByUserIdAsync(data.UserId); if (!origData.RolesList.Contains(new Role { RoleId = superuserRole }, new RoleComparer())) { throw new Error(this.__ResStr("noSup", "Only a superuser can assign superuser status to another user")); } } } if (string.Compare(data.UserName, SuperuserDefinitionDataProvider.SuperUserName, true) == 0 && string.Compare(originalName, SuperuserDefinitionDataProvider.SuperUserName, true) != 0) { return(UpdateStatusEnum.NewKeyExists); } if (string.Compare(originalName, SuperuserDefinitionDataProvider.SuperUserName, true) == 0) { if (data.UserName != originalName) { throw new Error(this.__ResStr("cantRenameSuper", "The user \"{0}\" can't be renamed.", originalName)); } using (SuperuserDefinitionDataProvider superDP = new SuperuserDefinitionDataProvider()) { return(await superDP.UpdateItemAsync(data)); } } UserDefinition origUser = Auditing.Active ? await GetItemAsync(originalName) : null; UpdateStatusEnum result = await DataProvider.UpdateAsync(originalName, data.UserName, data); await Auditing.AddAuditAsync($"{nameof(UserDefinitionDataProvider)}.{nameof(UpdateItemAsync)}", originalName, Guid.Empty, "Update User", DataBefore : origUser, DataAfter : data ); return(result); }
public async Task AddConfigAsync(RecaptchaV2Config data) { data.Key = KEY; if (!await DataProvider.AddAsync(data)) { throw new InternalError("Unexpected error adding RecaptchaV2 Settings"); } await Auditing.AddAuditAsync($"{nameof(RecaptchaV2ConfigDataProvider)}.{nameof(AddConfigAsync)}", "Config", Guid.Empty, "Add RecaptchaV2 Config", DataBefore : null, DataAfter : data, ExpensiveMultiInstance : true ); }
public async Task <bool> AddItemAsync(HolidayEntry data) { if (!await DataProvider.AddAsync(data)) { return(false); } await Auditing.AddAuditAsync($"{nameof(HolidayEntryDataProvider)}.{nameof(AddItemAsync)}", Dataset, Guid.Empty, $"Add Holiday Entry {data.Id}", DataBefore : null, DataAfter : data ); return(true); }
private async Task AddConfigAsync(SearchConfigData data) { data.Id = KEY; if (!await DataProvider.AddAsync(data)) { throw new InternalError("Unexpected error adding settings"); } await Auditing.AddAuditAsync($"{nameof(SearchConfigDataProvider)}.{nameof(AddConfigAsync)}", "Config", Guid.Empty, "Add Search Config", DataBefore : null, DataAfter : data, ExpensiveMultiInstance : true ); }
public async Task <bool> RemoveItemAsync(int key) { UserInfo origUserInfo = Auditing.Active ? await GetItemAsync(key) : null; bool result = await DataProvider.RemoveAsync(key); await Auditing.AddAuditAsync($"{nameof(UserInfoDataProvider)}.{nameof(RemoveItemAsync)}", key.ToString(), Guid.Empty, "Remove UserInfo", DataBefore : origUserInfo, DataAfter : null ); return(result); }
public async Task <bool> RemoveItemAsync(Guid moduleGuid) { MenuInfo origMenu = Auditing.Active ? await GetItemAsync(moduleGuid) : null; bool result = await DataProvider.RemoveAsync(moduleGuid); await Auditing.AddAuditAsync($"{nameof(MenuInfoDataProvider)}.{nameof(RemoveItemAsync)}", "Menu", moduleGuid, "Remove Menu", DataBefore : origMenu, DataAfter : null, ExpensiveMultiInstance : true ); return(result); }
protected async Task <UpdateStatusEnum> UpdateItemAsync(MenuInfo data) { MenuInfo origMenu = Auditing.Active ? await GetItemAsync(data.ModuleGuid) : null; UpdateStatusEnum result = await DataProvider.UpdateAsync(data.ModuleGuid, data.ModuleGuid, data); await Auditing.AddAuditAsync($"{nameof(MenuInfoDataProvider)}.{nameof(UpdateItemAsync)}", "Menu", data.ModuleGuid, "Update Menu", DataBefore : origMenu, DataAfter : data, ExpensiveMultiInstance : true ); return(result); }
public async Task <bool> AddItemAsync(VoiceMailData data) { data.Created = DateTime.UtcNow; if (!await DataProvider.AddAsync(data)) { return(false); } await Auditing.AddAuditAsync($"{nameof(VoiceMailDataProvider)}.{nameof(AddItemAsync)}", Dataset, Guid.Empty, $"Add Voice Mail Entry {data.Id}", DataBefore : null, DataAfter : data ); return(true); }
public async Task <ActionResult> OwinEdit_Partial(EditModel model) { if (!ModelState.IsValid) { return(PartialView(model)); } if (model.ExpireTimeSpan < new TimeSpan(0, 10, 0)) { ModelState.AddModelError(nameof(model.ExpireTimeSpan), this.__ResStr("timeSpan", "The minimum expiration timespan should be at least 10 minutes")); return(PartialView(model)); } if (model.SecurityStampValidationInterval < new TimeSpan(0, 1, 0)) { ModelState.AddModelError(nameof(model.SecurityStampValidationInterval), this.__ResStr("securityInterval", "The minimum validation interval should be at least 1 minute")); return(PartialView(model)); } OwinConfigHelper.SetValue <bool>(Module.AreaName, "Password:RequireDigit", model.RequireDigit); OwinConfigHelper.SetValue <int>(Module.AreaName, "Password:RequiredLength", model.RequiredLength); OwinConfigHelper.SetValue <bool>(Module.AreaName, "Password:RequireNonAlphanumeric", model.RequireNonAlphanumeric); OwinConfigHelper.SetValue <bool>(Module.AreaName, "Password:RequireUppercase", model.RequireUppercase); OwinConfigHelper.SetValue <bool>(Module.AreaName, "Password:RequireLowercase", model.RequireLowercase); OwinConfigHelper.SetValue <bool>(Module.AreaName, "OWin:SlidingExpiration", model.SlidingExpiration); OwinConfigHelper.SetValue <long>(Module.AreaName, "OWin:ExpireTimeSpan", model.ExpireTimeSpan.Ticks); OwinConfigHelper.SetValue <long>(Module.AreaName, "OWin:SecurityStampValidationInterval", model.SecurityStampValidationInterval.Ticks); OwinConfigHelper.SetValue <long>(Module.AreaName, "PasswordRenewal", model.PasswordRenewal.Ticks); OwinConfigHelper.SetValue <bool>(Module.AreaName, "MicrosoftAccount:Enabled", model.UseMicrosoft); OwinConfigHelper.SetValue <string>(Module.AreaName, "MicrosoftAccount:Public", model.MicrosoftPublic); OwinConfigHelper.SetValue <string>(Module.AreaName, "MicrosoftAccount:Private", model.MicrosoftPrivate); OwinConfigHelper.SetValue <bool>(Module.AreaName, "GoogleAccount:Enabled", model.UseGoogle); OwinConfigHelper.SetValue <string>(Module.AreaName, "GoogleAccount:Public", model.GooglePublic); OwinConfigHelper.SetValue <string>(Module.AreaName, "GoogleAccount:Private", model.GooglePrivate); OwinConfigHelper.SetValue <bool>(Module.AreaName, "FacebookAccount:Enabled", model.UseFacebook); OwinConfigHelper.SetValue <string>(Module.AreaName, "FacebookAccount:Public", model.FacebookPublic); OwinConfigHelper.SetValue <string>(Module.AreaName, "FacebookAccount:Private", model.FacebookPrivate); OwinConfigHelper.SetValue <bool>(Module.AreaName, "TwitterAccount:Enabled", model.UseTwitter); OwinConfigHelper.SetValue <string>(Module.AreaName, "TwitterAccount:Public", model.TwitterPublic); OwinConfigHelper.SetValue <string>(Module.AreaName, "TwitterAccount:Private", model.TwitterPrivate); await OwinConfigHelper.SaveAsync(); await Auditing.AddAuditAsync($"{nameof(OwinEditModuleController)}.{nameof(OwinEdit_Partial)}", "Login", Guid.Empty, $"{nameof(OwinEdit_Partial)}", RequiresRestart : true ); return(FormProcessed(model, this.__ResStr("okSaved", "Login provider settings successfully saved - These settings won't take effect until the site (including all instances) is restarted."), NextPage: Manager.CurrentSite.HomePageUrl)); }
private async Task AddConfigAsync(BlogConfigData data) { data.Id = KEY; await SaveImagesAsync(ModuleDefinition.GetPermanentGuid(typeof(BlogConfigModule)), data); if (!await DataProvider.AddAsync(data)) { throw new InternalError("Unexpected error adding settings"); } await Auditing.AddAuditAsync($"{nameof(BlogConfigDataProvider)}.{nameof(AddConfigAsync)}", "Config", Guid.Empty, "Add Blog Config", DataBefore : null, DataAfter : data, ExpensiveMultiInstance : true ); }
public async Task UpdateItemAsync(VoiceMailData data) { VoiceMailData origEmail = Auditing.Active ? await GetItemAsync(data.CallSid) : null; UpdateStatusEnum status = await DataProvider.UpdateByIdentityAsync(data.Id, data); if (status != UpdateStatusEnum.OK) { throw new InternalError("Unexpected error {0} updating item", status); } await Auditing.AddAuditAsync($"{nameof(VoiceMailDataProvider)}.{nameof(UpdateItemAsync)}", Dataset, Guid.Empty, $"Update Voice Mail Entry {data.Id}", DataBefore : origEmail, DataAfter : data ); }
public async Task <bool> RemoveItemAsync(string resourceName) { Authorization origData = Auditing.Active ? await GetItemAsync(resourceName) : null; if (!await DataProvider.RemoveAsync(resourceName)) { return(false); } await Auditing.AddAuditAsync($"{nameof(AuthorizationDataProvider)}.{nameof(RemoveItemAsync)}", resourceName, Guid.Empty, "Remove Authorization", DataBefore : origData, DataAfter : null, ExpensiveMultiInstance : true ); return(true); }
public async Task <bool> RemoveItemByIdentityAsync(int id) { BlockedNumberEntry origData = Auditing.Active ? await GetItemByIdentityAsync(id) : null; if (!await DataProvider.RemoveByIdentityAsync(id)) { return(false); } await Auditing.AddAuditAsync($"{nameof(BlockedNumberDataProvider)}.{nameof(RemoveItemByIdentityAsync)}", Dataset, Guid.Empty, $"Remove Blocked Number {id}", DataBefore : origData, DataAfter : null ); return(true); }
public async Task <bool> AddItemAsync(BlockedNumberEntry data) { data.Created = DateTime.UtcNow; data.Number = PhoneNumberAttribute.GetE164(data.Number); if (!await DataProvider.AddAsync(data)) { return(false); } await Auditing.AddAuditAsync($"{nameof(BlockedNumberDataProvider)}.{nameof(AddItemAsync)}", Dataset, Guid.Empty, $"Add Blocked Number {data.Id}", DataBefore : null, DataAfter : data ); return(true); }
public async Task <bool> AddItemAsync(UserInfo userInfo) { userInfo.Created = DateTime.UtcNow; if (string.IsNullOrWhiteSpace(userInfo.Country)) { userInfo.Country = Globals.DefaultCountry; } bool result = await DataProvider.AddAsync(userInfo); await Auditing.AddAuditAsync($"{nameof(UserInfoDataProvider)}.{nameof(AddItemAsync)}", userInfo.UserId.ToString(), Guid.Empty, "Add UserInfo", DataBefore : null, DataAfter : userInfo ); return(result); }
public async Task UpdateConfigAsync(SearchConfigData data) { SearchConfigData origConfig = Auditing.Active ? await GetItemAsync() : null; data.Id = KEY; UpdateStatusEnum status = await DataProvider.UpdateAsync(data.Id, data.Id, data); if (status != UpdateStatusEnum.OK) { throw new InternalError("Unexpected error saving settings {0}", status); } await Auditing.AddAuditAsync($"{nameof(SearchConfigDataProvider)}.{nameof(UpdateConfigAsync)}", "Config", Guid.Empty, "Update Search Config", DataBefore : origConfig, DataAfter : data, ExpensiveMultiInstance : true ); }